@tangle-network/agent-eval 0.221.8 → 0.222.1

package/dist/{types-DZ0mYVw9.d.ts → types-DUR0dqET.d.ts}

@@ -1,6 +1,5 @@
-import { c as RunSplitTag } from "./run-record-C3awiXPf.js";
-import { R as Scenario, d as DispatchContext } from "./types-M6eF9m-r.js";
-//#region src/benchmarks/types.d.ts
+import { c as RunSplitTag } from "./run-record-D2BFMPGl.js";
+import { R as Scenario, d as DispatchContext } from "./types-e3HGaI7P.js";
 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';
 interface BenchmarkDatasetItem<TPayload = unknown> {
@@ -97,6 +96,5 @@ declare const BENCHMARK_SPLIT_SEED = "agent-eval-v1";
  *   holdout:20%   (paper-grade held-out, gated reads)
  */
 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-DZ0mYVw9.d.ts.map
+//# sourceMappingURL=types-DUR0dqET.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-DUR0dqET.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;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;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-M6eF9m-r.d.ts → types-e3HGaI7P.d.ts}

@@ -1,20 +1,18 @@
-import { g as PaidCallResult, i as CostChannel, l as CostLedgerSummary, o as CostLedgerHandle, r as CostBreakdown, u as CostProvenance, y as RunPaidCallInput } from "./cost-ledger-C1W3ICmP.js";
-import { d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-C3awiXPf.js";
-import { v as ProposalFinding } from "./types-6Lfdlshp.js";
-import { j as LlmCallMetadata } from "./types-B_IFcKp5.js";
-import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
-import { A as SearchLedgerHash, F as SearchNodeRegisteredEvent, G as SearchSplit, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, U as SearchReservation, Z as SearchTask, b as SearchClosedEvent, d as SearchCellCancelledEvent, i as SearchArtifactRef, l as SearchCandidateSurface, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, w as SearchEdgeRecordedEvent, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
-import { y as LedgerProjector } from "./index-CalAsXMR.js";
-import { i as RolloutSearchLineage } from "./mint-CkzpVPdz.js";
-//#region src/campaign/search-state-identity.d.ts
+import { g as PaidCallResult, i as CostChannel, l as CostLedgerSummary, o as CostLedgerHandle, r as CostBreakdown, u as CostProvenance, y as RunPaidCallInput } from "./cost-ledger-Czro9wmo.js";
+import { a as RunRecord, d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-D2BFMPGl.js";
+import { v as ProposalFinding } from "./types-BEvjDziM.js";
+import { j as LlmCallMetadata } from "./types-0KglnQ9o.js";
+import { L as SeriesDistribution, a as MintedRolloutLine, m as RolloutEvidenceAttempt, t as ChatMessage, y as RolloutRole } from "./schema-DkFJr3Y8.js";
+import { A as SearchLedgerHash, F as SearchNodeRegisteredEvent, G as SearchSplit, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, U as SearchReservation, Z as SearchTask, b as SearchClosedEvent, d as SearchCellCancelledEvent, i as SearchArtifactRef, l as SearchCandidateSurface, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, w as SearchEdgeRecordedEvent, z as SearchOperationRecordedEvent } from "./search-ledger-types-qiYRUo_N.js";
+import { y as LedgerProjector } from "./index-B1Bm9oJA.js";
+import { s as TraceStore } from "./store-CMs5wGXP.js";
+import "./reward-ST4PXNXF.js";
 /** Deterministic node id: identical content in one search is one node. */
 declare function searchNodeId(searchId: string, artifactDigest: string): string;
 /** Deterministic cell id: one node on one task in one split at one repeat. */
 declare function searchCellId(searchId: string, nodeId: string, taskId: string, split: SearchSplit, rep: number): string;
 /** Digest a split's task list in taskId order. */
 declare function searchTaskSetDigest(tasks: readonly SearchTask[]): SearchLedgerHash;
-//#endregion
-//#region src/campaign/search-state-types.d.ts
 interface SearchDecisionRecord {
   sequence: number;
   decision: SearchNodeDecision;
@@ -137,8 +135,6 @@ interface NodeRecord {
   scoredCells: number;
   spend: SearchSpend;
 }
-//#endregion
-//#region src/campaign/search-state-indexes.d.ts
 declare class SearchLedgerIndexes {
   readonly tasks: Map<string, {
     split: SearchSplit;
@@ -162,8 +158,79 @@ declare class SearchLedgerIndexes {
   operation(operationId: string): SearchOperation | undefined;
   scoredCells(nodeId: string, split: SearchSplit): SearchScoredCell[];
 }
-//#endregion
-//#region src/campaign/search-state-view.d.ts
+/** Redactor for transcript/step payload text (secrets, PII), not opaque identity. */
+type RolloutScrubber = (text: string) => string;
+/** A search cell's place in its search tree, read from the search ledger. */
+interface RolloutSearchLineage {
+  /** Edges between the cell's node and the search root; the root is 0. */
+  depth: number;
+  /** Order in which the node registered in its search; the root is 0. */
+  ordinal: number;
+  /** Repeat index of the cell on its task, from 0. */
+  rep: number;
+  /** Run id of the cell whose execution contains this search; null for a
+   *  top-level search. */
+  containingRunId: string | null;
+}
+interface MintRolloutOptions {
+  scrub?: RolloutScrubber;
+  /**
+   * Full canonical capture, including turns no longer in the model's context.
+   * When supplied, missing/empty capture is refused, never replaced with a
+   * span summary. Use the execution owner's capture or the existing harness
+   * readers; reviewer traces and compacted histories are not full capture.
+   */
+  messagesOf?: (runId: string) => readonly ChatMessage[] | undefined | Promise<readonly ChatMessage[] | undefined>;
+  /** Provider attempts from a retained receipt bound to the exact run. */
+  evidenceOf?: (runId: string) => {
+    runId: string;
+    attempts: readonly RolloutEvidenceAttempt[];
+  } | undefined | Promise<{
+    runId: string;
+    attempts: readonly RolloutEvidenceAttempt[];
+  } | undefined>;
+  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */
+  maxSteps?: number;
+  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */
+  role?: RolloutRole;
+  /** Task suite label. Default: the record's `experimentId`. */
+  suite?: string;
+  /** Injected clock for deterministic output. */
+  now?: () => Date;
+  /**
+   * Lineage of a search run, read from its search ledger. It fills the line's
+   * `generation` (node depth), `candidate_index` (node order), `task.rep` and
+   * `parent_rollout_id` (the containing cell's run). Mint refuses a record
+   * that carries `search` when this is absent, because a null `generation`
+   * states that the run is not part of a search.
+   */
+  searchLineage?: (search: RunSearchCoordinates) => RolloutSearchLineage | Promise<RolloutSearchLineage>;
+}
+interface MintRolloutResult {
+  rows: MintedRolloutLine[];
+  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */
+  missingTraces: string[];
+}
+/**
+ * Why a record cannot be minted, one entry per missing field, empty when it can.
+ *
+ * Exported so a caller can partition a whole ledger — "which of my 2742 records
+ * predate 0.126" — without catching an exception per record, and without
+ * re-deriving the field list on their side. A re-derived list is a list that
+ * drifts from the door it is supposed to predict.
+ *
+ * Takes a `RunRecord` because that is what the caller holds and what the
+ * compiler agrees they hold. The type is precisely the thing that is wrong, so
+ * the checks read the record as the untyped bag it actually is on disk.
+ */
+declare function unmintableReasons(record: RunRecord): string[];
+/**
+ * Join RunRecords with their traces into canonical rollout lines. Records
+ * without spans or an explicit capture are emitted as labeled gap lines and reported in
+ * `missingTraces`. Execution-only records without a task score are rejected
+ * because a missing training label is not a zero reward.
+ */
+declare function mintRolloutRows(records: RunRecord[], store: TraceStore, options?: MintRolloutOptions): Promise<MintRolloutResult>;
 /**
  * Per-unit means of scored cells, in unitId order. Each unit sums its cells in
  * cellId order, so the result depends on the set of cells alone, never on the
@@ -228,8 +295,6 @@ declare class SearchStateView {
   lineage(coordinates: RunSearchCoordinates): RolloutSearchLineage;
   private live;
 }
-//#endregion
-//#region src/campaign/search-state-projection.d.ts
 /**
  * The pure, incremental projection of one search ledger. `apply` refuses any
  * entry that breaks an invariant; the journal then discards this instance and
@@ -291,8 +356,6 @@ declare class SearchState implements LedgerProjector<SearchLedgerEntry, SearchSt
     };
   };
 }
-//#endregion
-//#region src/campaign/search-summary.d.ts
 /** The proposer's own read of a search: its node's cells on the train split,
  * the only split a proposer may ever see. */
 interface SearchProposerView {
@@ -328,8 +391,6 @@ interface SearchSummaryOptions {
  * state already in hand).
  */
 declare function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string;
-//#endregion
-//#region src/campaign/types.d.ts
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
 interface Scenario {
@@ -1015,6 +1076,5 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
    *  without retaining customer task content in the result. */
   scenarios: Array<CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>>;
 }
-//#endregion
-export { SearchCompletion as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, SearchProposerView as G, SurfaceProposer as H, ProposedCandidate as I, searchProposerView as J, SearchSummaryOptions as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, SearchCell as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchStateView as X, SearchState as Y, searchUnitScores as Z, GateDecision as _, CampaignResult as a, SearchUnitScore as at, GenerationRecord as b, CampaignTraceWriter as c, searchTaskSetDigest as ct, DispatchContext as d, SearchDecisionRecord as et, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchSpend as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, GateCheckStatus as m, CampaignArtifactWriter as n, SearchOperation as nt, CampaignScenarioIdentity as o, searchCellId as ot, Gate as p, renderSearchSummary as q, CampaignCellResult as r, SearchScoredCell as rt, CampaignTokenUsage as s, searchNodeId as st, CampaignAggregates as t, SearchNode as tt, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-M6eF9m-r.d.ts.map
+export { MintRolloutResult as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, SearchProposerView as G, SurfaceProposer as H, ProposedCandidate as I, searchProposerView as J, SearchSummaryOptions as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, MintRolloutOptions as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchStateView as X, SearchState as Y, searchUnitScores as Z, GateDecision as _, CampaignResult as a, SearchCompletion as at, GenerationRecord as b, CampaignTraceWriter as c, SearchOperation as ct, DispatchContext as d, SearchUnitScore as dt, RolloutScrubber as et, DispatchFn as f, searchCellId as ft, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchCell as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, SearchScoredCell as lt, GateCheckStatus as m, searchTaskSetDigest as mt, CampaignArtifactWriter as n, mintRolloutRows as nt, CampaignScenarioIdentity as o, SearchDecisionRecord as ot, Gate as p, searchNodeId as pt, renderSearchSummary as q, CampaignCellResult as r, unmintableReasons as rt, CampaignTokenUsage as s, SearchNode as st, CampaignAggregates as t, RolloutSearchLineage as tt, ComponentSurface as u, SearchSpend as ut, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
+//# sourceMappingURL=types-e3HGaI7P.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-e3HGaI7P.d.ts","names":[],"sources":["../src/campaign/search-state-identity.ts","../src/campaign/search-state-types.ts","../src/campaign/search-state-indexes.ts","../src/rollout/mint.ts","../src/campaign/search-state-view.ts","../src/campaign/search-state-projection.ts","../src/campaign/search-summary.ts","../src/campaign/types.ts"],"mappings":"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"}

package/dist/{verdict-BGQmxQ8A.js → verdict-C8TcdwfD.js}

@@ -1,5 +1,5 @@
-import { n as contentHash } from "./verdict-cache-CL_7tePD.js";
-//#region src/verdict.ts
+import { n as contentHash } from "./verdict-cache-BVH-fl18.js";
+// src/verdict.ts
 /**
 * Validator-output verdict — substrate primitive for "did this output pass,
 * and how well?"
@@ -55,7 +55,6 @@ function equivalenceVerdict(record) {
 		} } : {}
 	};
 }
-//#endregion
 export { equivalenceVerdict as n, certificationEvidenceDigest as t };
 
-//# sourceMappingURL=verdict-BGQmxQ8A.js.map
+//# sourceMappingURL=verdict-C8TcdwfD.js.map

package/dist/{verdict-BGQmxQ8A.js.map → verdict-C8TcdwfD.js.map}

@@ -1 +1 @@
-{"version":3,"file":"verdict-BGQmxQ8A.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 AGENTS.md \"Dependency and evidence boundaries\" 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-C8TcdwfD.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 AGENTS.md \"Dependency and evidence boundaries\" 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-C24NELtN.d.ts → verdict-D_qiBQ6_.d.ts}

@@ -1,4 +1,3 @@
-//#region src/verification-strategy.d.ts
 /**
  * Verification-strategy family — the shared vocabulary for "what certified
  * this result", covering tasks with an answer key and tasks without one.
@@ -293,8 +292,6 @@ declare function defineEquivalenceCheck(spec: EquivalenceCheckSpec): Equivalence
  * honest record of an undischarged check.
  */
 declare function runEquivalenceCheck(definition: EquivalenceCheckDefinition, arms: readonly [EquivalenceArm, EquivalenceArm], checker: EquivalenceChecker): Promise<EquivalenceRecord>;
-//#endregion
-//#region src/verdict.d.ts
 /**
  * What certified a verdict — the epistemics a bare `valid` + `score` pair
  * cannot carry. A kernel-checked proof and an LLM judge can produce the
@@ -374,6 +371,5 @@ declare function certificationEvidenceDigest(evidence: unknown): string;
  * `notes`.
  */
 declare function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict;
-//#endregion
 export { runEquivalenceCheck as C, defineEquivalenceCheck as S, StrategyChecker as _, CheckerIdentity as a, VerificationStrategyProfile as b, EquivalenceCheckDefinition as c, EquivalenceCheckerInput as d, EquivalenceCheckerResult as f, EquivalenceRecord as g, EquivalenceProtocolError as h, equivalenceVerdict as i, EquivalenceCheckSpec as l, EquivalenceObligationStatus as m, VerdictCertification as n, CheckerOutcome as o, EquivalenceObligation as p, certificationEvidenceDigest as r, EquivalenceArm as s, DefaultVerdict as t, EquivalenceChecker as u, VERIFICATION_STRATEGIES as v, VerificationStrategySource as x, VERIFICATION_STRATEGY_SOURCES as y };
-//# sourceMappingURL=verdict-C24NELtN.d.ts.map
+//# sourceMappingURL=verdict-D_qiBQ6_.d.ts.map

package/dist/verdict-D_qiBQ6_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-D_qiBQ6_.d.ts","names":[],"sources":["../src/verification-strategy.ts","../src/verdict.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqEY;;;;;;;;;UAoBK;;EAEf;;EAEA;;;;;;;;cASW,yBAAyB,OACpC,4BACA;;cAkDW,wCAEC;;;;;;UAOG;;EAEf;;EAEA;;;;;EAKA,OAAO;;;;;;;KAQG,eAAe;EACrB;EAAiB,OAAO;;EACxB;EAAkB;;;;;;;;;;;;;UAaP,gBAAgB,OAAO;;EAEtC,UAAU;EACV,UAAU;;EAEV;EACA,MAAM,OAAO,QAAQ,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmC7B;;;;;;EAMf,QAAQ;;;;;;EAMR;;EAEA;;;;;;EAMA;;;UAIe;WACN,MAAM,SAAS;;;UAIT;EACf;;EAEA;;;;;;;EAOA;;;;;;EAMA;;IAEE;;IAEA;;;KAIQ;;;;;;;;;;;;;UAiBK;EACf,QAAQ;;EAER;;EAEA;;EAEA,SAAS;;EAET;;;UAIe;EACf,MAAM,SAAS;EACf,gBAAgB,gBAAgB;EAChC,YAAY;;;UAIG;EACf;EACA;;;;;;;;UASe;EACf;;EAEA;EACA;;;KAIU,qBAAqB,gBAAgB,yBAAyB;;cAG7D,iCAAiC;WACnC;EAeG,YAAA,MAAM,kCAAkC;;;;;;;;;iBActC,uBAAuB,MAAM,uBAAuB;;;;;;;;;;;;;;iBAmE9C,oBACpB,YAAY,4BACZ,gBAAgB,gBAAgB,iBAChC,SAAS,qBACR,QAAQ;;;;;;;;;;UCjaM;;;;;;EAMf,UAAU;;;;;;EAMV,SAAS;;;;;;;EAOT;;EAEA;;;;;;;;;;UAWe;;EAEf;;EAEA;;EAEA,SAAS;;EAET;;;;;;;;EAQA,gBAAgB;;;;;;;;;;iBAWF,4BAA4B;;;;;;;;;;;;iBAqB5B,mBAAmB,QAAQ,oBAAoB"}

package/dist/{verdict-cache-CL_7tePD.js → verdict-cache-BVH-fl18.js}

@@ -1,6 +1,6 @@
-import { a as hashCanonical, r as canonicalString } from "./canonical-Dq2hOQ8L.js";
+import { a as hashCanonical, r as canonicalString } from "./canonical-CicJlINA.js";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
-//#region src/verdict-cache.ts
+// src/verdict-cache.ts
 /**
 * Content-addressed judge-verdict caching.
 *
@@ -82,7 +82,6 @@ function fileVerdictCache(path) {
 		}
 	};
 }
-//#endregion
 export { contentHash as n, fileVerdictCache as r, canonicalJson as t };
 
-//# sourceMappingURL=verdict-cache-CL_7tePD.js.map
+//# sourceMappingURL=verdict-cache-BVH-fl18.js.map

package/dist/{verdict-cache-CL_7tePD.js.map → verdict-cache-BVH-fl18.js.map}

@@ -1 +1 @@
-{"version":3,"file":"verdict-cache-CL_7tePD.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 { JudgeScore } from './campaign/types'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\n\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\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\n\n\n\n\n\n\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK;AAC9B;;;;AAKA,SAAgB,YAAY,OAAwB;CAClD,OAAO,cAAc,KAAK,CAAC,CAAC,MAAM,CAAgB;AACpD;AAkBA,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"}
+{"version":3,"file":"verdict-cache-BVH-fl18.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 { JudgeScore } from './campaign/types'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\n\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\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\n\n\n\n\n\n\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK;AAC9B;;;;AAKA,SAAgB,YAAY,OAAwB;CAClD,OAAO,cAAc,KAAK,CAAC,CAAC,MAAM,CAAgB;AACpD;AAkBA,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,11 +1,10 @@
-import { m as CustomTokenPricing, o as CostLedgerHandle } from "../cost-ledger-C1W3ICmP.js";
-import { x as ChatClient } from "../types-B_IFcKp5.js";
-import { s as TraceStore } from "../store-B3nWRy3B.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-CYVJXolG.js";
+import { m as CustomTokenPricing, o as CostLedgerHandle } from "../cost-ledger-Czro9wmo.js";
+import { x as ChatClient } from "../types-0KglnQ9o.js";
+import { s as TraceStore } from "../store-CMs5wGXP.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DsHR9krG.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";
-//#region src/wire/schemas.d.ts
 declare const RubricDimensionSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
@@ -114,14 +113,14 @@ export declare const TraceEventSchema: z.ZodObject<{
   runId: z.ZodString;
   spanId: z.ZodOptional<z.ZodString>;
   kind: z.ZodEnum<{
-    budget_breach: "budget_breach";
-    budget_decrement: "budget_decrement";
-    custom: "custom";
+    policy_violation: "policy_violation";
     error: "error";
+    custom: "custom";
     log: "log";
-    policy_violation: "policy_violation";
-    redaction_applied: "redaction_applied";
+    budget_decrement: "budget_decrement";
+    budget_breach: "budget_breach";
     state_mutation: "state_mutation";
+    redaction_applied: "redaction_applied";
   }>;
   timestamp: z.ZodNumber;
   payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -132,14 +131,14 @@ declare const TracesIngestRequestSchema: z.ZodObject<{
     runId: z.ZodString;
     spanId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
-      budget_breach: "budget_breach";
-      budget_decrement: "budget_decrement";
-      custom: "custom";
+      policy_violation: "policy_violation";
       error: "error";
+      custom: "custom";
       log: "log";
-      policy_violation: "policy_violation";
-      redaction_applied: "redaction_applied";
+      budget_decrement: "budget_decrement";
+      budget_breach: "budget_breach";
       state_mutation: "state_mutation";
+      redaction_applied: "redaction_applied";
     }>;
     timestamp: z.ZodNumber;
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -165,15 +164,15 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
     id: z.ZodString;
     stepIndex: z.ZodNumber;
     artifactType: z.ZodEnum<{
-      action: "action";
+      text: "text";
       code: "code";
-      data: "data";
-      decision: "decision";
-      other: "other";
       plan: "plan";
       research: "research";
-      text: "text";
+      action: "action";
       ui: "ui";
+      decision: "decision";
+      data: "data";
+      other: "other";
     }>;
     artifact: z.ZodUnknown;
     options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
@@ -181,8 +180,8 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
       type: z.ZodString;
       risk: z.ZodOptional<z.ZodEnum<{
         high: "high";
-        low: "low";
         medium: "medium";
+        low: "low";
       }>>;
       costUsd: z.ZodOptional<z.ZodNumber>;
       externalSideEffect: z.ZodOptional<z.ZodBoolean>;
@@ -192,31 +191,31 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
     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";
+        metric: "metric";
         user: "user";
+        judge: "judge";
+        environment: "environment";
+        policy: "policy";
       }>;
       kind: z.ZodEnum<{
         approve: "approve";
-        comment: "comment";
+        reject: "reject";
+        select: "select";
         edit: "edit";
-        metric_outcome: "metric_outcome";
-        policy_block: "policy_block";
         rank: "rank";
         rate: "rate";
-        reject: "reject";
+        comment: "comment";
+        metric_outcome: "metric_outcome";
+        policy_block: "policy_block";
         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";
+        error: "error";
         warning: "warning";
       }>>;
       createdAt: z.ZodString;
@@ -228,31 +227,31 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
   labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     source: z.ZodEnum<{
-      environment: "environment";
-      judge: "judge";
-      metric: "metric";
-      policy: "policy";
       system: "system";
+      metric: "metric";
       user: "user";
+      judge: "judge";
+      environment: "environment";
+      policy: "policy";
     }>;
     kind: z.ZodEnum<{
       approve: "approve";
-      comment: "comment";
+      reject: "reject";
+      select: "select";
       edit: "edit";
-      metric_outcome: "metric_outcome";
-      policy_block: "policy_block";
       rank: "rank";
       rate: "rate";
-      reject: "reject";
+      comment: "comment";
+      metric_outcome: "metric_outcome";
+      policy_block: "policy_block";
       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";
+      error: "error";
       warning: "warning";
     }>>;
     createdAt: z.ZodString;
@@ -270,8 +269,8 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
   split: z.ZodOptional<z.ZodEnum<{
     dev: "dev";
     holdout: "holdout";
-    test: "test";
     train: "train";
+    test: "test";
   }>>;
   tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   createdAt: z.ZodString;
@@ -310,14 +309,12 @@ type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
  * can detect but does not have to act on.
  */
 export declare const WIRE_VERSION = "1.1.0";
-//#endregion
-//#region src/wire/handlers.d.ts
 /** Caller-fixable error. The transport renders this to 4xx + ErrorResponse. */
 export declare class WireError extends Error {
   readonly code: string;
   readonly status: number;
-  readonly details?: unknown;
-  constructor(code: string, message: string, status?: number, details?: unknown);
+  readonly details?: unknown | undefined;
+  constructor(code: string, message: string, status?: number, details?: unknown | undefined);
 }
 interface HandleJudgeOptions {
   costLedger?: CostLedgerHandle;
@@ -345,8 +342,6 @@ interface IngestionStores {
   traceStore?: TraceStore;
   feedbackStore?: FeedbackTrajectoryStore;
 }
-//#endregion
-//#region src/wire/rpc.d.ts
 interface RpcRequest {
   method: 'judge' | 'listRubrics' | 'version';
   params?: unknown;
@@ -367,8 +362,6 @@ interface RpcOptions {
   judgeModel?: string;
 }
 export declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
-//#endregion
-//#region src/wire/server.d.ts
 interface CreateAppOptions {
   /** Stores wired to the ingestion endpoints. */
   stores?: IngestionStores;
@@ -418,6 +411,5 @@ interface StartedServer {
  * (`startServerAsync({ port: 0 })`) and any caller that needs to dial back.
  */
 export declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
-//#endregion
 export type { ErrorResponse, FeedbackIngestResponse, HandleJudgeOptions, IngestionStores, JudgeRequest, JudgeResult, ListRubricsResponse, RpcOptions, Rubric, RubricInfo, ServeOptions, StartedServer, TracesIngestRequest, TracesIngestResponse, VersionResponse, WireFailureMode, WireFeedbackTrajectory, WireRubricDimension, WireTraceEvent };
 //# 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","../../src/wire/rpc.ts","../../src/wire/server.ts"],"mappings":";;;;;;;;cAoBa,uBAAqB,EAAA;;;;;;GAkBD,EAAA,KAAA;cAE3B,mBAAiB,EAAA;;;GAKM,EAAA,KAAA;cAIhB,cAAY,EAAA;;;;;;;;;;;;;;;;;;;GA6BL,EAAA,KAAA;cAIP,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAwBL,EAAA,KAAA;cAEb,mBAAiB,EAAA;;;;;;;;;GA6BL,EAAA,KAAA;cAInB,kBAAgB,EAAA;;;;;;;;;;GAcE,EAAA,KAAA;cAEX,2BAAyB,EAAA;;;;;;;;;;;;GAIL,EAAA,KAAA;cAIpB,uBAAqB,EAAA;;;;;GAWL,EAAA,KAAA;;;;;;;qBAiBhB,kBAAgB,EAAA;;;;;;;;;;;;;;;;GA0BD,EAAA,KAAA;cAEf,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;GAQL,EAAA,KAAA;cAEpB,4BAA0B,EAAA;;;;;;;GAiBL,EAAA,KAAA;qBA2DrB,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BD,EAAA,KAAA;cAEvB,8BAA4B,EAAA;;;GAKL,EAAA,KAAA;KAExB,iBAAiB,EAAE,aAAa;KAChC,sBAAsB,EAAE,aAAa;KACrC,uBAAuB,EAAE,aAAa;KACtC,yBAAyB,EAAE,aAAa;KACxC,yBAAyB,EAAE,aAAa;qBAIvC,qBAAmB,EAAA;;;;;;GAcL,EAAA,KAAA;KAIf,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,SAAS,EAAE,aAAa;KACxB,eAAe,EAAE,aAAa;KAC9B,cAAc,EAAE,aAAa;KAC7B,aAAa,EAAE,aAAa;KAC5B,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,gBAAgB,EAAE,aAAa;;;;;;;qBAU9B;;;;qBChWA,kBAAkB;WAEX;WAEA;WACA;EAJlB,YACkB,cAChB,iBACgB,iBACA;;UAgJH;EACf,aAAa;EACb;;;;;;EAMA,OAAO;EACP;;EAEA,UAAU;EACV,SAAS;;;;;;;;;;UAsGM;EACf,aAAa;EACb,gBAAgB;;;;UC5RR;EACR;EACA;;UAGQ;EACR;;UAGQ;EACR;IAAS;IAAc;IAAiB;;;UAGzB;;EAEf,OAAO;EACP;;wBAGoB,YACpB,KAAK,YACL,UAAS,aACR,QAAQ,aAAa;;;UCNd;;EAER,SAAS;;;;;;EAMT,OAAO;;EAEP;;;;;;;;;;EAUA;IACE,mBAAmB,4BAA4B;;;wBAMnC,UAAU,OAAM,mBAAqB,0BAAA,+BAAA;UA0IpC,qBAAqB;;EAEpC;;EAEA;;wBAGc,YAAY,OAAM,eAAoB;UAUrC;EACf,QAAQ;;;;EAIR;;EAEA;;EAEA,SAAS;;;;;;;wBAQK,iBAAiB,OAAM,eAAoB,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../src/wire/rpc.ts","../../src/wire/server.ts"],"mappings":";;;;;;;cAoBa,uBAAqB,EAAA;;;;;;GAkBD,EAAA,KAAA;cAE3B,mBAAiB,EAAA;;;GAKM,EAAA,KAAA;cAIhB,cAAY,EAAA;;;;;;;;;;;;;;;;;;;GA6BL,EAAA,KAAA;cAIP,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAwBL,EAAA,KAAA;cAEb,mBAAiB,EAAA;;;;;;;;;GA6BL,EAAA,KAAA;cAInB,kBAAgB,EAAA;;;;;;;;;;GAcE,EAAA,KAAA;cAEX,2BAAyB,EAAA;;;;;;;;;;;;GAIL,EAAA,KAAA;cAIpB,uBAAqB,EAAA;;;;;GAWL,EAAA,KAAA;;;;;;;qBAiBhB,kBAAgB,EAAA;;;;;;;;;;;;;;;;GA0BD,EAAA,KAAA;cAEf,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;GAQL,EAAA,KAAA;cAEpB,4BAA0B,EAAA;;;;;;;GAiBL,EAAA,KAAA;qBA2DrB,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BD,EAAA,KAAA;cAEvB,8BAA4B,EAAA;;;GAKL,EAAA,KAAA;KAExB,iBAAiB,EAAE,aAAa;KAChC,sBAAsB,EAAE,aAAa;KACrC,uBAAuB,EAAE,aAAa;KACtC,yBAAyB,EAAE,aAAa;KACxC,yBAAyB,EAAE,aAAa;qBAIvC,qBAAmB,EAAA;;;;;;GAcL,EAAA,KAAA;KAIf,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,SAAS,EAAE,aAAa;KACxB,eAAe,EAAE,aAAa;KAC9B,cAAc,EAAE,aAAa;KAC7B,aAAa,EAAE,aAAa;KAC5B,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,gBAAgB,EAAE,aAAa;;;;;;;qBAU9B;;qBChWA,kBAAkB;WAEX;WAEA;WACA;EAHA,YAAA,cAChB,iBACgB,iBACA;;UAgJH;EACf,aAAa;EACb;;;;;;EAMA,OAAO;EACP;;EAEA,UAAU;EACV,SAAS;;;;;;;;;;UAsGM;EACf,aAAa;EACb,gBAAgB;;UC5RR;EACR;EACA;;UAGQ;EACR;;UAGQ;EACR;IAAS;IAAc;IAAiB;;;UAGzB;;EAEf,OAAO;EACP;;wBAGoB,YACpB,KAAK,YACL,UAAS,aACR,QAAQ,aAAa;UCNd;;EAER,SAAS;;;;;;EAMT,OAAO;;EAEP;;;;;;;;;;EAUA;IACE,mBAAmB,4BAA4B;;;wBAMnC,UAAU,OAAM,mBAAqB,0BAAA,+BAAA;UA0IpC,qBAAqB;;EAEpC;;EAEA;;wBAGc,YAAY,OAAM,eAAoB;UAUrC;EACf,QAAQ;;;;EAIR;;EAEA;;EAEA,SAAS;;;;;;;wBAQK,iBAAiB,OAAM,eAAoB,QAAQ"}

package/dist/wire/index.js

@@ -1,2 +1 @@
-import { a as dispatchRpc, c as WireError, d as FeedbackTrajectorySchema, f as TraceEventSchema, n as startServer, p as WIRE_VERSION, r as startServerAsync, t as createApp, u as ErrorResponseSchema } from "../server-ChhXPCgX.js";
-export { ErrorResponseSchema, FeedbackTrajectorySchema, TraceEventSchema, WIRE_VERSION, WireError, createApp, dispatchRpc, startServer, startServerAsync };
+export { u as ErrorResponseSchema, d as FeedbackTrajectorySchema, f as TraceEventSchema, p as WIRE_VERSION, c as WireError, t as createApp, a as dispatchRpc, n as startServer, r as startServerAsync } from "../server-DA6h3co5.js";

package/docs/eval-surface-map.md

@@ -107,6 +107,17 @@ Use registered gates for inference across independent source units; their `paire
 `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.
 
+`summarizeNumberSeries(values, { percentiles: [95, 99.9], medianInterval: { criticalValue: 1.96 } })`
+also reports the requested percentiles on a 0–100 scale and a deterministic median rank band.
+The band uses ranks `floor(n/2 − criticalValue·sqrt(n)/2)` and
+`ceil(n/2 + 1 + criticalValue·sqrt(n)/2)`, clamped to the observed sample.
+Its `method`, `criticalValue`, `sampleSize`, and ranks describe the evidence;
+it is a normal approximation over order statistics, not a bootstrap interval or a promotion test.
+An empty sample returns `null`; a singleton band is a point and establishes no spread.
+The optional fields appear only when requested, so existing campaign distributions retain their shape.
+Options must use finite, in-range percentiles and a finite, nonnegative critical value, even for an empty sample.
+Calls with options also reject non-finite observations and sum overflow rather than serializing missing numbers as `null`.
+
 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.
@@ -155,6 +166,10 @@ The receipt records the stage (`dispatch` or `judge`), the serialized error, the
 `abortOnCellError: true` stops the campaign on the first failed cell; the default keeps the remaining schedule running and returns the failed cell.
 
 `cellRetry: { attempts, retryable }` opts in to bounded in-run retry.
+An optional `retryResult(artifact)` retries a measured failed result without turning it into a dispatch error.
+Each attempt retains its artifact; only the final attempt enters the result and reusable cache.
+Use `onCellSettled(cell, scenario)` for completion-order progress after each final cell is persisted, including cache hits.
+Campaign cancellation returns the settled prefix after active dispatches drain; dispatch or accounting failures still reject.
 A failed attempt that `retryable` accepts is dispatched again in the same slot (same `cellId`, same seed) until it succeeds or `attempts` is exhausted.
 Use `transientDispatchFailure()` as the predicate to retry only dispatch-stage transport failures (502/503/504, dropped streams, admission rejections) and never judge-stage failures.
 Every attempt charges the shared cost ledger, so the final cell's `costUsd` and `costCallIds` cover all attempts.