@tangle-network/agent-eval 0.216.1 → 0.217.1

package/dist/{verdict-E4eRNf7-.d.ts → verdict-C24NELtN.d.ts}

@@ -279,19 +279,6 @@ declare class EquivalenceProtocolError extends Error {
  * 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.
@@ -388,5 +375,5 @@ declare function certificationEvidenceDigest(evidence: unknown): string;
  */
 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
+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

package/dist/{verdict-E4eRNf7-.d.ts.map → verdict-C24NELtN.d.ts.map}

@@ -1 +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"}
+{"version":3,"file":"verdict-C24NELtN.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;;;;;;;;;;;;;;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-Bm8EKL2s.js → verdict-cache-CL_7tePD.js}

@@ -1,4 +1,4 @@
-import { a as hashCanonical, r as canonicalString } from "./canonical-B2RqLofv.js";
+import { a as hashCanonical, r as canonicalString } from "./canonical-Dq2hOQ8L.js";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 //#region src/verdict-cache.ts
 /**
@@ -85,4 +85,4 @@ function fileVerdictCache(path) {
 //#endregion
 export { contentHash as n, fileVerdictCache as r, canonicalJson as t };
 
-//# sourceMappingURL=verdict-cache-Bm8EKL2s.js.map
+//# sourceMappingURL=verdict-cache-CL_7tePD.js.map

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

@@ -0,0 +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"}

package/dist/wire/index.d.ts

@@ -1,12 +1,12 @@
 import { a as CostLedgerHandle, p as CustomTokenPricing } from "../cost-ledger-Jk62OBfF.js";
-import { x as ChatClient } from "../types-C02qtnG8.js";
-import { s as TraceStore } from "../store-C4avFjIi.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-C4EG0nNH.js";
+import { x as ChatClient } from "../types-D-mgRzlh.js";
+import { s as TraceStore } from "../store-B3nWRy3B.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-BWmhRBGu.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";
 //#region src/wire/schemas.d.ts
-export declare const RubricDimensionSchema: z.ZodObject<{
+declare const RubricDimensionSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
   weight: z.ZodDefault<z.ZodNumber>;
@@ -17,7 +17,7 @@ declare const FailureModeSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
 }, z.core.$strip>;
-export declare const RubricSchema: z.ZodObject<{
+declare const RubricSchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   systemPrompt: z.ZodString;
@@ -37,7 +37,7 @@ export declare const RubricSchema: z.ZodObject<{
     description: z.ZodString;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
-export declare const JudgeRequestSchema: z.ZodObject<{
+declare const JudgeRequestSchema: z.ZodObject<{
   rubricName: z.ZodOptional<z.ZodString>;
   rubric: z.ZodOptional<z.ZodObject<{
     name: z.ZodString;
@@ -63,7 +63,7 @@ export declare const JudgeRequestSchema: z.ZodObject<{
   context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare const JudgeResultSchema: z.ZodObject<{
+declare const JudgeResultSchema: z.ZodObject<{
   composite: z.ZodNumber;
   dimensions: z.ZodRecord<z.ZodString, z.ZodNumber>;
   failureModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -84,7 +84,7 @@ declare const RubricInfoSchema: z.ZodObject<{
   failureModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
   rubricVersion: z.ZodString;
 }, z.core.$strip>;
-export declare const ListRubricsResponseSchema: z.ZodObject<{
+declare const ListRubricsResponseSchema: z.ZodObject<{
   rubrics: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
@@ -97,19 +97,15 @@ export declare const ListRubricsResponseSchema: z.ZodObject<{
     rubricVersion: z.ZodString;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const VersionResponseSchema: z.ZodObject<{
+declare const VersionResponseSchema: z.ZodObject<{
   package: z.ZodString;
   version: z.ZodString;
   wireVersion: z.ZodString;
   apiSurface: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
-export declare const HealthResponseSchema: z.ZodObject<{
-  status: z.ZodLiteral<"ok">;
-  uptimeSec: z.ZodNumber;
-}, z.core.$strip>;
 /**
- * Minimal `TraceEvent` shape that the production runtime emits.
- * Matches `trace/schema.ts` `TraceEvent` but is duplicated here as a
+ * Minimal `WireTraceEvent` shape that the production runtime emits.
+ * Matches `trace/schema.ts` `WireTraceEvent` but is duplicated here as a
  * wire schema so non-TypeScript clients can validate without depending
  * on internal types.
  */
@@ -130,7 +126,7 @@ export declare const TraceEventSchema: z.ZodObject<{
   timestamp: z.ZodNumber;
   payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
-export declare const TracesIngestRequestSchema: z.ZodObject<{
+declare const TracesIngestRequestSchema: z.ZodObject<{
   events: z.ZodArray<z.ZodObject<{
     eventId: z.ZodString;
     runId: z.ZodString;
@@ -149,7 +145,7 @@ export declare const TracesIngestRequestSchema: z.ZodObject<{
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const TracesIngestResponseSchema: z.ZodObject<{
+declare const TracesIngestResponseSchema: z.ZodObject<{
   accepted: z.ZodNumber;
   rejected: z.ZodNumber;
   errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -282,15 +278,15 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
   updatedAt: z.ZodOptional<z.ZodString>;
   metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-export declare const FeedbackIngestResponseSchema: z.ZodObject<{
+declare const FeedbackIngestResponseSchema: z.ZodObject<{
   id: z.ZodString;
   persisted: z.ZodBoolean;
 }, z.core.$strip>;
-export type TraceEvent = z.infer<typeof TraceEventSchema>;
-export type TracesIngestRequest = z.infer<typeof TracesIngestRequestSchema>;
-export type TracesIngestResponse = z.infer<typeof TracesIngestResponseSchema>;
-export type FeedbackTrajectory = z.infer<typeof FeedbackTrajectorySchema>;
-export type FeedbackIngestResponse = z.infer<typeof FeedbackIngestResponseSchema>;
+type WireTraceEvent = z.infer<typeof TraceEventSchema>;
+type TracesIngestRequest = z.infer<typeof TracesIngestRequestSchema>;
+type TracesIngestResponse = z.infer<typeof TracesIngestResponseSchema>;
+type WireFeedbackTrajectory = z.infer<typeof FeedbackTrajectorySchema>;
+type FeedbackIngestResponse = z.infer<typeof FeedbackIngestResponseSchema>;
 export declare const ErrorResponseSchema: z.ZodObject<{
   error: z.ZodObject<{
     code: z.ZodString;
@@ -298,15 +294,15 @@ export declare const ErrorResponseSchema: z.ZodObject<{
     details: z.ZodOptional<z.ZodUnknown>;
   }, z.core.$strip>;
 }, z.core.$strip>;
-export type RubricDimension = z.infer<typeof RubricDimensionSchema>;
-export type FailureMode = z.infer<typeof FailureModeSchema>;
-export type Rubric = z.infer<typeof RubricSchema>;
-export type JudgeRequest = z.infer<typeof JudgeRequestSchema>;
-export type JudgeResult = z.infer<typeof JudgeResultSchema>;
-export type RubricInfo = z.infer<typeof RubricInfoSchema>;
-export type ListRubricsResponse = z.infer<typeof ListRubricsResponseSchema>;
-export type VersionResponse = z.infer<typeof VersionResponseSchema>;
-export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+type WireRubricDimension = z.infer<typeof RubricDimensionSchema>;
+type WireFailureMode = z.infer<typeof FailureModeSchema>;
+type Rubric = z.infer<typeof RubricSchema>;
+type JudgeRequest = z.infer<typeof JudgeRequestSchema>;
+type JudgeResult = z.infer<typeof JudgeResultSchema>;
+type RubricInfo = z.infer<typeof RubricInfoSchema>;
+type ListRubricsResponse = z.infer<typeof ListRubricsResponseSchema>;
+type VersionResponse = z.infer<typeof VersionResponseSchema>;
+type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
 /**
  * Bump the major on any breaking change to a request/response schema — the
  * Python client compares majors and refuses a mismatch. Bump the minor when a
@@ -314,24 +310,6 @@ export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
  * can detect but does not have to act on.
  */
 export declare const WIRE_VERSION = "1.1.0";
-/**
- * The digest scheme `hashRubric` mints, named inside the value it produces.
- * A consumer holding a tag from an earlier release reads a different scheme
- * here and can tell "this package changed how it hashes" from "the rubric
- * changed" — the two are indistinguishable when the value is an untagged hex
- * string.
- */
-export declare const RUBRIC_VERSION_SCHEME = "sha256-rfc8785";
-/**
- * Stable identity of a rubric, as `<name>@sha256-rfc8785:<hex>`. Two scores
- * are comparable when this matches exactly.
- *
- * The digest comes from `hashCanonical`, this package's only canonical-JSON
- * encoder (RFC 8785). RFC 8785 orders keys by UTF-16 code unit, which is a
- * property of the value alone — so the same rubric produces the same tag on
- * every machine, which a locale-collated key order does not guarantee.
- */
-export declare function hashRubric(rubric: Rubric): string;
 //#endregion
 //#region src/wire/handlers.d.ts
 /** Caller-fixable error. The transport renders this to 4xx + ErrorResponse. */
@@ -341,7 +319,7 @@ export declare class WireError extends Error {
   readonly details?: unknown;
   constructor(code: string, message: string, status?: number, details?: unknown);
 }
-export interface HandleJudgeOptions {
+interface HandleJudgeOptions {
   costLedger?: CostLedgerHandle;
   costPhase?: string;
   /**
@@ -355,9 +333,6 @@ export interface HandleJudgeOptions {
   pricing?: CustomTokenPricing;
   signal?: AbortSignal;
 }
-export declare function handleJudge(req: JudgeRequest, options?: HandleJudgeOptions): Promise<JudgeResult>;
-export declare function handleListRubrics(): ListRubricsResponse;
-export declare function handleVersion(): VersionResponse;
 /**
  * Pluggable stores the wire layer routes ingestion writes into. Both
  * are optional — when omitted, the corresponding endpoint returns 503.
@@ -366,344 +341,10 @@ export declare function handleVersion(): VersionResponse;
  * `FileSystemFeedbackTrajectoryStore` here. Tests substitute in-memory
  * stores.
  */
-export interface IngestionStores {
+interface IngestionStores {
   traceStore?: TraceStore;
   feedbackStore?: FeedbackTrajectoryStore;
 }
-/**
- * `POST /v1/traces/ingest` — accept a batch of `TraceEvent`s from the
- * production runtime. Best-effort: each event is appended independently;
- * one bad event does not poison the batch.
- *
- * Idempotency: the underlying store is append-only; consumers retrying
- * the same payload will get duplicate events. Consumers should
- * de-duplicate by `eventId` downstream — production traces frequently
- * land via at-least-once buses (Kafka, SQS) where dedup is unavoidable.
- */
-export declare function handleTracesIngest(req: TracesIngestRequest, stores: IngestionStores): Promise<TracesIngestResponse>;
-/**
- * `POST /v1/feedback` — accept a single `FeedbackTrajectory` from the
- * production runtime. Idempotent on `id`: re-posting the same trajectory
- * replaces the prior record.
- */
-export declare function handleFeedbackIngest(req: FeedbackTrajectory, stores: IngestionStores): Promise<FeedbackIngestResponse>;
-//#endregion
-//#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts
-type IExtensionName = `x-${string}`;
-type IExtensionType = any;
-type ISpecificationExtension = {
-  [extensionName: IExtensionName]: IExtensionType;
-};
-//#endregion
-//#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/oas-common.d.ts
-interface ServerObject extends ISpecificationExtension {
-  url: string;
-  description?: string;
-  variables?: {
-    [v: string]: ServerVariableObject;
-  };
-}
-interface ServerVariableObject extends ISpecificationExtension {
-  enum?: string[] | boolean[] | number[];
-  default: string | boolean | number;
-  description?: string;
-}
-//#endregion
-//#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/openapi31.d.ts
-interface OpenAPIObject extends ISpecificationExtension {
-  openapi: string;
-  info: InfoObject;
-  servers?: ServerObject[];
-  paths?: PathsObject;
-  components?: ComponentsObject;
-  security?: SecurityRequirementObject[];
-  tags?: TagObject[];
-  externalDocs?: ExternalDocumentationObject;
-  webhooks?: PathsObject;
-}
-interface InfoObject extends ISpecificationExtension {
-  title: string;
-  description?: string;
-  termsOfService?: string;
-  contact?: ContactObject;
-  license?: LicenseObject;
-  version: string;
-}
-interface ContactObject extends ISpecificationExtension {
-  name?: string;
-  url?: string;
-  email?: string;
-}
-interface LicenseObject extends ISpecificationExtension {
-  name: string;
-  identifier?: string;
-  url?: string;
-}
-interface ComponentsObject extends ISpecificationExtension {
-  schemas?: {
-    [schema: string]: SchemaObject | ReferenceObject;
-  };
-  responses?: {
-    [response: string]: ResponseObject | ReferenceObject;
-  };
-  parameters?: {
-    [parameter: string]: ParameterObject | ReferenceObject;
-  };
-  examples?: {
-    [example: string]: ExampleObject | ReferenceObject;
-  };
-  requestBodies?: {
-    [request: string]: RequestBodyObject | ReferenceObject;
-  };
-  headers?: {
-    [header: string]: HeaderObject | ReferenceObject;
-  };
-  securitySchemes?: {
-    [securityScheme: string]: SecuritySchemeObject | ReferenceObject;
-  };
-  links?: {
-    [link: string]: LinkObject | ReferenceObject;
-  };
-  callbacks?: {
-    [callback: string]: CallbackObject | ReferenceObject;
-  };
-  pathItems?: {
-    [pathItem: string]: PathItemObject | ReferenceObject;
-  };
-}
-interface PathsObject extends ISpecificationExtension {
-  [path: string]: PathItemObject;
-}
-interface PathItemObject extends ISpecificationExtension {
-  $ref?: string;
-  summary?: string;
-  description?: string;
-  get?: OperationObject;
-  put?: OperationObject;
-  post?: OperationObject;
-  delete?: OperationObject;
-  options?: OperationObject;
-  head?: OperationObject;
-  patch?: OperationObject;
-  trace?: OperationObject;
-  servers?: ServerObject[];
-  parameters?: (ParameterObject | ReferenceObject)[];
-}
-interface OperationObject extends ISpecificationExtension {
-  tags?: string[];
-  summary?: string;
-  description?: string;
-  externalDocs?: ExternalDocumentationObject;
-  operationId?: string;
-  parameters?: (ParameterObject | ReferenceObject)[];
-  requestBody?: RequestBodyObject | ReferenceObject;
-  responses?: ResponsesObject;
-  callbacks?: CallbacksObject;
-  deprecated?: boolean;
-  security?: SecurityRequirementObject[];
-  servers?: ServerObject[];
-}
-interface ExternalDocumentationObject extends ISpecificationExtension {
-  description?: string;
-  url: string;
-}
-type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
-type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
-interface BaseParameterObject extends ISpecificationExtension {
-  description?: string;
-  required?: boolean;
-  deprecated?: boolean;
-  allowEmptyValue?: boolean;
-  style?: ParameterStyle;
-  explode?: boolean;
-  allowReserved?: boolean;
-  schema?: SchemaObject | ReferenceObject;
-  examples?: {
-    [param: string]: ExampleObject | ReferenceObject;
-  };
-  example?: any;
-  content?: ContentObject;
-}
-interface ParameterObject extends BaseParameterObject {
-  name: string;
-  in: ParameterLocation;
-}
-interface RequestBodyObject extends ISpecificationExtension {
-  description?: string;
-  content: ContentObject;
-  required?: boolean;
-}
-interface ContentObject {
-  [mediatype: string]: MediaTypeObject;
-}
-interface MediaTypeObject extends ISpecificationExtension {
-  schema?: SchemaObject | ReferenceObject;
-  examples?: ExamplesObject;
-  example?: any;
-  encoding?: EncodingObject;
-}
-interface EncodingObject extends ISpecificationExtension {
-  [property: string]: EncodingPropertyObject | any;
-}
-interface EncodingPropertyObject {
-  contentType?: string;
-  headers?: {
-    [key: string]: HeaderObject | ReferenceObject;
-  };
-  style?: string;
-  explode?: boolean;
-  allowReserved?: boolean;
-  [key: string]: any;
-}
-interface ResponsesObject extends ISpecificationExtension {
-  default?: ResponseObject | ReferenceObject;
-  [statuscode: string]: ResponseObject | ReferenceObject | any;
-}
-interface ResponseObject extends ISpecificationExtension {
-  description: string;
-  headers?: HeadersObject;
-  content?: ContentObject;
-  links?: LinksObject;
-}
-interface CallbacksObject extends ISpecificationExtension {
-  [name: string]: CallbackObject | ReferenceObject | any;
-}
-interface CallbackObject extends ISpecificationExtension {
-  [name: string]: PathItemObject | any;
-}
-interface HeadersObject {
-  [name: string]: HeaderObject | ReferenceObject;
-}
-interface ExampleObject {
-  summary?: string;
-  description?: string;
-  value?: any;
-  externalValue?: string;
-  [property: string]: any;
-}
-interface LinksObject {
-  [name: string]: LinkObject | ReferenceObject;
-}
-interface LinkObject extends ISpecificationExtension {
-  operationRef?: string;
-  operationId?: string;
-  parameters?: LinkParametersObject;
-  requestBody?: any | string;
-  description?: string;
-  server?: ServerObject;
-  [property: string]: any;
-}
-interface LinkParametersObject {
-  [name: string]: any | string;
-}
-interface HeaderObject extends BaseParameterObject {
-  $ref?: string;
-}
-interface TagObject extends ISpecificationExtension {
-  name: string;
-  description?: string;
-  externalDocs?: ExternalDocumentationObject;
-  [extension: string]: any;
-}
-interface ExamplesObject {
-  [name: string]: ExampleObject | ReferenceObject;
-}
-interface ReferenceObject {
-  $ref: string;
-  summary?: string;
-  description?: string;
-}
-type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
-interface SchemaObject extends ISpecificationExtension {
-  $ref?: string;
-  discriminator?: DiscriminatorObject;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  xml?: XmlObject;
-  externalDocs?: ExternalDocumentationObject;
-  example?: any;
-  examples?: any[];
-  deprecated?: boolean;
-  type?: SchemaObjectType | SchemaObjectType[];
-  format?: 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
-  allOf?: (SchemaObject | ReferenceObject)[];
-  oneOf?: (SchemaObject | ReferenceObject)[];
-  anyOf?: (SchemaObject | ReferenceObject)[];
-  not?: SchemaObject | ReferenceObject;
-  items?: SchemaObject | ReferenceObject;
-  properties?: {
-    [propertyName: string]: SchemaObject | ReferenceObject;
-  };
-  additionalProperties?: SchemaObject | ReferenceObject | boolean;
-  propertyNames?: SchemaObject | ReferenceObject;
-  description?: string;
-  default?: any;
-  title?: string;
-  multipleOf?: number;
-  maximum?: number;
-  const?: any;
-  exclusiveMaximum?: number;
-  minimum?: number;
-  exclusiveMinimum?: number;
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-  maxItems?: number;
-  minItems?: number;
-  uniqueItems?: boolean;
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  enum?: any[];
-  prefixItems?: (SchemaObject | ReferenceObject)[];
-  contentMediaType?: string;
-  contentEncoding?: string;
-}
-interface DiscriminatorObject {
-  propertyName: string;
-  mapping?: {
-    [key: string]: string;
-  };
-}
-interface XmlObject extends ISpecificationExtension {
-  name?: string;
-  namespace?: string;
-  prefix?: string;
-  attribute?: boolean;
-  wrapped?: boolean;
-}
-type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
-interface SecuritySchemeObject extends ISpecificationExtension {
-  type: SecuritySchemeType;
-  description?: string;
-  name?: string;
-  in?: string;
-  scheme?: string;
-  bearerFormat?: string;
-  flows?: OAuthFlowsObject;
-  openIdConnectUrl?: string;
-}
-interface OAuthFlowsObject extends ISpecificationExtension {
-  implicit?: OAuthFlowObject;
-  password?: OAuthFlowObject;
-  clientCredentials?: OAuthFlowObject;
-  authorizationCode?: OAuthFlowObject;
-}
-interface OAuthFlowObject extends ISpecificationExtension {
-  authorizationUrl?: string;
-  tokenUrl?: string;
-  refreshUrl?: string;
-  scopes: ScopesObject;
-}
-interface ScopesObject extends ISpecificationExtension {
-  [scope: string]: any;
-}
-interface SecurityRequirementObject {
-  [name: string]: string[];
-}
-//#endregion
-//#region src/wire/openapi.d.ts
-export declare function buildOpenApi(packageVersion: string): OpenAPIObject;
 //#endregion
 //#region src/wire/rpc.d.ts
 interface RpcRequest {
@@ -726,26 +367,6 @@ interface RpcOptions {
   judgeModel?: string;
 }
 export declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
-/** Read one JSON request from stdin, write one JSON response to stdout. */
-export declare function runRpcOnce(method?: string, options?: RpcOptions): Promise<number>;
-/** Read JSONL requests from stdin, write JSONL responses to stdout. */
-export declare function runRpcBatch(method?: string, options?: RpcOptions): Promise<number>;
-//#endregion
-//#region src/wire/rubrics.d.ts
-/** Get a built-in rubric by name, or undefined. */
-export declare function getBuiltinRubric(name: string): Rubric | undefined;
-/** List built-in rubrics with their stable versions. */
-export declare function listBuiltinRubrics(): {
-  name: string;
-  description: string;
-  dimensions: {
-    id: string;
-    description: string;
-    weight: number;
-  }[];
-  failureModes: string[];
-  rubricVersion: string;
-}[];
 //#endregion
 //#region src/wire/server.d.ts
 interface CreateAppOptions {
@@ -798,5 +419,5 @@ interface StartedServer {
  */
 export declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
 //#endregion
-export type { RpcOptions, ServeOptions, StartedServer };
+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":["WireFeedbackTrajectory"],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/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","../../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"}

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-import { A as WIRE_VERSION, C as RUBRIC_VERSION_SCHEME, D as TracesIngestRequestSchema, E as TraceEventSchema, O as TracesIngestResponseSchema, S as ListRubricsResponseSchema, T as RubricSchema, _ as FeedbackIngestResponseSchema, a as runRpcBatch, b as JudgeRequestSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as ErrorResponseSchema, h as listBuiltinRubrics, i as dispatchRpc, j as hashRubric, k as VersionResponseSchema, l as handleFeedbackIngest, m as getBuiltinRubric, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FeedbackTrajectorySchema, w as RubricDimensionSchema, x as JudgeResultSchema, y as HealthResponseSchema } from "../server-e9oWO_bN.js";
-export { ErrorResponseSchema, FeedbackIngestResponseSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RUBRIC_VERSION_SCHEME, RubricDimensionSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };
+import { a as 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-DoVbqqtJ.js";
+export { ErrorResponseSchema, FeedbackTrajectorySchema, TraceEventSchema, WIRE_VERSION, WireError, createApp, dispatchRpc, startServer, startServerAsync };

package/docs/changes/jev-evidence-review.md

@@ -5,7 +5,7 @@
 thresholds and result policy. Review identity includes authored option order; request JSON is
 not sorted before dispatch. Missing or partial negative evidence cannot become a clean review.
 
-The optional `examples/jev-behavior-review.ts` recipe covers reward gaming, evaluator tampering,
+The optional behavior-review recipe (its example file is not in this tree) covers reward gaming, evaluator tampering,
 policy/authorization/data-boundary breaches, injection-following, contradicted completion,
 oversight bypass, matched-baseline anomalies and cross-run behavior. It composes the existing
 `jevAnalyst`; the taxonomy is not installed in the generic evaluator and is not a calibrated