@tangle-network/agent-eval 0.171.0 → 0.172.0

package/dist/{tool-groups-RGYfVWpc.d.ts → tool-groups-DjwlMBvW.d.ts}

@@ -1,5 +1,5 @@
 import { w as TraceAnalysisStore } from "./types-DMoNFDWi.js";
-import { m as TraceAnalysisToolDescriptor } from "./engine-CAmTUk52.js";
+import { m as TraceAnalysisToolDescriptor } from "./engine-BfRay1qD.js";
 //#region src/analyst/tool-groups.d.ts
 /** Named tool sets. Kinds pass `tools: TRACE_TOOL_GROUPS.failureForensics` etc. */
 type TraceToolGroupName =
@@ -25,4 +25,4 @@ type TraceToolGroupName =
 declare function buildTraceToolsForGroup(group: TraceToolGroupName, store: TraceAnalysisStore): TraceAnalysisToolDescriptor[];
 //#endregion
 export { buildTraceToolsForGroup as n, TraceToolGroupName as t };
-//# sourceMappingURL=tool-groups-RGYfVWpc.d.ts.map
+//# sourceMappingURL=tool-groups-DjwlMBvW.d.ts.map

package/dist/tool-groups-DjwlMBvW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-groups-DjwlMBvW.d.ts","names":[],"sources":["../src/analyst/tool-groups.ts"],"mappings":";;;;KAmBY;;;;;;;;;;;;;;;;;;;;iBAgDI,wBACd,OAAO,oBACP,OAAO,qBACN"}

package/dist/trace-repair/index.d.ts

@@ -2,7 +2,7 @@ import { r as CaptureIntegrityError } from "../errors-DEE6u6ot.js";
 import { b as CustomTokenPricing, c as CostLedgerHandle, p as CostProvenance } from "../cost-ledger-DbQdN3nO.js";
 import { u as RunTokenUsage } from "../run-record-DQjRcYwA.js";
 import { t as DefaultVerdict } from "../verdict-E4eRNf7-.js";
