@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/{types-D216SgwM.d.ts → types-Cx3YUh2r.d.ts}

@@ -1,5 +1,5 @@
-import { r as CaptureIntegrityError, t as AgentEvalError } from "./errors-CKPfb2aH.js";
-import { b as CustomTokenPricing, c as CostLedgerHandle, f as CostLedgerSummary, g as CostReceiptInput, x as MaximumCharge } from "./cost-ledger-Bv_e8XHY.js";
+import { t as AgentEvalError } from "./errors-DEE6u6ot.js";
+import { b as CustomTokenPricing, c as CostLedgerHandle, g as CostReceiptInput, x as MaximumCharge } from "./cost-ledger-DbQdN3nO.js";
 //#region src/trace/raw-provider-sink.d.ts
 /**
  * RawProviderSink — first-class persistence for the actual HTTP-level
@@ -180,23 +180,6 @@ declare class CrossFamilyError extends Error {
 declare function assertCrossFamily(models: string[], opts?: AssertCrossFamilyOptions): JudgeFamily[];
 //#endregion
 //#region src/integrity/served-model.d.ts
-/**
- * Output-token budget a liveness probe must grant a model.
- *
- * Identity is only readable off a response the provider actually produced. A
- * reasoning model spends budget on hidden reasoning tokens before it emits a
- * single visible one, so a cap of a few tokens makes a HEALTHY deepseek/glm
- * model fail with `reasoning_budget_exhausted` — it names no model, its
- * identity reads as `unreported`, and a preflight scores it DEAD. 64 clears
- * that floor. Every probe in this package reads this constant, so two probes
- * cannot reach two different answers about the same router.
- *
- * Cost: a probe spends at most `PROBE_MAX_TOKENS` output tokens per model,
- * plus whatever reasoning tokens a reasoning model bills — roughly 400 output
- * tokens for a six-model preflight. That is fractions of a cent, and far
- * cheaper than a campaign that runs on a model nobody proved was alive.
- */
-declare const PROBE_MAX_TOKENS = 64;
 /** How a served id relates to the id that was requested. */
 type ServedModelVerdict =
 /** Byte-identical after normalisation — the requested model answered. */
@@ -221,37 +204,6 @@ interface ServedModelCheck {
   /** True for every verdict except `exact` and `alias`. */
   substituted: boolean;
 }
-/**
- * Reduce a model id to its comparable core: lowercase, no surrounding space,
- * no `provider/` prefix, no `@snapshot` / `:batch` / `:free` tier suffix, no
- * trailing build date, and `.`/`_` folded to `-` so one version is spelled one
- * way.
- *
- * Dropping the build date is what makes snapshot resolution legible as the
- * non-event it is: a router answering `gpt-4o-mini` with
- * `gpt-4o-mini-2024-07-18` pinned a floating alias to a reproducible build —
- * the same model, which is the behaviour we want. Only routing decoration is
- * stripped; version digits are load-bearing, so `deepseek-v3.2` and
- * `deepseek-v4-flash` stay distinct, and comparison is EXACT equality rather
- * than a prefix test (a prefix rule would accept `gpt-5` → `gpt-5-mini`, a
- * silent downgrade wearing the right vendor name).
- */
-declare function normalizeModelId(modelId: string): string;
-/**
- * Classify one requested/served pair. Pure — no I/O — so it is safe inside
- * response handlers, reducers, and CI gates.
- *
- * `served` is the id echoed by the provider (OpenAI-compatible bodies put it
- * at `model`). `null`/`undefined` means the body omitted it; that is
- * `unreported`, NOT a pass — a provider that does not name what answered has
- * not proven identity, and a transport that drops the field must not read as
- * agreement.
- */
-declare function checkServedModel(requested: string, served: string | null | undefined): ServedModelCheck;
-declare class ModelSubstitutionError extends AgentEvalError {
-  readonly checks: ReadonlyArray<ServedModelCheck>;
-  constructor(message: string, checks: ReadonlyArray<ServedModelCheck>);
-}
 interface AssertServedModelOptions {
   /**
    * Accept a different model of the same provider family (e.g. requested
@@ -267,50 +219,6 @@ interface AssertServedModelOptions {
   /** Prefixed to the thrown message, e.g. the judge or campaign cell name. */
   context?: string;
 }
