@tangle-network/agent-eval 0.133.3 → 0.134.0

package/dist/{skillopt-optimization-method-Dxr8pdZd.d.ts → skillopt-optimization-method-DJ3l4w8W.d.ts}

@@ -3,11 +3,12 @@ import { a as RunRecord } from "./run-record-DcObtIGh.js";
 import { s as TraceStore } from "./store-CT9YIIve.js";
 import { n as LlmCallMetadata } from "./llm-client-BiK4HW0u.js";
 import { A as ChatClient } from "./types-Cc3qbqzj.js";
-import { C as JudgeDimension, H as SurfaceProposer, N as ParetoParent, R as Scenario, S as JudgeConfig, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, h as GateContext, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, v as GateResult, y as GenerationCandidate } from "./types-BokuXvOG.js";
+import { m as ProposalFinding } from "./types-DVjczBM9.js";
+import { C as JudgeDimension, H as SurfaceProposer, N as ParetoParent, R as Scenario, S as JudgeConfig, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, h as GateContext, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, v as GateResult, y as GenerationCandidate } from "./types-DiWLru6Z.js";
 import { _ as PairedBootstrapResult } from "./statistics-D_4Snl-5.js";
 import { a as DatasetScenario, t as Dataset } from "./dataset-BvtnC8Dc.js";
 import { t as DetectRewardHackingInput } from "./reward-hacking-D-QqXvg-.js";
-import { g as TraceSpanEvent, t as HostedClient } from "./client-Du7B81wW.js";
+import { g as TraceSpanEvent, t as HostedClient } from "./client-BIyh1RCr.js";
 import { z } from "zod";
 //#region src/llm-judge.d.ts
 /** A rubric dimension as a bare key or the full `{ key, description }` shape. A
@@ -1315,7 +1316,7 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
   /** Dispatcher that takes the CURRENT surface + scenario → artifact. */
   dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: Parameters<RunCampaignOptions<TScenario, TArtifact>['dispatch']>[1]) => Promise<TArtifact>;
   /** The candidate-generation strategy. */
-  proposer: SurfaceProposer;
+  proposer: SurfaceProposer<ProposalFinding>;
   populationSize: number;
   maxGenerations: number;
   /** Candidate campaigns run at once. Default 1. Total concurrent cells are
@@ -1324,14 +1325,8 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
   /** DEPTH knob forwarded to the proposer's `propose()` — max iterations the
    *  agentic generator may take per candidate. */
   maxImprovementShots?: number;
-  /** Optional analysis report forwarded to `propose()`. Opaque here; the
-   *  proposer types it. */
-  report?: unknown;
-  /** Structured findings forwarded to `propose()` as `ctx.findings`. A
-   *  findings producer emits these from the
-   *  generation's traces; findings-grounded proposers consume them. Opaque here;
-   *  the proposer types its `TFindings`. Empty when no producer is wired. */
-  findings?: unknown[];
+  /** Search or observed-production findings forwarded to candidate generation. */
+  findings?: ReadonlyArray<ProposalFinding>;
   /** Per-generation findings producer. Runs once on the BASELINE campaign
    *  (as `generation: -1`, the baseline convention) before generation 0
    *  proposes — so even a single-generation run proposes with trace context —
@@ -1354,7 +1349,7 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
     /** Shared run spend account and receipt attribution phase. */
     costLedger?: CostLedgerHandle;
     costPhase?: string;
