@tangle-network/agent-eval 0.150.1 → 0.161.0

package/dist/{types-B2NsbrNy.d.ts → types-D9ssmxKL.d.ts}

@@ -1,6 +1,6 @@
 import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
-import { a as RunRecord, n as RunCostProvenance, u as RunTokenUsage } from "./run-record-DVV82Gwh.js";
-import { a as JudgeInput, p as ChatClient } from "./types-jUBXJ7Iz.js";
+import { a as RunRecord, n as RunCostProvenance, u as RunTokenUsage } from "./run-record-VVy4T9OW.js";
+import { a as JudgeInput, p as ChatClient } from "./types-Bfk0uxRj.js";
 import { RE2JS } from "re2js";
 //#region src/trace-analyst/types.d.ts
 /**
@@ -594,4 +594,4 @@ type AnalystRunEvent = {
 };
 //#endregion
 export { SearchSpanResult as A, ViewSpansResult as B, TRACE_ANALYSIS_LIMITS as C, DatasetOverview as D, DEFAULT_TRACE_ANALYST_BUDGETS as E, TraceAnalystFilters as F, ViewTraceResult as H, TraceAnalystSpan as I, TraceAnalystSpanKind as L, SpanMatchRecord as M, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as N, ErrorCluster as O, TraceAnalystByteBudgets as P, TraceAnalystSpanStatus as R, BoundedTraceAnalysisStoreOptions as S, TraceAnalysisStoreContext as T, ViewTraceOversized as V, ProposalFinding as _, AnalystInputKind as a, makeFinding as b, AnalystRunInputs as c, AnalystSeverity as d, AnalystUsageReceipt as f, ExecutionProbeRequest as g, ExecutionProbeOutcome as h, AnalystFinding as i, SearchTraceResult as j, QueryTracesPage as k, AnalystRunResult as l, ExecutionProbe as m, AnalystContext as n, AnalystRequirements as o, EvidenceRef as p, AnalystCost as r, AnalystRunEvent as s, Analyst as t, AnalystRunSummary as u, ProposalFindingOrigin as v, TraceAnalysisStore as w, makeProposalFinding as x, computeFindingId as y, TraceAnalystTraceSummary as z };
-//# sourceMappingURL=types-B2NsbrNy.d.ts.map
+//# sourceMappingURL=types-D9ssmxKL.d.ts.map

package/dist/{types-B2NsbrNy.d.ts.map → types-D9ssmxKL.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-B2NsbrNy.d.ts","names":[],"sources":["../src/trace-analyst/types.ts","../src/trace-analyst/store-contract.ts","../src/analyst/types.ts"],"mappings":"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"}
+{"version":3,"file":"types-D9ssmxKL.d.ts","names":[],"sources":["../src/trace-analyst/types.ts","../src/trace-analyst/store-contract.ts","../src/analyst/types.ts"],"mappings":"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"}

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

@@ -1,4 +1,91 @@
-import { h as RolloutLine } from "./schema-Cef2cFmb.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 {
@@ -88,6 +175,12 @@ interface SupervisorRunSources {
    * settled `verdict` may be a legacy string or `{ valid, score, ... }`.
    */
   readonly journal: string | null;
+  /**
+   * Source-specific reason `journal` is null. The analyzer uses it verbatim as
+   * the `unavailable` reason on every journal-dependent metric, so a non-loops
+   * layout names its own journal file instead of inheriting the loops paths.
+   */
+  readonly journalMissingReason?: string;
   /** Per-brain-call tap (JSONL): finish_reason, completion tokens, requested max tokens. */
   readonly brainLog: string | null;
   /** Source-specific reason `brainLog` is absent. */
