@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/verdict-E4eRNf7-.d.ts

@@ -0,0 +1,392 @@
+//#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.
+ *
+ * Charter Wave 5 (docs/charter.md): an unsolved problem has no held-out
+ * suite by definition, so the held-out suite must be ONE member of a
+ * strategy family, not the family itself. This module carries the taxonomy,
+ * the port shape, and the one protocol built directly on that port: the
+ * blind two-arm statement-equivalence check. A checker is an injected
+ * executable boundary that returns a typed outcome, so a consumer binds its
+ * own kernel (a Lean toolchain, a metamorphic harness, a replication
+ * runner) and this package never chooses one. Instruments, never methods.
+ *
+ * Full family doc, per-member failure modes in prose, and the BCWW pilot
+ * worked example: docs/verification-strategies.md. How every executed
+ * verdict lands in `DefaultVerdict` with a certification: docs/verdicts.md.
+ *
+ * Leaf module: no imports from this package. `src/verdict.ts` and
+ * `src/rl/verifiable-reward.ts` both build on these types.
+ */
+/**
+ * One member of the verification-strategy family.
+ *
+ * Every member has a documented failure mode — the specific way it can
+ * certify a wrong result. A consumer that reads a certification must weigh
+ * the member's failure mode, not treat "certified" as one bit.
+ *
+ * - `'compile'` — typecheck / build / lint passed. Deterministic.
+ *   Failure mode: code that compiles is not code that is correct; the
+ *   weakest deterministic member.
+ * - `'test'` — unit / integration / held-out suite pass-rate. Deterministic.
+ *   Failure mode: assumes an answer key exists; certifies nothing outside
+ *   the suite's coverage, and a stubbed integration reports green.
+ * - `'schema'` — structured output validates. Deterministic.
+ *   Failure mode: shape is not meaning; a well-formed wrong answer passes.
+ * - `'sandbox'` — sandbox execution exit code. Deterministic.
+ *   Failure mode: an exit code compresses the whole run to one bit; a
+ *   faked success exits 0.
+ * - `'judge'` — LLM judge score. Probabilistic.
+ *   Failure mode: drifts across model versions and is Goodhart-gameable by
+ *   the graded policy.
+ * - `'composite'` — weighted blend across members. Determinism inherited
+ *   from its members.
+ *   Failure mode: scalar collapse — the blend hides which member carried
+ *   the score and which failed.
+ * - `'proof-kernel'` — a proof assistant's kernel accepted a formal proof.
+ *   Deterministic.
+ *   Failure mode: the formalization gap. The kernel certifies the formal
+ *   statement, never that the formal statement matches the informal claim;
+ *   a proved theorem about the wrong statement is a wrong result with a
+ *   valid certificate. Discharge it with the blind statement-equivalence
+ *   protocol (`runEquivalenceCheck` in this module).
+ * - `'invariant'` — invariant / metamorphic properties held on the result.
+ *   Deterministic.
+ *   Failure mode: weak invariants pass everything. An invariant set earns
+ *   weight only through seeded-bug calibration — a mutation the set
+ *   provably rejects; an uncalibrated set is a rubber stamp.
+ * - `'replication'` — an independent re-execution reproduced the result
+ *   from pinned inputs. Deterministic given the pins.
+ *   Failure mode: replication re-runs the method, so it catches
+ *   nondeterminism and environment drift, never a methodological error the
+ *   method itself carries.
+ * - `'agreement'` — independently-derived results agree. Probabilistic.
+ *   Failure mode: the shared blind spot. Derivers that share training
+ *   corpora, priors, or the same misread of the source agree for the same
+ *   wrong reason; the blindness provenance of each arm is what the
+ *   certificate rests on.
+ */
+type VerificationStrategySource = 'compile' | 'test' | 'schema' | 'sandbox' | 'judge' | 'composite' | 'proof-kernel' | 'invariant' | 'replication' | 'agreement';
+/**
+ * What a strategy member can honestly claim about its outcomes.
+ *
+ * `determinism: 'inherited'` exists only for `'composite'`: a blend takes
+ * the class of its members. The reward axis stays binary
+ * (`VerifiableReward.determinism`); this registry describes the family,
+ * it never scores a run.
+ */
+interface VerificationStrategyProfile {
+  /** Determinism class a well-formed checker of this member can claim. */
+  determinism: 'deterministic' | 'probabilistic' | 'inherited';
+  /** The documented way this member certifies a wrong result. */
+  failureMode: string;
+}
+/**
+ * The family registry. `Record` over the union keeps it exhaustive: adding
+ * a member to `VerificationStrategySource` without a profile here fails to
+ * compile. The failure mode travels with the taxonomy so a reader of a
+ * certification can surface it without this package's docs at hand.
+ */
+declare const VERIFICATION_STRATEGIES: Record<VerificationStrategySource, VerificationStrategyProfile>;
+/** Every family member, derived from the registry so it cannot drift. */
+declare const VERIFICATION_STRATEGY_SOURCES: readonly VerificationStrategySource[];
+/**
+ * Exact identity of the thing that checked. "lean4 4.33.0 with Mathlib
+ * db584cd6d46c" and "lean4, some version" are different certificates: the
+ * first is re-runnable, the second is a story.
+ */
+interface CheckerIdentity {
+  /** Toolchain or model name, e.g. `'lean4'` or a judge model id. */
+  name: string;
+  /** Exact version or snapshot, e.g. `'4.33.0'` or a model snapshot id. */
+  version: string;
+  /**
+   * Content pins the version alone does not capture, e.g.
+   * `{ mathlib: 'db584cd6d46c' }`. Keyed by dependency name.
+   */
+  pins?: Record<string, string>;
+}
+/**
+ * Typed outcome of an external checker call. Callers MUST inspect
+ * `succeeded` before touching `value`; a failed check keeps its full error
+ * text instead of collapsing to null.
+ */
+type CheckerOutcome<Result> = {
+  succeeded: true;
+  value: Result;
+} | {
+  succeeded: false;
+  error: string;
+};
+/**
+ * The port shape every strategy binds through: an injected executable
+ * boundary. This package defines the port and refuses to ship any
+ * implementation behind it — the consumer binds its own kernel, invariant
+ * harness, replication runner, or judge, and the binding carries its own
+ * identity and determinism claim.
+ *
+ * A checker that ran but could not decide returns
+ * `{ succeeded: false, error }` with the reason; `succeeded: true` is
+ * reserved for a discharged check.
+ */
+interface StrategyChecker<Input, Result> {
+  /** Which family member this checker discharges obligations for. */
+  strategy: VerificationStrategySource;
+  identity: CheckerIdentity;
+  /** Determinism class this checker claims for its outcomes. */
+  determinism: 'deterministic' | 'probabilistic';
+  check(input: Input): Promise<CheckerOutcome<Result>>;
+}
+/**
+ * Statement-equivalence protocol — the blind two-arm design as a typed
+ * primitive.
+ *
+ * The problem it closes is the proof-kernel failure mode (the
+ * formalization gap): a kernel certifies a formal statement, never that
+ * the formal statement matches the informal claim. The protocol makes the
+ * gap measurable: two arms derive the formal statement independently and
+ * blind to each other, then a checker discharges the obligation that the
+ * two statements are equivalent. A statement mismatch is a successful
+ * outcome — it is the formalization gap made visible with a separating
+ * witness in hand.
+ *
+ * The protocol is pure contract + record types + the asymmetry refusals.
+ * Execution binds through the same `StrategyChecker` port as every other
+ * strategy: the consumer injects its own kernel. The pilot record this
+ * shape reproduces was assembled by hand for the BCWW (4.6) inequality;
+ * docs/verification-strategies.md carries the worked example with artifact
+ * paths. `equivalenceVerdict` (src/verdict.ts) lands a finished record in
+ * the shared verdict spine.
+ *
+ * The refusals are the design. An arm that saw the other arm's statement,
+ * or the outcome it feeds, did not independently derive anything — the
+ * check is invalid, and this module throws rather than record it.
+ */
+/**
+ * The two-arm blind design. `arms: 2` and `blind: true` are literal types
+ * on purpose: a wider design is a different protocol, not a parameter.
+ */
+interface EquivalenceCheckSpec {
+  /**
+   * The strategy member whose obligation the check discharges — the pilot
+   * used `'proof-kernel'`: the Lean kernel proved the two statements
+   * equivalent. The bound checker must declare the same member.
+   */
+  source: VerificationStrategySource;
+  /**
+   * Stable identity of the claim under verification: a path, digest, or
+   * citation. Pilot: arXiv:1507.05650 inequality (4.6) plus the
+   * five-atom counterexample record.
+   */
+  artifact: string;
+  /** Exactly two independent arms. An N-arm design is not this protocol. */
+  arms: 2;
+  /**
+   * Blind derivation is the point: a non-blind run is not a weaker check,
+   * it is no check. `false` is unrepresentable here and refused at runtime
+   * for untyped callers.
+   */
+  blind: true;
+}
+/** A validated, frozen spec. Produced only by `defineEquivalenceCheck`. */
+interface EquivalenceCheckDefinition {
+  readonly spec: Readonly<EquivalenceCheckSpec>;
+}
+/** One arm's committed statement plus the provenance the record rests on. */
+interface EquivalenceArm {
+  armId: string;
+  /** The committed formal statement text (pilot: the arm's `Statement.lean` source). */
+  statement: string;
+  /**
+   * What this arm derived the statement from. Pilot arm A: the paper's
+   * LaTeX source; pilot arm B: the campaign's artifacts. The two arms
+   * SHOULD derive from different renderings of the claim — that is what
+   * makes agreement informative.
+   */
+  derivedFrom: string;
+  /**
+   * The blindness declaration. Both flags must be `true`; a `false` value
+   * is refused loudly, because recording a non-blind arm would launder an
+   * invalid check into a valid-looking record.
+   */
+  blindness: {
+    /** This arm never saw any other arm's statement before committing its own. */
+    toOtherArms: boolean;
+    /** This arm never saw the verification outcome before committing. */
+    toOutcome: boolean;
+  };
+}
+type EquivalenceObligationStatus = 'proved' | 'refuted-with-separating-witness' | 'unresolved';
+/**
+ * The discharged (or undischarged) equivalence obligation.
+ *
+ * Field presence is status-dependent and enforced by
+ * `buildEquivalenceRecord`:
+ * - `'proved'` requires `evidenceDigest` and forbids `separatingWitness`.
+ * - `'refuted-with-separating-witness'` requires both the witness and
+ *   `evidenceDigest`.
+ * - `'unresolved'` requires `unresolvedReason` and forbids the witness —
+ *   an undischarged obligation keeps its diagnostic instead of faking
+ *   either verdict.
+ */
+interface EquivalenceObligation {
+  status: EquivalenceObligationStatus;
+  /** The input on which the two statements provably disagree. */
+  separatingWitness?: string;
+  /** Why the obligation could not be discharged (checker error text, coverage limit). */
+  unresolvedReason?: string;
+  /** The checker that ran (or failed to run) the obligation. */
+  checker: CheckerIdentity;
+  /** Digest of the checker's evidence artifact (pilot: the kernel-checked `Check.lean` run). */
+  evidenceDigest?: string;
+}
+/** The record the protocol produces — the by-hand pilot record, typed. */
+interface EquivalenceRecord {
+  spec: Readonly<EquivalenceCheckSpec>;
+  arms: readonly [EquivalenceArm, EquivalenceArm];
+  obligation: EquivalenceObligation;
+}
+/** Input the bound checker receives: the artifact identity and both committed statements. */
+interface EquivalenceCheckerInput {
+  artifact: string;
+  statements: readonly [string, string];
+}
+/**
+ * What a checker that RAN must return. `'unresolved'` is deliberately not
+ * a checker result: a checker that could not decide returns
+ * `{ succeeded: false, error }` through the port, and the protocol records
+ * the unresolved obligation with that reason.
+ */
+interface EquivalenceCheckerResult {
+  status: 'proved' | 'refuted-with-separating-witness';
+  /** Required when `status` is refuted. */
+  separatingWitness?: string;
+  evidenceDigest: string;
+}
+/** An equivalence checker is a `StrategyChecker` — same port as every strategy. */
+type EquivalenceChecker = StrategyChecker<EquivalenceCheckerInput, EquivalenceCheckerResult>;
+/** A refused equivalence check. `code` names the exact refusal for programmatic handling. */
+declare class EquivalenceProtocolError extends Error {
+  readonly code: 'arm-count' | 'not-blind' | 'arm-saw-other' | 'arm-saw-outcome' | 'duplicate-arm-id' | 'empty-field' | 'unknown-source' | 'witness-missing' | 'witness-on-proved' | 'witness-on-unresolved' | 'reason-missing' | 'evidence-missing' | 'checker-strategy-mismatch';
+  constructor(code: EquivalenceProtocolError['code'], message: string);
+}
+/**
+ * Validate and freeze a two-arm blind equivalence check spec.
+ *
+ * The literal types already refuse a wide design at compile time; the
+ * runtime checks hold the same line for untyped callers. There is no
+ * escape hatch: `arms: 3` or `blind: false` throws, never downgrades.
+ */
+declare function defineEquivalenceCheck(spec: EquivalenceCheckSpec): EquivalenceCheckDefinition;
+/**
+ * Assemble the equivalence record, refusing every asymmetry.
+ *
+ * Refusals (each throws `EquivalenceProtocolError`):
+ * - an arm whose `blindness.toOtherArms` is false — it saw the other
+ *   statement, so nothing was independently derived;
+ * - an arm whose `blindness.toOutcome` is false — it could steer its
+ *   statement toward (or away from) the known result;
+ * - duplicate arm ids, empty statements, empty derivations;
+ * - an obligation whose fields contradict its status (see
+ *   `EquivalenceObligation`).
+ */
+declare function buildEquivalenceRecord(definition: EquivalenceCheckDefinition, arms: readonly [EquivalenceArm, EquivalenceArm], obligation: EquivalenceObligation): EquivalenceRecord;
+/**
+ * Discharge the obligation through an injected checker and return the
+ * record.
+ *
+ * Order matters: every arm refusal fires BEFORE the checker runs — an
+ * invalid check must not spend. A checker whose `strategy` differs from
+ * `spec.source` is refused for the same reason: a judge cannot silently
+ * discharge a proof-kernel obligation.
+ *
+ * A checker failure (`succeeded: false`) is not thrown: it becomes an
+ * `'unresolved'` obligation carrying the full error text, which is the
+ * 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
+ * same `{ valid: true, score: 1 }`; this record is what tells them apart.
+ *
+ * Every field is required on purpose. A certification without a checker
+ * identity or an evidence digest is exactly the unverifiable claim this
+ * record exists to kill.
+ */
+interface VerdictCertification {
+  /**
+   * Which verification-strategy member produced the certificate. Each
+   * member's failure mode is documented on the family type and in
+   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).
+   */
+  strategy: VerificationStrategySource;
+  /**
+   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',
+   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model
+   * id + snapshot for a judge.
+   */
+  checker: CheckerIdentity;
+  /**
+   * Every step the certificate rests on that the checker did NOT verify,
+   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share
+   * training-corpus blind spots'. An empty array is the producer's
+   * explicit, auditable claim that there are none — it is not a default.
+   */
+  assumptions: string[];
+  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */
+  evidenceDigest: string;
+}
+/**
+ * Minimal verdict shape — `valid` + `score` are required; `scores` +
+ * `notes` are optional surface. Validators that need richer shapes
+ * parameterise `Validator<Output, MyVerdict>` with their own type.
+ *
+ * Need structured extras? Extend DefaultVerdict with typed fields — never
+ * serialize extras into `notes`.
+ */
+interface DefaultVerdict {
+  /** Whether the output meets the validator's pass criteria. */
+  valid: boolean;
+  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */
+  score: number;
+  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */
+  scores?: Record<string, number>;
+  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */
+  notes?: string;
+  /**
+   * What certified this verdict, when anything did. Absent = uncertified:
+   * scored, but no strategy vouches for it. A consumer that cares reads
+   * `certification.strategy` to tell a kernel-checked verdict from a
+   * judge-scored one; a consumer that does not read it sees the exact
+   * verdict it always saw.
+   */
+  certification?: VerdictCertification;
+}
+/**
+ * Digest a certification's evidence artifact: sha-256 over the canonical
+ * JSON of the evidence AS SERIALIZED. The JSON round-trip drops
+ * `undefined`-valued fields on purpose — certified verdicts persist as
+ * JSON, so the digest must cover exactly what a reader of the persisted
+ * artifact can re-digest, nothing the wire cannot carry. Throws when the
+ * evidence has no JSON form at all.
+ */
+declare function certificationEvidenceDigest(evidence: unknown): string;
+/**
+ * Land a finished statement-equivalence record in the shared verdict
+ * spine. `valid` answers the protocol's question — are the two blind
+ * statements equivalent — so a refutation is `valid: false` even though a
+ * separating witness in hand is a successful protocol outcome.
+ *
+ * Certification is present exactly when the obligation was discharged
+ * (proved or refuted): the checker vouches for the discharge either way.
+ * An unresolved obligation certifies nothing and keeps its reason in
+ * `notes`.
+ */
+declare function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict;
+//#endregion
+export { defineEquivalenceCheck as C, buildEquivalenceRecord 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, runEquivalenceCheck as w, VerificationStrategySource as x, VERIFICATION_STRATEGY_SOURCES as y };
+//# sourceMappingURL=verdict-E4eRNf7-.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-E4eRNf7-.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;EAeT,YAAY,MAAM,kCAAkC;;;;;;;;;iBActC,uBAAuB,MAAM,uBAAuB;;;;;;;;;;;;;iBAwCpD,uBACd,YAAY,4BACZ,gBAAgB,gBAAgB,iBAChC,YAAY,wBACX;;;;;;;;;;;;;;iBAuBmB,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-BCcOh0kF.js → verdict-cache-mZf5FEiY.js}

