@tangle-network/agent-eval 0.131.1 → 0.133.0

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-B11XCkdf2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B11XCkdf2.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-D_F6VAKe.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-lXLmashy.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-Cmj6nynr.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-D_F6VAKe.d.ts.map

package/dist/metrics-C9YY1OcL.js

@@ -1,239 +0,0 @@
-//#region src/metrics.ts
-/** Per-1K token pricing for exact model ids. */
-const MODEL_PRICING = {
-	"gpt-4o": {
-		input: .0025,
-		output: .01
-	},
-	"gpt-4o-mini": {
-		input: 15e-5,
-		output: 6e-4
-	},
-	"gpt-4-turbo": {
-		input: .01,
-		output: .03
-	},
-	"claude-sonnet-4-20250514": {
-		input: .003,
-		output: .015
-	},
-	"claude-opus-4-20250514": {
-		input: .015,
-		output: .075
-	},
-	"claude-3-haiku-20240307": {
-		input: 25e-5,
-		output: .00125
-	}
-};
-/** Family-level pricing fallbacks (per-1K), matched against a normalized id
-*  after exact lookup misses. Ordered — first match wins. Covers the model
-*  ids actually used through the Tangle router + cli-bridge harnesses
-*  (`claude-code/sonnet`, `opencode/zai-coding-plan/glm-5.1`,
-*  `kimi-code/kimi-k2.6`, `deepseek-v4-pro`, `anthropic/claude-sonnet-4-6`, …),
-*  none of which appear in the exact table above — without this they priced
-*  to a silent $0, blanking every cost/Pareto axis downstream. */
-const FAMILY_PRICING = [
-	[/claude.*opus/, {
-		input: .015,
-		output: .075
-	}],
-	[/claude.*haiku/, {
-		input: 8e-4,
-		output: .004
-	}],
-	[/claude.*sonnet|claude-code|claude-sonnet/, {
-		input: .003,
-		output: .015
-	}],
-	[/gpt-4o-mini/, {
-		input: 15e-5,
-		output: 6e-4
-	}],
-	[/gpt-5|gpt-4\.1|o[134]\b/, {
-		input: .00125,
-		output: .01
-	}],
-	[/gpt-4o|gpt-4/, {
-		input: .0025,
-		output: .01
-	}],
-	[/deepseek/, {
-		input: 3e-4,
-		output: .0011
-	}],
-	[/glm|zhipu|zai/, {
-		input: 6e-4,
-		output: .0022
-	}],
-	[/kimi|moonshot/, {
-		input: 6e-4,
-		output: .0025
-	}],
-	[/qwen/, {
-		input: 4e-4,
-		output: .0012
-	}],
-	[/gemini.*flash/, {
-		input: 1e-4,
-		output: 4e-4
-	}],
-	[/gemini/, {
-		input: .00125,
-		output: .005
-	}],
-	[/llama/, {
-		input: 2e-4,
-		output: 6e-4
-	}]
-];
-/** Normalize a model id for pricing: drop a `@snapshot` suffix, lowercase,
-*  and keep the final harness/provider-prefixed segment so family regexes
-*  match (`opencode/zai-coding-plan/glm-5.1` → `glm-5.1`). */
-function normalizeModelId(model) {
-	return (model.split("@")[0] ?? model).trim().toLowerCase();
-}
-/** Resolve pricing for a model id: exact table, then family fallback.
-*  Returns null when the id matches nothing (caller decides — never a
-*  silent-zero masquerading as a real $0 cost). */
-function resolveModelPricing(model) {
-	if (MODEL_PRICING[model]) return MODEL_PRICING[model];
-	const id = normalizeModelId(model);
-	if (MODEL_PRICING[id]) return MODEL_PRICING[id];
-	for (const [pattern, price] of FAMILY_PRICING) if (pattern.test(id)) return price;
-	return null;
-}
-/** True when `model` has known pricing (exact or family). Lets cost-aware
-*  callers distinguish a real $0 from an unpriced model. */
-function isModelPriced(model) {
-	return resolveModelPricing(model) !== null;
-}
-const warnedUnpricedModels = /* @__PURE__ */ new Set();
-/** Estimate token count from string length (chars / 4 approximation) */
-function estimateTokens(text) {
-	return Math.ceil(text.length / 4);
-}
-/** Calculate cost in USD from token counts and model. Unknown models warn
-*  once (not a silent zero) and return 0 so callers that ignore pricing keep
-*  working; cost-sensitive callers should gate on {@link isModelPriced}. */
-function estimateCost(inputTokens, outputTokens, model) {
-	const pricing = resolveModelPricing(model);
-	if (!pricing) {
-		if (!warnedUnpricedModels.has(model)) {
-			warnedUnpricedModels.add(model);
-			console.warn(`estimateCost: no pricing for model "${model}" — returning 0; add it to MODEL_PRICING/FAMILY_PRICING (cost/Pareto axes will be blank until then)`);
-		}
-		return 0;
-	}
-	return inputTokens / 1e3 * pricing.input + outputTokens / 1e3 * pricing.output;
-}
-/**
-* TokenCounter — accumulates token usage and cost across turns.
-*/
-var TokenCounter = class {
-	totalInput = 0;
-	totalOutput = 0;
-	totalCost = 0;
-	model;
-	constructor(model = "gpt-4o") {
-		this.model = model;
-	}
-	/** Record tokens for a turn, returns per-turn cost */
-	record(inputTokens, outputTokens) {
-		this.totalInput += inputTokens;
-		this.totalOutput += outputTokens;
-		const cost = estimateCost(inputTokens, outputTokens, this.model);
-		this.totalCost += cost;
-		return cost;
-	}
-	/** Estimate and record from raw text */
-	recordFromText(inputText, outputText) {
-		const inputTokens = estimateTokens(inputText);
-		const outputTokens = estimateTokens(outputText);
-		return {
-			inputTokens,
-			outputTokens,
-			cost: this.record(inputTokens, outputTokens)
-		};
-	}
-	getTotalInput() {
-		return this.totalInput;
-	}
-	getTotalOutput() {
-		return this.totalOutput;
-	}
-	getTotalCost() {
-		return this.totalCost;
-	}
-};
-/**
-* MetricsCollector — collects per-turn metrics from the product.
-*
-* After each turn, queries the product's APIs to measure state changes.
-*/
-var MetricsCollector = class {
-	client;
-	workspaceId;
-	metrics = [];
-	constructor(client, workspaceId) {
-		this.client = client;
-		this.workspaceId = workspaceId;
-	}
-	/** Collect metrics after a turn completes */
-	async collect(turn, responseLatencyMs, responseChars, codeBlocksProduced, blocksExtracted, completionCriteriaMet, completionCriteriaTotal, qualityScore, inputTokens = 0, outputTokens = 0, estimatedCostUsd = 0) {
-		const state = await this.getState();
-		const m = {
-			turn,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			tasks: state.tasks,
-			events: state.events,
-			proposals: state.proposals,
-			vaultFiles: state.vaultFiles.length,
-			responseLatencyMs,
-			responseChars,
-			codeBlocksProduced,
-			blocksExtracted,
-			qualityScore,
-			inputTokens,
-			outputTokens,
-			estimatedCostUsd,
-			totalCostUsd: estimatedCostUsd,
-			completionPercent: completionCriteriaTotal > 0 ? completionCriteriaMet / completionCriteriaTotal * 100 : 0
-		};
-		this.metrics.push(m);
-		return m;
-	}
-	/** Get current product state */
-	async getState() {
-		const [tasks, events, approvals, vaultFiles] = await Promise.all([
-			this.client.getTasks(this.workspaceId),
-			this.client.getEvents(this.workspaceId),
-			this.client.getApprovals(this.workspaceId),
-			this.client.getVaultTree(this.workspaceId)
-		]);
-		return {
-			tasks: tasks.length,
-			events: events.length,
-			proposals: {
-				pending: approvals.filter((a) => a.status === "pending").length,
-				approved: approvals.filter((a) => a.status === "approved").length,
-				rejected: approvals.filter((a) => a.status === "rejected").length
-			},
-			vaultFiles,
-			codeBlocks: 0,
-			generations: 0
-		};
-	}
-	/** Get all collected metrics */
-	getMetrics() {
-		return [...this.metrics];
-	}
-	/** Get convergence curve (completion% over turns) */
-	getConvergenceCurve() {
-		return this.metrics.map((m) => m.completionPercent);
-	}
-};
-//#endregion
-export { estimateTokens as a, estimateCost as i, MetricsCollector as n, isModelPriced as o, TokenCounter as r, resolveModelPricing as s, MODEL_PRICING as t };
-
-//# sourceMappingURL=metrics-C9YY1OcL.js.map