-  }) => Promise<unknown[]>;
+  }) => Promise<ReadonlyArray<ProposalFinding>>;
   /**
    * Optional override for how the WINNER is selected among coverage-complete
    * candidates (and how the incumbent bar is set). Returns a lexicographic rank
@@ -1384,6 +1379,8 @@ interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
       campaign: CampaignResult<TArtifact, TScenario>;
     }>;
   }>;
+  /** Frozen snapshot of the exact starting surface measured by `baselineCampaign`. */
+  baselineSurface: MutableSurface;
   winnerSurface: MutableSurface;
   winnerSurfaceHash: string;
   /** Proposer label for the promoted surface. Present when the winning
@@ -1742,4 +1739,4 @@ interface SkillOptOptimizationMethodConfig<TScenario extends Scenario, TArtifact
 declare function skillOptOptimizationMethod<TScenario extends Scenario, TArtifact>(config: SkillOptOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
 //#endregion
 export { Objective as $, optimizationTokenUsageFromSummary as $t, RunEvalOptions as A, CanarySeverity as At, OptimizerModelBudget as B, ComparisonCost as Bt, RunImprovementLoopOptions as C, ReferenceEquivalenceJudgeResult as Cn, scoreRedTeamOutput as Ct, RunOptimizationOptions as D, LlmJudgeDimension as Dn, CanaryKind as Dt, PremeasuredOptimizationBaseline as E, runReferenceEquivalenceJudge as En, CanaryEvaluation as Et, GepaOptimizationMethodConfig as F, ExternalTextOptimizerContext as Ft, ObjectiveSource as G, OptimizationMethodProvenance as Gt, AxisVerdict as H, OptimizationMethodComparison as Ht, GepaOptimizationRecipe as I, ExternalTextOptimizerResult as It, PromotionPolicy as J, OptimizationMethodScore as Jt, ParetoSignificanceGateOptions as K, OptimizationMethodResult as Kt, GepaRunnerCommand as L, ExternalOptimizationExample as Lt, GepaAdaptiveEngineRun as M, composeGate as Mt, GepaEngineOptions as N, externalTextOptimizationMethod as Nt, RunOptimizationResult as O, LlmJudgeOptions as On, CanaryOptions as Ot, GepaEngineRun as P, ExternalTextOptimizationMethodConfig as Pt, Direction as Q, costFromLedgerSummary as Qt, gepaOptimizationMethod as R, ExternalTextEvaluationResponse as Rt, verifyLoopProvenanceRecord as S, ReferenceEquivalenceJudgeOptions as Sn, redTeamReport as St, runImprovementLoop as T, createReferenceEquivalenceJudge as Tn, CanaryAlert as Tt, BuildEvidenceVectorOptions as U, OptimizationMethodInput as Ut, AxisEvidence as V, OptimizationMethod as Vt, EvidenceVector as W, OptimizationMethodPairwise as Wt, paretoPolicy as X, OptimizationTokenUsage as Xt, buildEvidenceVector as Y, OptimizationPackageSource as Yt, paretoSignificanceGate as Z, compareOptimizationMethods as Zt, emitLoopProvenance as _, OpenAutoPrResult as _n, RedTeamCategory as _t, BuildLoopProvenanceArgs as a, planCampaignRun as an, scalarScore as at, provenanceRecordPath as b, REFERENCE_EQUIVALENCE_JUDGE_VERSION as bn, RedTeamReport as bt, LoopProvenanceArgsFromResult as c, createRunCostLedger as cn, powerPreflight as ct, LoopProvenanceEvidence as d, assertCampaignDesign as dn, DefaultProductionGateCheck as dt, CampaignCellFailureReceipt as en, ParetoResult as et, LoopProvenanceOptimizationMethod as f, assertCampaignSplitIdentity as fn, DefaultProductionGateOptions as ft, canonicalDigest as g, OpenAutoPrOptions as gn, RedTeamCase as gt, campaignMeasurementDigest as h, campaignSplitDigestFromIdentities as hn, DEFAULT_RED_TEAM_CORPUS as ht, skillOptOptimizationMethod as i, RunCampaignOptions as in, paretoFrontierWithCrowding as it, runEval as j, runCanaries as jt, runOptimization as k, llmJudge as kn, CanaryReport as kt, LoopProvenanceBackend as l, fsCampaignStorage as ln, HeldOutGateOptions as lt, buildLoopProvenanceRecord as m, campaignSplitDigest as mn, defaultProductionGate as mt, SkillOptRunnerCommand as n, CampaignRunPlanCell as nn, dominates as nt, EmitLoopProvenanceArgs as o, runCampaign as on, PowerPreflight as ot, LoopProvenanceRecord as p, campaignScenarioIdentity as pn, DefaultProductionRewardHackingOptions as pt, PromotionObjective as q, OptimizationMethodRunOptions as qt, SkillOptTrainerConfig as r, PlanCampaignRunOptions as rn, paretoFrontier as rt, EmitLoopProvenanceResult as s, CampaignStorage as sn, PowerPreflightOptions as st, SkillOptOptimizationMethodConfig as t, CampaignRunPlan as tn, crowdingDistance as tt, LoopProvenanceCandidate as u, inMemoryCampaignStorage as un, heldOutGate as ut, loopProvenanceArgsFromResult as v, openAutoPr as vn, RedTeamFinding as vt, RunImprovementLoopResult as w, ReferenceEquivalenceScenario as wn, toolNamesForRun as wt, provenanceSpansPath as x, ReferenceEquivalenceJudgeInput as xn, redTeamDataset as xt, loopProvenanceSpans as y, REFERENCE_EQUIVALENCE_INPUT_LIMITS as yn, RedTeamPayload as yt, OpenAICompatibleOptimizerModel as z, CompareOptimizationMethodsOptions as zt };
-//# sourceMappingURL=skillopt-optimization-method-Dxr8pdZd.d.ts.map
+//# sourceMappingURL=skillopt-optimization-method-DJ3l4w8W.d.ts.map

package/dist/skillopt-optimization-method-DJ3l4w8W.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillopt-optimization-method-DJ3l4w8W.d.ts","names":[],"sources":["../src/llm-judge.ts","../src/reference-equivalence-judge.ts","../src/campaign/auto-pr.ts","../src/campaign/coverage.ts","../src/campaign/external-optimizer-contracts.ts","../src/campaign/storage.ts","../src/campaign/run-campaign.ts","../src/campaign/presets/compare-optimization-methods.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/gates/compose.ts","../src/canary.ts","../src/red-team.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts","../src/campaign/gates/power-preflight.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/presets/run-eval.ts","../src/campaign/presets/run-optimization.ts","../src/campaign/presets/run-improvement-loop.ts","../src/campaign/provenance.ts","../src/campaign/skillopt-optimization-method.ts"],"mappings":"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"}

package/dist/{summary-report-DyOhItws.d.ts → summary-report-DGp0-_XO.d.ts}

@@ -1,7 +1,32 @@
 import { a as RunRecord } from "./run-record-DcObtIGh.js";
 import { n as FailureClusterReport } from "./failure-cluster-CqcvCcdR.js";
 //#region src/held-out-gate.d.ts
-type HeldOutGateRejectionCode = 'few_runs' | 'missing_split_scores' | 'missing_cost' | 'negative_delta' | 'indeterminate_delta' | 'overfit_gap' | 'cost_ceiling';
+type HeldOutGateRejectionCode = 'few_runs' | 'incomplete_coverage' | 'missing_split_scores' | 'missing_cost' | 'negative_delta' | 'indeterminate_delta' | 'overfit_gap' | 'cost_ceiling';
+/**
+ * How much of one split's DEALT work the comparison actually measured.
+ *
+ * `answered + unscoredPairs + candidateOnly + baselineOnly === dealt` — a
+ * complete, mutually exclusive partition of the item slots the split was dealt,
+ * so nothing can leave the comparison without appearing in exactly one bucket.
+ */
+interface SplitCoverage {
+  /** Work items the split was dealt: every item with a row on either arm. */
+  dealt: number;
+  /** Dealt items carrying a finite score on BOTH arms — the only ones any
+   *  paired statistic can read. */
+  answered: number;
+  /** Dealt items with a row on both arms where at least one row carried no
+   *  finite score: a run happened and produced nothing (crash, timeout, judge
+   *  failure). Measured absence, not an absent item. */
+  unscoredPairs: number;
+  /** Dealt items only the candidate produced a row for. */
+  candidateOnly: number;
+  /** Dealt items only the baseline produced a row for. */
+  baselineOnly: number;
+  /** `answered / dealt`, or 0 when nothing was dealt. 1 means every dealt item
+   *  was scored on both arms. */
+  coverage: number;
+}
 interface HeldOutGateConfig {
   /** Minimum number of paired (candidate, baseline) holdout observations
    *  required before promotion. The exact small-sample test may require more
@@ -24,6 +49,23 @@ interface HeldOutGateConfig {
   /** Optional deterministic seed for the bootstrap. Default undefined
    *  (Math.random). */
   seed?: number;
+  /**
+   * Smallest acceptable `answered / dealt` fraction, required on BOTH splits.
+   * Default 1: every work item the comparison was dealt must carry a real score
+   * on both arms before the gate will decide anything.
+   *
+   * The default is 1 because a missing score is missing data, and a promotion
+   * computed over "the items that happened to answer" is a promotion computed
+   * over a set the candidate selected by failing (see the module header). One
+   * split below `minCoverage` rejects with `incomplete_coverage`.
+   *
+   * Lowering it is a real, defensible choice for a caller who accepts a known
+   * flake rate — but it must be DECLARED, not inherited: the shrunken
+   * denominator then still ships in `GateEvidence.holdoutCoverage` /
+   * `searchCoverage`, so the verdict can never be read without it. Must be in
+   * [0, 1]; anything else throws rather than clamping.
+   */
+  minCoverage?: number;
   /**
    * Hard ceiling on the candidate's median per-task USD cost. When the
    * candidate clears the quality gates (paired-delta + overfit-gap) but
@@ -45,6 +87,19 @@ interface GateEvidence {
   unpairedCandidateRuns: number;
   /** Baseline holdout rows with no candidate row at the same work identity. */
   unpairedBaselineRuns: number;
+  /**
+   * How much of the dealt HOLDOUT work carried a score on both arms — the
+   * denominator behind `productiveRuns`, `medianPairedDelta`, `pairedCI` and
+   * `holdoutScore`. A `coverage` below 1 means those numbers describe a
+   * SUBSET of the items the comparison was dealt, and which items are in that
+   * subset was decided by whichever arm went dark.
+   */
+  holdoutCoverage: SplitCoverage;
+  /**
+   * The same accounting for the SEARCH split — the denominator behind
+   * `searchScore`, and therefore behind both overfit gaps.
+   */
+  searchCoverage: SplitCoverage;
   /** Median of paired holdout deltas, or null when there are no pairs. */
   medianPairedDelta: number | null;
   /** Bootstrap CI on the median paired holdout delta, if computed. */
@@ -106,6 +161,7 @@ declare class HeldOutGate {
   private readonly resamples;
   private readonly seed?;
   private readonly costPerTaskCeiling?;
+  private readonly minCoverage;
   constructor(config: HeldOutGateConfig);
   /** Decide whether `candidate` should replace `baseline`.
    *  Pairing is by `(experimentId, scenarioId, seed)`.
@@ -404,5 +460,5 @@ interface ResearchReport {
  */
 declare function researchReport(runs: RunRecord[], opts?: ResearchReportOptions): Promise<ResearchReport>;
 //#endregion
-export { HeldOutGateConfig as C, HeldOutGate as S, paretoChart as _, ParetoPoint as a, GateDecision as b, ResearchReportCandidate as c, ResearchReportOptions as d, ResearchReportRecommendation as f, gainHistogram as g, SummaryTableRow as h, ParetoFigureSpec as i, ResearchReportDecision as l, SummaryTableOptions as m, GainDistributionFigureSpec as n, RESEARCH_REPORT_HARD_PAIR_FLOOR as o, SummaryTable as p, GainDistributionOptions as r, ResearchReport as s, GainDistributionBin as t, ResearchReportMethodology as u, researchReport as v, HeldOutGateRejectionCode as w, GateEvidence as x, summaryTable as y };
-//# sourceMappingURL=summary-report-DyOhItws.d.ts.map
+export { HeldOutGateConfig as C, HeldOutGate as S, SplitCoverage as T, paretoChart as _, ParetoPoint as a, GateDecision as b, ResearchReportCandidate as c, ResearchReportOptions as d, ResearchReportRecommendation as f, gainHistogram as g, SummaryTableRow as h, ParetoFigureSpec as i, ResearchReportDecision as l, SummaryTableOptions as m, GainDistributionFigureSpec as n, RESEARCH_REPORT_HARD_PAIR_FLOOR as o, SummaryTable as p, GainDistributionOptions as r, ResearchReport as s, GainDistributionBin as t, ResearchReportMethodology as u, researchReport as v, HeldOutGateRejectionCode as w, GateEvidence as x, summaryTable as y };
+//# sourceMappingURL=summary-report-DGp0-_XO.d.ts.map

package/dist/summary-report-DGp0-_XO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary-report-DGp0-_XO.d.ts","names":[],"sources":["../src/held-out-gate.ts","../src/summary-report.ts"],"mappings":";;;KAyEY;;;;;;;;UAiBK;;EAEf;;;EAGA;;;;EAIA;;EAEA;;EAEA;;;EAGA;;UAGe;;;;EAIf;;;EAGA;;;;EAIA;;;EAGA;;EAEA;;EAEA;;;EAGA;;;;;;;;;;;;;;;;;EAiBA;;;;;;;;;;;;;EAaA;;UAGe;;EAEf;;EAEA;;EAEA;;;;;;;;EAQA,iBAAiB;;;;;EAKjB,gBAAgB;;EAEhB;;EAEA;IAAY;IAAa;;;EAEzB;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA;;;EAGA;;;;;;;EAOA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA,UAAU;;EAEV;;EAEA,eAAe;;;;;;;cAQJ;mBACM;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;EAEjB,YAAY,QAAQ;;;;EAmCpB,SAAS,WAAW,aAAa,UAAU,cAAc;;;;UC9O1C;;;EAGf;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;EACf,MAAM;EACN;EACA;;EAEA;;;;;;;iBAQc,aAAa,MAAM,aAAa,OAAM,sBAA2B;UA6IhE;EACf;;EAEA;;EAEA;;EAEA;;;EAGA;;;EAGA;;UAGe;EACf;EACA;EACA,QAAQ;EACR;IAAQ;IAAc;;;;;;;;iBAQR,YACd,MAAM,aACN;EACE;EACA,gBAAgB,eAAe;IAEhC;UAsDc;;EAEf;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;EACA,MAAM;EACN;EACA;IAAM;IAAa;;;UAGJ;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;iBAQc,cACd,MAAM,aACN,qBACA,oBACA,OAAM,0BACL;KA8ES;;;;;;cAYC;UAEI;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;EASA;;;;;;;EAOA;IAAS;IAAa;;;;;;EAKtB;;;;;EAKA;;EAEA,gBAAgB,eAAe;;EAE/B,kBAAkB;;EAElB;;EAEA;;EAEA;;;;;;EAMA;;UAGe;EACf,UAAU;EACV;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IAAU;IAAa;;;;;;;EAMvB;EACA;;;;;;;EAOA;EACA;EACA,OAAO;EACP,UAAU;EACV;;UAGe;;;;;EAKf;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;;;;;;EAMA;EACA;EACA;IAAQ;IAAa;;EACrB;EACA,gBAAgB;EAChB,YAAY;EACZ,SAAS;EACT;IACE,QAAQ;IACR,OAAO;;EAET,aAAa;EACb,kBAAkB;EAClB;EACA;;;;;;;;;;;;;;;;;;;;;iBA6IoB,eACpB,MAAM,aACN,OAAM,wBACL,QAAQ"}

package/dist/types-DVjczBM9.d.ts

@@ -0,0 +1,276 @@
+import { c as CostLedgerHandle } from "./cost-ledger-fGS_u_O1.js";
+import { a as RunRecord, n as RunCostProvenance, u as RunTokenUsage } from "./run-record-DcObtIGh.js";
+import { A as ChatClient, m as JudgeInput } from "./types-Cc3qbqzj.js";
+import { t as TraceAnalysisStore } from "./store-CxJry_cs.js";
+//#region src/analyst/types.d.ts
+/**
+ * Unified envelope every analyst emits. Schema-versioned so renderers
+ * and time-series diffs survive future field additions.
+ */
+interface AnalystFinding {
+  schema_version: '1.0.0';
+  /**
+   * Stable hash over identity-defining fields (analyst_id + canonical
+   * claim + area + optional subject). Two findings from two runs that
+   * "are the same finding" share this id — that's what `diffFindings`
+   * uses to compute appeared/disappeared sets across runs.
+   */
+  finding_id: string;
+  analyst_id: string;
+  produced_at: string;
+  severity: AnalystSeverity;
+  /**
+   * Coarse classification. Renderers group by this. Free-form so
+   * domain-specific analysts can introduce categories without a
+   * schema change ('agent-reasoning', 'verification', 'cost',
+   * 'tool-use', 'safety', 'latency', 'data-quality', ...).
+   */
+  area: string;
+  claim: string;
+  rationale?: string;
+  evidence_refs: EvidenceRef[];
+  recommended_action?: string;
+  validation_plan?: string;
+  /** 0..1 — the analyst's own confidence. Not calibrated across analysts. */
+  confidence: number;
+  /**
+   * Optional subject the finding is about — leaf id, agent id, request
+   * id. Included in finding_id when present so per-subject findings
+   * diff cleanly across runs.
+   */
+  subject?: string;
+  /** True when this finding was lifted from a judge result rather than observed
+   *  directly in a trace or artifact. Descriptive only: proposal access is
+   *  controlled by `ProposalFinding.proposal_origin`. */
+  derived_from_judge?: boolean;
+  /** Analyst-private extras; renderers ignore unless they know the analyst. */
+  metadata?: Record<string, unknown>;
+}
+type AnalystSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+/** Data sources that candidate generation may intentionally learn from. */
+type ProposalFindingOrigin = 'search' | 'production';
+/** A finding explicitly admitted as candidate-generation input. */
+type ProposalFinding = AnalystFinding & {
+  readonly proposal_origin: ProposalFindingOrigin;
+};
+interface EvidenceRef {
+  /**
+   * Where the evidence lives. `span` and `event` refer to OTLP trace
+   * elements; `artifact` to a file inside the run's artifact tree;
+   * `finding` to another AnalystFinding (cross-analyst chaining);
+   * `metric` to a named scalar reading the renderer knows how to read.
+   */
+  kind: 'span' | 'event' | 'artifact' | 'finding' | 'metric';
+  uri: string;
+  excerpt?: string;
+}
+/**
+ * The discriminator the registry uses to pass the right input.
+ * `custom` is the escape hatch — analysts that need something else
+ * (e.g. an embedding cache, a partner SDK handle) read it from
+ * `AnalystRunInputs.custom[<analyst id>]`.
+ */
+type AnalystInputKind = 'trace-store' | 'artifact-dir' | 'run-record' | 'judge-input' | 'custom';
+interface AnalystCost {
+  /** `deterministic` analysts MUST NOT call the LLM. */
+  kind: 'deterministic' | 'llm';
+  /** Optional declared upper bound; the registry can enforce a budget. */
+  est_usd_per_run?: number;
+  /** Models the analyst expects to use (informational). */
+  models?: string[];
+  /** Maximum post-cancellation wait for provider usage. Model analysts default to 5 seconds. */
+  settlement_timeout_ms?: number;
+}
+interface AnalystRequirements {
+  /** Min number of shots / samples the analyst needs to produce signal. */
+  min_shots?: number;
+  /** Capabilities the runtime must supply (e.g. ['network', 'gpu']). */
+  capabilities?: string[];
+}
+/**
+ * What's passed to every analyst call. The registry resolves which
+ * field the analyst's `inputKind` selects and asserts it's present.
+ */
+interface AnalystRunInputs {
+  traceStore?: TraceAnalysisStore;
+  artifactDir?: string;
+  runRecord?: RunRecord;
+  judgeInput?: JudgeInput;
+  /** Keyed by analyst id; populated by callers that registered custom analysts. */
+  custom?: Record<string, unknown>;
+}
+interface AnalystContext {
+  runId: string;
+  /** Stable correlation id so logs from a single registry.run() share a tag. */
+  correlationId: string;
+  /** Enforced wall-clock deadline (epoch ms). */
+  deadlineMs?: number;
+  /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */
+  budgetUsd?: number;
+  /** Shared paid-call account when the analyst runs inside a larger campaign. */
+  costLedger?: CostLedgerHandle;
+  /** Attribution phase used when writing to the shared paid-call account. */
+  costPhase?: string;
+  /**
+   * Shared chat client. Analysts that call an LLM go through this so
+   * the operator picks transport (sandbox-sdk | router | cli-bridge |
+   * direct-provider | mock) at the registry boundary without touching
+   * analyst code.
+   */
+  chat?: ChatClient;
+  /**
+   * Findings from a prior run the operator wants the analyst to see as
+   * retrieval context. Kinds that take advantage of cross-run memory
+   * (failure-mode "I saw this cluster last run", knowledge-gap "the wiki
+   * page I asked for is still missing") render these into the actor's
+   * working set. Filtering is the operator's job: pass the slice that
+   * matches the analyst's id, or pass everything and let the kind
+   * filter. Empty / absent means no cross-run context.
+   */
+  priorFindings?: ReadonlyArray<AnalystFinding>;
+  /**
+   * Findings emitted by analysts that completed earlier in this registry run.
+   * This is separate from `priorFindings`: upstream findings are dependency
+   * context for the current pass, while prior findings are cross-run memory.
+   * The registry populates this only when `RegistryRunOpts.chainFindings` is on.
+   */
+  upstreamFindings?: ReadonlyArray<AnalystFinding>;
+  /**
+   * Report metered work independently of findings. This keeps an empty finding
+   * set from erasing token/cost telemetry. Multiple receipts are accumulated.
+   */
+  recordUsage?: (receipt: AnalystUsageReceipt) => void;
+  /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */
+  tags?: Record<string, string>;
+  /** Logger callback — analysts SHOULD prefer this over console.* for testability. */
+  log?: (msg: string, fields?: Record<string, unknown>) => void;
+  /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */
+  signal?: AbortSignal;
+}
+/**
+ * The minimal contract. Concrete analysts can refine `TInput` so
+ * implementations stay type-safe (e.g. a trace analyst's `TInput` is
+ * `TraceAnalysisStore`); the registry passes the right field from
+ * `AnalystRunInputs` based on `inputKind`.
+ */
+interface Analyst<TInput = unknown> {
+  /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */
+  readonly id: string;
+  /** Human-readable. One sentence. */
+  readonly description: string;
+  readonly inputKind: AnalystInputKind;
+  readonly cost: AnalystCost;
+  readonly requires?: AnalystRequirements;
+  /** Bump on breaking changes to claim wording or area so old finding_ids don't collide. */
+  readonly version: string;
+  analyze(input: TInput, ctx: AnalystContext): Promise<AnalystFinding[]>;
+}
+/** Metered work performed by one analyst call. */
+interface AnalystUsageReceipt {
+  /** Number of model-usage records observed at the provider boundary. */
+  calls: number | null;
+  /** Null when the provider did not return token accounting. */
+  tokens: RunTokenUsage | null;
+  /** Observed, estimated, or explicitly uncaptured dollar cost. */
+  cost: RunCostProvenance;
+  /** Known lower bound when one or more calls have uncaptured cost. */
+  knownCostUsd?: number;
+}
+/**
+ * Compute the stable finding_id from the identity-defining fields.
+ * Default implementation hashes {analyst_id, area, subject, normalized claim}.
+ * Analysts that emit findings whose claim text varies per run (timestamps,
+ * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,
+ * or (b) move the variable part into `rationale`/`metadata` and keep the
+ * `claim` static.
+ */
+declare function computeFindingId(input: {
+  analyst_id: string;
+  area: string;
+  subject?: string;
+  claim: string;
+  /** Override the claim for hashing — use when the displayed claim has run-specific bits. */
+  id_basis?: string;
+}): string;
+/**
+ * Convenience factory: produce a fully-formed AnalystFinding with the
+ * id computed automatically. Analyst code stays terse.
+ */
+declare function makeFinding(init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
+  id_basis?: string;
+  produced_at?: string;
+}): AnalystFinding;
+/** Build a finding whose source is explicitly allowed during candidate generation. */
+declare function makeProposalFinding(init: Omit<ProposalFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
+  id_basis?: string;
+  produced_at?: string;
+}): ProposalFinding;
+interface AnalystRunSummary {
+  analyst_id: string;
+  status: 'ok' | 'skipped' | 'failed';
+  /** Why skipped — missing input, budget exceeded, capability unmet. */
+  reason?: string;
+  findings_count: number;
+  latency_ms: number;
+  /** Additive model usage and cost provenance for this analyst. */
+  usage: AnalystUsageReceipt;
+  /** When `status='failed'`: the error class + message, never the full stack. */
+  error?: {
+    class: string;
+    message: string;
+  };
+}
+interface AnalystRunResult {
+  run_id: string;
+  correlation_id: string;
+  started_at: string;
+  ended_at: string;
+  findings: AnalystFinding[];
+  per_analyst: AnalystRunSummary[];
+  /** Total LLM cost in USD across all analysts in this registry.run(). */
+  total_cost_usd: number;
+  /**
+   * Provenance for `total_cost_usd`. When uncaptured, the numeric field is only
+   * the known subtotal and must not be treated as the run's total spend.
+   */
+  total_cost_provenance?: RunCostProvenance;
+}
+/**
+ * Events emitted by `AnalystRegistry.runStream(...)` in real time as
+ * the registry executes. UIs subscribe via `for await (const ev of
+ * registry.runStream(...))`; `registry.run(...)` is a thin collector
+ * over the same stream, so the two surfaces share their invariants.
+ *
+ * Per-finding events are intentionally omitted — analyzers are batch
+ * operations (an Ax actor returns the full `findings:json[]` at the
+ * end of the responder), so streaming inside one analyst would only
+ * emit partial JSON consumers can't render. The kind-completion event
+ * is the right granularity; subscribers wanting per-finding rendering
+ * iterate `event.findings` themselves.
+ */
+type AnalystRunEvent = {
+  type: 'run-started';
+  run_id: string;
+  correlation_id: string;
+  started_at: string;
+  /** The ordered list of analyst ids the registry will run. */
+  analyst_ids: ReadonlyArray<string>;
+} | {
+  type: 'analyst-skipped';
+  summary: AnalystRunSummary;
+} | {
+  type: 'analyst-started';
+  analyst_id: string;
+  started_at: string;
+} | {
+  type: 'analyst-completed';
+  /** `summary.status` is `'ok'` for clean completion or `'failed'` for thrown analysts. */
+  summary: AnalystRunSummary;
+  findings: ReadonlyArray<AnalystFinding>;
+} | {
+  type: 'run-completed';
+  result: AnalystRunResult;
+};
+//#endregion
+export { makeFinding as _, AnalystInputKind as a, AnalystRunInputs as c, AnalystSeverity as d, AnalystUsageReceipt as f, computeFindingId as g, ProposalFindingOrigin as h, AnalystFinding as i, AnalystRunResult as l, ProposalFinding as m, AnalystContext as n, AnalystRequirements as o, EvidenceRef as p, AnalystCost as r, AnalystRunEvent as s, Analyst as t, AnalystRunSummary as u, makeProposalFinding as v };
+//# sourceMappingURL=types-DVjczBM9.d.ts.map