-/**
- * The one place the accept/reject policy lives, so a caller that reports
- * substitution (a preflight table, a run record) and a caller that throws on it
- * can never drift apart. A cross-family substitution is never acceptable.
- */
-declare function servedModelAcceptable(check: ServedModelCheck, opts?: AssertServedModelOptions): boolean;
-/**
- * Throw `ModelSubstitutionError` unless the served id is the requested model.
- * Returns the check on success so callers can record the served id alongside
- * the result.
- */
-declare function assertServedModel(requested: string, served: string | null | undefined, opts?: AssertServedModelOptions): ServedModelCheck;
-/**
- * Batch form: check every pair and throw naming EVERY substitution, so one
- * failure does not hide the rest. Returns all checks on success.
- */
-declare function assertServedModels(pairs: ReadonlyArray<{
-  requested: string;
-  served: string | null | undefined;
-}>, opts?: AssertServedModelOptions): ServedModelCheck[];
-interface AssertCrossFamilyServedOptions extends AssertServedModelOptions {
-  /** Minimum distinct SERVED families required. Default 2. */
-  minFamilies?: number;
-  /** Count `unknown`-family served ids toward the total. Default false. */
-  allowUnknown?: boolean;
-}
-declare class ServedCrossFamilyError extends AgentEvalError {
-  readonly families: JudgeFamily[];
-  readonly checks: ReadonlyArray<ServedModelCheck>;
-  constructor(message: string, families: JudgeFamily[], checks: ReadonlyArray<ServedModelCheck>);
-}
-/**
- * Family-diversity rule over the models that actually ANSWERED.
- *
- * `assertCrossFamily` (../judge-families) reads the requested ids and so
- * cannot see a gateway that answers three "different" requests from one
- * provider. This one asserts no substitution first, then counts families from
- * the served ids — a panel that collapsed to one family under the hood fails
- * here even though its request list looked diverse.
- */
-declare function assertCrossFamilyServed(pairs: ReadonlyArray<{
-  requested: string;
-  served: string | null | undefined;
-}>, opts?: AssertCrossFamilyServedOptions): JudgeFamily[];
 //#endregion
 //#region src/llm-client.d.ts
 interface LlmMessage {
@@ -529,8 +437,6 @@ interface LlmClientOptions {
  * consistently across transports.
  */
 declare function isTransientLlmError(err: unknown): boolean;
-/** Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 16s. Attempt is 0-indexed. */
-declare function backoffMs(attempt: number): number;
 /**
  * Strip a ```json / ``` code fence if the model emitted one.
  * Idempotent for naked JSON. Some models (claude-code via router, certain
@@ -553,12 +459,6 @@ declare function callLlmJson<T = unknown>(req: LlmCallRequest, opts?: LlmClientO
   value: T;
   result: LlmCallResult;
 }>;
-type LlmRouteAssertionReason = 'no_explicit_base_url' | 'base_url_blocked' | 'base_url_not_allowed' | 'no_auth' | 'wrong_provider';
-declare class LlmRouteAssertionError extends CaptureIntegrityError {
-  readonly reason: LlmRouteAssertionReason;
-  readonly baseUrl: string;
-  constructor(message: string, reason: LlmRouteAssertionReason, baseUrl: string);
-}
 interface LlmRouteRequirements {
   /**
    * Throw if `opts.baseUrl` is undefined, i.e. the call would fall back to
@@ -738,11 +638,6 @@ interface ArtifactCheck {
   minCount?: number;
   description: string;
 }
-interface JudgeConfig {
-  model: string;
-  temperature: number;
-  rubric: JudgeRubric;
-}
 interface JudgeRubric {
   name: string;
   description: string;
@@ -755,19 +650,6 @@ interface RubricDimension {
   anchor_high: string;
   weight: number;
 }
-interface ScenarioResult {
-  scenarioId: string;
-  persona: string;
-  turns: TurnResult[];
-  artifactResults: ArtifactResult[];
-  judgeScores: JudgeScore[];
-  judgeErrors: number;
-  overallScore: number;
-  totalDurationMs: number;
-  artifacts: CollectedArtifacts;
-  /** Agent and judge spend attributed to this scenario. */
-  cost?: CostLedgerSummary;
-}
 interface TurnResult {
   turnIndex: number;
   userMessage: string;
@@ -780,11 +662,6 @@ interface TurnResult {
   containsCode: boolean;
   containsToolCall: boolean;
 }
-interface ArtifactResult {
-  check: ArtifactCheck;
-  passed: boolean;
-  detail?: string;
-}
 interface JudgeScore {
   judgeName: string;
   dimension: string;
@@ -807,36 +684,6 @@ interface CollectedArtifacts {
   }[];
   toolCalls: string[];
 }
-interface BenchmarkReport {
-  timestamp: string;
-  generation: number;
-  promptVersion: string;
-  scenarioCount: number;
-  results: ScenarioResult[];
-  cost?: CostLedgerSummary;
-  summary: {
-    overallAvg: number;
-    byPersona: Record<string, {
-      avg: number;
-      passed: number;
-      total: number;
-    }>;
-    byDimension: Record<string, {
-      avg: number;
-      scores: number[];
-    }>;
-    weakest: {
-      scenario: string;
-      score: number;
-      reason: string;
-    }[];
-    strongest: {
-      scenario: string;
-      score: number;
-      reason: string;
-    }[];
-  };
-}
 interface RouteMap {
   signup?: string;
   login?: string;
@@ -856,23 +703,6 @@ interface ProductClientConfig {
   /** Per-request timeout in ms before the request is aborted. Default 30s. */
   timeoutMs?: number;
 }
-interface ScenarioFile {
-  id: string;
-  category: string;
-  persona: string;
-  label: string;
-  thesis: string;
-  isControl?: boolean;
-  rubric?: {
-    dimensions: {
-      name: string;
-      description: string;
-      weight: number;
-    }[];
-  };
-  turns: Turn[];
-  artifactChecks: ArtifactCheck[];
-}
 interface CompletionCriterion {
   name: string;
   check: (state: DriverState) => boolean;
@@ -934,59 +764,6 @@ interface DriverState {
   codeBlocks: number;
   generations: number;
 }
-interface TurnMetrics {
-  turn: number;
-  timestamp: string;
-  tasks: number;
-  events: number;
-  proposals: {
-    pending: number;
-    approved: number;
-    rejected: number;
-  };
-  vaultFiles: number;
-  responseLatencyMs: number;
-  responseChars: number;
-  codeBlocksProduced: number;
-  blocksExtracted: number;
-  qualityScore?: number;
-  inputTokens: number;
-  outputTokens: number;
-  estimatedCostUsd: number;
-  totalCostUsd: number;
-  completionPercent: number;
-}
-interface DriverResult {
-  personaId: string;
-  /** True when the simulated user professionally signed off (driver said DONE). */
-  completed: boolean;
-  /** Turn at which the simulated user signed off, or null if it never did. */
-  turnsToCompletion: number | null;
-  /**
-   * Turn at which nominal completionCriteria were first all met, or null.
-   * Distinct from turnsToCompletion: criteria can be met while the
-   * simulated professional is still unsatisfied with the work's rigor.
-   */
-  criteriaMetAtTurn: number | null;
-  totalTurns: number;
-  metrics: TurnMetrics[];
-  finalState: DriverState;
-  convergenceCurve: number[];
-  totalCostUsd: number;
-  finalQualityScore: number | null;
-}
-interface BenchmarkRunnerConfig {
-  scenarios: Scenario[];
-  judges: JudgeFn[];
-  systemPrompt: string;
-  model?: string;
-  judgeModel?: string;
-  passThreshold?: number;
-  generation?: number;
-  promptVersion?: string;
-  /** Shared ledger for agent and judge calls made by the benchmark. */
-  costLedger?: CostLedgerHandle;
-}
 interface JudgeInput {
   scenario: Scenario;
   turns: TurnResult[];
@@ -998,26 +775,12 @@ interface JudgeInput {
   signal?: AbortSignal;
 }
 type JudgeFn = (chat: ChatClient, input: JudgeInput) => Promise<JudgeScore[]>;
-interface TestResult {
-  name: string;
-  passed: boolean;
-  duration: number;
-  detail?: string;
-  checks: CheckResult[];
-}
 interface CheckResult {
   name: string;
   passed: boolean;
   expected: string;
   actual: string;
 }
-interface EvalResult {
-  scenario: string;
-  status: 'pass' | 'fail' | 'skip';
-  duration: number;
-  detail?: string;
-  artifact?: string;
-}
 //#endregion
-export { assertLlmRoute as $, ChatClient as A, InMemoryRawProviderSinkOptions as At, SandboxSdkTransportOpts as B, ScenarioFile as C, CrossFamilyError as Ct, TurnMetrics as D, FileSystemRawProviderSink as Dt, Turn as E, judgeFamily as Et, CreateChatClientOpts as F, RawProviderSink as Ft, LlmCallResult as G, LlmCallError as H, CustomTransportOpts as I, RawProviderSinkFilter as It, LlmMessage as J, LlmClient as K, DirectProviderTransportOpts as L, defaultProviderRedactor as Lt, ChatResponse as M, ProviderRedactor as Mt, ChatTransport as N, RawProviderDirection as Nt, TurnResult as O, FileSystemRawProviderSinkOptions as Ot, CliBridgeTransportOpts as P, RawProviderEvent as Pt, LlmUsage as Q, MockTransportOpts as R, providerFromBaseUrl as Rt, Scenario as S, AssertCrossFamilyOptions as St, TestResult as T, assertCrossFamily as Tt, LlmCallMetadata as U, createChatClient as V, LlmCallRequest as W, LlmRouteAssertionError as X, LlmResponseError as Y, LlmRouteRequirements as Z, PersonaConfig as _, assertServedModel as _t, CheckResult as a, isTransientLlmError as at, RouteMap as b, normalizeModelId as bt, DriverResult as c, stripFencedJson as ct, FeedbackPattern as d, ModelSubstitutionError as dt, backoffMs as et, JudgeConfig as f, PROBE_MAX_TOKENS as ft, JudgeScore as g, assertCrossFamilyServed as gt, JudgeRubric as h, ServedModelVerdict as ht, BenchmarkRunnerConfig as i, costReceiptFromLlmError as it, ChatRequest as j, NoopRawProviderSink as jt, ChatCallOpts as k, InMemoryRawProviderSink as kt, DriverState as l, AssertCrossFamilyServedOptions as lt, JudgeInput as m, ServedModelCheck as mt, ArtifactResult as n, callLlmJson as nt, CollectedArtifacts as o, maximumChargeForLlmRequest as ot, JudgeFn as p, ServedCrossFamilyError as pt, LlmClientOptions as q, BenchmarkReport as r, costReceiptFromLlm as rt, CompletionCriterion as s, probeLlm as st, ArtifactCheck as t, callLlm as tt, EvalResult as u, AssertServedModelOptions as ut, PersonaRigor as v, assertServedModels as vt, ScenarioResult as w, JudgeFamily as wt, RubricDimension as x, servedModelAcceptable as xt, ProductClientConfig as y, checkServedModel as yt, RouterTransportOpts as z };
-//# sourceMappingURL=types-D216SgwM.d.ts.map
+export { InMemoryRawProviderSinkOptions as $, LlmClientOptions as A, isTransientLlmError as B, SandboxSdkTransportOpts as C, LlmCallRequest as D, LlmCallMetadata as E, assertLlmRoute as F, AssertCrossFamilyOptions as G, probeLlm as H, callLlm as I, assertCrossFamily as J, CrossFamilyError as K, callLlmJson as L, LlmResponseError as M, LlmRouteRequirements as N, LlmCallResult as O, LlmUsage as P, InMemoryRawProviderSink as Q, costReceiptFromLlm as R, RouterTransportOpts as S, LlmCallError as T, stripFencedJson as U, maximumChargeForLlmRequest as V, ServedModelCheck as W, FileSystemRawProviderSink as X, judgeFamily as Y, FileSystemRawProviderSinkOptions as Z, CliBridgeTransportOpts as _, JudgeInput as a, RawProviderSinkFilter as at, DirectProviderTransportOpts as b, PersonaConfig as c, Scenario as d, NoopRawProviderSink as et, ChatCallOpts as f, ChatTransport as g, ChatResponse as h, JudgeFn as i, RawProviderSink as it, LlmMessage as j, LlmClient as k, ProductClientConfig as l, ChatRequest as m, CompletionCriterion as n, RawProviderDirection as nt, JudgeRubric as o, defaultProviderRedactor as ot, ChatClient as p, JudgeFamily as q, DriverState as r, RawProviderEvent as rt, JudgeScore as s, providerFromBaseUrl as st, CheckResult as t, ProviderRedactor as tt, RouteMap as u, CreateChatClientOpts as v, createChatClient as w, MockTransportOpts as x, CustomTransportOpts as y, costReceiptFromLlmError as z };
+//# sourceMappingURL=types-Cx3YUh2r.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-Cx3YUh2r.d.ts","names":[],"sources":["../src/trace/raw-provider-sink.ts","../src/judge-families.ts","../src/integrity/served-model.ts","../src/llm-client.ts","../src/analyst/chat-client.ts","../src/types.ts"],"mappings":"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"}

package/dist/{types-BvDKaULh.d.ts → types-DLQx4mKU.d.ts}

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

package/dist/{types-BvDKaULh.d.ts.map → types-DLQx4mKU.d.ts.map}

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

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

@@ -1,4 +1,4 @@
-import { h as RolloutLine } from "./schema-Cef2cFmb2.js";
+import { h as RolloutLine } from "./schema-Cef2cFmb.js";
 //#region src/supervisor-run/types.d.ts
 /** A metric that could not be computed, with the reason its artifact was missing. */
 interface Unavailable {
@@ -369,4 +369,4 @@ interface SupervisorRunTreeGap {
 }
 //#endregion
 export { Unavailable as C, showMeasured as D, isUnavailable as E, unavailable as O, SupervisorRunTreeGapCode as S, WorkerLogSource as T, SupervisorRunReport as _, OrchestrationMetrics as a, SupervisorRunTree as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SupervisorRunReader as g, SupervisorRunNodeRole as h, NO_SOURCE_LIMITS as i, RoleSpend as l, SteerBreakdown as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunRollup as v, WallDistribution as w, SupervisorRunTreeGap as x, SupervisorRunSources as y };
-//# sourceMappingURL=types-D4mog56g.d.ts.map
+//# sourceMappingURL=types-yLK8gXE9.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types-D4mog56g.d.ts","names":[],"sources":["../src/supervisor-run/types.ts"],"mappings":";;;UAiCiB;WACN;;;KAIC,SAAS,KAAK,IAAI;iBAEd,YAAY,iBAAiB;iBAI7B,cAAc,aAAa,KAAK;;iBAKhC,aAAa,GAAG;;KAWpB;;;;;UAMK;;;;;WAKN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;;;;;;;;;;;;;UAcM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;cAIE,kBAAkB;;;;;;;;;;UAiBd;;WAEN;WACA;;WAEA;;WAEA;;;;;;WAMA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,kBAAkB;;WAElB;;WAEA;;;;;;;WAOA;;WAEA;;WAEA;;WAEA;;;;;WAKA;IACP;IACA;IACA;IACA;;IAEA;IACA;;WAEO;;WAEA,QAAQ;;;;;;WAMR;;;;;WAKA;;;;;;UAOM;;WAEN;EACT,QAAQ,QAAQ;;cAOL;cACA;UAEI;;WAEN;WACA;;WAEA;;WAEA;;UAGM;WACN,gBAAgB;WAChB,gBAAgB;WAChB,kBAAkB;;WAElB,QAAQ;WACR,iBAAiB;WACjB,gBAAgB,kBAAkB;;WAElC,kBAAkB;;;;;;WAMlB,OAAO;WACP,WAAW;WACX,gBAAgB;;WAEhB,UAAU;;WAEV,gBAAgB;;WAEhB,iBAAiB;WACjB,oBAAoB;WACpB,kBAAkB;;WAElB,QAAQ;WACR,SAAS;;WAET,mBAAmB;;UAGb;WACN,iBAAiB,SAAS;WAC1B,iBAAiB,SAAS;;WAE1B,UAAU;;WAEV,UAAU;;WAEV,WAAW;;WAEX,oBAAoB;;WAEpB,wBAAwB;;WAExB,eAAe;WACf,qBAAqB;;UAGf;WACN,UAAU;WACV,WAAW;;;;;;WAMX,WAAW;WACX,YAAY;WACZ,KAAK;WACL;;UAGM;;WAEN;WACA;;WAEA,MAAM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;WACA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;;UAGM;;WAEN,OAAO;;;;;;;;WAQP,kBAAkB;;WAElB,SAAS;WACT,UAAU;;;;;;WAMV;WACA,yBAAyB;WACzB,0BAA0B,SAAS;WACnC,WAAW,kBAAkB;;UAGvB;WACN;WACA;WACA;WACA;;UAGM;WACN,WAAW;WACX,YAAY;WACZ,WAAW;WACX,eAAe;WACf,YAAY;WACZ,aAAa;WACb,YAAY;WACZ,YAAY;WACZ,UAAU;WACV,OAAO,SAAS;;WAEhB;;UAGM;WACN,eAAe;;WAEf;WACA;WACA;WACA,cAAc;WACd,yBAAyB;WACzB;WACA,eAAe;WACf,UAAU;WACV,WAAW;WACX,SAAS;;WAET;;WAEA;;UAGM;WACN;WACA;WACA,QAAQ;WACR,OAAO;WACP,aAAa;WACb,SAAS;WACT,UAAU;WACV,KAAK;;UAGC;WACN,eAAe;WACf;WACA,aAAa;WACb,iBAAiB;WACjB;WACA,WAAW;WACX,mBAAmB;WACnB,iBAAiB;WACjB,aAAa;WACb,qBAAqB;WACrB,eAAe;WACf,UAAU;WACV,eAAe;WACf,kBAAkB;;;;;;;;UASZ;WACN;WACA,gBAAgB;;WAEhB,eAAe;;;KAId;UASK;WACN,MAAM;WACN;WACA;WACA"}
+{"version":3,"file":"types-yLK8gXE9.d.ts","names":[],"sources":["../src/supervisor-run/types.ts"],"mappings":";;;UAiCiB;WACN;;;KAIC,SAAS,KAAK,IAAI;iBAEd,YAAY,iBAAiB;iBAI7B,cAAc,aAAa,KAAK;;iBAKhC,aAAa,GAAG;;KAWpB;;;;;UAMK;;;;;WAKN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;;;;;;;;;;;;;UAcM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;cAIE,kBAAkB;;;;;;;;;;UAiBd;;WAEN;WACA;;WAEA;;WAEA;;;;;;WAMA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,kBAAkB;;WAElB;;WAEA;;;;;;;WAOA;;WAEA;;WAEA;;WAEA;;;;;WAKA;IACP;IACA;IACA;IACA;;IAEA;IACA;;WAEO;;WAEA,QAAQ;;;;;;WAMR;;;;;WAKA;;;;;;UAOM;;WAEN;EACT,QAAQ,QAAQ;;cAOL;cACA;UAEI;;WAEN;WACA;;WAEA;;WAEA;;UAGM;WACN,gBAAgB;WAChB,gBAAgB;WAChB,kBAAkB;;WAElB,QAAQ;WACR,iBAAiB;WACjB,gBAAgB,kBAAkB;;WAElC,kBAAkB;;;;;;WAMlB,OAAO;WACP,WAAW;WACX,gBAAgB;;WAEhB,UAAU;;WAEV,gBAAgB;;WAEhB,iBAAiB;WACjB,oBAAoB;WACpB,kBAAkB;;WAElB,QAAQ;WACR,SAAS;;WAET,mBAAmB;;UAGb;WACN,iBAAiB,SAAS;WAC1B,iBAAiB,SAAS;;WAE1B,UAAU;;WAEV,UAAU;;WAEV,WAAW;;WAEX,oBAAoB;;WAEpB,wBAAwB;;WAExB,eAAe;WACf,qBAAqB;;UAGf;WACN,UAAU;WACV,WAAW;;;;;;WAMX,WAAW;WACX,YAAY;WACZ,KAAK;WACL;;UAGM;;WAEN;WACA;;WAEA,MAAM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;WACA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;;UAGM;;WAEN,OAAO;;;;;;;;WAQP,kBAAkB;;WAElB,SAAS;WACT,UAAU;;;;;;WAMV;WACA,yBAAyB;WACzB,0BAA0B,SAAS;WACnC,WAAW,kBAAkB;;UAGvB;WACN;WACA;WACA;WACA;;UAGM;WACN,WAAW;WACX,YAAY;WACZ,WAAW;WACX,eAAe;WACf,YAAY;WACZ,aAAa;WACb,YAAY;WACZ,YAAY;WACZ,UAAU;WACV,OAAO,SAAS;;WAEhB;;UAGM;WACN,eAAe;;WAEf;WACA;WACA;WACA,cAAc;WACd,yBAAyB;WACzB;WACA,eAAe;WACf,UAAU;WACV,WAAW;WACX,SAAS;;WAET;;WAEA;;UAGM;WACN;WACA;WACA,QAAQ;WACR,OAAO;WACP,aAAa;WACb,SAAS;WACT,UAAU;WACV,KAAK;;UAGC;WACN,eAAe;WACf;WACA,aAAa;WACb,iBAAiB;WACjB;WACA,WAAW;WACX,mBAAmB;WACnB,iBAAiB;WACjB,aAAa;WACb,qBAAqB;WACrB,eAAe;WACf,UAAU;WACV,eAAe;WACf,kBAAkB;;;;;;;;UASZ;WACN;WACA,gBAAgB;;WAEhB,eAAe;;;KAId;UASK;WACN,MAAM;WACN;WACA;WACA"}

package/dist/verdict-BndeTAh_.js

@@ -0,0 +1,61 @@
+import { n as contentHash } from "./verdict-cache-mZf5FEiY.js";
+//#region src/verdict.ts
+/**
+* Validator-output verdict — substrate primitive for "did this output pass,
+* and how well?"
+*
+* Used by:
+*   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.
+*   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.
+*     Runtime keeps `Validator` because it's coupled to runtime-shaped
+*     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE
+*     itself is a substrate concept and lives here.
+*
+* Repo layering: agent-eval is the substrate (no upward deps). Both
+* agent-runtime and agent-knowledge consume this type FROM agent-eval —
+* never the other way around. See CLAUDE.md "Repo layering" for the rule.
+*/
+/**
+* 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.
+*/
+function certificationEvidenceDigest(evidence) {
+	const serialized = JSON.stringify(evidence);
+	if (serialized === void 0) throw new Error("certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill");
+	return contentHash(JSON.parse(serialized));
+}
+/**
+* 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`.
+*/
+function equivalenceVerdict(record) {
+	const { obligation, spec, arms } = record;
+	const discharged = obligation.status !== "unresolved";
+	const notes = obligation.status === "proved" ? `statements equivalent: ${spec.artifact}` : obligation.status === "refuted-with-separating-witness" ? `formalization gap witnessed: ${obligation.separatingWitness}` : `obligation undischarged: ${obligation.unresolvedReason}`;
+	return {
+		valid: obligation.status === "proved",
+		score: obligation.status === "proved" ? 1 : 0,
+		notes,
+		...discharged && obligation.evidenceDigest !== void 0 ? { certification: {
+			strategy: spec.source,
+			checker: obligation.checker,
+			assumptions: [`arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`],
+			evidenceDigest: obligation.evidenceDigest
+		} } : {}
+	};
+}
+//#endregion
+export { equivalenceVerdict as n, certificationEvidenceDigest as t };
+
+//# sourceMappingURL=verdict-BndeTAh_.js.map

package/dist/verdict-BndeTAh_.js.map

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