@@ -1,5 +1,5 @@
-import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
 //#region src/verdict-cache.ts
 /**
 * Content-addressed judge-verdict caching.
@@ -61,16 +61,6 @@ function canonicalJson(value) {
 function contentHash(value) {
 	return createHash("sha256").update(canonicalJson(value)).digest("hex");
 }
-/** Process-local Map-backed store. */
-function inMemoryVerdictCache() {
-	const entries = /* @__PURE__ */ new Map();
-	return {
-		get: (key) => entries.get(key),
-		set: (key, score) => {
-			entries.set(key, score);
-		}
-	};
-}
 function parseCacheLine(line, path, lineNo) {
 	let parsed;
 	try {
@@ -111,49 +101,7 @@ function fileVerdictCache(path) {
 		}
 	};
 }
-/**
-* Wrap a `JudgeConfig` so repeat judgments of the same artifact are served
-* from the store instead of re-invoking `score()`. The wrapper is generic
-* over the judge's own type parameters and preserves `appliesTo` — it is a
-* drop-in replacement anywhere a `JudgeConfig` is accepted.
-*
-* A judge that throws is NOT cached: the error propagates and the next
-* attempt re-judges (caching a failure would pin a transient outage forever).
-*/
-function cachedJudge(judge, store, options) {
-	if (typeof options.judgeVersion !== "string" || options.judgeVersion.trim() === "") throw new Error("cachedJudge: judgeVersion is required and must be a non-empty string");
-	const stats = {
-		hits: 0,
-		misses: 0
-	};
-	const wrapped = {
-		name: judge.name,
-		dimensions: judge.dimensions,
-		judgeVersion: options.judgeVersion,
-		async score(input) {
-			const key = contentHash({
-				artifact: canonicalJson(input.artifact),
-				scenarioId: input.scenario.id,
-				judgeName: judge.name,
-				dimensions: judge.dimensions,
-				judgeVersion: options.judgeVersion
-			});
-			const cached = await store.get(key);
-			if (cached !== void 0) {
-				stats.hits += 1;
-				return cached;
-			}
-			const score = await judge.score(input);
-			await store.set(key, score);
-			stats.misses += 1;
-			return score;
-		},
-		stats: () => ({ ...stats })
-	};
-	if (judge.appliesTo) wrapped.appliesTo = judge.appliesTo;
-	return wrapped;
-}
 //#endregion