package/dist/types-DVjczBM9.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DVjczBM9.d.ts","names":[],"sources":["../src/analyst/types.ts"],"mappings":";;;;;;;;;UA4BiB;EACf;;;;;;;EAOA;EACA;EACA;EACA,UAAU;;;;;;;EAOV;EACA;EACA;EACA,eAAe;EACf;EACA;;EAEA;;;;;;EAMA;;;;EAIA;;EAEA,WAAW;;KAGD;;KAGA;;KAGA,kBAAkB;WACnB,iBAAiB;;UAGX;;;;;;;EAOf;EACA;EACA;;;;;;;;KAWU;UAOK;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;;;;;UAOe;EACf,aAAa;EACb;EACA,YAAY;EACZ,aAAa;;EAEb,SAAS;;UAGM;EACf;;EAEA;;EAEA;;EAEA;;EAEA,aAAa;;EAEb;;;;;;;EAOA,OAAO;;;;;;;;;;EAUP,gBAAgB,cAAc;;;;;;;EAO9B,mBAAmB,cAAc;;;;;EAKjC,eAAe,SAAS;;EAExB,OAAO;;EAEP,OAAO,aAAa,SAAS;;EAE7B,SAAS;;;;;;;;UASM,QAAQ;;WAEd;;WAEA;WACA,WAAW;WACX,MAAM;WACN,WAAW;;WAEX;EACT,QAAQ,OAAO,QAAQ,KAAK,iBAAiB,QAAQ;;;UAItC;;EAEf;;EAEA,QAAQ;;EAER,MAAM;;EAEN;;;;;;;;;;iBAac,iBAAiB;EAC/B;EACA;EACA;EACA;;EAEA;;;;;;iBAyBc,YACd,MAAM,KAAK;EACT;EACA;IAED;;iBAiBa,oBACd,MAAM,KAAK;EACT;EACA;IAED;UAOc;EACf;EACA;;EAEA;EACA;EACA;;EAEA,OAAO;;EAEP;IAAU;IAAe;;;UAGV;EACf;EACA;EACA;EACA;EACA,UAAU;EACV,aAAa;;EAEb;;;;;EAKA,wBAAwB;;;;;;;;;;;;;;;KAkBd;EAEN;EACA;EACA;EACA;;EAEA,aAAa;;EAGb;EACA,SAAS;;EAGT;EACA;EACA;;EAGA;;EAEA,SAAS;EACT,UAAU,cAAc;;EAGxB;EACA,QAAQ"}

