@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/integrity/backend-integrity.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Backend-integrity guard: distinguish "agent failed" from "eval ran against
+ * a stub / unconfigured backend." Without this guard a canonical eval can
+ * silently report `0/N passed` and look like an agent-quality problem when
+ * the LLM was never actually called — the failure mode we just hit running
+ * the 4-vertical parallel eval (legal-sandbox-stub returned hard-coded 33-104
+ * char strings; gtm/creative defaulted to a cli-bridge that wasn't running).
+ *
+ * The shape:
+ *
+ *   const report = summarizeBackendIntegrity(records)
+ *   assertRealBackend(records)   // throws BackendIntegrityError if 100% stub
+ *
+ * A record is "stub-mode" if its `tokenUsage.input === 0 && tokenUsage.output === 0`.
+ * (`costUsd` alone is unreliable — some backends successfully call LLMs but
+ *  don't propagate pricing, producing real tokens with $0 cost.)
+ *
+ * Verdicts:
+ *   - `real`   — at least one record has nonzero token usage
+ *   - `stub`   — every record is stub-mode (eval ran blind)
+ *   - `mixed`  — some records real, some stub (partial backend failure;
+ *                often the 429-cascade or auth-half-failed case)
+ */
+import { AgentEvalError } from '../errors';
+import type { RunRecord } from '../run-record';
+export interface BackendIntegrityReport {
+    /** Total records inspected. */
+    totalRecords: number;
+    /** Records with input=0 AND output=0 (a stub fingerprint). */
+    stubRecords: number;
+    /** Records with nonzero token usage (real LLM activity). */
+    realRecords: number;
+    /** Records where output>0 but costUsd=0 (real LLM, broken cost ledger). */
+    uncostedRecords: number;
+    /** Sum of input tokens across all records. */
+    totalInputTokens: number;
+    /** Sum of output tokens across all records. */
+    totalOutputTokens: number;
+    /** Sum of costUsd across all records. */
+    totalCostUsd: number;
+    /** Worst-case integrity verdict. */
+    verdict: 'real' | 'mixed' | 'stub';
+    /** Human-readable diagnosis suitable for terminal output. */
+    diagnosis: string;
+}
+/**
+ * Error thrown when an integrity assertion fails. Caller can pattern-match
+ * by `code === 'AGENT_EVAL_BACKEND_STUB'` to differentiate from other
+ * errors.
+ */
+export declare class BackendIntegrityError extends AgentEvalError {
+    readonly report: BackendIntegrityReport;
+    constructor(message: string, report: BackendIntegrityReport);
+}
+/**
+ * Inspect a batch of RunRecords and return an integrity report. Pure
+ * function — no I/O, no logging. The caller decides what to do with the
+ * verdict (print warning, throw, gate CI, etc.).
+ */
+export declare function summarizeBackendIntegrity(records: ReadonlyArray<RunRecord>): BackendIntegrityReport;
+/**
+ * Throw BackendIntegrityError if the verdict is 'stub' — i.e. every record
+ * shows zero LLM activity. Non-strict callers can pass `{ allowMixed: false }`
+ * to also reject mixed verdicts (recommended for CI gates).
+ *
+ * Real backends pass through silently.
+ */
+export declare function assertRealBackend(records: ReadonlyArray<RunRecord>, opts?: {
+    allowMixed?: boolean;
+}): BackendIntegrityReport;
+//# sourceMappingURL=backend-integrity.d.ts.map

package/dist/integrity/backend-integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-integrity.d.ts","sourceRoot":"","sources":["../../src/integrity/backend-integrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,MAAM,WAAW,sBAAsB;IACrC,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAA;IACpB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAA;IACnB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,eAAe,EAAE,MAAM,CAAA;IACvB,8CAA8C;IAC9C,gBAAgB,EAAE,MAAM,CAAA;IACxB,+CAA+C;IAC/C,iBAAiB,EAAE,MAAM,CAAA;IACzB,yCAAyC;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAA;IAClC,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,cAAc;aAGrC,MAAM,EAAE,sBAAsB;gBAD9C,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,sBAAsB;CAIjD;AAUD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,GAChC,sBAAsB,CA6CxB;AAoCD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,EACjC,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GAClC,sBAAsB,CAgBxB"}

package/dist/integrity/preflight.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Backend preflight: verify the models a campaign is about to spend tokens
+ * against are actually served by the router BEFORE the run starts. The PRE-hoc
+ * complement to `assertRealBackend` (which inspects RunRecords AFTER the run to
+ * catch a stub/unconfigured backend).
+ *
+ * Two checks, increasing in cost:
+ *   - membership (free): GET `{baseUrl}/models` once; a model is `listed` when
+ *     its id is in the served set.
+ *   - probe (spends a tiny number of tokens): POST `{baseUrl}/chat/completions`
+ *     per model with a 1-message, 5-token request; `served` is whether the
+ *     router returns 2xx, with the HTTP `status` and the body's `error.message`
+ *     captured in `detail`.
+ *
+ * A default model the router cannot serve is a config bug. Gate a campaign on
+ * `assertModelsServed` and it surfaces every dead id with its status + detail
+ * instead of silently producing a stub run.
+ */
+import { AgentEvalError } from '../errors';
+export interface ModelPreflight {
+    /** The model id as supplied by the caller. */
+    model: string;
+    /** Membership in the `{baseUrl}/models` served set. */
+    listed: boolean;
+    /** 2xx on a 1-token chat probe. `null` when `probe` was not requested. */
+    served: boolean | null;
+    /** HTTP status of the probe. `null` when not probed. */
+    status: number | null;
+    /** Probe body's `error.message` when present, else `null`. */
+    detail: string | null;
+}
+export interface PreflightModelsOptions {
+    /** Router base URL, e.g. `https://router.tangle.tools/v1`. Trailing slash tolerated. */
+    baseUrl: string;
+    /** Bearer token sent as `Authorization: Bearer <apiKey>`. */
+    apiKey: string;
+    /** Model ids to check. */
+    models: string[];
+    /** When true, additionally spend a 1-token chat probe per model. Default false. */
+    probe?: boolean;
+    /** Injectable fetch for tests; defaults to the global. */
+    fetchImpl?: typeof fetch;
+}
+export interface PreflightOutcome {
+    succeeded: boolean;
+    value: ModelPreflight[] | null;
+    error: string | null;
+}
+/**
+ * Check that `models` are reachable on the router. Returns a typed outcome —
+ * a network failure yields `{ succeeded: false, error }`, never a throw and
+ * never a partial result silently reported as success. No retries, no
+ * fallbacks.
+ *
+ * The membership check (one GET) always runs. When `probe` is true, each model
+ * additionally gets a 1-token chat probe so a model that is listed but
+ * unconfigured (a 401 `model_not_found` from the router) is caught.
+ */
+export declare function preflightModels(opts: PreflightModelsOptions): Promise<PreflightOutcome>;
+export declare class ModelsUnreachableError extends AgentEvalError {
+    readonly results: ReadonlyArray<ModelPreflight>;
+    constructor(message: string, results: ReadonlyArray<ModelPreflight>);
+}
+/**
+ * Throw `ModelsUnreachableError` naming EVERY model that is unlisted or (when
+ * probed) failed its probe — with status + detail per model. A model is dead
+ * if it is unlisted, or if `served === false`. Callers gate a campaign on this
+ * before spending tokens. When the network call itself fails the underlying
+ * outcome error is rethrown — there is no partial silent pass.
+ */
+export declare function assertModelsServed(opts: PreflightModelsOptions): Promise<ModelPreflight[]>;
+//# sourceMappingURL=preflight.d.ts.map

package/dist/integrity/preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.d.ts","sourceRoot":"","sources":["../../src/integrity/preflight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,cAAc,EAAe,MAAM,WAAW,CAAA;AAEvD,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAA;IACb,uDAAuD;IACvD,MAAM,EAAE,OAAO,CAAA;IACf,0EAA0E;IAC1E,MAAM,EAAE,OAAO,GAAG,IAAI,CAAA;IACtB,wDAAwD;IACxD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAA;IACf,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAA;IACd,0BAA0B;IAC1B,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,mFAAmF;IACnF,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAwBD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA4D7F;AAED,qBAAa,sBAAuB,SAAQ,cAAc;aAGtC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC;gBADtD,OAAO,EAAE,MAAM,EACC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC;CAKzD;AAYD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAiBhG"}

package/dist/integrity/preflight.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preflight.test.d.ts.map

package/dist/integrity/preflight.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.test.d.ts","sourceRoot":"","sources":["../../src/integrity/preflight.test.ts"],"names":[],"mappings":""}

package/dist/integrity/single-backend.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Single-backend guard: assert the agent and the rubric judge run through the
+ * SAME backend config, so the judge can't silently re-route through a
+ * different (often paid) backend than the agent.
+ *
+ * The bug class: `--backend cli-bridge` rewires the agent, but the judge still
+ * reads `process.env.TANGLE_API_KEY` → router. Cost is billed against the
+ * router, the eval reports the cli-bridge model, and the data is unusable.
+ * Four consumers hand-roll this comparison (legal at `canonical.ts:702-795`);
+ * this is the one substrate copy.
+ *
+ * Complements `assertRealBackend` (records → stub vs real) and
+ * `assertCrossFamily` (judge-ensemble family diversity): this one compares two
+ * backend *configs* before the run.
+ */
+import { AgentEvalError } from '../errors';
+/**
+ * Minimal backend-config shape the assertion reads. Consumers may pass richer
+ * types — only these five fields are inspected.
+ */
+export interface BackendDescriptor {
+    /** Backend route — e.g. `'tcloud' | 'cli-bridge' | 'sandbox' | 'direct-provider'`;
+     *  free-form for consumer extensibility. */
+    kind: string;
+    /** Resolved base URL. Compared lexically (trailing slash stripped). */
+    baseUrl: string;
+    /** Model id (with snapshot suffix). Compared lexically. */
+    model: string;
+    /** Optional provider override. Compared when both set; flagged when only
+     *  one side sets it. */
+    provider?: string;
+    /** Bearer token. Values are NEVER compared (security) — only that EITHER
+     *  both are set OR both are empty. Mismatched presence is a divergence. */
+    apiKey?: string;
+}
+export interface AssertSingleBackendOptions {
+    /** When true, ANY field divergence fails. When false (default), only
+     *  `kind` / `baseUrl` / `provider` / `apiKeyPresence` divergence throws —
+     *  a different judge `model` on the same route is allowed (the legal
+     *  pattern: a cheaper judge model). */
+    strict?: boolean;
+    agentLabel?: string;
+    judgeLabel?: string;
+}
+export type SingleBackendField = 'kind' | 'baseUrl' | 'model' | 'provider' | 'apiKeyPresence';
+export interface SingleBackendDivergence {
+    field: SingleBackendField;
+    agent: string | undefined;
+    judge: string | undefined;
+}
+export interface SingleBackendReport {
+    /** True when agent + judge agree per the configured strictness. */
+    ok: boolean;
+    /** Every divergence detected (includes `model` even when non-blocking). */
+    divergences: ReadonlyArray<SingleBackendDivergence>;
+}
+export declare class SingleBackendError extends AgentEvalError {
+    readonly report: SingleBackendReport;
+    constructor(message: string, report: SingleBackendReport);
+}
+/**
+ * Throw `SingleBackendError` when the agent and judge backends diverge in a
+ * way that would re-route the judge through a different backend than the
+ * agent. Returns the report so callers can log it in either case.
+ */
+export declare function assertSingleBackend(agent: BackendDescriptor, judge: BackendDescriptor, opts?: AssertSingleBackendOptions): SingleBackendReport;
+//# sourceMappingURL=single-backend.d.ts.map

package/dist/integrity/single-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-backend.d.ts","sourceRoot":"","sources":["../../src/integrity/single-backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAE1C;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;gDAC4C;IAC5C,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAA;IACb;4BACwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;+EAC2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC;;;2CAGuC;IACvC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,CAAA;AAE7F,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,kBAAkB,CAAA;IACzB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,mEAAmE;IACnE,EAAE,EAAE,OAAO,CAAA;IACX,2EAA2E;IAC3E,WAAW,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAA;CACpD;AAED,qBAAa,kBAAmB,SAAQ,cAAc;aAGlC,MAAM,EAAE,mBAAmB;gBAD3C,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,mBAAmB;CAK9C;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,iBAAiB,EACxB,IAAI,GAAE,0BAA+B,GACpC,mBAAmB,CA6CrB"}

package/dist/intent-match-judge.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Intent-match judge — "did the agent build the right APP, ignoring
+ * whether every feature is wired up?"
+ *
+ * Distinct from {@link runSemanticConceptJudge} which scores per-concept
+ * presence. The semantic judge can return 0/4 concepts present even
+ * when the agent built a thoughtful, polished, on-brief app that just
+ * lacks one or two features. The semantic judge can also return 4/4
+ * present even when the agent shipped the wrong project (keyword-rich
+ * stub).
+ *
+ * Intent-match asks ONE question:
+ *   "Looking at the agent's work as a whole — independent of feature
+ *    coverage — is this an honest attempt at the user's request?"
+ *
+ * Returns a 0–1 score and a 1-sentence evidence string. Use as a sanity
+ * check on `completenessScore`-style metrics: if intent-match is high
+ * and concept count is low, the agent built the right thing but is
+ * missing features (ship and iterate). If intent-match is low, the
+ * agent built the wrong thing (reject regardless of concept count).
+ *
+ * Soft-fails on LLM/JSON error (`available: false`) so callers can
+ * treat failure as "judge skipped."
+ */
+import { type LlmClientOptions } from './llm-client';
+export declare const INTENT_MATCH_JUDGE_VERSION = "intent-match-judge-v1-2026-04-24";
+export interface IntentMatchInput {
+    /** The full natural-language prompt the agent was handed. */
+    userRequest: string;
+    /** Top-level source files from the agent's workdir. */
+    sourceFiles: Array<{
+        path: string;
+        content: string;
+    }>;
+    /** Rendered HTML the preview returned, when available. */
+    servedHtml?: string;
+    /** Optional metadata to inject (id, vertical, difficulty). */
+    artifactLabel?: string;
+    artifactDescription?: string;
+}
+export interface IntentMatchResult {
+    kind: 'intent-match';
+    version: string;
+    /** 0..1 — 1 = unmistakably the right app, 0 = unrelated to the brief. */
+    score: number;
+    /** One-sentence rationale citing concrete evidence (file or HTML). */
+    evidence: string;
+    durationMs: number;
+    costUsd: number | null;
+    available: boolean;
+    error?: string;
+}
+export interface IntentMatchOptions {
+    model?: string;
+    timeoutMs?: number;
+    maxSourceChars?: number;
+    maxPerFileChars?: number;
+    maxHtmlChars?: number;
+    llm?: LlmClientOptions;
+}
+/**
+ * Run the intent-match judge. Soft-fails to available=false on error.
+ */
+export declare function runIntentMatchJudge(input: IntentMatchInput, options?: IntentMatchOptions): Promise<IntentMatchResult>;
+/**
+ * Factory: pin LLM options once, return a closure.
+ */
+export declare function createIntentMatchJudge(options?: IntentMatchOptions): (input: IntentMatchInput) => Promise<IntentMatchResult>;
+//# sourceMappingURL=intent-match-judge.d.ts.map

package/dist/intent-match-judge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-match-judge.d.ts","sourceRoot":"","sources":["../src/intent-match-judge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAe,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEjE,eAAO,MAAM,0BAA0B,qCAAqC,CAAA;AAE5E,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACrD,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,cAAc,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,GAAG,CAAC,EAAE,gBAAgB,CAAA;CACvB;AAmED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAiE5B;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,kBAAuB,GAC/B,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAEzD"}

package/dist/intent-match-judge.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=intent-match-judge.test.d.ts.map

package/dist/intent-match-judge.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-match-judge.test.d.ts","sourceRoot":"","sources":["../src/intent-match-judge.test.ts"],"names":[],"mappings":""}

package/dist/{judge-calibration-0p2QcWNE.d.ts → judge-calibration.d.ts}

@@ -18,19 +18,19 @@
  * Returns actionable diagnostics, not a single number. Consumers then
  * decide whether to trust the judge, retrain it, or add a tie-breaker.
  */
-interface GoldenItem {
+export interface GoldenItem {
     itemId: string;
     humanScore: number;
     /** Optional group used for per-group bias audits (e.g. model-of-output family). */
     group?: string;
 }
-interface CandidateScore {
+export interface CandidateScore {
     itemId: string;
     score: number;
     /** Optional — enables positional-bias analysis (did order matter?). */
     positionOfAInput?: 'first' | 'second';
 }
-interface CalibrationResult {
+export interface CalibrationResult {
     n: number;
     pearson: number;
     /** Cohen's κ with quadratic weights over integer-rounded scores. */
@@ -45,8 +45,8 @@ interface CalibrationResult {
         delta: number;
     }>;
 }
-declare function calibrateJudge(golden: GoldenItem[], candidate: CandidateScore[]): CalibrationResult;
-interface PositionalBiasResult {
+export declare function calibrateJudge(golden: GoldenItem[], candidate: CandidateScore[]): CalibrationResult;
+export interface PositionalBiasResult {
     /**
      * Score delta (first-position - second-position) averaged across items
      * presented in both positions. Non-zero = positional bias.
@@ -58,17 +58,17 @@ interface PositionalBiasResult {
  * Feed the same items to the judge twice with A/B swapped and pass all
  * results here. Items that don't appear in both positions are ignored.
  */
-declare function positionalBias(scores: CandidateScore[]): PositionalBiasResult;
-interface VerbosityBiasResult {
+export declare function positionalBias(scores: CandidateScore[]): PositionalBiasResult;
+export interface VerbosityBiasResult {
     /** Pearson correlation between output length and score. Strong positive = verbosity bias. */
     pearson: number;
     n: number;
 }
-declare function verbosityBias(samples: Array<{
+export declare function verbosityBias(samples: Array<{
     outputLen: number;
     score: number;
 }>): VerbosityBiasResult;
-interface SelfPreferenceResult {
+export interface SelfPreferenceResult {
     /** Mean judge score when judge's family matches output's family. */
     inFamilyMean: number;
     outOfFamilyMean: number;
@@ -80,11 +80,11 @@ interface SelfPreferenceResult {
  * model X (in-family) and model Y (out-of-family). Non-zero delta
  * indicates self-preference.
  */
-declare function selfPreference(samples: Array<{
+export declare function selfPreference(samples: Array<{
     score: number;
     inFamily: boolean;
 }>): SelfPreferenceResult;
-interface ContinuousAgreement {
+export interface ContinuousAgreement {
     /** Cohen's κ_w with quadratic weights, computed on raw [0,1] scores. */
     weightedKappa: number;
     /** ICC(2,1): two-way random effects, absolute agreement, single rater. */
@@ -103,7 +103,7 @@ interface ContinuousAgreement {
     /** Number of raters. */
     raters: number;
 }
-interface ContinuousAgreementOptions {
+export interface ContinuousAgreementOptions {
     /** Bootstrap iterations. Default 1000. Set to 0 to skip CIs (CI = [NaN, NaN]). */
     bootstrap?: number;
     /** κ weighting scheme. Default 'quadratic'. */
@@ -120,8 +120,8 @@ interface ContinuousAgreementOptions {
  * are dropped. Returns NaN metrics if fewer than 2 raters or 2 complete
  * items remain.
  */
-declare function continuousAgreement(scores: number[][], opts?: ContinuousAgreementOptions): ContinuousAgreement;
-interface ContinuousCalibrationResult extends CalibrationResult {
+export declare function continuousAgreement(scores: number[][], opts?: ContinuousAgreementOptions): ContinuousAgreement;
+export interface ContinuousCalibrationResult extends CalibrationResult {
     /** Cohen's κ_w computed on raw (un-rounded) scores. */
     weightedKappaContinuous: number;
     /** ICC(2,1) treating golden + candidate as two raters. */
@@ -137,6 +137,5 @@ interface ContinuousCalibrationResult extends CalibrationResult {
  * agreement metrics. The old fields (n, pearson, kappa, mae, worstItems)
  * are preserved unchanged so existing callers continue to work.
  */
-declare function calibrateJudgeContinuous(golden: GoldenItem[], candidate: CandidateScore[], opts?: ContinuousAgreementOptions): ContinuousCalibrationResult;
-
-export { type ContinuousAgreement as C, type GoldenItem as G, type PositionalBiasResult as P, type SelfPreferenceResult as S, type VerbosityBiasResult as V, type CalibrationResult as a, type ContinuousCalibrationResult as b, type CandidateScore as c, type ContinuousAgreementOptions as d, calibrateJudge as e, calibrateJudgeContinuous as f, continuousAgreement as g, positionalBias as p, selfPreference as s, verbosityBias as v };
+export declare function calibrateJudgeContinuous(golden: GoldenItem[], candidate: CandidateScore[], opts?: ContinuousAgreementOptions): ContinuousCalibrationResult;
+//# sourceMappingURL=judge-calibration.d.ts.map

package/dist/judge-calibration.d.ts.map

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

package/dist/judge-ensemble.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Judge-ensemble reducer — folds N independent judge verdicts on the same
+ * artifact into one aggregate score.
+ *
+ * The pattern every multi-model judge re-implements: run K uncorrelated judges
+ * (different model families remove within-family bias), then reduce their
+ * per-dimension verdicts to a single composite + an inter-rater disagreement
+ * signal. This is the pure reduction — no LLM, no I/O — so a lift it produces
+ * is attributable to the scores, not to where they came from.
+ *
+ * Fail-loud: a judge that errored or returned malformed output is recorded in
+ * `failedJudges` with `perDimension: null`, never folded into a zero. If EVERY
+ * judge failed the reducer throws — a silent zero here would corrupt the gate's
+ * number. A failed judge still burned tokens, so its `costUsd` is still summed.
+ */
+/** One judge's verdict. `perDimension: null` ⇒ that judge call failed (threw or
+ *  returned malformed output) — recorded, never folded into a zero. */
+export interface JudgeVerdict<D extends string = string> {
+    /** Judge identity (typically the model id) — the `perJudge` / `failedJudges` key. */
+    model: string;
+    /** Per-dimension scores, or `null` when the judge failed. */
+    perDimension: Record<D, number> | null;
+    /** Optional one-line rationale; the first non-empty one becomes the aggregate's. */
+    rationale?: string;
+    /** Optional reported cost — summed across ALL verdicts (failed included). */
+    costUsd?: number;
+    /** Optional per-dimension reasoning/evidence. Carried through to
+     *  `EnsembleAggregate.verdicts` verbatim — never folded into the math. */
+    detail?: Partial<Record<D, {
+        reasoning?: string;
+        evidence?: string;
+    }>>;
+}
+/** The aggregated ensemble result. */
+export interface EnsembleAggregate<D extends string = string> {
+    /** Mean over SURVIVING judges, per dimension (absent-everywhere ⇒ 0). */
+    perDimension: Record<D, number>;
+    /** Weighted mean of `perDimension` (uniform unless `weights` given). */
+    composite: number;
+    /** Each surviving judge's clamped per-dimension scores, for trace drill-down. */
+    perJudge: Record<string, Record<D, number>>;
+    /** Max over dimensions of (max − min) across survivors — the inter-rater signal. */
+    maxDisagreement: number;
+    /** Models whose verdict was null (failed). */
+    failedJudges: string[];
+    /** Sum of `costUsd` over ALL verdicts, failed included. */
+    costUsd: number;
+    /** First non-empty survivor rationale, or `'llm-judge'`. */
+    rationale: string;
+    /** The input verdicts, verbatim — drill-down to raw scores, `detail`
+     *  reasoning/evidence, and per-verdict cost without re-running judges. */
+    verdicts: JudgeVerdict<D>[];
+}
+/**
+ * Reduce per-judge verdicts to one aggregate. Generic over the rubric: pass the
+ * stable-ordered `dimensionKeys` the judges scored.
+ *
+ * - Per-dimension score = mean over surviving judges (out-of-range clamped to [0,1]).
+ * - `composite` = `weightedComposite` of `perDimension`. No `weights` ⇒ uniform
+ *   over every dimension. A partial `weights` map selects AND weights exactly the
+ *   named dimensions (others excluded from the composite) — the substrate's
+ *   sum-normalized weighting, not re-implemented here.
+ * - Throws if `verdicts` or `dimensionKeys` is empty, or if every judge failed.
+ */
+export declare function aggregateJudgeVerdicts<D extends string>(verdicts: readonly JudgeVerdict<D>[], dimensionKeys: readonly D[], weights?: Partial<Record<D, number>>): EnsembleAggregate<D>;
+//# sourceMappingURL=judge-ensemble.d.ts.map

package/dist/judge-ensemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-ensemble.d.ts","sourceRoot":"","sources":["../src/judge-ensemble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;uEACuE;AACvE,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACrD,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACtC,oFAAoF;IACpF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;8EAC0E;IAC1E,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;CACvE;AAED,sCAAsC;AACtC,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC1D,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;IAC/B,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA;IAC3C,oFAAoF;IACpF,eAAe,EAAE,MAAM,CAAA;IACvB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAA;IACjB;8EAC0E;IAC1E,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAA;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EACrD,QAAQ,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,EACpC,aAAa,EAAE,SAAS,CAAC,EAAE,EAC3B,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACnC,iBAAiB,CAAC,CAAC,CAAC,CA6EtB"}

package/dist/judge-ensemble.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The ensemble reducer's job is to fold N judge verdicts into one trustworthy
+ * number. These tests pin the invariants a silent zero would break: a failed
+ * judge never counts as zero, all-failed throws, cost includes failures, and
+ * the composite/disagreement signals match the per-dimension survivors.
+ */
+export {};
+//# sourceMappingURL=judge-ensemble.test.d.ts.map

package/dist/judge-ensemble.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-ensemble.test.d.ts","sourceRoot":"","sources":["../src/judge-ensemble.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/judge-families.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Judge model-family classification + cross-family enforcement.
+ *
+ * A judge ensemble built entirely from one provider family shares that
+ * family's blind spots and self-preference — its "agreement" is correlated
+ * bias, not independent signal. `assertCrossFamily` makes the consumer prove
+ * the ensemble spans ≥2 families; `judgeFamily` is the single regex map that
+ * replaces the per-consumer copies (tax/legal/creative/gtm each ship one).
+ */
+/** Provider family a model belongs to. `unknown` when no rule matches. */
+export type JudgeFamily = 'anthropic' | 'openai' | 'google' | 'meta' | 'mistral' | 'deepseek' | 'xai' | 'qwen' | 'cohere' | 'amazon' | 'moonshot' | 'zhipu' | 'unknown';
+/**
+ * Classify a model id into its provider family. Strips a `@snapshot` suffix
+ * and prefers an explicit `provider/...` prefix; otherwise matches the model
+ * name. Returns `unknown` when nothing matches (callers decide whether that's
+ * acceptable — `assertCrossFamily` counts it as its own family).
+ */
+export declare function judgeFamily(modelId: string): JudgeFamily;
+export interface AssertCrossFamilyOptions {
+    /** Minimum number of distinct families the ensemble must span. Default 2. */
+    minFamilies?: number;
+    /** When false (default), `unknown`-family models do NOT count toward the
+     *  family total — an ensemble of all-unclassifiable models is not provably
+     *  cross-family. Set true to count `unknown` as one shared family. */
+    allowUnknown?: boolean;
+}
+export declare class CrossFamilyError extends Error {
+    readonly families: JudgeFamily[];
+    readonly models: string[];
+    constructor(message: string, families: JudgeFamily[], models: string[]);
+}
+/**
+ * Throw unless the judge models span at least `minFamilies` distinct provider
+ * families. Pass the model ids backing your judge ensemble. Fail-loud by
+ * design — a correlated single-family ensemble silently inflates agreement.
+ */
+export declare function assertCrossFamily(models: string[], opts?: AssertCrossFamilyOptions): JudgeFamily[];
+//# sourceMappingURL=judge-families.d.ts.map

package/dist/judge-families.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-families.d.ts","sourceRoot":"","sources":["../src/judge-families.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,0EAA0E;AAC1E,MAAM,MAAM,WAAW,GACnB,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,SAAS,GACT,UAAU,GACV,KAAK,GACL,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,OAAO,GACP,SAAS,CAAA;AA+Cb;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAYxD;AAED,MAAM,WAAW,wBAAwB;IACvC,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;0EAEsE;IACtE,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,qBAAa,gBAAiB,SAAQ,KAAK;aAGvB,QAAQ,EAAE,WAAW,EAAE;aACvB,MAAM,EAAE,MAAM,EAAE;gBAFhC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,WAAW,EAAE,EACvB,MAAM,EAAE,MAAM,EAAE;CAKnC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,GAAE,wBAA6B,GAClC,WAAW,EAAE,CAmBf"}

package/dist/judge-panel.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Multi-model judge panel — `ensembleJudge` builds a campaign `JudgeConfig`
+ * that fans one artifact out to K judge models and reduces their verdicts
+ * through `aggregateJudgeVerdicts` (src/judge-ensemble.ts).
+ *
+ * The panel is the fail-loud composition of the substrate's existing judge
+ * primitives:
+ *   - `assertCrossFamily` (construction-time) — a single-family panel is
+ *     correlated bias, not independent signal.
+ *   - `withJudgeRetry` (per model, opt-in) — transient-fault retry with a
+ *     typed outcome; a judge that exhausts retries is recorded as failed,
+ *     never folded into a zero.
+ *   - `aggregateJudgeVerdicts` — the pure reducer; throws when EVERY judge
+ *     failed so a silent zero can't reach the gate.
+ *
+ * The returned `JudgeScore` is on the campaign [0,1] scale and carries the
+ * ensemble extras (`maxDisagreement`, `failedJudges`, `perJudge`) declared
+ * on the canonical `JudgeScore` in src/campaign/types.ts.
+ */
+import type { JudgeConfig } from './campaign/types';
+import { type JudgeVerdict } from './judge-ensemble';
+import { type JudgeRetryPolicy } from './judge-retry';
+export interface EnsembleJudgeOptions<D extends string> {
+    /** Judge name — becomes the returned `JudgeConfig.name`. */
+    name: string;
+    /** Rubric dimensions every model scores. Keys of the verdict's `perDimension`. */
+    dimensions: D[];
+    /** Judge model ids — one `scoreWith` call per entry. List a model twice to
+     *  sample it twice (votes are suffix-keyed `model#2` so none overwrite). */
+    models: string[];
+    /**
+     * Score the artifact with one model. Throw (or reject) on failure — the
+     * panel records that model as a failed judge; it is never folded into a
+     * zero. Verdict scores are clamped to [0,1] by the reducer.
+     */
+    scoreWith: (model: string, input: {
+        artifact: unknown;
+        scenario?: unknown;
+    }) => Promise<JudgeVerdict<D>>;
+    /**
+     * Per-model retry policy, applied via `withJudgeRetry`. The panel's
+     * `models` list drives the fan-out, so `retry.models` (the fallback
+     * rotation) is overridden to each panel model in turn.
+     */
+    retry?: JudgeRetryPolicy;
+    /** Enforce `assertCrossFamily` over `models` at construction. Default true.
+     *  Opt out only for deliberate single-family panels (e.g. self-consistency
+     *  sampling of one model). */
+    crossFamily?: boolean;
+    /** Composite weights forwarded to `aggregateJudgeVerdicts`: a partial map
+     *  selects AND weights exactly the named dimensions. Omit for uniform. */
+    weights?: Partial<Record<D, number>>;
+}
+/**
+ * Build a campaign-shaped `JudgeConfig` whose `score()` runs every panel
+ * model in parallel and reduces the surviving verdicts to one canonical
+ * `JudgeScore` in [0,1].
+ *
+ * Failure semantics: a model whose `scoreWith` throws (or exhausts `retry`)
+ * lands in `failedJudges` and is excluded from the means. When EVERY model
+ * fails, `aggregateJudgeVerdicts` throws — the campaign engine records a
+ * failed cell instead of averaging a fabricated zero.
+ */
+export declare function ensembleJudge<D extends string>(opts: EnsembleJudgeOptions<D>): JudgeConfig<unknown>;
+//# sourceMappingURL=judge-panel.d.ts.map

package/dist/judge-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-panel.d.ts","sourceRoot":"","sources":["../src/judge-panel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,kBAAkB,CAAA;AAC/D,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE5E,OAAO,EAAE,KAAK,gBAAgB,EAAkB,MAAM,eAAe,CAAA;AAErE,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,MAAM;IACpD,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,CAAC,EAAE,CAAA;IACf;gFAC4E;IAC5E,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB;;;;OAIG;IACH,SAAS,EAAE,CACT,KAAK,EAAE,MAAM,EACb,KAAK,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAC7C,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7B;;;;OAIG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAA;IACxB;;kCAE8B;IAC9B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;8EAC0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA;CACrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5C,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC5B,WAAW,CAAC,OAAO,CAAC,CA2DtB"}