-export { inMemoryVerdictCache as a, fileVerdictCache as i, canonicalJson as n, contentHash as r, cachedJudge as t };
+export { contentHash as n, fileVerdictCache as r, canonicalJson as t };
 
-//# sourceMappingURL=verdict-cache-BCcOh0kF.js.map
+//# sourceMappingURL=verdict-cache-mZf5FEiY.js.map

package/dist/{verdict-cache-BCcOh0kF.js.map → verdict-cache-mZf5FEiY.js.map}

@@ -1 +1 @@
-{"version":3,"file":"verdict-cache-BCcOh0kF.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 a sha-256 over the canonical JSON of everything that can\n * change a verdict: the artifact content, the scenario id, the judge name,\n * the full dimension list (key + description — the description IS the rubric\n * 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 *\n * Strict canonicalization (`canonicalJson`) throws on undefined / function /\n * symbol / non-finite numbers — an artifact that cannot be unambiguously\n * serialized cannot be content-addressed, and coercing it would let two\n * different artifacts collide on one key.\n */\n\nimport { createHash } from 'node:crypto'\nimport { appendFileSync, existsSync, readFileSync } from 'node:fs'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\nfunction canonicalizeAt(value: unknown, path: string): string {\n  if (value === null) return 'null'\n  switch (typeof value) {\n    case 'boolean':\n      return value ? 'true' : 'false'\n    case 'number':\n      if (!Number.isFinite(value)) {\n        throw new Error(\n          `canonicalJson: non-finite number (${value}) at ${path} — ambiguity is an error, not a coercion`,\n        )\n      }\n      return JSON.stringify(value)\n    case 'string':\n      return JSON.stringify(value)\n    case 'undefined':\n    case 'function':\n    case 'symbol':\n      throw new Error(\n        `canonicalJson: ${typeof value} at ${path} — ambiguity is an error, not a coercion`,\n      )\n    case 'bigint':\n      throw new Error(`canonicalJson: bigint at ${path} — not representable in JSON`)\n    case 'object':\n      break\n  }\n  const obj = value as Record<string, unknown>\n  // Honor toJSON (Date → ISO string) before structural checks — without it a\n  // Date would canonicalize to '{}' and every timestamp would collide.\n  if (typeof obj.toJSON === 'function') {\n    return canonicalizeAt((obj as { toJSON(): unknown }).toJSON(), path)\n  }\n  if (Array.isArray(obj)) {\n    return `[${obj.map((item, i) => canonicalizeAt(item, `${path}[${i}]`)).join(',')}]`\n  }\n  if (obj instanceof Map || obj instanceof Set) {\n    throw new Error(\n      `canonicalJson: ${obj instanceof Map ? 'Map' : 'Set'} at ${path} — would serialize as '{}'; convert to a plain object/array first`,\n    )\n  }\n  const keys = Object.keys(obj).sort()\n  const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalizeAt(obj[k], `${path}.${k}`)}`)\n  return `{${parts.join(',')}}`\n}\n\n/**\n * Stable JSON stringify: object keys sorted recursively, so two semantically\n * equal values produce byte-identical output regardless of key insertion\n * order. Throws on undefined / function / symbol / NaN / ±Infinity / bigint /\n * Map / Set — anything JSON.stringify would coerce or drop silently.\n *\n * Distinct from `pre-registration.ts`'s `canonicalize`/`hashJson`, which are\n * permissive (coercion allowed) and async (web-crypto). Use THIS pair when a\n * hash collision or silent coercion would corrupt a cache key or attestation.\n */\nexport function canonicalJson(value: unknown): string {\n  return canonicalizeAt(value, '$')\n}\n\n/** Hex sha-256 over `canonicalJson(value)`. The content address used by the\n *  verdict cache and report attestation. */\nexport function contentHash(value: unknown): string {\n  return createHash('sha256').update(canonicalJson(value)).digest('hex')\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 = 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":"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"}
+{"version":3,"file":"verdict-cache-mZf5FEiY.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 a sha-256 over the canonical JSON of everything that can\n * change a verdict: the artifact content, the scenario id, the judge name,\n * the full dimension list (key + description — the description IS the rubric\n * 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 *\n * Strict canonicalization (`canonicalJson`) throws on undefined / function /\n * symbol / non-finite numbers — an artifact that cannot be unambiguously\n * serialized cannot be content-addressed, and coercing it would let two\n * different artifacts collide on one key.\n */\n\nimport { createHash } from 'node:crypto'\nimport { appendFileSync, existsSync, readFileSync } from 'node:fs'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\nfunction canonicalizeAt(value: unknown, path: string): string {\n  if (value === null) return 'null'\n  switch (typeof value) {\n    case 'boolean':\n      return value ? 'true' : 'false'\n    case 'number':\n      if (!Number.isFinite(value)) {\n        throw new Error(\n          `canonicalJson: non-finite number (${value}) at ${path} — ambiguity is an error, not a coercion`,\n        )\n      }\n      return JSON.stringify(value)\n    case 'string':\n      return JSON.stringify(value)\n    case 'undefined':\n    case 'function':\n    case 'symbol':\n      throw new Error(\n        `canonicalJson: ${typeof value} at ${path} — ambiguity is an error, not a coercion`,\n      )\n    case 'bigint':\n      throw new Error(`canonicalJson: bigint at ${path} — not representable in JSON`)\n    case 'object':\n      break\n  }\n  const obj = value as Record<string, unknown>\n  // Honor toJSON (Date → ISO string) before structural checks — without it a\n  // Date would canonicalize to '{}' and every timestamp would collide.\n  if (typeof obj.toJSON === 'function') {\n    return canonicalizeAt((obj as { toJSON(): unknown }).toJSON(), path)\n  }\n  if (Array.isArray(obj)) {\n    return `[${obj.map((item, i) => canonicalizeAt(item, `${path}[${i}]`)).join(',')}]`\n  }\n  if (obj instanceof Map || obj instanceof Set) {\n    throw new Error(\n      `canonicalJson: ${obj instanceof Map ? 'Map' : 'Set'} at ${path} — would serialize as '{}'; convert to a plain object/array first`,\n    )\n  }\n  const keys = Object.keys(obj).sort()\n  const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalizeAt(obj[k], `${path}.${k}`)}`)\n  return `{${parts.join(',')}}`\n}\n\n/**\n * Stable JSON stringify: object keys sorted recursively, so two semantically\n * equal values produce byte-identical output regardless of key insertion\n * order. Throws on undefined / function / symbol / NaN / ±Infinity / bigint /\n * Map / Set — anything JSON.stringify would coerce or drop silently.\n *\n * Distinct from `pre-registration.ts`'s `canonicalize`/`hashJson`, which are\n * permissive (coercion allowed) and async (web-crypto). Use THIS pair when a\n * hash collision or silent coercion would corrupt a cache key or attestation.\n */\nexport function canonicalJson(value: unknown): string {\n  return canonicalizeAt(value, '$')\n}\n\n/** Hex sha-256 over `canonicalJson(value)`. The content address used by the\n *  verdict cache and report attestation. */\nexport function contentHash(value: unknown): string {\n  return createHash('sha256').update(canonicalJson(value)).digest('hex')\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 = 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":";;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAS,eAAe,OAAgB,MAAsB;CAC5D,IAAI,UAAU,MAAM,OAAO;CAC3B,QAAQ,OAAO,OAAf;EACE,KAAK,WACH,OAAO,QAAQ,SAAS;EAC1B,KAAK;GACH,IAAI,CAAC,OAAO,SAAS,KAAK,GACxB,MAAM,IAAI,MACR,qCAAqC,MAAM,OAAO,KAAK,yCACzD;GAEF,OAAO,KAAK,UAAU,KAAK;EAC7B,KAAK,UACH,OAAO,KAAK,UAAU,KAAK;EAC7B,KAAK;EACL,KAAK;EACL,KAAK,UACH,MAAM,IAAI,MACR,kBAAkB,OAAO,MAAM,MAAM,KAAK,yCAC5C;EACF,KAAK,UACH,MAAM,IAAI,MAAM,4BAA4B,KAAK,6BAA6B;EAChF,KAAK,UACH;CACJ;CACA,MAAM,MAAM;CAGZ,IAAI,OAAO,IAAI,WAAW,YACxB,OAAO,eAAgB,IAA8B,OAAO,GAAG,IAAI;CAErE,IAAI,MAAM,QAAQ,GAAG,GACnB,OAAO,IAAI,IAAI,KAAK,MAAM,MAAM,eAAe,MAAM,GAAG,KAAK,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;CAEnF,IAAI,eAAe,OAAO,eAAe,KACvC,MAAM,IAAI,MACR,kBAAkB,eAAe,MAAM,QAAQ,MAAM,MAAM,KAAK,kEAClE;CAIF,OAAO,IAFM,OAAO,KAAK,GAAG,CAAC,CAAC,KACb,CAAC,CAAC,KAAK,MAAM,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,eAAe,IAAI,IAAI,GAAG,KAAK,GAAG,GAAG,GAC5E,CAAC,CAAC,KAAK,GAAG,EAAE;AAC7B;;;;;;;;;;;AAYA,SAAgB,cAAc,OAAwB;CACpD,OAAO,eAAe,OAAO,GAAG;AAClC;;;AAIA,SAAgB,YAAY,OAAwB;CAClD,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,cAAc,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK;AACvE;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-Bv_e8XHY.js";
-import { Z as LlmRouteRequirements, q as LlmClientOptions } from "../types-D216SgwM.js";
+import { c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
+import { A as LlmClientOptions, N as LlmRouteRequirements } from "../types-Cx3YUh2r.js";
 import { s as TraceStore } from "../store-CT9YIIve.js";
-import { _ as FeedbackTrajectoryStore } from "../feedback-trajectory-CacHpxsp.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-juOozjAc.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";

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-iu0ede49.js";
+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-ulsOdrTI.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 };

package/docs/charter.md

@@ -68,8 +68,8 @@ The audit refuted "built four times": traces imports this package's whole analys
    One declarative unit — AgentProfile + evidence projection + reply contract + budget declaration — compiled to any engine, guarded by a byte-identity kill test against the bespoke arms.
 6. **Verification without an answer key.**
    A strategy family where the held-out suite is one member: proof kernels, invariant and metamorphic checks, independent derivation agreement, replication.
-   The type layer now exists (`docs/verification-strategies.md`): the reward-source union is open, verdicts carry certifications, and the blind statement-equivalence protocol grades the formalization gap.
-   What remains is execution: a real kernel checker bound through the port, and the certified records flowing from live runs.
+   The type layer exists (`docs/verification-strategies.md`) and the certifications are now produced, not just typed: every in-package verifier — the layer pipeline, the completion oracle, trace contracts, declarative oracles, trajectory replay, the repair grader — lands in `DefaultVerdict` with a certification naming its checker, strategy member, and unverified assumptions (`docs/verdicts.md`).
+   What remains is execution without an answer key: a real kernel checker bound through the port.
 7. **Session forking as one primitive.**
    Both halves exist unjoined: agent-runtime's `SandboxLineage.fork` (live checkpoint) and this package's trajectory replay (recorded prefix).
    Braid branches are metadata pointers; the provider session is always new.
@@ -99,7 +99,7 @@ Wave 5 — science.
 The verification-strategy family, proof kernels first.
 Its pilot is live: two independent Lean formalizations of the BCWW (4.6) inequality — one from the paper, one from the campaign's artifacts — with a kernel-checked equivalence verdict and the campaign's counterexample checked against both.
 A statement mismatch is a successful outcome; it is the formalization gap made visible.
-The contract layer is shipped: the family and checker port (`src/verification-strategy.ts`), verdict certifications (`src/verdict.ts`), and the blind two-arm equivalence protocol (`src/equivalence-check.ts`) — see `docs/verification-strategies.md` for the family, each member's failure mode, and the pilot as the worked example.
+The contract layer is shipped: the family, checker port, and blind two-arm equivalence protocol (`src/verification-strategy.ts`) and verdict certifications (`src/verdict.ts`) — see `docs/verification-strategies.md` for the family, each member's failure mode, and the pilot as the worked example.
 
 ## Standing principles (each earned by a measured burn)