package/dist/{types-BokuXvOG.d.ts → types-DiWLru6Z.d.ts}

@@ -1,6 +1,7 @@
 import { S as PaidCallResult, T as RunPaidCallInput, a as CostChannel, c as CostLedgerHandle, f as CostLedgerSummary } from "./cost-ledger-fGS_u_O1.js";
 import { u as RunTokenUsage } from "./run-record-DcObtIGh.js";
 import { n as LlmCallMetadata } from "./llm-client-BiK4HW0u.js";
+import { m as ProposalFinding } from "./types-DVjczBM9.js";
 //#region src/campaign/types.d.ts
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
@@ -239,56 +240,38 @@ interface ScoredSurfaceOutcome {
     scorableCells: number;
   };
 }
-/** Everything a proposer may read to plan the next
- *  batch of candidates. The first six fields are always present; the rest are
- *  optional context the loop supplies when available, so simple proposers can
- *  ignore them while a code-tier agentic generator consumes the report and
- *  dataset.
- *  See `docs/campaign-proposers.md`. */
-interface ProposeContext<TFindings = unknown> {
-  currentSurface: MutableSurface;
-  history: GenerationRecord[];
-  findings: TFindings[];
+/** Search state supplied to one candidate-generation call.
+ *  Final evaluation data is not represented in this contract. */
+interface ProposeContext<TFindings = ProposalFinding> {
+  readonly currentSurface: MutableSurface;
+  readonly history: ReadonlyArray<GenerationRecord>;
+  readonly findings: ReadonlyArray<TFindings>;
   /** BREADTH: how many candidate surfaces to return this generation. */
-  populationSize: number;
-  generation: number;
-  signal: AbortSignal;
+  readonly populationSize: number;
+  readonly generation: number;
+  readonly signal: AbortSignal;
   /** Present when a multi-track lineage requests this proposal. */
-  track?: ProposalTrackContext;
+  readonly track?: ProposalTrackContext;
   /** Measured baseline for this optimization run. `runOptimization` always
    *  supplies it; optional for standalone proposer callers. */
-  baselineOutcome?: ScoredSurfaceOutcome;
+  readonly baselineOutcome?: ScoredSurfaceOutcome;
   /** Measured result for `currentSurface`, the complete global incumbent every
    *  new candidate mutates. `runOptimization` always supplies it. */
-  incumbentOutcome?: ScoredSurfaceOutcome;
-  /** Optional analysis report produced before proposal. Opaque to the substrate:
-   *  the proposer that consumes it owns the shape. */
-  report?: unknown;
-  /** Handle to all captured data — the proposer samples traces / artifacts /
-   *  rewards here to ground its proposals. */
-  dataset?: LabeledScenarioStore;
+  readonly incumbentOutcome?: ScoredSurfaceOutcome;
   /** DEPTH: max iterations the agentic generator may take per candidate.
    *  1 = single-shot; >1 = it may iterate on its own change before handing it
    *  back to be measured. */
-  maxImprovementShots?: number;
+  readonly maxImprovementShots?: number;
   /** GEPA Pareto frontier across ALL generations so far — the non-dominated
    *  surfaces by per-scenario objective vector. Empty/absent on generation 0
    *  (only the baseline is scored). A reflective proposer combines the
    *  complementary lessons of these parents (each excels on different
    *  scenarios) into a merged candidate. Proposers doing pure single-parent
    *  reflection may ignore it. See {@link ParetoParent}. */
-  paretoParents?: ParetoParent[];
+  readonly paretoParents?: ReadonlyArray<ParetoParent>;
   /** Shared run spend account and receipt attribution phase. */
-  costLedger?: CostLedgerHandle;
-  costPhase?: string;
-  /** FIREWALL (non-negotiable): the held-out judge is write-only — its verdicts
-   *  score the chosen output and gate promotion, and are NEVER an input to
-   *  proposal/steering (else the optimizer games the acceptance axis = an
-   *  oracle). This `never`-typed field makes that a compile-time tripwire: a
-   *  proposer that tries to thread judge verdicts into the proposal will not type.
-   *  Steering may consume TRACE-OBSERVABLE signals (what the agent did) via
-   *  `findings`/`report`; it may NOT consume the judge's held-out verdict. */
-  judgeScores?: never;
+  readonly costLedger?: CostLedgerHandle;
+  readonly costPhase?: string;
 }
 /** A surface-improvement strategy. Given the current best
  *  surface, the history of what's been tried + scored, and any external
@@ -302,7 +285,7 @@ interface ProposeContext<TFindings = unknown> {
  *  behavior-fuzzing `MutationProposer` (`fuzz/types`), a scenario generator for
  *  a different loop.
  */
-interface SurfaceProposer<TFindings = unknown> {
+interface SurfaceProposer<TFindings = ProposalFinding> {
   kind: string;
   /** Plan: propose N candidate surfaces for the next generation. A proposer
    *  may return bare `MutableSurface`s or `ProposedCandidate`s that carry the
@@ -312,7 +295,7 @@ interface SurfaceProposer<TFindings = unknown> {
   /** Decide: stop early when the proposer judges the search converged or
    *  exhausted. Default (omitted) runs all `maxGenerations`. */
   decide?(args: {
-    history: GenerationRecord[];
+    history: ReadonlyArray<GenerationRecord>;
   }): {
     stop: boolean;
     reason?: string;
@@ -637,4 +620,4 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
 }
 //#endregion
 export { LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, labelTrustRank as G, SurfaceProposer as H, ProposedCandidate as I, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, GateDecision as _, CampaignResult as a, GenerationRecord as b, CampaignTraceWriter as c, DispatchContext as d, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, GateCheckStatus as m, CampaignArtifactWriter as n, CampaignScenarioIdentity as o, Gate as p, CampaignCellResult as r, CampaignTokenUsage as s, CampaignAggregates as t, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-BokuXvOG.d.ts.map
+//# sourceMappingURL=types-DiWLru6Z.d.ts.map

package/dist/types-DiWLru6Z.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DiWLru6Z.d.ts","names":[],"sources":["../src/campaign/types.ts"],"mappings":"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"}

package/docs/campaign-proposers.md

@@ -407,6 +407,11 @@ Concurrent processes cannot write the same compatible run at the same time.
 
 Use `SurfaceProposer` when your code or runtime owns candidate creation.
 The proposer receives the current surface, prior campaign history, findings, generation number, requested population size, and cancellation signal.
+Every proposal finding must declare `proposal_origin: 'search' | 'production'`.
+`runOptimization()` rejects unclassified findings before it calls the proposer.
+Opaque reports and capture stores are not proposal input.
+Convert analysis into explicit findings or close over a caller-owned knowledge source in your proposer.
+Any caller-owned source must exclude final evaluation cases and results.
 
 ```ts
 import type { SurfaceProposer } from '@tangle-network/agent-eval/campaign'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.133.3",
+  "version": "0.134.0",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {

package/dist/default-registry-Cl3pHo4n.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-registry-Cl3pHo4n.d.ts","names":[],"sources":["../src/analyst/types.ts","../src/analyst/finding-signature.ts","../src/analyst/kind-factory.ts","../src/analyst/registry.ts","../src/analyst/default-registry.ts"],"mappings":"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"}