@@ -189,6 +282,15 @@ interface OrchestrationMetrics {
   readonly delegationDepth: Measured<number>;
   readonly timeToFirstSpawnMs: Measured<number>;
   readonly supervisorWallMs: Measured<number>;
+  /**
+   * Which measurement `supervisorWallMs` holds — never a silent substitution.
+   * `stamps`: explicit start and completion stamps. `journal-span`: the start
+   * stamp (or first stamped event) to the last stamped journal event — a
+   * lower bound, derived when the store wrote no completion stamp. `idleMs`,
+   * `idlePct`, and `workerUtilization` cover the same span. Unavailable
+   * exactly when `supervisorWallMs` is, with the same reason.
+   */
+  readonly supervisorWallSource: Measured<'stamps' | 'journal-span'>;
   /** Wall time inside the supervisor run with ZERO live workers. */
   readonly idleMs: Measured<number>;
   readonly idlePct: Measured<number>;
@@ -251,13 +353,33 @@ interface PerWorkerRow {
   /** Numeric verdict score exactly as recorded; null means no score was recorded. */
   readonly score: number | null;
 }
-interface WallDistribution {
-  readonly n: number;
-  readonly min: number;
-  readonly p50: number;
-  readonly p90: number;
-  readonly max: number;
-  readonly sum: number;
+/**
+ * `SeriesDistribution` (from `../statistics`) over per-worker wall
+ * milliseconds. The fold itself is `summarizeNumberSeries`, exported for any
+ * series — fleet wall medians, tokens-per-claim spreads — not only wall.
+ */
+type WallDistribution = SeriesDistribution;
+/** One spend measurement and the number of source records behind it. */
+interface SpendMeasurement {
+  readonly usd: Measured<number>;
+  /** Source records folded into `usd`; 0 when the measurement is unavailable. */
+  readonly records: number;
+}
+/**
+ * The run's total inference spend, measured two ways.
+ *
+ * `closeRecord` is the spend the store recorded as settled when the run
+ * closed (loops `state.json` `result.spentUsd`; Runtime `result.json`
+ * `spentTotal.usd`) — the billing-shaped answer. `journalDerived` is the
+ * spend execution observably consumed (journal `metered` + `settled` rows) —
+ * the execution-accounting answer. Neither is canonical for the other's
+ * question. The two cover different records at different moments, so
+ * divergence between them is itself a signal (a dropped settlement, a
+ * double meter, spend after the close) — read it, never average it away.
+ */
+interface SpendMeasurements {
+  readonly journalDerived: SpendMeasurement;
+  readonly closeRecord: SpendMeasurement;
 }
 interface EconomicsMetrics {
   /** Driver/brain inference — journal `metered` events. */
@@ -272,6 +394,14 @@ interface EconomicsMetrics {
   readonly brainTruncations: Measured<number>;
   /** Worker inference — journal `settled` spend plus the harness session join. */
   readonly workers: RoleSpend;
+  /** Both total-spend measurements, each with its own record count. */
+  readonly spend: SpendMeasurements;
+  /**
+   * 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.
+   */
   readonly totalUsd: Measured<number>;
   /**
    * Where `totalUsd` came from. CLI-backend workers never price their own inference into
@@ -343,7 +473,27 @@ interface SupervisorRunRollup {
   readonly idlePctMean: Measured<number>;
   readonly workersSpawnedTotal: Measured<number>;
   readonly acceptedTotal: Measured<number>;
+  /**
+   * Sum of the per-run collapsed `totalUsd`. Prefer `spendUsd`: this total
+   * mixes close-record and journal-derived cells without saying which.
+   */
   readonly usdTotal: Measured<number>;
+  /**
+   * Fleet spend measured two ways. `runs` is each measurement's own
+   * denominator — the cells where that measurement was available. The two
+   * sums cover different run sets, so comparing the values without their
+   * denominators manufactures a phantom divergence.
+   */
+  readonly spendUsd: {
+    readonly journalDerived: {
+      readonly value: Measured<number>;
+      readonly runs: number;
+    };
+    readonly closeRecord: {
+      readonly value: Measured<number>;
+      readonly runs: number;
+    };
+  };
   readonly resolvedCount: Measured<number>;
   readonly perCell: readonly RollupCellRow[];
 }
@@ -368,5 +518,5 @@ interface SupervisorRunTreeGap {
   readonly count?: number;
 }
 //#endregion
-export { Unavailable as C, showMeasured as D, isUnavailable as E, unavailable as O, SupervisorRunTreeGapCode as S, WorkerLogSource as T, SupervisorRunReport as _, OrchestrationMetrics as a, SupervisorRunTree as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SupervisorRunReader as g, SupervisorRunNodeRole as h, NO_SOURCE_LIMITS as i, RoleSpend as l, SteerBreakdown as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunRollup as v, WallDistribution as w, SupervisorRunTreeGap as x, SupervisorRunSources as y };
-//# sourceMappingURL=types-yLK8gXE9.d.ts.map
+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

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

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

package/dist/{verdict-BndeTAh_.js → verdict-B0xltqu6.js}

@@ -1,4 +1,4 @@
-import { n as contentHash } from "./verdict-cache-mZf5FEiY.js";
+import { n as contentHash } from "./verdict-cache-CdVVTVmn.js";
 //#region src/verdict.ts
 /**
 * Validator-output verdict — substrate primitive for "did this output pass,
@@ -58,4 +58,4 @@ function equivalenceVerdict(record) {
 //#endregion
 export { equivalenceVerdict as n, certificationEvidenceDigest as t };
 
-//# sourceMappingURL=verdict-BndeTAh_.js.map
+//# sourceMappingURL=verdict-B0xltqu6.js.map

package/dist/{verdict-BndeTAh_.js.map → verdict-B0xltqu6.js.map}

@@ -1 +1 @@
-{"version":3,"file":"verdict-BndeTAh_.js","names":[],"sources":["../src/verdict.ts"],"sourcesContent":["/**\n * Validator-output verdict — substrate primitive for \"did this output pass,\n * and how well?\"\n *\n * Used by:\n *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.\n *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.\n *     Runtime keeps `Validator` because it's coupled to runtime-shaped\n *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE\n *     itself is a substrate concept and lives here.\n *\n * Repo layering: agent-eval is the substrate (no upward deps). Both\n * agent-runtime and agent-knowledge consume this type FROM agent-eval —\n * never the other way around. See CLAUDE.md \"Repo layering\" for the rule.\n */\n\nimport { contentHash } from './verdict-cache'\nimport type {\n  CheckerIdentity,\n  EquivalenceRecord,\n  VerificationStrategySource,\n} from './verification-strategy'\n\n/**\n * What certified a verdict — the epistemics a bare `valid` + `score` pair\n * cannot carry. A kernel-checked proof and an LLM judge can produce the\n * same `{ valid: true, score: 1 }`; this record is what tells them apart.\n *\n * Every field is required on purpose. A certification without a checker\n * identity or an evidence digest is exactly the unverifiable claim this\n * record exists to kill.\n */\nexport interface VerdictCertification {\n  /**\n   * Which verification-strategy member produced the certificate. Each\n   * member's failure mode is documented on the family type and in\n   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).\n   */\n  strategy: VerificationStrategySource\n  /**\n   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',\n   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model\n   * id + snapshot for a judge.\n   */\n  checker: CheckerIdentity\n  /**\n   * Every step the certificate rests on that the checker did NOT verify,\n   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share\n   * training-corpus blind spots'. An empty array is the producer's\n   * explicit, auditable claim that there are none — it is not a default.\n   */\n  assumptions: string[]\n  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */\n  evidenceDigest: string\n}\n\n/**\n * Minimal verdict shape — `valid` + `score` are required; `scores` +\n * `notes` are optional surface. Validators that need richer shapes\n * parameterise `Validator<Output, MyVerdict>` with their own type.\n *\n * Need structured extras? Extend DefaultVerdict with typed fields — never\n * serialize extras into `notes`.\n */\nexport interface DefaultVerdict {\n  /** Whether the output meets the validator's pass criteria. */\n  valid: boolean\n  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */\n  score: number\n  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */\n  scores?: Record<string, number>\n  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */\n  notes?: string\n  /**\n   * What certified this verdict, when anything did. Absent = uncertified:\n   * scored, but no strategy vouches for it. A consumer that cares reads\n   * `certification.strategy` to tell a kernel-checked verdict from a\n   * judge-scored one; a consumer that does not read it sees the exact\n   * verdict it always saw.\n   */\n  certification?: VerdictCertification\n}\n\n/**\n * Digest a certification's evidence artifact: sha-256 over the canonical\n * JSON of the evidence AS SERIALIZED. The JSON round-trip drops\n * `undefined`-valued fields on purpose — certified verdicts persist as\n * JSON, so the digest must cover exactly what a reader of the persisted\n * artifact can re-digest, nothing the wire cannot carry. Throws when the\n * evidence has no JSON form at all.\n */\nexport function certificationEvidenceDigest(evidence: unknown): string {\n  const serialized = JSON.stringify(evidence)\n  if (serialized === undefined) {\n    throw new Error(\n      'certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill',\n    )\n  }\n  return contentHash(JSON.parse(serialized))\n}\n\n/**\n * Land a finished statement-equivalence record in the shared verdict\n * spine. `valid` answers the protocol's question — are the two blind\n * statements equivalent — so a refutation is `valid: false` even though a\n * separating witness in hand is a successful protocol outcome.\n *\n * Certification is present exactly when the obligation was discharged\n * (proved or refuted): the checker vouches for the discharge either way.\n * An unresolved obligation certifies nothing and keeps its reason in\n * `notes`.\n */\nexport function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict {\n  const { obligation, spec, arms } = record\n  const discharged = obligation.status !== 'unresolved'\n  const notes =\n    obligation.status === 'proved'\n      ? `statements equivalent: ${spec.artifact}`\n      : obligation.status === 'refuted-with-separating-witness'\n        ? `formalization gap witnessed: ${obligation.separatingWitness}`\n        : `obligation undischarged: ${obligation.unresolvedReason}`\n  return {\n    valid: obligation.status === 'proved',\n    score: obligation.status === 'proved' ? 1 : 0,\n    notes,\n    ...(discharged && obligation.evidenceDigest !== undefined\n      ? {\n          certification: {\n            strategy: spec.source,\n            checker: obligation.checker,\n            // The arms' blindness declarations are attested by the arms,\n            // never verified by the checker — the one step every\n            // equivalence certificate rests on.\n            assumptions: [\n              `arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`,\n            ],\n            evidenceDigest: obligation.evidenceDigest,\n          } satisfies VerdictCertification,\n        }\n      : {}),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,4BAA4B,UAA2B;CACrE,MAAM,aAAa,KAAK,UAAU,QAAQ;CAC1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,0IACF;CAEF,OAAO,YAAY,KAAK,MAAM,UAAU,CAAC;AAC3C;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,QAA2C;CAC5E,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,aAAa,WAAW,WAAW;CACzC,MAAM,QACJ,WAAW,WAAW,WAClB,0BAA0B,KAAK,aAC/B,WAAW,WAAW,oCACpB,gCAAgC,WAAW,sBAC3C,4BAA4B,WAAW;CAC/C,OAAO;EACL,OAAO,WAAW,WAAW;EAC7B,OAAO,WAAW,WAAW,WAAW,IAAI;EAC5C;EACA,GAAI,cAAc,WAAW,mBAAmB,KAAA,IAC5C,EACE,eAAe;GACb,UAAU,KAAK;GACf,SAAS,WAAW;GAIpB,aAAa,CACX,QAAQ,KAAK,EAAE,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,MAAM,gCACnD;GACA,gBAAgB,WAAW;EAC7B,EACF,IACA,CAAC;CACP;AACF"}
+{"version":3,"file":"verdict-B0xltqu6.js","names":[],"sources":["../src/verdict.ts"],"sourcesContent":["/**\n * Validator-output verdict — substrate primitive for \"did this output pass,\n * and how well?\"\n *\n * Used by:\n *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.\n *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.\n *     Runtime keeps `Validator` because it's coupled to runtime-shaped\n *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE\n *     itself is a substrate concept and lives here.\n *\n * Repo layering: agent-eval is the substrate (no upward deps). Both\n * agent-runtime and agent-knowledge consume this type FROM agent-eval —\n * never the other way around. See CLAUDE.md \"Repo layering\" for the rule.\n */\n\nimport { contentHash } from './verdict-cache'\nimport type {\n  CheckerIdentity,\n  EquivalenceRecord,\n  VerificationStrategySource,\n} from './verification-strategy'\n\n/**\n * What certified a verdict — the epistemics a bare `valid` + `score` pair\n * cannot carry. A kernel-checked proof and an LLM judge can produce the\n * same `{ valid: true, score: 1 }`; this record is what tells them apart.\n *\n * Every field is required on purpose. A certification without a checker\n * identity or an evidence digest is exactly the unverifiable claim this\n * record exists to kill.\n */\nexport interface VerdictCertification {\n  /**\n   * Which verification-strategy member produced the certificate. Each\n   * member's failure mode is documented on the family type and in\n   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).\n   */\n  strategy: VerificationStrategySource\n  /**\n   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',\n   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model\n   * id + snapshot for a judge.\n   */\n  checker: CheckerIdentity\n  /**\n   * Every step the certificate rests on that the checker did NOT verify,\n   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share\n   * training-corpus blind spots'. An empty array is the producer's\n   * explicit, auditable claim that there are none — it is not a default.\n   */\n  assumptions: string[]\n  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */\n  evidenceDigest: string\n}\n\n/**\n * Minimal verdict shape — `valid` + `score` are required; `scores` +\n * `notes` are optional surface. Validators that need richer shapes\n * parameterise `Validator<Output, MyVerdict>` with their own type.\n *\n * Need structured extras? Extend DefaultVerdict with typed fields — never\n * serialize extras into `notes`.\n */\nexport interface DefaultVerdict {\n  /** Whether the output meets the validator's pass criteria. */\n  valid: boolean\n  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */\n  score: number\n  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */\n  scores?: Record<string, number>\n  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */\n  notes?: string\n  /**\n   * What certified this verdict, when anything did. Absent = uncertified:\n   * scored, but no strategy vouches for it. A consumer that cares reads\n   * `certification.strategy` to tell a kernel-checked verdict from a\n   * judge-scored one; a consumer that does not read it sees the exact\n   * verdict it always saw.\n   */\n  certification?: VerdictCertification\n}\n\n/**\n * Digest a certification's evidence artifact: sha-256 over the canonical\n * JSON of the evidence AS SERIALIZED. The JSON round-trip drops\n * `undefined`-valued fields on purpose — certified verdicts persist as\n * JSON, so the digest must cover exactly what a reader of the persisted\n * artifact can re-digest, nothing the wire cannot carry. Throws when the\n * evidence has no JSON form at all.\n */\nexport function certificationEvidenceDigest(evidence: unknown): string {\n  const serialized = JSON.stringify(evidence)\n  if (serialized === undefined) {\n    throw new Error(\n      'certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill',\n    )\n  }\n  return contentHash(JSON.parse(serialized))\n}\n\n/**\n * Land a finished statement-equivalence record in the shared verdict\n * spine. `valid` answers the protocol's question — are the two blind\n * statements equivalent — so a refutation is `valid: false` even though a\n * separating witness in hand is a successful protocol outcome.\n *\n * Certification is present exactly when the obligation was discharged\n * (proved or refuted): the checker vouches for the discharge either way.\n * An unresolved obligation certifies nothing and keeps its reason in\n * `notes`.\n */\nexport function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict {\n  const { obligation, spec, arms } = record\n  const discharged = obligation.status !== 'unresolved'\n  const notes =\n    obligation.status === 'proved'\n      ? `statements equivalent: ${spec.artifact}`\n      : obligation.status === 'refuted-with-separating-witness'\n        ? `formalization gap witnessed: ${obligation.separatingWitness}`\n        : `obligation undischarged: ${obligation.unresolvedReason}`\n  return {\n    valid: obligation.status === 'proved',\n    score: obligation.status === 'proved' ? 1 : 0,\n    notes,\n    ...(discharged && obligation.evidenceDigest !== undefined\n      ? {\n          certification: {\n            strategy: spec.source,\n            checker: obligation.checker,\n            // The arms' blindness declarations are attested by the arms,\n            // never verified by the checker — the one step every\n            // equivalence certificate rests on.\n            assumptions: [\n              `arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`,\n            ],\n            evidenceDigest: obligation.evidenceDigest,\n          } satisfies VerdictCertification,\n        }\n      : {}),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,4BAA4B,UAA2B;CACrE,MAAM,aAAa,KAAK,UAAU,QAAQ;CAC1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,0IACF;CAEF,OAAO,YAAY,KAAK,MAAM,UAAU,CAAC;AAC3C;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,QAA2C;CAC5E,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,aAAa,WAAW,WAAW;CACzC,MAAM,QACJ,WAAW,WAAW,WAClB,0BAA0B,KAAK,aAC/B,WAAW,WAAW,oCACpB,gCAAgC,WAAW,sBAC3C,4BAA4B,WAAW;CAC/C,OAAO;EACL,OAAO,WAAW,WAAW;EAC7B,OAAO,WAAW,WAAW,WAAW,IAAI;EAC5C;EACA,GAAI,cAAc,WAAW,mBAAmB,KAAA,IAC5C,EACE,eAAe;GACb,UAAU,KAAK;GACf,SAAS,WAAW;GAIpB,aAAa,CACX,QAAQ,KAAK,EAAE,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,MAAM,gCACnD;GACA,gBAAgB,WAAW;EAC7B,EACF,IACA,CAAC;CACP;AACF"}

package/dist/verdict-cache-CdVVTVmn.js

@@ -0,0 +1,88 @@
+import { i as hashCanonical, r as canonicalString } from "./canonical-IL-Bu-14.js";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+//#region src/verdict-cache.ts
+/**
+* Content-addressed judge-verdict caching.
+*
+* LAW: cache JUDGE VERDICTS only — judging the same artifact with the same
+* judge+rubric is pure. NEVER cache agent rollouts. (A router that cached
+* identical fanout prompts silently destroyed best-of-N diversity; rollout
+* caching reintroduces that failure class. Judging has no diversity to
+* destroy — same artifact + same rubric ⇒ same verdict is the desired
+* property, not a bug.)
+*
+* The cache key is `v2:` + a sha-256 over the canonical JSON of everything
+* that can change a verdict: the artifact content, the scenario id, the judge
+* name, the full dimension list (key + description — the description IS the
+* rubric text shown to the judge), and a caller-supplied `judgeVersion`.
+* `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes
+* without a version bump would otherwise silently serve stale verdicts.
+* The `v2:` prefix names the key scheme; a store written under another scheme
+* misses once and repopulates.
+*
+* Canonical JSON is RFC 8785 from `ledger-core/canonical` — the package's one
+* identity scheme. It refuses `undefined`, functions, symbols, non-finite
+* numbers, class instances (including `Date`), `Map`, `Set`, cycles, and
+* unpaired surrogates: an artifact that cannot be unambiguously serialized
+* cannot be content-addressed, and coercing it would let two different
+* artifacts collide on one key. Pass timestamps as ISO strings.
+*/
+/**
+* Canonical JSON (RFC 8785): object keys sorted recursively, so two
+* semantically equal values produce byte-identical output regardless of key
+* insertion order. Throws `LedgerCanonicalizationError` on any value with no
+* faithful JSON form — see `ledger-core/canonical`.
+*/
+function canonicalJson(value) {
+	return canonicalString(value);
+}
+/** Hex sha-256 over `canonicalJson(value)`. The content address used by the
+*  verdict cache and report attestation. Equals `hashCanonical(value)` with
+*  the `sha256:` prefix removed. */
+function contentHash(value) {
+	return hashCanonical(value).slice(7);
+}
+function parseCacheLine(line, path, lineNo) {
+	let parsed;
+	try {
+		parsed = JSON.parse(line);
+	} catch (err) {
+		throw new Error(`fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const rec = parsed;
+	if (typeof rec !== "object" || rec === null || typeof rec.key !== "string" || typeof rec.score !== "object" || rec.score === null || typeof rec.score.composite !== "number" || typeof rec.score.dimensions !== "object") throw new Error(`fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`);
+	return rec;
+}
+/**
+* JSONL-file-backed store: the full file is loaded into an in-memory index at
+* construction; every `set` appends one line synchronously (durable before
+* the verdict is returned). A corrupt or malformed line throws at load with
+* file:line — a skipped line would silently re-judge (cost) or, worse, mask
+* a half-written file that needs operator attention.
+*/
+function fileVerdictCache(path) {
+	const entries = /* @__PURE__ */ new Map();
+	if (existsSync(path)) {
+		const lines = readFileSync(path, "utf8").split("\n");
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (line === void 0 || line.trim() === "") continue;
+			const rec = parseCacheLine(line, path, i + 1);
+			entries.set(rec.key, rec.score);
+		}
+	}
+	return {
+		get: (key) => entries.get(key),
+		set: (key, score) => {
+			appendFileSync(path, `${JSON.stringify({
+				key,
+				score
+			})}\n`, "utf8");
+			entries.set(key, score);
+		}
+	};
+}
+//#endregion
+export { contentHash as n, fileVerdictCache as r, canonicalJson as t };
+
+//# sourceMappingURL=verdict-cache-CdVVTVmn.js.map

package/dist/verdict-cache-CdVVTVmn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-cache-CdVVTVmn.js","names":[],"sources":["../src/verdict-cache.ts"],"sourcesContent":["/**\n * Content-addressed judge-verdict caching.\n *\n * LAW: cache JUDGE VERDICTS only — judging the same artifact with the same\n * judge+rubric is pure. NEVER cache agent rollouts. (A router that cached\n * identical fanout prompts silently destroyed best-of-N diversity; rollout\n * caching reintroduces that failure class. Judging has no diversity to\n * destroy — same artifact + same rubric ⇒ same verdict is the desired\n * property, not a bug.)\n *\n * The cache key is `v2:` + a sha-256 over the canonical JSON of everything\n * that can change a verdict: the artifact content, the scenario id, the judge\n * name, the full dimension list (key + description — the description IS the\n * rubric text shown to the judge), and a caller-supplied `judgeVersion`.\n * `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes\n * without a version bump would otherwise silently serve stale verdicts.\n * The `v2:` prefix names the key scheme; a store written under another scheme\n * misses once and repopulates.\n *\n * Canonical JSON is RFC 8785 from `ledger-core/canonical` — the package's one\n * identity scheme. It refuses `undefined`, functions, symbols, non-finite\n * numbers, class instances (including `Date`), `Map`, `Set`, cycles, and\n * unpaired surrogates: an artifact that cannot be unambiguously serialized\n * cannot be content-addressed, and coercing it would let two different\n * artifacts collide on one key. Pass timestamps as ISO strings.\n */\n\nimport { appendFileSync, existsSync, readFileSync } from 'node:fs'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\n/** Key scheme of every entry `cachedJudge` writes. */\nexport const VERDICT_CACHE_KEY_SCHEME = 'v2'\n\n/**\n * Canonical JSON (RFC 8785): object keys sorted recursively, so two\n * semantically equal values produce byte-identical output regardless of key\n * insertion order. Throws `LedgerCanonicalizationError` on any value with no\n * faithful JSON form — see `ledger-core/canonical`.\n */\nexport function canonicalJson(value: unknown): string {\n  return canonicalString(value)\n}\n\n/** Hex sha-256 over `canonicalJson(value)`. The content address used by the\n *  verdict cache and report attestation. Equals `hashCanonical(value)` with\n *  the `sha256:` prefix removed. */\nexport function contentHash(value: unknown): string {\n  return hashCanonical(value).slice('sha256:'.length)\n}\n\n// ── store contract ─────────────────────────────────────────────────────────\n\n/** Pluggable verdict store. Sync or async on both legs — `cachedJudge`\n *  awaits the results either way. */\nexport interface VerdictCacheStore {\n  get(key: string): Promise<JudgeScore | undefined> | JudgeScore | undefined\n  set(key: string, score: JudgeScore): Promise<void> | void\n}\n\n/** Process-local Map-backed store. */\nexport function inMemoryVerdictCache(): VerdictCacheStore {\n  const entries = new Map<string, JudgeScore>()\n  return {\n    get: (key) => entries.get(key),\n    set: (key, score) => {\n      entries.set(key, score)\n    },\n  }\n}\n\ninterface VerdictCacheLine {\n  key: string\n  score: JudgeScore\n}\n\nfunction parseCacheLine(line: string, path: string, lineNo: number): VerdictCacheLine {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(line)\n  } catch (err) {\n    throw new Error(\n      `fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n  const rec = parsed as Partial<VerdictCacheLine>\n  if (\n    typeof rec !== 'object' ||\n    rec === null ||\n    typeof rec.key !== 'string' ||\n    typeof rec.score !== 'object' ||\n    rec.score === null ||\n    typeof rec.score.composite !== 'number' ||\n    typeof rec.score.dimensions !== 'object'\n  ) {\n    throw new Error(\n      `fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`,\n    )\n  }\n  return rec as VerdictCacheLine\n}\n\n/**\n * JSONL-file-backed store: the full file is loaded into an in-memory index at\n * construction; every `set` appends one line synchronously (durable before\n * the verdict is returned). A corrupt or malformed line throws at load with\n * file:line — a skipped line would silently re-judge (cost) or, worse, mask\n * a half-written file that needs operator attention.\n */\nexport function fileVerdictCache(path: string): VerdictCacheStore {\n  const entries = new Map<string, JudgeScore>()\n  if (existsSync(path)) {\n    const lines = readFileSync(path, 'utf8').split('\\n')\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i]\n      if (line === undefined || line.trim() === '') continue\n      const rec = parseCacheLine(line, path, i + 1)\n      entries.set(rec.key, rec.score)\n    }\n  }\n  return {\n    get: (key) => entries.get(key),\n    set: (key, score) => {\n      appendFileSync(path, `${JSON.stringify({ key, score })}\\n`, 'utf8')\n      entries.set(key, score)\n    },\n  }\n}\n\n// ── cached judge wrapper ───────────────────────────────────────────────────\n\nexport interface VerdictCacheStats {\n  hits: number\n  misses: number\n}\n\nexport interface CachedJudgeOptions {\n  /** REQUIRED — part of the cache key. Bump on any change to the judge's\n   *  prompt, model, ensemble, or scoring logic; silent judge upgrades must\n   *  never serve stale verdicts. */\n  judgeVersion: string\n}\n\n/** The wrapped judge: same `JudgeConfig` seam, plus hit/miss observability. */\nexport type CachedJudge<TArtifact, TScenario extends Scenario = Scenario> = JudgeConfig<\n  TArtifact,\n  TScenario\n> & {\n  stats(): VerdictCacheStats\n}\n\n/**\n * Wrap a `JudgeConfig` so repeat judgments of the same artifact are served\n * from the store instead of re-invoking `score()`. The wrapper is generic\n * over the judge's own type parameters and preserves `appliesTo` — it is a\n * drop-in replacement anywhere a `JudgeConfig` is accepted.\n *\n * A judge that throws is NOT cached: the error propagates and the next\n * attempt re-judges (caching a failure would pin a transient outage forever).\n */\nexport function cachedJudge<TArtifact, TScenario extends Scenario = Scenario>(\n  judge: JudgeConfig<TArtifact, TScenario>,\n  store: VerdictCacheStore,\n  options: CachedJudgeOptions,\n): CachedJudge<TArtifact, TScenario> {\n  if (typeof options.judgeVersion !== 'string' || options.judgeVersion.trim() === '') {\n    throw new Error('cachedJudge: judgeVersion is required and must be a non-empty string')\n  }\n  const stats: VerdictCacheStats = { hits: 0, misses: 0 }\n  const wrapped: CachedJudge<TArtifact, TScenario> = {\n    name: judge.name,\n    dimensions: judge.dimensions,\n    judgeVersion: options.judgeVersion,\n    async score(input) {\n      const key = `${VERDICT_CACHE_KEY_SCHEME}:${contentHash({\n        artifact: canonicalJson(input.artifact),\n        scenarioId: input.scenario.id,\n        judgeName: judge.name,\n        dimensions: judge.dimensions,\n        judgeVersion: options.judgeVersion,\n      })}`\n      const cached = await store.get(key)\n      if (cached !== undefined) {\n        stats.hits += 1\n        return cached\n      }\n      const score = await judge.score(input)\n      await store.set(key, score)\n      stats.misses += 1\n      return score\n    },\n    stats: () => ({ ...stats }),\n  }\n  if (judge.appliesTo) wrapped.appliesTo = judge.appliesTo\n  return wrapped\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK;AAC9B;;;;AAKA,SAAgB,YAAY,OAAwB;CAClD,OAAO,cAAc,KAAK,CAAC,CAAC,MAAM,CAAgB;AACpD;AA2BA,SAAS,eAAe,MAAc,MAAc,QAAkC;CACpF,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,IAAI;CAC1B,SAAS,KAAK;EACZ,MAAM,IAAI,MACR,sCAAsC,KAAK,GAAG,OAAO,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GAC3G;CACF;CACA,MAAM,MAAM;CACZ,IACE,OAAO,QAAQ,YACf,QAAQ,QACR,OAAO,IAAI,QAAQ,YACnB,OAAO,IAAI,UAAU,YACrB,IAAI,UAAU,QACd,OAAO,IAAI,MAAM,cAAc,YAC/B,OAAO,IAAI,MAAM,eAAe,UAEhC,MAAM,IAAI,MACR,6CAA6C,KAAK,GAAG,OAAO,wDAC9D;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,iBAAiB,MAAiC;CAChE,MAAM,0BAAU,IAAI,IAAwB;CAC5C,IAAI,WAAW,IAAI,GAAG;EACpB,MAAM,QAAQ,aAAa,MAAM,MAAM,CAAC,CAAC,MAAM,IAAI;EACnD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,SAAS,KAAA,KAAa,KAAK,KAAK,MAAM,IAAI;GAC9C,MAAM,MAAM,eAAe,MAAM,MAAM,IAAI,CAAC;GAC5C,QAAQ,IAAI,IAAI,KAAK,IAAI,KAAK;EAChC;CACF;CACA,OAAO;EACL,MAAM,QAAQ,QAAQ,IAAI,GAAG;EAC7B,MAAM,KAAK,UAAU;GACnB,eAAe,MAAM,GAAG,KAAK,UAAU;IAAE;IAAK;GAAM,CAAC,EAAE,KAAK,MAAM;GAClE,QAAQ,IAAI,KAAK,KAAK;EACxB;CACF;AACF"}

package/dist/wire/index.d.ts

@@ -1,7 +1,7 @@
-import { c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
-import { A as LlmClientOptions, N as LlmRouteRequirements } from "../types-jUBXJ7Iz.js";
-import { s as TraceStore } from "../store-CT9YIIve.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DpTTjo0q.js";
+import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
+import { s as TraceStore } from "../store-B06JdC56.js";
+import { p as ChatClient } from "../types-Bfk0uxRj.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-B3ZHaHV_.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";
@@ -157,103 +157,6 @@ declare const TracesIngestResponseSchema: z.ZodObject<{
     message: z.ZodString;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
-declare const FeedbackLabelSchema: z.ZodObject<{
-  id: z.ZodOptional<z.ZodString>;
-  source: z.ZodEnum<{
-    environment: "environment";
-    judge: "judge";
-    metric: "metric";
-    policy: "policy";
-    system: "system";
-    user: "user";
-  }>;
-  kind: z.ZodEnum<{
-    approve: "approve";
-    comment: "comment";
-    edit: "edit";
-    metric_outcome: "metric_outcome";
-    policy_block: "policy_block";
-    rank: "rank";
-    rate: "rate";
-    reject: "reject";
-    revision_request: "revision_request";
-    select: "select";
-  }>;
-  value: z.ZodUnknown;
-  reason: z.ZodOptional<z.ZodString>;
-  severity: z.ZodOptional<z.ZodEnum<{
-    critical: "critical";
-    error: "error";
-    info: "info";
-    warning: "warning";
-  }>>;
-  createdAt: z.ZodString;
-  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-declare const FeedbackAttemptSchema: z.ZodObject<{
-  id: z.ZodString;
-  stepIndex: z.ZodNumber;
-  artifactType: z.ZodEnum<{
-    action: "action";
-    code: "code";
-    data: "data";
-    decision: "decision";
-    other: "other";
-    plan: "plan";
-    research: "research";
-    text: "text";
-    ui: "ui";
-  }>;
-  artifact: z.ZodUnknown;
-  options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-  proposedAction: z.ZodOptional<z.ZodObject<{
-    type: z.ZodString;
-    risk: z.ZodOptional<z.ZodEnum<{
-      high: "high";
-      low: "low";
-      medium: "medium";
-    }>>;
-    costUsd: z.ZodOptional<z.ZodNumber>;
-    externalSideEffect: z.ZodOptional<z.ZodBoolean>;
-    requiresApproval: z.ZodOptional<z.ZodBoolean>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  }, z.core.$strip>>;
-  feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    source: z.ZodEnum<{
-      environment: "environment";
-      judge: "judge";
-      metric: "metric";
-      policy: "policy";
-      system: "system";
-      user: "user";
-    }>;
-    kind: z.ZodEnum<{
-      approve: "approve";
-      comment: "comment";
-      edit: "edit";
-      metric_outcome: "metric_outcome";
-      policy_block: "policy_block";
-      rank: "rank";
-      rate: "rate";
-      reject: "reject";
-      revision_request: "revision_request";
-      select: "select";
-    }>;
-    value: z.ZodUnknown;
-    reason: z.ZodOptional<z.ZodString>;
-    severity: z.ZodOptional<z.ZodEnum<{
-      critical: "critical";
-      error: "error";
-      info: "info";
-      warning: "warning";
-    }>>;
-    createdAt: z.ZodString;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  }, z.core.$strip>>>;
-  createdAt: z.ZodString;
-  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
 declare const FeedbackTrajectorySchema: z.ZodObject<{
   id: z.ZodString;
   projectId: z.ZodOptional<z.ZodString>;
@@ -426,9 +329,15 @@ declare class WireError extends Error {
 interface HandleJudgeOptions {
   costLedger?: CostLedgerHandle;
   costPhase?: string;
-  llm?: LlmClientOptions;
+  /**
+   * Caller-owned transport for the judge call. agent-eval holds no provider
+   * credential: the process that serves this endpoint binds its own client.
+   * Omitting it makes `/v1/judge` refuse with `llm_not_configured`.
+   */
+  chat?: ChatClient;
   defaultModel?: string;
-  routeRequirements?: LlmRouteRequirements;
+  /** Endpoint rates used when the transport reports no billed amount. */
+  pricing?: CustomTokenPricing;
   signal?: AbortSignal;
 }
 declare function handleJudge(req: JudgeRequest, options?: HandleJudgeOptions): Promise<JudgeResult>;
@@ -797,9 +706,9 @@ interface RpcError {
   };
 }
 interface RpcOptions {
-  llm?: LlmClientOptions;
+  /** Caller-owned transport for `/v1/judge`. Without it the method refuses. */
+  chat?: ChatClient;
   judgeModel?: string;
-  llmRouteRequirements?: LlmRouteRequirements;
 }
 declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
 /** Read one JSON request from stdin, write one JSON response to stdout. */
@@ -808,7 +717,6 @@ declare function runRpcOnce(method?: string, options?: RpcOptions): Promise<numb
 declare function runRpcBatch(method?: string, options?: RpcOptions): Promise<number>;
 //#endregion
 //#region src/wire/rubrics.d.ts
-declare const BUILTIN_RUBRICS: Record<string, Rubric>;
 /** Get a built-in rubric by name, or undefined. */
 declare function getBuiltinRubric(name: string): Rubric | undefined;
 /** List built-in rubrics with their stable versions. */
@@ -828,12 +736,14 @@ declare function listBuiltinRubrics(): {
 interface CreateAppOptions {
   /** Stores wired to the ingestion endpoints. */
   stores?: IngestionStores;
-  /** Model provider used by `/v1/judge`. */
-  llm?: LlmClientOptions;
+  /**
+   * Caller-owned transport used by `/v1/judge`. agent-eval holds no provider
+   * credential; without a client the endpoint refuses with
+   * `llm_not_configured`.
+   */
+  chat?: ChatClient;
   /** Default judge model when a request does not provide one. */
   judgeModel?: string;
-  /** Model route checks applied before every judge call. */
-  llmRouteRequirements?: LlmRouteRequirements;
   /**
    * Bearer-token auth. When provided, every endpoint EXCEPT `/healthz`
    * and `/v1/version` requires `Authorization: Bearer <token>`. The
@@ -873,5 +783,5 @@ interface StartedServer {
  */
 declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
 //#endregion
-export { BUILTIN_RUBRICS, ErrorResponse, ErrorResponseSchema, FailureMode, FailureModeSchema, FeedbackAttemptSchema, FeedbackIngestResponse, FeedbackIngestResponseSchema, FeedbackLabelSchema, FeedbackTrajectory, FeedbackTrajectorySchema, HandleJudgeOptions, HealthResponseSchema, IngestionStores, JudgeRequest, JudgeRequestSchema, JudgeResult, JudgeResultSchema, ListRubricsResponse, ListRubricsResponseSchema, type RpcOptions, Rubric, RubricDimension, RubricDimensionSchema, RubricInfo, RubricInfoSchema, RubricSchema, type ServeOptions, type StartedServer, TraceEvent, TraceEventSchema, TracesIngestRequest, TracesIngestRequestSchema, TracesIngestResponse, TracesIngestResponseSchema, VersionResponse, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };
+export { ErrorResponse, ErrorResponseSchema, FailureMode, FeedbackIngestResponse, FeedbackIngestResponseSchema, FeedbackTrajectory, FeedbackTrajectorySchema, HandleJudgeOptions, HealthResponseSchema, IngestionStores, JudgeRequest, JudgeRequestSchema, JudgeResult, JudgeResultSchema, ListRubricsResponse, ListRubricsResponseSchema, type RpcOptions, Rubric, RubricDimension, RubricDimensionSchema, RubricInfo, RubricSchema, type ServeOptions, type StartedServer, TraceEvent, TraceEventSchema, TracesIngestRequest, TracesIngestRequestSchema, TracesIngestResponse, TracesIngestResponseSchema, VersionResponse, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };
 //# sourceMappingURL=index.d.ts.map

package/dist/wire/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/openapi31.d.ts","../../src/wire/openapi.ts","../../src/wire/rpc.ts","../../src/wire/rubrics.ts","../../src/wire/server.ts"],"x_google_ignoreList":[2,3,4],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/openapi31.d.ts","../../src/wire/openapi.ts","../../src/wire/rpc.ts","../../src/wire/rubrics.ts","../../src/wire/server.ts"],"x_google_ignoreList":[2,3,4],"mappings":"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"}

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-import { A as TraceEventSchema, C as HealthResponseSchema, D as RubricDimensionSchema, E as ListRubricsResponseSchema, F as hashRubric, M as TracesIngestResponseSchema, N as VersionResponseSchema, O as RubricInfoSchema, P as WIRE_VERSION, S as FeedbackTrajectorySchema, T as JudgeResultSchema, _ as ErrorResponseSchema, a as runRpcBatch, b as FeedbackIngestResponseSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as listBuiltinRubrics, h as getBuiltinRubric, i as dispatchRpc, j as TracesIngestRequestSchema, k as RubricSchema, l as handleFeedbackIngest, m as BUILTIN_RUBRICS, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FailureModeSchema, w as JudgeRequestSchema, x as FeedbackLabelSchema, y as FeedbackAttemptSchema } from "../server-dIWwF3j_.js";
-export { BUILTIN_RUBRICS, ErrorResponseSchema, FailureModeSchema, FeedbackAttemptSchema, FeedbackIngestResponseSchema, FeedbackLabelSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RubricDimensionSchema, RubricInfoSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };
+import { A as hashRubric, C as RubricDimensionSchema, D as TracesIngestResponseSchema, E as TracesIngestRequestSchema, O as VersionResponseSchema, S as ListRubricsResponseSchema, T as TraceEventSchema, _ as FeedbackIngestResponseSchema, a as runRpcBatch, b as JudgeRequestSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as ErrorResponseSchema, h as listBuiltinRubrics, i as dispatchRpc, k as WIRE_VERSION, l as handleFeedbackIngest, m as getBuiltinRubric, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FeedbackTrajectorySchema, w as RubricSchema, x as JudgeResultSchema, y as HealthResponseSchema } from "../server-BtFd4uzB.js";
+export { ErrorResponseSchema, FeedbackIngestResponseSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RubricDimensionSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };