@tangle-network/agent-eval 0.132.0 → 0.133.1

package/dist/extract-usage-BrQ8mCLX.js

@@ -1,155 +0,0 @@
-import { TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, firstTokenCount, tokenUsageSource } from "@tangle-network/agent-core/telemetry";
-import { SSEChunkParser } from "@tangle-network/agent-core/sse";
-//#region src/trace/extract-usage.ts
-/**
-* Provider response and SSE usage extraction.
-*
-* Missing usage returns `null`; reported zeroes and cache-only activity remain
-* distinguishable from absent telemetry.
-*/
-const INPUT_OTHER_KEYS = ["input_other"];
-const EXCLUSIVE_REASONING_KEYS = [
-	"reasoning",
-	"reasoning_tokens",
-	"reasoningTokens"
-];
-const INCLUSIVE_REASONING_KEYS = ["reasoning_output_tokens", "reasoningOutputTokens"];
-const INPUT_DETAIL_KEYS = ["prompt_tokens_details", "input_tokens_details"];
-const OUTPUT_DETAIL_KEYS = ["completion_tokens_details", "output_tokens_details"];
-const CACHED_KEYS = [
-	"cache",
-	"cached_tokens",
-	"cached_input_tokens",
-	"cache_read_tokens",
-	"cache_read_input_tokens",
-	"cachedTokens",
-	"cachedInputTokens",
-	"cacheReadTokens",
-	"cacheReadInputTokens",
-	"input_cache_read"
-];
-const CACHE_WRITE_KEYS = [
-	"cache_creation_tokens",
-	"cache_creation_input_tokens",
-	"cacheCreationTokens",
-	"cacheCreationInputTokens",
-	"input_cache_creation"
-];
-function nestedRecord(source, key) {
-	const value = source[key];
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function nestedNumber(source, recordKeys, valueKeys) {
-	for (const recordKey of recordKeys) {
-		const value = firstTokenCount(nestedRecord(source, recordKey), valueKeys);
-		if (value !== void 0) return value;
-	}
-}
-/**
-* Pull `{ input, output, cached?, cacheWrite? }` from a parsed response
-* body. Accepts a top-level `usage` object (the common case) or a body that IS
-* the usage object. Returns null only when none of those categories is present.
-*/
-function extractUsage(body) {
-	if (!body || typeof body !== "object") return null;
-	const usage = tokenUsageSource(body);
-	const input = firstTokenCount(usage, TOKEN_USAGE_INPUT_KEYS);
-	const inputOther = firstTokenCount(usage, INPUT_OTHER_KEYS);
-	const output = firstTokenCount(usage, TOKEN_USAGE_OUTPUT_KEYS);
-	const exclusiveReasoning = firstTokenCount(usage, EXCLUSIVE_REASONING_KEYS);
-	const inclusiveReasoning = firstTokenCount(usage, INCLUSIVE_REASONING_KEYS) ?? nestedNumber(usage, OUTPUT_DETAIL_KEYS, ["reasoning_tokens", "reasoningTokens"]);
-	const reasoning = exclusiveReasoning ?? inclusiveReasoning;
-	const nestedCache = nestedRecord(usage, "cache");
-	const cached = firstTokenCount(usage, CACHED_KEYS) ?? firstTokenCount(nestedCache, ["read"]) ?? nestedNumber(usage, INPUT_DETAIL_KEYS, ["cached_tokens", "cachedTokens"]);
-	const cacheWrite = firstTokenCount(usage, CACHE_WRITE_KEYS) ?? firstTokenCount(nestedCache, ["write"]);
-	if (input === void 0 && inputOther === void 0 && output === void 0 && reasoning === void 0 && cached === void 0 && cacheWrite === void 0) return null;
-	const result = {
-		input: (input ?? 0) + (inputOther ?? 0),
-		output: (output ?? (inclusiveReasoning !== void 0 ? inclusiveReasoning : 0)) + (exclusiveReasoning ?? 0)
-	};
-	if (reasoning !== void 0) result.reasoning = reasoning;
-	if (cached !== void 0) result.cached = cached;
-	if (cacheWrite !== void 0) result.cacheWrite = cacheWrite;
-	return result;
-}
-/**
-* Extract token usage from a complete SSE response body using the shared SSE
-* frame parser. Cumulative snapshots are the fail-safe default because summing
-* them inflates billing; callers with explicit delta events opt into `mode: 'delta'`.
-*/
-function extractUsageFromSse(text, options = {}) {
-	const mode = options.mode ?? "cumulative";
-	let input = 0;
-	let output = 0;
-	let reasoning = 0;
-	let sawReasoning = false;
-	let cached = 0;
-	let sawCached = false;
-	let cacheWrite = 0;
-	let sawCacheWrite = false;
-	let found = false;
-	const parser = new SSEChunkParser({ transform: parseSseJson });
-	const events = [...parser.push(text), ...parser.flush()];
-	const merge = mode === "delta" ? (current, next) => current + next : Math.max;
-	for (const event of events) {
-		const usage = extractUsage(event.data);
-		if (!usage) continue;
-		input = merge(input, usage.input);
-		output = merge(output, usage.output);
-		if (usage.reasoning !== void 0) {
-			reasoning = merge(reasoning, usage.reasoning);
-			sawReasoning = true;
-		}
-		if (usage.cached !== void 0) {
-			cached = merge(cached, usage.cached);
-			sawCached = true;
-		}
-		if (usage.cacheWrite !== void 0) {
-			cacheWrite = merge(cacheWrite, usage.cacheWrite);
-			sawCacheWrite = true;
-		}
-		found = true;
-	}
-	if (!found) return null;
-	return {
-		input,
-		output,
-		...sawReasoning ? { reasoning } : {},
-		...sawCached ? { cached } : {},
-		...sawCacheWrite ? { cacheWrite } : {}
-	};
-}
-function parseSseJson(raw) {
-	const payload = raw.trim();
-	if (!payload || payload === "[DONE]") return null;
-	try {
-		return JSON.parse(payload);
-	} catch {
-		return null;
-	}
-}
-/**
-* Extract usage from an HTTP `Response` without consuming the caller's body:
-* clones, reads the text, and tries the JSON parser first, then the SSE
-* accumulator. Best-effort — returns null on any read/parse miss so a usage tee
-* never takes down the underlying call.
-*/
-async function extractUsageFromResponse(response, sseOptions) {
-	let text;
-	try {
-		text = await response.clone().text();
-	} catch {
-		return null;
-	}
-	let json;
-	try {
-		json = JSON.parse(text);
-	} catch {
-		json = void 0;
-	}
-	return extractUsage(json) ?? extractUsageFromSse(text, sseOptions);
-}
-//#endregion
-export { extractUsageFromResponse as n, extractUsageFromSse as r, extractUsage as t };
-
-//# sourceMappingURL=extract-usage-BrQ8mCLX.js.map

package/dist/extract-usage-BrQ8mCLX.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-usage-BrQ8mCLX.js","names":["obj"],"sources":["../src/trace/extract-usage.ts"],"sourcesContent":["/**\n * Provider response and SSE usage extraction.\n *\n * Missing usage returns `null`; reported zeroes and cache-only activity remain\n * distinguishable from absent telemetry.\n */\n\nimport { SSEChunkParser } from '@tangle-network/agent-core/sse'\nimport {\n  firstTokenCount,\n  TOKEN_USAGE_INPUT_KEYS,\n  TOKEN_USAGE_OUTPUT_KEYS,\n  tokenUsageSource,\n} from '@tangle-network/agent-core/telemetry'\nimport type { RunTokenUsage } from '../run-record'\n\nexport type ExtractedUsage = RunTokenUsage\nexport type SseUsageMode = 'cumulative' | 'delta'\n\nexport interface ExtractUsageFromSseOptions {\n  /** Provider usage events are cumulative snapshots unless explicitly marked as deltas. */\n  mode?: SseUsageMode\n}\n\nconst INPUT_OTHER_KEYS = ['input_other'] as const\nconst EXCLUSIVE_REASONING_KEYS = ['reasoning', 'reasoning_tokens', 'reasoningTokens'] as const\nconst INCLUSIVE_REASONING_KEYS = ['reasoning_output_tokens', 'reasoningOutputTokens'] as const\nconst INPUT_DETAIL_KEYS = ['prompt_tokens_details', 'input_tokens_details'] as const\nconst OUTPUT_DETAIL_KEYS = ['completion_tokens_details', 'output_tokens_details'] as const\nconst CACHED_KEYS = [\n  'cache',\n  'cached_tokens',\n  'cached_input_tokens',\n  'cache_read_tokens',\n  'cache_read_input_tokens',\n  'cachedTokens',\n  'cachedInputTokens',\n  'cacheReadTokens',\n  'cacheReadInputTokens',\n  'input_cache_read',\n] as const\nconst CACHE_WRITE_KEYS = [\n  'cache_creation_tokens',\n  'cache_creation_input_tokens',\n  'cacheCreationTokens',\n  'cacheCreationInputTokens',\n  'input_cache_creation',\n] as const\n\nfunction nestedRecord(\n  source: Record<string, unknown>,\n  key: string,\n): Record<string, unknown> | undefined {\n  const value = source[key]\n  return value && typeof value === 'object' && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined\n}\n\nfunction nestedNumber(\n  source: Record<string, unknown>,\n  recordKeys: readonly string[],\n  valueKeys: readonly string[],\n): number | undefined {\n  for (const recordKey of recordKeys) {\n    const value = firstTokenCount(nestedRecord(source, recordKey), valueKeys)\n    if (value !== undefined) return value\n  }\n  return undefined\n}\n\n/**\n * Pull `{ input, output, cached?, cacheWrite? }` from a parsed response\n * body. Accepts a top-level `usage` object (the common case) or a body that IS\n * the usage object. Returns null only when none of those categories is present.\n */\nexport function extractUsage(body: unknown): ExtractedUsage | null {\n  if (!body || typeof body !== 'object') return null\n  const obj = body as Record<string, unknown>\n  const usage = tokenUsageSource(obj)\n  const input = firstTokenCount(usage, TOKEN_USAGE_INPUT_KEYS)\n  const inputOther = firstTokenCount(usage, INPUT_OTHER_KEYS)\n  const output = firstTokenCount(usage, TOKEN_USAGE_OUTPUT_KEYS)\n  const exclusiveReasoning = firstTokenCount(usage, EXCLUSIVE_REASONING_KEYS)\n  const inclusiveReasoning =\n    firstTokenCount(usage, INCLUSIVE_REASONING_KEYS) ??\n    nestedNumber(usage, OUTPUT_DETAIL_KEYS, ['reasoning_tokens', 'reasoningTokens'])\n  const reasoning = exclusiveReasoning ?? inclusiveReasoning\n  const nestedCache = nestedRecord(usage, 'cache')\n  const cached =\n    firstTokenCount(usage, CACHED_KEYS) ??\n    firstTokenCount(nestedCache, ['read']) ??\n    nestedNumber(usage, INPUT_DETAIL_KEYS, ['cached_tokens', 'cachedTokens'])\n  const cacheWrite =\n    firstTokenCount(usage, CACHE_WRITE_KEYS) ?? firstTokenCount(nestedCache, ['write'])\n  if (\n    input === undefined &&\n    inputOther === undefined &&\n    output === undefined &&\n    reasoning === undefined &&\n    cached === undefined &&\n    cacheWrite === undefined\n  )\n    return null\n  const result: ExtractedUsage = {\n    input: (input ?? 0) + (inputOther ?? 0),\n    output:\n      (output ?? (inclusiveReasoning !== undefined ? inclusiveReasoning : 0)) +\n      (exclusiveReasoning ?? 0),\n  }\n  if (reasoning !== undefined) result.reasoning = reasoning\n  if (cached !== undefined) result.cached = cached\n  if (cacheWrite !== undefined) result.cacheWrite = cacheWrite\n  return result\n}\n\n/**\n * Extract token usage from a complete SSE response body using the shared SSE\n * frame parser. Cumulative snapshots are the fail-safe default because summing\n * them inflates billing; callers with explicit delta events opt into `mode: 'delta'`.\n */\nexport function extractUsageFromSse(\n  text: string,\n  options: ExtractUsageFromSseOptions = {},\n): ExtractedUsage | null {\n  const mode = options.mode ?? 'cumulative'\n  let input = 0\n  let output = 0\n  let reasoning = 0\n  let sawReasoning = false\n  let cached = 0\n  let sawCached = false\n  let cacheWrite = 0\n  let sawCacheWrite = false\n  let found = false\n  const parser = new SSEChunkParser<unknown>({ transform: parseSseJson })\n  const events = [...parser.push(text), ...parser.flush()]\n  const merge = mode === 'delta' ? (current: number, next: number) => current + next : Math.max\n\n  for (const event of events) {\n    const usage = extractUsage(event.data)\n    if (!usage) continue\n    input = merge(input, usage.input)\n    output = merge(output, usage.output)\n    if (usage.reasoning !== undefined) {\n      reasoning = merge(reasoning, usage.reasoning)\n      sawReasoning = true\n    }\n    if (usage.cached !== undefined) {\n      cached = merge(cached, usage.cached)\n      sawCached = true\n    }\n    if (usage.cacheWrite !== undefined) {\n      cacheWrite = merge(cacheWrite, usage.cacheWrite)\n      sawCacheWrite = true\n    }\n    found = true\n  }\n  if (!found) return null\n  return {\n    input,\n    output,\n    ...(sawReasoning ? { reasoning } : {}),\n    ...(sawCached ? { cached } : {}),\n    ...(sawCacheWrite ? { cacheWrite } : {}),\n  }\n}\n\nfunction parseSseJson(raw: string): unknown | null {\n  const payload = raw.trim()\n  if (!payload || payload === '[DONE]') return null\n  try {\n    return JSON.parse(payload)\n  } catch {\n    return null\n  }\n}\n\n/**\n * Extract usage from an HTTP `Response` without consuming the caller's body:\n * clones, reads the text, and tries the JSON parser first, then the SSE\n * accumulator. Best-effort — returns null on any read/parse miss so a usage tee\n * never takes down the underlying call.\n */\nexport async function extractUsageFromResponse(\n  response: Response,\n  sseOptions?: ExtractUsageFromSseOptions,\n): Promise<ExtractedUsage | null> {\n  let text: string\n  try {\n    text = await response.clone().text()\n  } catch {\n    return null\n  }\n  let json: unknown\n  try {\n    json = JSON.parse(text)\n  } catch {\n    json = undefined\n  }\n  return extractUsage(json) ?? extractUsageFromSse(text, sseOptions)\n}\n"],"mappings":"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"}

package/dist/index-3cdlURSk2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-3cdlURSk2.d.ts","names":[],"sources":["../src/rollout/exporters.ts","../src/rollout/gate-checks.ts","../src/rollout/interchange/harbor.ts","../src/rollout/ledger.ts","../src/rollout/reward.ts","../src/rollout/mint.ts","../src/rollout/readers/claude-jsonl.ts","../src/rollout/readers/opencode-sqlite.ts","../src/rollout/release/gate-report.ts","../src/rollout/release/scrub.ts","../src/rollout/release/card.ts","../src/rollout/release/hf-dataset.ts"],"mappings":"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"}

package/dist/index-BAvgST_9.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BAvgST_9.d.ts","names":[],"sources":["../src/ledger-core/atomic-file-lock.ts","../src/ledger-core/journal-file.ts","../src/ledger-core/journal.ts"],"mappings":";;UAiBiB;WACN;WACA;WACA;;UAGM;WACN,OAAO;EAChB;;KAGU;WACG;WAA0B;WAAyB,QAAQ;;WAC3D;WAA0B;;KAE7B;WACG;WAAyB,MAAM;IAC1C;UAEa;WACN;WACA;;cAGE,4BAA4B;WACrB;;;iBASJ,oBACd,SAAS,wBACR;;;;;;;iBAea,yBACd,SAAS,wBACR;;;;;UC/Dc;;EAEf;EACA,eAAe,iBAAiB;IAAY;MAAoB;;;;iBAKlD,iBAAiB,cAAc,cAAc,SAAS;iBAYtD,mBAAmB,GAAG,cAAc,SAAS,mBAAmB,WAAW,IAAI;KAQnF,eAAe;EAAO;EAAgB,OAAO;;EAAQ;;iBAEjD,sBAAsB,GACpC,cACA,SAAS,mBACT,WAAW,IACV,eAAe;;;KClBN;;;iBAII,gBAAgB;iBAIhB,cAAc,iBAAiB;;UAK9B;EACf;;;;;UAMe,kBAAkB,cAAc;EAC/C;EACA,cAAc;EACd,OAAO;EACP,WAAW;;KAGD,cAAc,uBAAuB,cAAc,mBAAmB,SAChF,kBAAkB;UAEH;EACf;EACA;;;;;UAMe,gBAAgB,OAAO;EACtC,MAAM,OAAO,OAAO;EACpB,OAAO,SAAS,UAAU;;UAGX,mBACf,uBACA,cAAc,iBACd,oBACQ;;EAER,QAAQ;EACR,cAAc,kBAAkB;;;;EAIhC,WAAW,cAAc,SAAS,oBAAoB,cAAc,QAAQ;;EAE5E,iBAAiB,OAAO,cAAc,QAAQ,QAAQ;EACtD,mBAAmB,gBAAgB,cAAc,QAAQ,QAAQ;;UAGlD,mBAAmB,OAAO;EACzC,SAAS;EACT,YAAY;;UAGG,mBAAmB,OAAO;EACzC,OAAO;;EAEP;EACA,YAAY;;;;cAiBD,kBAAkB,uBAAuB,cAAc,iBAAiB;WAC1E;mBACQ;mBACA;EAEjB,YAAY,cAAc,OAAO,mBAAmB,QAAQ,OAAO;EAM7D,UAAU,QAAQ,mBAAmB,cAAc,QAAQ,QAAQ;EAMnE,OACJ,OAAO,QACN,QAAQ,mBAAmB,cAAc,QAAQ,QAAQ;UA+BpD;UAKA;UAuCA"}

package/dist/index-CXs7QlR5.d.ts

@@ -1,217 +0,0 @@
-import { f as Run } from "./schema-BtVldJ3T.js";
-import { s as TraceStore } from "./store-CT9YIIve.js";
-import { a as OutcomeFilter, o as OutcomeStore } from "./outcome-store-BYHIuO0e.js";
-import "./rubric-predictive-validity-C1dCLcvb.js";
-import { a as ContinuousCalibrationResult, n as CandidateScore, o as GoldenItem, r as ContinuousAgreement, t as CalibrationResult } from "./judge-calibration-DFtEMlde.js";
-import { n as SeriesConvergenceResult, t as SeriesConvergenceOptions } from "./series-convergence-ofsqPWhs.js";
-import { i as CorpusAgreementReport } from "./statistics-DbvkkDPa.js";
-//#region src/meta-eval/correlation-study.d.ts
-interface EvalMetricSpec {
-  id: string;
-  /** Extract a scalar from a run (defaults cover score/pass/durationMs/costUsd/tokens). */
-  extract?: (run: Run, store: TraceStore) => Promise<number | null>;
-}
-interface OutcomePair {
-  evalMetric: string;
-  outcomeMetric: string;
-}
-interface CorrelationResult {
-  evalMetric: string;
-  outcomeMetric: string;
-  n: number;
-  pearson: number;
-  spearman: number;
-  /** 95% bootstrap CI for Pearson. */
-  pearsonCi95: {
-    lower: number;
-    upper: number;
-  };
-  /** Rough verdict: 'strong' ≥ 0.7, 'moderate' ≥ 0.4, else 'weak'. */
-  verdict: 'strong' | 'moderate' | 'weak';
-}
-interface CorrelationStudyResult {
-  pairs: CorrelationResult[];
-  joinedSamples: number;
-  skippedRuns: number;
-}
-interface CorrelationStudyOptions {
-  /** Only join outcomes captured within this window after run.startedAt. */
-  maxCaptureLagMs?: number;
-  /** Restrict to a subset of outcomes (cohort, region, source). */
-  outcomeFilter?: OutcomeFilter;
-  /** Which outcome per run to use when multiple exist. Default 'latest'. */
-  reduction?: 'latest' | 'mean' | 'max';
-  /** Bootstrap iterations for the CI. Default 500. */
-  bootstrapIterations?: number;
-}
-declare function correlationStudy(traceStore: TraceStore, outcomeStore: OutcomeStore, evalMetrics: EvalMetricSpec[], outcomeMetricNames: string[], options?: CorrelationStudyOptions): Promise<CorrelationStudyResult>;
-//#endregion
-//#region src/meta-eval/calibration.d.ts
-interface CalibrationBin {
-  lower: number;
-  upper: number;
-  n: number;
-  evalMean: number;
-  outcomeMean: number;
-  /** |outcomeMean − evalMean|; contributes to ECE weighted by n/total. */
-  gap: number;
-}
-interface CalibrationReport {
-  evalMetric: string;
-  outcomeMetric: string;
-  n: number;
-  bins: CalibrationBin[];
-  /** Expected Calibration Error — Σ (n_i/N) × |outcomeMean_i − evalMean_i|. */
-  ece: number;
-  /** Max bin gap — upper bound on miscalibration. */
-  maxGap: number;
-}
-interface CalibrationOptions {
-  bins?: number;
-  /** Equal-width (fixed bin edges) or equal-frequency (quantile bins). */
-  binning?: 'equal-width' | 'equal-frequency';
-  /** Clip eval values to [lo, hi] before binning. */
-  range?: {
-    lo: number;
-    hi: number;
-  };
-}
-interface CalibrationPair {
-  evalScore: number;
-  outcome: number;
-}
-declare function calibrationCurve(traceStore: TraceStore, outcomeStore: OutcomeStore, evalMetric: EvalMetricSpec, outcomeMetric: string, options?: CalibrationOptions): Promise<CalibrationReport | null>;
-declare function calibrationFromPairs(inputPairs: CalibrationPair[], evalMetric: string, outcomeMetric: string, options?: CalibrationOptions): CalibrationReport | null;
-//#endregion
-//#region src/meta-eval/sentinel.d.ts
-declare const SENTINEL_METRIC_NAMES: readonly ['irr', 'calibrationKappa', 'sentinelPassRate'];
-type SentinelMetricName = (typeof SENTINEL_METRIC_NAMES)[number];
-interface SentinelMetrics {
-  /** Inter-rater reliability — ICC(2,1) from agreement instruments. */
-  irr?: number;
-  /** Weighted κ vs the human golden set (`calibrateJudge*`). */
-  calibrationKappa?: number;
-  /** Fraction of a fixed sentinel golden set the judge still scores within tolerance. */
-  sentinelPassRate?: number;
-}
-interface SentinelSnapshot {
-  /** Caller-supplied ISO-8601 timestamp — the module never reads a clock. */
-  at: string;
-  judgeId: string;
-  /** Exact model identity behind the judge (pin the full version string). */
-  judgeModel: string;
-  /**
-   * Metrics measured at `at`. May be empty: an empty-metrics snapshot is a
-   * model-change marker — it records the new `judgeModel` immediately and
-   * the silent-upgrade alarm stays raised until a golden-grounded snapshot
-   * (calibrationKappa or sentinelPassRate) follows.
-   */
-  metrics: SentinelMetrics;
-}
-/** Identity + timestamp the caller supplies alongside an instrument output. */
-interface SnapshotMeta {
-  at: string;
-  judgeId: string;
-  judgeModel: string;
-}
-/** Shape guard for snapshots crossing a boundary (store append, JSONL load, report input). */
-declare function validateSentinelSnapshot(snapshot: SentinelSnapshot, source?: string): void;
-/**
- * From `calibrateJudge` / `calibrateJudgeContinuous` output. Prefers the
- * un-rounded continuous κ_w when the report carries one (integer κ
- * discards information for [0,1] judges).
- */
-declare function snapshotFromCalibration(report: CalibrationResult | ContinuousCalibrationResult, meta: SnapshotMeta): SentinelSnapshot;
-/**
- * From `corpusInterRaterAgreement` (statistics.ts) or `continuousAgreement`
- * (judge-calibration.ts) output. IRR = ICC(2,1) — the reliability
- * coefficient both instruments compute. For ensemble-level agreement,
- * `meta.judgeId` names the ensemble and `meta.judgeModel` pins its
- * composition (e.g. a joined list of member model strings).
- */
-declare function snapshotFromAgreement(report: CorpusAgreementReport | ContinuousAgreement, meta: SnapshotMeta): SentinelSnapshot;
-interface SentinelSetOptions {
-  /** Max |judge − human| for an item to count as passed. Default 0.1 (tuned for [0,1] scores). */
-  tolerance?: number;
-}
-/**
- * From a rerun of a fixed sentinel golden set: the same `GoldenItem`s the
- * judge was originally calibrated on, re-scored periodically. Pass rate =
- * fraction of joined items where the judge stays within `tolerance` of the
- * human score. Items the judge didn't score are excluded from the
- * denominator; zero joined items is an error, not a 0% pass rate.
- */
-declare function snapshotFromSentinelSet(scores: CandidateScore[], golden: GoldenItem[], meta: SnapshotMeta, options?: SentinelSetOptions): SentinelSnapshot;
-interface SentinelStore {
-  append(snapshot: SentinelSnapshot): Promise<void>;
-  /** All snapshots (optionally for one judge), in append order. */
-  history(judgeId?: string): Promise<SentinelSnapshot[]>;
-}
-declare function inMemorySentinelStore(initial?: SentinelSnapshot[]): SentinelStore;
-/**
- * JSONL store — one snapshot per line, appended atomically per call.
- * A corrupt or shape-invalid line is a loud error naming the file and
- * line number: a sentinel history that silently drops records would
- * defeat the drift detection it exists to provide.
- */
-declare function fileSentinelStore(path: string): SentinelStore;
-interface SentinelThresholds {
-  /** Floor for irr — below it the judge ensemble is unreliable regardless of trend. Default 0.6. */
-  minIrr?: number;
-  /** Max tolerated calibrationKappa drop vs the series baseline. Default 0.15. */
-  maxKappaDrop?: number;
-  /** Max tolerated sentinelPassRate drop vs the series baseline. Default 0.1. */
-  maxSentinelDrop?: number;
-  /** Newest snapshot older than this (days, vs asOf) = the sentinel itself went blind. Default 30. */
-  staleAfterDays?: number;
-}
-interface JudgeSentinelOptions {
-  /** Caller-supplied ISO timestamp staleness is measured against. */
-  asOf: string;
-  thresholds?: SentinelThresholds;
-  /** Forwarded to `analyzeSeries` (window, stableCv, driftRun). */
-  convergence?: SeriesConvergenceOptions;
-}
-interface SentinelTrend {
-  judgeId: string;
-  metric: SentinelMetricName;
-  /** Verbatim `analyzeSeries` state for this judge×metric history. */
-  state: SeriesConvergenceResult['state'];
-  /** Newest value in the series. */
-  current: number;
-  /** Oldest value in the series — the reference the drop thresholds compare against. */
-  baseline: number;
-  /** current − baseline (signed; negative = decayed). */
-  drift: number;
-  alarmed: boolean;
-  reason?: string;
-}
-interface SentinelReport {
-  perJudge: SentinelTrend[];
-  alarms: string[];
-  healthy: boolean;
-  /**
-   * `judgeId:metric` pairs with too few snapshots for the convergence
-   * machine. Named, not counted — a blind spot you can't see is a blind
-   * spot you won't fix. Floor/drop checks still apply to thin series, so
-   * insufficient history alone never masks an alarm.
-   */
-  insufficientHistory: string[];
-}
-declare function judgeSentinelReport(history: SentinelSnapshot[], opts: JudgeSentinelOptions): SentinelReport;
-interface EvalHealthStamp {
-  healthy: boolean;
-  alarms: string[];
-}
-/**
- * The object a campaign attaches to its verdicts. Compute it from the
- * sentinel report in a post-campaign hook (or a nightly job feeding the
- * next day's campaigns) and store it alongside the verdict payload.
- * `healthy: false` means the judges that produced those verdicts have an
- * unresolved drift / decay / silent-upgrade / staleness alarm — treat the
- * verdicts as carrying an integrity warning until recalibration clears it.
- */
-declare function evalHealthStamp(report: SentinelReport): EvalHealthStamp;
-//#endregion
-export { EvalMetricSpec as A, CalibrationPair as C, CorrelationResult as D, calibrationFromPairs as E, correlationStudy as M, CorrelationStudyOptions as O, CalibrationOptions as S, calibrationCurve as T, snapshotFromAgreement as _, SentinelMetrics as a, validateSentinelSnapshot as b, SentinelSnapshot as c, SentinelTrend as d, SnapshotMeta as f, judgeSentinelReport as g, inMemorySentinelStore as h, SentinelMetricName as i, OutcomePair as j, CorrelationStudyResult as k, SentinelStore as l, fileSentinelStore as m, JudgeSentinelOptions as n, SentinelReport as o, evalHealthStamp as p, SENTINEL_METRIC_NAMES as r, SentinelSetOptions as s, EvalHealthStamp as t, SentinelThresholds as u, snapshotFromCalibration as v, CalibrationReport as w, CalibrationBin as x, snapshotFromSentinelSet as y };
-//# sourceMappingURL=index-CXs7QlR5.d.ts.map