package/dist/metrics-C9YY1OcL.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metrics-C9YY1OcL.js","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["import type { ProductClient } from './client'\nimport type { DriverState, TurnMetrics } from './types'\n\ninterface TokenPrice {\n  input: number\n  output: number\n}\n\n/** Per-1K token pricing for exact model ids. */\nexport const MODEL_PRICING: Record<string, TokenPrice> = {\n  'gpt-4o': { input: 0.0025, output: 0.01 },\n  'gpt-4o-mini': { input: 0.00015, output: 0.0006 },\n  'gpt-4-turbo': { input: 0.01, output: 0.03 },\n  'claude-sonnet-4-20250514': { input: 0.003, output: 0.015 },\n  'claude-opus-4-20250514': { input: 0.015, output: 0.075 },\n  'claude-3-haiku-20240307': { input: 0.00025, output: 0.00125 },\n}\n\n/** Family-level pricing fallbacks (per-1K), matched against a normalized id\n *  after exact lookup misses. Ordered — first match wins. Covers the model\n *  ids actually used through the Tangle router + cli-bridge harnesses\n *  (`claude-code/sonnet`, `opencode/zai-coding-plan/glm-5.1`,\n *  `kimi-code/kimi-k2.6`, `deepseek-v4-pro`, `anthropic/claude-sonnet-4-6`, …),\n *  none of which appear in the exact table above — without this they priced\n *  to a silent $0, blanking every cost/Pareto axis downstream. */\nconst FAMILY_PRICING: Array<[RegExp, TokenPrice]> = [\n  [/claude.*opus/, { input: 0.015, output: 0.075 }],\n  [/claude.*haiku/, { input: 0.0008, output: 0.004 }],\n  [/claude.*sonnet|claude-code|claude-sonnet/, { input: 0.003, output: 0.015 }],\n  [/gpt-4o-mini/, { input: 0.00015, output: 0.0006 }],\n  [/gpt-5|gpt-4\\.1|o[134]\\b/, { input: 0.00125, output: 0.01 }],\n  [/gpt-4o|gpt-4/, { input: 0.0025, output: 0.01 }],\n  [/deepseek/, { input: 0.0003, output: 0.0011 }],\n  [/glm|zhipu|zai/, { input: 0.0006, output: 0.0022 }],\n  [/kimi|moonshot/, { input: 0.0006, output: 0.0025 }],\n  [/qwen/, { input: 0.0004, output: 0.0012 }],\n  [/gemini.*flash/, { input: 0.0001, output: 0.0004 }],\n  [/gemini/, { input: 0.00125, output: 0.005 }],\n  [/llama/, { input: 0.0002, output: 0.0006 }],\n]\n\n/** Normalize a model id for pricing: drop a `@snapshot` suffix, lowercase,\n *  and keep the final harness/provider-prefixed segment so family regexes\n *  match (`opencode/zai-coding-plan/glm-5.1` → `glm-5.1`). */\nfunction normalizeModelId(model: string): string {\n  return (model.split('@')[0] ?? model).trim().toLowerCase()\n}\n\n/** Resolve pricing for a model id: exact table, then family fallback.\n *  Returns null when the id matches nothing (caller decides — never a\n *  silent-zero masquerading as a real $0 cost). */\nexport function resolveModelPricing(model: string): TokenPrice | null {\n  if (MODEL_PRICING[model]) return MODEL_PRICING[model]\n  const id = normalizeModelId(model)\n  if (MODEL_PRICING[id]) return MODEL_PRICING[id]\n  for (const [pattern, price] of FAMILY_PRICING) {\n    if (pattern.test(id)) return price\n  }\n  return null\n}\n\n/** True when `model` has known pricing (exact or family). Lets cost-aware\n *  callers distinguish a real $0 from an unpriced model. */\nexport function isModelPriced(model: string): boolean {\n  return resolveModelPricing(model) !== null\n}\n\nconst warnedUnpricedModels = new Set<string>()\n\n/** Estimate token count from string length (chars / 4 approximation) */\nexport function estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4)\n}\n\n/** Calculate cost in USD from token counts and model. Unknown models warn\n *  once (not a silent zero) and return 0 so callers that ignore pricing keep\n *  working; cost-sensitive callers should gate on {@link isModelPriced}. */\nexport function estimateCost(inputTokens: number, outputTokens: number, model: string): number {\n  const pricing = resolveModelPricing(model)\n  if (!pricing) {\n    if (!warnedUnpricedModels.has(model)) {\n      warnedUnpricedModels.add(model)\n      console.warn(\n        `estimateCost: no pricing for model \"${model}\" — returning 0; add it to ` +\n          'MODEL_PRICING/FAMILY_PRICING (cost/Pareto axes will be blank until then)',\n      )\n    }\n    return 0\n  }\n  return (inputTokens / 1000) * pricing.input + (outputTokens / 1000) * pricing.output\n}\n\n/**\n * TokenCounter — accumulates token usage and cost across turns.\n */\nexport class TokenCounter {\n  private totalInput = 0\n  private totalOutput = 0\n  private totalCost = 0\n  private model: string\n\n  constructor(model = 'gpt-4o') {\n    this.model = model\n  }\n\n  /** Record tokens for a turn, returns per-turn cost */\n  record(inputTokens: number, outputTokens: number): number {\n    this.totalInput += inputTokens\n    this.totalOutput += outputTokens\n    const cost = estimateCost(inputTokens, outputTokens, this.model)\n    this.totalCost += cost\n    return cost\n  }\n\n  /** Estimate and record from raw text */\n  recordFromText(\n    inputText: string,\n    outputText: string,\n  ): { inputTokens: number; outputTokens: number; cost: number } {\n    const inputTokens = estimateTokens(inputText)\n    const outputTokens = estimateTokens(outputText)\n    const cost = this.record(inputTokens, outputTokens)\n    return { inputTokens, outputTokens, cost }\n  }\n\n  getTotalInput(): number {\n    return this.totalInput\n  }\n  getTotalOutput(): number {\n    return this.totalOutput\n  }\n  getTotalCost(): number {\n    return this.totalCost\n  }\n}\n\n/**\n * MetricsCollector — collects per-turn metrics from the product.\n *\n * After each turn, queries the product's APIs to measure state changes.\n */\nexport class MetricsCollector {\n  private client: ProductClient\n  private workspaceId: string\n  private metrics: TurnMetrics[] = []\n  constructor(client: ProductClient, workspaceId: string) {\n    this.client = client\n    this.workspaceId = workspaceId\n  }\n\n  /** Collect metrics after a turn completes */\n  async collect(\n    turn: number,\n    responseLatencyMs: number,\n    responseChars: number,\n    codeBlocksProduced: number,\n    blocksExtracted: number,\n    completionCriteriaMet: number,\n    completionCriteriaTotal: number,\n    qualityScore?: number,\n    inputTokens = 0,\n    outputTokens = 0,\n    estimatedCostUsd = 0,\n  ): Promise<TurnMetrics> {\n    const state = await this.getState()\n\n    const m: TurnMetrics = {\n      turn,\n      timestamp: new Date().toISOString(),\n      tasks: state.tasks,\n      events: state.events,\n      proposals: state.proposals,\n      vaultFiles: state.vaultFiles.length,\n      responseLatencyMs,\n      responseChars,\n      codeBlocksProduced,\n      blocksExtracted,\n      qualityScore,\n      inputTokens,\n      outputTokens,\n      estimatedCostUsd,\n      totalCostUsd: estimatedCostUsd,\n      completionPercent:\n        completionCriteriaTotal > 0 ? (completionCriteriaMet / completionCriteriaTotal) * 100 : 0,\n    }\n\n    this.metrics.push(m)\n    return m\n  }\n\n  /** Get current product state */\n  async getState(): Promise<DriverState> {\n    const [tasks, events, approvals, vaultFiles] = await Promise.all([\n      this.client.getTasks(this.workspaceId),\n      this.client.getEvents(this.workspaceId),\n      this.client.getApprovals(this.workspaceId),\n      this.client.getVaultTree(this.workspaceId),\n    ])\n\n    return {\n      tasks: tasks.length,\n      events: events.length,\n      proposals: {\n        pending: approvals.filter((a) => a.status === 'pending').length,\n        approved: approvals.filter((a) => a.status === 'approved').length,\n        rejected: approvals.filter((a) => a.status === 'rejected').length,\n      },\n      vaultFiles,\n      codeBlocks: 0,\n      generations: 0,\n    }\n  }\n\n  /** Get all collected metrics */\n  getMetrics(): TurnMetrics[] {\n    return [...this.metrics]\n  }\n\n  /** Get convergence curve (completion% over turns) */\n  getConvergenceCurve(): number[] {\n    return this.metrics.map((m) => m.completionPercent)\n  }\n}\n"],"mappings":"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"}