-import { i as TraceAnalystLimits, t as TraceAnalysisEngine } from "../engine-CAmTUk52.js";
+import { i as TraceAnalystLimits, t as TraceAnalysisEngine } from "../engine-BfRay1qD.js";
 import { t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
 import { a as RecordedTrajectoryStep, h as isRecordedTimeout } from "../steps-CiNVJry_.js";
 //#region src/trace-repair/mini-swe-scaffold.d.ts

package/dist/traces.d.ts

@@ -2,10 +2,10 @@ import { c as ValidationError, o as LimitExceededError, r as CaptureIntegrityErr
 import { C as TraceEvent, E as isToolSpan, S as ToolSpan, T as isLlmSpan, _ as Span, a as FAILURE_CLASSES, b as SpanStatus, c as JudgeSpan, d as RetrievalSpan, f as Run, g as SandboxSpan, h as RunStatus, i as EventKind, l as LlmSpan, m as RunOutcome, n as BudgetLedgerEntry, o as FailureClass, p as RunLayer, r as BudgetSpec, s as GenericSpan, t as Artifact, u as Message, v as SpanBase, w as isJudgeSpan, x as TRACE_SCHEMA_VERSION, y as SpanKind } from "./schema-DID1Cqct.js";
 import { a as RunRecord, l as RunTerminalOutcome, s as RunSplitTag, u as RunTokenUsage } from "./run-record-DQjRcYwA.js";
 import { A as SearchSpanResult, B as ViewSpansResult, C as TRACE_ANALYSIS_LIMITS, D as DatasetOverview, E as DEFAULT_TRACE_ANALYST_BUDGETS, F as TraceAnalystFilters, H as ViewTraceResult, I as TraceAnalystSpan, L as TraceAnalystSpanKind, M as SpanMatchRecord, N as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, O as ErrorCluster, P as TraceAnalystByteBudgets, R as TraceAnalystSpanStatus, S as BoundedTraceAnalysisStoreOptions, T as TraceAnalysisStoreContext, V as ViewTraceOversized, j as SearchTraceResult, k as QueryTracesPage, w as TraceAnalysisStore, z as TraceAnalystTraceSummary } from "./types-DMoNFDWi.js";
-import { A as REDACTION_VERSION, B as exportRunAsOtlp, C as scoreTraceInsightReadiness, D as AnalyzeTracesResult, E as AnalyzeTracesOptions, F as OtlpFlatLine, G as ExtractedUsage, H as CaptureFetchOptions, I as OTEL_AGENT_EVAL_SCOPE, J as extractUsageFromResponse, K as SseUsageMode, L as OtlpExport, M as RedactionRule, N as redactString, O as analyzeTraces, P as redactValue, R as OtlpResourceSpans, S as planTraceInsightQuestions, T as AnalyzeTracesInput, U as captureFetchToRawSink, V as CaptureFetchContext, W as ExtractUsageFromSseOptions, X as createBoundedTraceAnalysisStore, Y as extractUsageFromSse, _ as buildTraceInsightPrompt, a as ToolSpansToTraceAnalysisStoreOptions, b as domainEvidencePattern, c as TraceInsightFinding, d as TraceInsightQualityGate, f as TraceInsightQuestion, g as buildTraceInsightContext, h as TraceInsightTask, i as OtlpFileTraceStoreOptions, j as RedactionReport, k as DEFAULT_REDACTION_RULES, l as TraceInsightPanelRole, m as TraceInsightSuite, n as toolSpansToTraceAnalysisStore, o as otlpTextToTraceAnalysisStore, p as TraceInsightReadiness, q as extractUsage, r as OtlpFileTraceStore, s as TraceInsightContext, t as ToolTraceMissingError, u as TraceInsightPromptInput, v as defaultTraceInsightPanel, w as tokenizeDomainWords, x as inferDomainKeywords, y as describeTraceInsightScope, z as OtlpSpan } from "./store-tool-spans-D_qMl2__.js";
+import { A as REDACTION_VERSION, B as exportRunAsOtlp, C as scoreTraceInsightReadiness, D as AnalyzeTracesResult, E as AnalyzeTracesOptions, F as OtlpFlatLine, G as ExtractedUsage, H as CaptureFetchOptions, I as OTEL_AGENT_EVAL_SCOPE, J as extractUsageFromResponse, K as SseUsageMode, L as OtlpExport, M as RedactionRule, N as redactString, O as analyzeTraces, P as redactValue, R as OtlpResourceSpans, S as planTraceInsightQuestions, T as AnalyzeTracesInput, U as captureFetchToRawSink, V as CaptureFetchContext, W as ExtractUsageFromSseOptions, X as createBoundedTraceAnalysisStore, Y as extractUsageFromSse, _ as buildTraceInsightPrompt, a as ToolSpansToTraceAnalysisStoreOptions, b as domainEvidencePattern, c as TraceInsightFinding, d as TraceInsightQualityGate, f as TraceInsightQuestion, g as buildTraceInsightContext, h as TraceInsightTask, i as OtlpFileTraceStoreOptions, j as RedactionReport, k as DEFAULT_REDACTION_RULES, l as TraceInsightPanelRole, m as TraceInsightSuite, n as toolSpansToTraceAnalysisStore, o as otlpTextToTraceAnalysisStore, p as TraceInsightReadiness, q as extractUsage, r as OtlpFileTraceStore, s as TraceInsightContext, t as ToolTraceMissingError, u as TraceInsightPromptInput, v as defaultTraceInsightPanel, w as tokenizeDomainWords, x as inferDomainKeywords, y as describeTraceInsightScope, z as OtlpSpan } from "./store-tool-spans-BvdUbeOB.js";
 import { a as NoopRawProviderSink, c as RawProviderEvent, d as defaultProviderRedactor, f as providerFromBaseUrl, i as InMemoryRawProviderSinkOptions, l as RawProviderSink, n as FileSystemRawProviderSinkOptions, o as ProviderRedactor, r as InMemoryRawProviderSink, s as RawProviderDirection, t as FileSystemRawProviderSink, u as RawProviderSinkFilter } from "./raw-provider-sink-BU29Sh8h.js";
 import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o as SpanFilter, r as FileSystemTraceStoreOptions, s as TraceStore, t as EventFilter } from "./store-Cq9oOrI1.js";
-import { f as BuildTraceAnalysisToolsOptions, g as traceAnalystFunctionGroup, h as buildTraceAnalysisToolDescriptors, m as TraceAnalysisToolDescriptor, p as TRACE_ANALYST_TOOL_NAMESPACE } from "./engine-CAmTUk52.js";
+import { f as BuildTraceAnalysisToolsOptions, g as traceAnalystFunctionGroup, h as buildTraceAnalysisToolDescriptors, m as TraceAnalysisToolDescriptor, p as TRACE_ANALYST_TOOL_NAMESPACE } from "./engine-BfRay1qD.js";
 import { a as TraceEmitterOptions, i as TraceEmitter, n as RunCompleteHookContext, r as SpanHandle, t as RunCompleteHook } from "./emitter-Bvnu0VzL.js";
 import { C as TOOL_LATENCY_MS, D as asNumber, E as applyLlmSpanOtlpAttributes, O as contextInputTokens, S as TOOL_ARGS_CAPTURED, T as TOOL_NAME_ATTR_KEYS, _ as LlmSpanOtlpInput, a as LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, b as RUN_COST_ATTR_KEYS, c as LLM_COST_USD, d as LLM_MODEL_ATTR_KEYS, f as LLM_MODEL_NAME, g as LLM_REASONING_TOKEN_ATTR_KEYS, h as LLM_REASONING_TOKENS, i as LLM_CACHE_WRITE_TOKENS, k as firstNumberAttr, l as LLM_INPUT_TOKENS, m as LLM_OUTPUT_TOKEN_ATTR_KEYS, n as LLM_CACHED_TOKENS, o as LLM_CONTEXT_TOKENS, p as LLM_OUTPUT_TOKENS, r as LLM_CACHED_TOKEN_ATTR_KEYS, s as LLM_COST_ATTR_KEYS, t as INPUT_VALUE, u as LLM_INPUT_TOKEN_ATTR_KEYS, v as OPENINFERENCE_SPAN_KIND, w as TOOL_NAME, x as SPAN_KIND_ATTR_KEYS, y as OUTPUT_VALUE } from "./attribute-vocabulary-DLJ6303h.js";
 import { a as RunIntegrityReport, i as RunIntegrityIssueCode, n as RunIntegrityExpectations, o as assertRunCaptured, r as RunIntegrityIssue, s as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-B_EDELom.js";

package/dist/{types-CMyW4GnH.d.ts → types-CCZ34qmV.d.ts}

@@ -1,5 +1,5 @@
 import { s as RunSplitTag } from "./run-record-DQjRcYwA.js";
-import { R as Scenario, d as DispatchContext } from "./types-JHMOqZI4.js";
+import { R as Scenario, d as DispatchContext } from "./types-nokrtr7M.js";
 //#region src/benchmarks/types.d.ts
 type BenchmarkTaskKind = 'retrieval' | 'rag-answer' | 'hallucination' | 'kb-improvement' | 'routing' | 'custom';
 type BenchmarkFamily = 'beir' | 'mteb-retrieval' | 'msmarco' | 'trec-dl' | 'miracl' | 'lotte' | 'bright' | 'crag' | 'hotpotqa' | 'kilt' | 'ragtruth' | 'faithbench' | 'first-party' | 'custom';
@@ -90,4 +90,4 @@ declare const BENCHMARK_SPLIT_SEED = "agent-eval-v1";
 declare function deterministicSplit(itemId: string, seed?: string): RunSplitTag;
 //#endregion
 export { BenchmarkFamily as a, BenchmarkSource as c, BenchmarkEvaluation as i, BenchmarkTaskKind as l, BenchmarkAdapter as n, BenchmarkResponder as o, BenchmarkDatasetItem as r, BenchmarkScenario as s, BENCHMARK_SPLIT_SEED as t, deterministicSplit as u };
-//# sourceMappingURL=types-CMyW4GnH.d.ts.map
+//# sourceMappingURL=types-CCZ34qmV.d.ts.map

package/dist/{types-CMyW4GnH.d.ts.map → types-CCZ34qmV.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-CMyW4GnH.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;EACA;EACA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}
+{"version":3,"file":"types-CCZ34qmV.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;EACA;EACA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}

package/dist/{types-DeIUdzNd.d.ts → types-CoPUTiXb.d.ts}

@@ -1,91 +1,5 @@
+import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
 import { m as RolloutLine } from "./schema-BzWDXhOR.js";
-//#region src/statistics/descriptive.d.ts
-/**
- * Descriptive statistics: means, bootstrap spread, correlation, and the
- * weighted judge-dimension composite. Nothing here is a significance test.
- */
-/** Weighted mean — falls back to uniform weights when omitted */
-declare function weightedMean(scores: {
-  score: number;
-  weight?: number;
-}[]): number;
-/**
- * Percentile bootstrap confidence interval on the mean of `scores`.
- *
- * Descriptive spread. It is not a significance test, and at small n its bounds
- * are anti-conservative in the same way {@link pairedBootstrap}'s are — see
- * {@link BOOTSTRAP_GATE_MIN_N}. With no `seed` the resampling is seeded from
- * the scores themselves, so the interval is reproducible either way.
- */
-declare function confidenceInterval(scores: number[], confidence?: number, opts?: {
-  seed?: number;
-  resamples?: number;
-}): {
-  mean: number;
-  lower: number;
-  upper: number;
-};
-/** Partial credit: returns 0-1 ratio of current toward target */
-declare function partialCredit(current: number, target: number): number;
-/** Distribution summary of a number series: count, extremes, quantiles, sum. */
-interface SeriesDistribution {
-  readonly n: number;
-  readonly min: number;
-  readonly p50: number;
-  readonly p90: number;
-  readonly max: number;
-  readonly sum: number;
-}
-/**
- * Fold a number series into its distribution summary. Quantiles use the
- * nearest-rank definition — the `ceil(q·n)`-th order statistic — so every
- * reported quantile is a value from the series. Returns `null` for an empty
- * series: an empty series has no distribution, and a zero-filled summary
- * would read as a measured all-zero series.
- */
-declare function summarizeNumberSeries(values: readonly number[]): SeriesDistribution | null;
-/**
- * Average-rank-with-ties transform (1-indexed). Tied values receive the mean
- * of the ranks they span, the standard correction for Spearman's ρ.
- */
-declare function ranks(xs: number[]): number[];
-/**
- * Pearson product-moment correlation coefficient r ∈ [-1, 1] between two
- * equal-length series. See the edge-case contract above: NaN for n < 2 or
- * unequal lengths, 1 when both series are constant, 0 when exactly one is.
- */
-declare function pearsonR(a: number[], b: number[]): number;
-/**
- * Spearman's rank correlation ρ — Pearson over the average-rank-with-ties
- * transform of each series. Same edge-case contract as {@link pearsonR}.
- */
-declare function spearmanR(a: number[], b: number[]): number;
-interface WeightedCompositeInput {
-  /** Per-dimension scores (typically 0..1). */
-  dims: Record<string, number>;
-  /** Weight per dimension. Every weighted dimension MUST be present in
-   *  `dims` — a weight for an absent dimension is a config error and throws,
-   *  because silently dropping it would renormalise the composite onto a
-   *  different denominator than intended. */
-  weights: Record<string, number>;
-  /** Optional pass threshold; when set, the result reports `pass`. */
-  threshold?: number;
-}
-interface WeightedCompositeResult {
-  composite: number;
-  pass?: boolean;
-}
-/**
- * Weighted composite over judge dimensions: `Σ(score_d · w_d) / Σ(w_d)` across
- * the weighted dimensions. The canonical replacement for the per-consumer
- * hand-rolled composite math (tax/legal/creative/gtm each ship a copy).
- *
- * Fail-loud: throws if a weighted dimension is missing from `dims`, if any
- * weight is negative, or if the weights sum to 0 — none of which can produce
- * a meaningful composite.
- */
-declare function weightedComposite(input: WeightedCompositeInput): WeightedCompositeResult;
-//#endregion
 //#region src/supervisor-run/types.d.ts
 /** A metric that could not be computed, with the reason its artifact was missing. */
 interface Unavailable {
@@ -300,7 +214,12 @@ interface OrchestrationMetrics {
 interface DecisionMetrics {
   readonly settledByStatus: Measured<Record<string, number>>;
   readonly settledVerdicts: Measured<Record<string, number>>;
-  /** Worker verified its own work green AND produced a patch. */
+  /**
+   * Workers whose recorded verdict was green. A store that retains a delivered patch also
+   * requires patch bytes; a store that retains none accepts the verdict alone, because the
+   * verdict IS the acceptance decision that store recorded. `emptyPass` — the split that
+   * needs patch bytes — is what reads unavailable there.
+   */
   readonly accepted: Measured<number>;
   /** Worker settled with a failing verify. */
   readonly rejected: Measured<number>;
@@ -364,6 +283,17 @@ interface SpendMeasurement {
   readonly usd: Measured<number>;
   /** Source records folded into `usd`; 0 when the measurement is unavailable. */
   readonly records: number;
+  /**
+   * Records the store wrote with `usdKnown: false` — work that HAPPENED at a price the
+   * provider never reported. Those records are NOT folded into `usd`, so a run with any
+   * of them has a `usd` that is a floor on real spend, never the measured total. Dropping
+   * the whole channel instead would discard the records that DID carry a price.
+   */
+  readonly unknownRecords: number;
+  /** True exactly when `unknownRecords > 0`: `usd` covers some of the run, not all of it. */
+  readonly partial: boolean;
+  /** Node ids behind `unknownRecords`, in journal order. Empty when none. */
+  readonly unknownNodes: readonly string[];
 }
 /**
  * The run's total inference spend, measured two ways.
@@ -399,8 +329,9 @@ interface EconomicsMetrics {
   /**
    * One collapsed number kept for existing consumers: the close record when
    * the store wrote one, else the journal-derived sum. `totalUsdSource` names
-   * the pick. Prefer `spend` — the collapse hides which accounting question
-   * the number answers.
+   * the pick, and says so when the number is a partial floor because some
+   * records carried `usdKnown: false`. Prefer `spend` — the collapse hides
+   * which accounting question the number answers and how much of it is priced.
    */
   readonly totalUsd: Measured<number>;
   /**
@@ -518,5 +449,5 @@ interface SupervisorRunTreeGap {
   readonly count?: number;
 }
 //#endregion
-export { unavailable as A, weightedComposite as B, SupervisorRunTreeGap as C, WorkerLogSource as D, WallDistribution as E, partialCredit as F, pearsonR as I, ranks as L, WeightedCompositeInput as M, WeightedCompositeResult as N, isUnavailable as O, confidenceInterval as P, spearmanR as R, SupervisorRunTree as S, Unavailable as T, weightedMean as V, SupervisorRunNodeRole as _, OrchestrationMetrics as a, SupervisorRunRollup as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SteerBreakdown as g, SpendMeasurements as h, NO_SOURCE_LIMITS as i, SeriesDistribution as j, showMeasured as k, RoleSpend as l, SpendMeasurement as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunReader as v, SupervisorRunTreeGapCode as w, SupervisorRunSources as x, SupervisorRunReport as y, summarizeNumberSeries as z };
-//# sourceMappingURL=types-DeIUdzNd.d.ts.map
+export { unavailable as A, SupervisorRunTreeGap as C, WorkerLogSource as D, WallDistribution as E, isUnavailable as O, SupervisorRunTree as S, Unavailable as T, SupervisorRunNodeRole as _, OrchestrationMetrics as a, SupervisorRunRollup as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SteerBreakdown as g, SpendMeasurements as h, NO_SOURCE_LIMITS as i, showMeasured as k, RoleSpend as l, SpendMeasurement as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunReader as v, SupervisorRunTreeGapCode as w, SupervisorRunSources as x, SupervisorRunReport as y };
+//# sourceMappingURL=types-CoPUTiXb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-CoPUTiXb.d.ts","names":[],"sources":["../src/supervisor-run/types.ts"],"mappings":";;;;UAkCiB;WACN;;;KAIC,SAAS,KAAK,IAAI;iBAEd,YAAY,iBAAiB;iBAI7B,cAAc,aAAa,KAAK;;iBAKhC,aAAa,GAAG;;KAWpB;;;;;UAMK;;;;;WAKN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;;;;;;;;;;;;;UAcM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;cAIE,kBAAkB;;;;;;;;;;UAiBd;;WAEN;WACA;;WAEA;;WAEA;;;;;;WAMA;;;;;;WAMA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,kBAAkB;;WAElB;;WAEA;;;;;;;WAOA;;WAEA;;WAEA;;WAEA;;;;;WAKA;IACP;IACA;IACA;IACA;;IAEA;IACA;;WAEO;;WAEA,QAAQ;;;;;;WAMR;;;;;WAKA;;;;;;UAOM;;WAEN;EACT,QAAQ,QAAQ;;cAOL;cACA;UAEI;;WAEN;WACA;;WAEA;;WAEA;;UAGM;WACN,gBAAgB;WAChB,gBAAgB;WAChB,kBAAkB;;WAElB,QAAQ;WACR,iBAAiB;WACjB,gBAAgB,kBAAkB;;WAElC,kBAAkB;;;;;;WAMlB,OAAO;WACP,WAAW;WACX,gBAAgB;;WAEhB,UAAU;;WAEV,gBAAgB;;WAEhB,iBAAiB;WACjB,oBAAoB;WACpB,kBAAkB;;;;;;;;;WASlB,sBAAsB;;WAEtB,QAAQ;WACR,SAAS;;WAET,mBAAmB;;UAGb;WACN,iBAAiB,SAAS;WAC1B,iBAAiB,SAAS;;;;;;;WAO1B,UAAU;;WAEV,UAAU;;WAEV,WAAW;;WAEX,oBAAoB;;WAEpB,wBAAwB;;WAExB,eAAe;WACf,qBAAqB;;UAGf;WACN,UAAU;WACV,WAAW;;;;;;WAMX,WAAW;WACX,YAAY;WACZ,KAAK;WACL;;UAGM;;WAEN;WACA;;WAEA,MAAM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;WACA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;KAQC,mBAAmB;;UAGd;WACN,KAAK;;WAEL;;;;;;;WAOA;;WAEA;;WAEA;;;;;;;;;;;;;;UAeM;WACN,gBAAgB;WAChB,aAAa;;UAGP;;WAEN,OAAO;;;;;;;;WAQP,kBAAkB;;WAElB,SAAS;;WAET,OAAO;;;;;;;;WAQP,UAAU;;;;;;WAMV;WACA,yBAAyB;WACzB,0BAA0B,SAAS;WACnC,WAAW,kBAAkB;;UAGvB;WACN;WACA;WACA;WACA;;UAGM;WACN,WAAW;WACX,YAAY;WACZ,WAAW;WACX,eAAe;WACf,YAAY;WACZ,aAAa;WACb,YAAY;WACZ,YAAY;WACZ,UAAU;WACV,OAAO,SAAS;;WAEhB;;UAGM;WACN,eAAe;;WAEf;WACA;WACA;WACA,cAAc;WACd,yBAAyB;WACzB;WACA,eAAe;WACf,UAAU;WACV,WAAW;WACX,SAAS;;WAET;;WAEA;;UAGM;WACN;WACA;WACA,QAAQ;WACR,OAAO;WACP,aAAa;WACb,SAAS;WACT,UAAU;WACV,KAAK;;UAGC;WACN,eAAe;WACf;WACA,aAAa;WACb,iBAAiB;WACjB;WACA,WAAW;WACX,mBAAmB;WACnB,iBAAiB;WACjB,aAAa;WACb,qBAAqB;WACrB,eAAe;;;;;WAKf,UAAU;;;;;;;WAOV;aACE;eAA2B,OAAO;eAA2B;;aAC7D;eAAwB,OAAO;eAA2B;;;WAE5D,eAAe;WACf,kBAAkB;;;;;;;;UASZ;WACN;WACA,gBAAgB;;WAEhB,eAAe;;;KAId;UASK;WACN,MAAM;WACN;WACA;WACA"}

package/dist/{types-JHMOqZI4.d.ts → types-nokrtr7M.d.ts}

@@ -2,6 +2,7 @@ import { S as PaidCallResult, T as RunPaidCallInput, a as CostChannel, c as Cost
 import { u as RunTokenUsage } from "./run-record-DQjRcYwA.js";
 import { _ as ProposalFinding } from "./types-DMoNFDWi.js";
 import { C as LlmCallMetadata } from "./types-Bfk0uxRj.js";
+import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
 //#region src/campaign/types.d.ts
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
@@ -542,11 +543,20 @@ interface JudgeAggregate {
   stdev: number;
   ci95: [number, number];
   n: number;
+  /** Order statistics over the exact scores `mean` was taken over, from the
+   *  package's one distribution summary (`summarizeNumberSeries`). A mean and
+   *  a CI alone cannot separate a bimodal judge from a tight one, and cannot
+   *  show the outlier that carried the mean. Never null here: an aggregate is
+   *  only recorded for a judge that produced at least one score. */
+  distribution: SeriesDistribution;
 }
 interface ScenarioAggregate {
   meanComposite: number;
   ci95: [number, number];
   n: number;
+  /** Order statistics over the per-cell composites this scenario produced.
+   *  Same type and same contract as {@link JudgeAggregate.distribution}. */
+  distribution: SeriesDistribution;
 }
 interface GenerationRecord {
   generationIndex: number;
@@ -660,4 +670,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-JHMOqZI4.d.ts.map
+//# sourceMappingURL=types-nokrtr7M.d.ts.map

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

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

package/docs/eval-surface-map.md

@@ -43,6 +43,42 @@ is `runCampaign` with capture inverted; `runAgentMatrix` is the scheduler undern
 Merging any two of these conflates distinct mental models (measure ≠ search ≠
 release-gate). Keep them separate; pick by the table.
 
+## What a campaign result reports: the mean and the spread
+
+`CampaignResult.aggregates` carries two maps.
+`byJudge` holds one `JudgeAggregate` per judge that produced at least one score.
+`byScenario` holds one `ScenarioAggregate` per scenario that produced at least one composite.
+
+Each aggregate reports a mean, a seeded bootstrap `ci95` band, `n`, and a `distribution`.
+`distribution` is the `SeriesDistribution` value `summarizeNumberSeries` returns: `n`, `min`, `p50`, `p90`, `max`, and `sum` over the exact scores the mean was taken over.
+Quantiles use the nearest-rank definition, so every reported quantile is a score the campaign measured.
+
+Read the distribution before you read the mean.
+A mean and an interval alone cannot separate a bimodal judge from a tight one, and cannot show the outlier that carried the mean.
+Six cells scoring `0, 0, 0, 1, 1, 1` and six cells scoring `0.5` report the same mean; only `min` and `max` tell them apart.
+
+A judge that produced no score has no entry at all.
+An absent aggregate is the honest record of an unmeasured judge, and a zero-filled distribution would read as a measured all-zero series.
+
+`SeriesDistribution` is the one distribution summary in this package.
+It is not the `ScalarDistribution` the insight report uses; see `insight-report.md` for why those two shapes stay separate.
+
+## Planning the cell grid without a run directory
+
+`buildCellSchedule(scenarios, seed, reps)` returns the `(scenario × rep)` fan-out: one `CellScheduleSlot` per cell, with its `cellId` and its per-cell seed.
+It touches no filesystem, so a caller can size a design, or assert a design's cell count and seeds in a test, before a run directory exists.
+Scenarios that share a `seedGroup` receive the same per-replicate seeds, which is what makes a paired comparison see common randomness.
+
+Use `planCampaignRun` instead when you also need the cached, to-run, and blocked classification; that call needs a real run directory because it reads the durable cache.
+`cellDirectory` and `cellCachePath` name a cell's location once a run directory is chosen.
+
+## Evidence receipts: `attest`
+
+`attest(report, provenance)` content-addresses any serializable report and binds that address to the provenance needed to reproduce it: model versions, seeds, price-table hash, code SHA, and inputs hash.
+`verifyAttestation(report, attested)` returns a typed outcome rather than throwing, so a pipeline records why a report failed to verify instead of dying.
+`ATTESTATION_ALGORITHM` is the hash-scheme tag every attestation carries, and a verifier rejects an unknown algorithm instead of guessing.
+Signing stays with the consumer: an `AttestedReport` is a stable byte-identical payload to sign, and this package never holds keys.
+
 ## Failed cells: receipts and bounded retry
 
 A failed cell writes `<cell>/failure-receipt.json` before the campaign can abort.

package/docs/insight-report.md

@@ -148,6 +148,25 @@ When a measured mean is below 0.5, inspect the lowest-scoring runs before tuning
 
 **Use the histogram for:** finding bimodal failure modes. A bin with `count > 0` near zero and another > 0 near 1 means your agent has two distinct behaviors, not one noisy one.
 
+### Why this is not the same shape as a campaign aggregate
+
+This report uses `ScalarDistribution`.
+A campaign aggregate (`CampaignResult.aggregates`) uses `SeriesDistribution`, the value `summarizeNumberSeries` returns.
+The two shapes stay separate for three reasons, and none of them is an accident of history.
+
+1. `ScalarDistribution` is a wire contract.
+   `ScalarDistributionSchema` in `src/hosted/schemas.ts:45` is a strict Zod object.
+   It is embedded in `InsightReportSchema`, which is embedded in `EvalRunEventSchema`, which the hosted client validates every event against before it ships (`src/hosted/client.ts:182`).
+   A strict object rejects an unknown key, so adding or renaming a field breaks every event a consumer already sends.
+2. `ScalarDistribution` reports what a report needs and a series summary does not have: a histogram, the worst-N `tailRuns` by score, `p95` for a latency question, and `mean` plus `stddev` beside the order statistics.
+   `SeriesDistribution` is the in-memory summary of a plain number series with no run identity attached.
+3. The two answer at different `n = 0` boundaries.
+   `ScalarDistribution` represents an empty series as `n: 0` with every field `null`, because a report always has a slot for a metric it did not measure.
+   `summarizeNumberSeries` returns `null` for an empty series, because there is no distribution to report and a zero-filled summary would read as a measured all-zero series.
+
+Both refuse to encode a missing measurement as a zero.
+That is the shared rule; the shapes differ because the surfaces differ.
+
 ---
 
 ## `costQuality`: cost-vs-quality Pareto

package/docs/plants.md

@@ -0,0 +1,123 @@
+# Plants: does the grader catch a wrong answer?
+
+A grading run reports how the work scored.
+It cannot report whether the grader would have noticed a wrong answer, because every item it saw was authored in good faith.
+A plant closes that hole.
+A plant is an item authored wrong by construction, mixed into the live grading set, graded by the same path as everything else.
+The share of plants the grader refused is the **catch rate**.
+
+The measured motive: a sibling lab ran a deliverable gate that accepted any non-empty submission.
+It produced six false certifications in seventeen deliveries.
+No agent lied — the gate never asked a question the format could fail.
+A catch rate is the number that would have shown it on the first day.
+
+Everything below lives in `src/meta-eval/plants.ts` and is published from `@tangle-network/agent-eval/meta-eval`.
+
+## Three calls
+
+```ts
+import { catchRate, definePlant, seedPlants } from '@tangle-network/agent-eval/meta-eval'
+
+const plants = [
+  definePlant({
+    id: 'plant-throughput',
+    kind: 'wrong-value',
+    item: { itemId: 'claim-118', humanScore: 0 },
+    expectedVerdict: 'reject',
+  }),
+]
+
+const { items, manifest } = seedPlants(dataset, plants, { seed: 7, acceptThreshold: 0.5 })
+
+// Publish manifest.seal now. Keep `manifest` itself out of the graded workspace.
+const results = await grade(items.map((item) => item.itemId))
+
+const report = catchRate(results, manifest)
+```
+
+`report` is a `CatchRateReport`:
+
+| Field | Meaning |
+| --- | --- |
+| `status` | `evaluated`, `incomplete`, or `not_evaluated`. Only `evaluated` carries a rate. |
+| `reason` | Why the status is not `evaluated`. Absent when it is. |
+| `seeded` / `caught` / `missed` | Plants armed, graded as the seed demands, and graded against it. |
+| `indecisive` | The grader answered and declined to decide. Counted apart, in neither side of `rate`. |
+| `rate` | `caught / (caught + missed)`, or `null`. |
+| `byKind` | The same counts per plant kind. A kind nobody seeded is absent, never zero. |
+| `missedIds` | Every plant id the grader got wrong, by name. |
+| `missingIds` | Every plant id with no result at all. |
+| `unseeded` | How the same grader treated the rest of the set. |
+
+## What each call composes
+
+Plants add no parallel calibration machinery.
+Each piece is an existing primitive doing its own job.
+
+| Piece | Primitive it reuses |
+| --- | --- |
+| The seeded item | `GoldenItem` (`src/judge-calibration.ts`). Its `humanScore` is the grade a working grader owes the item, so the mixed set feeds `calibrateJudge` unchanged. |
+| The grader's output | `CandidateScore[]`, the array `calibrateJudge` and `snapshotFromSentinelSet` already read. A `PlantOutcome` is that shape with `score: null` added for "ran, declined to decide". |
+| "Caught" | The join in `snapshotFromSentinelSet` (`src/meta-eval/sentinel.ts`) with the labels inverted: the grade lands on the side of `acceptThreshold` the seed demands. |
+| The seal | `hashCanonical` (`src/ledger-core/canonical.ts`), the RFC 8785 digest the sealed-experiment path uses. |
+| The mix order | `mulberry32` (`src/statistics/random.ts`), the package's one seedable generator. |
+
+`src/canary.ts` is deliberately not this.
+Its three detectors — silent judge fallback, calibration drift, distribution shift — all watch the judge's own statistics.
+None injects an item the judge can fail.
+
+## The four kinds
+
+`kind` records how the item was authored wrong.
+It changes nothing about how the item is graded; it exists so `byKind` can show which defect a grader is blind to.
+
+| Kind | Authored by |
+| --- | --- |
+| `wrong-value` | Altering one load-bearing value: a number off by one, a comparison flipped. |
+| `self-certifying` | Giving the item a check that passes without testing the claim. |
+| `unreachable-input` | Pointing the check at an input that does not exist, so it cannot run at all. |
+| `duplicate` | Copying an item already in the set, which is owed a duplicate flag rather than a second grade. |
+
+## Blindness has two halves
+
+This module owns one half.
+It never puts a plant flag on a graded item: `seedPlants` returns the mixed set and a manifest, and only the manifest knows which ids are seeded.
+Every item in `items` carries the same two fields, so nothing a grader receives says which are plants.
+
+The caller owns the other half, and it is the half that decides whether the measurement means anything.
+
+- Keep the manifest out of the workspace the graded agents can read.
+  A truth label inside that tree is readable by the thing being measured.
+- Publish `manifest.seal` **before** the grading run.
+  A manifest edited afterwards to match the results no longer hashes to its seal, and `catchRate` refuses it with a `CaptureIntegrityError`.
+- Write the plant tag into a record only after the verdict is decided, so the tag cannot reach the verdict path.
+
+## What refuses, and why
+
+A catch rate that cannot refuse is not a measurement.
+
+| Condition | Result |
+| --- | --- |
+| A seeded plant has no result | `status: 'incomplete'`, `rate: null`, `missingIds` names them. A rate over the results that happened to come back is the number a broken run reports as success. |
+| Zero plants were seeded | `status: 'not_evaluated'`, `rate: null`. Never 1.0: a grader asked nothing it could fail did not score perfectly. |
+| Every seeded plant is indecisive | `status: 'not_evaluated'`, `rate: null`. No check tested the seeded defect, so nothing was measured. |
+| The manifest no longer matches its seal | `CaptureIntegrityError`. |
+| A result names an id the manifest never handed out, or repeats one | `ValidationError`. The results and the manifest describe different runs, and a rate across two runs is a fabrication. |
+| A plant record's `expectedVerdict` disagrees with its `humanScore` | `ValidationError` at `definePlant`. The same item would read as wrong here and as correct to every instrument that joins on the id. |
+
+## Reading the number
+
+`rate` alone can be gamed by a grader that refuses everything: it catches every reject-plant and scores 1.0.
+`unseeded` is where that shows.
+It reports how the same grader treated the items that were not seeded — `n`, `decided`, `rejected`, and `rejectionRate` — using no labels at all.
+
+- Catch rate 1.0 with `unseeded.rejectionRate` near 1.0 is a refusal reflex, not discrimination.
+- Catch rate 1.0 with `unseeded.rejectionRate` near 0 is a grader that separates the two classes.
+
+The stronger form is to seed both directions.
+A plant with `expectedVerdict: 'accept'` is a known-good item authored the same way, and a grader that refuses it is scored as a miss exactly like one that certifies a known-wrong item.
+
+## Related
+
+- [`docs/verdicts.md`](./verdicts.md) — where every verifier in this package lands its result.
+- [`docs/verification-strategies.md`](./verification-strategies.md) — certifying work that has no answer key at all.