@tangle-network/agent-eval 0.79.0 → 0.81.0

package/docs/self-improvement-map.md

@@ -0,0 +1,111 @@
+# The self-improvement map
+
+One loop. Four roles. A driver catalog of pluggable strategies. A bench rig that
+proves the loop produces real lift. Nothing here is duplicated — it is one engine
+pointed at different surfaces. This map exists because the surface count makes it
+*look* like many competing systems when it is one.
+
+Neighbors: [`concepts.md`](./concepts.md) (the mental model), [`trace-analysis.md`](./trace-analysis.md)
+(the evidence engine), [`distributed-driver.md`](./distributed-driver.md) (running the loop across cells).
+
+## The one loop
+
+`runImprovementLoop()` (wrapped by `selfImprove()` for the one-call surface). Every
+product imports the same function. Each generation it does four things:
+
+```
+   run AGENT on SCENARIOS ──► JUDGE scores each run
+                                      │
+                          DRIVER reads the failures and
+                          proposes better SURFACE versions
+                                      │
+                  GATE: did a candidate beat the parent on a
+                  HELD-OUT split, for real (significance test)?
+                        │ yes → promote      │ no → discard
+                                      │
+                              repeat N generations
+```
+
+## The four roles — keep them separate and the confusion clears
+
+| Role | What it is | Plain meaning |
+|---|---|---|
+| **Surface** | a *string* — an agent directive, a `SKILL.md`, a playbook, a memory, a judge rubric | **what** gets improved |
+| **Driver** | an `ImprovementDriver` (the catalog below) | **how** it is improved |
+| **Gate** | held-out split + significance (`paretoSignificanceGate` / `heldOutGate` / `defaultProductionGate`) | **did it actually get better**, vs noise |
+| **Judge** | scores a run | **how good** any version is |
+
+## The driver catalog (one loop, seven strategies)
+
+Source of truth: `src/campaign/drivers/guide.ts` (`DRIVER_GUIDE` + `selectDriver()`).
+The split that matters: **production drivers** mutate a live surface; **bench-only
+drivers** exist solely to be raced inside `compareDrivers`.
+
+| Driver | Surface | Strategy | Role | Notes |
+|---|---|---|---|---|
+| `gepaDriver` | prompt | reflective full-surface rewrite + Pareto frontier | **production default** | consumes trace-analysis findings — see below |
+| `skillOptDriver` | skill-doc | anchored add/delete/replace patch | production | preserves earlier rules; edit budget = "textual learning rate" |
+| `aceDriver` | playbook | append-only, provenance-tagged | production | accumulate hard-won lessons, never summarize away |
+| `memoryCurationDriver` | memory | dedup + rank + graft | production | compact alternative to `ace` |
+| `evolutionaryDriver` | any | population mutate → measure → select | production | blind search; no reflection over findings |
+| `traceAnalystDriver` | prompt | analysis → one LLM edit | **bench-only** | our evidence engine, wrapped as a driver |
+| `haloDriver` | prompt | analysis → one LLM edit | **bench-only**, external | wraps `pip install halo-engine` (Inference.net) |
+
+`selectDriver({ goal, surface })` ranks these for you. `GOAL_RANK`: explore →
+`gepa`; refine → `skillOpt`; accumulate → `ace`; benchmark → `traceAnalyst`/`halo`.
+
+## Trace analysis — what it is and the three places it is used
+
+"Trace analysis" is the **evidence layer**: it turns raw OTLP traces into "here is
+exactly *why* the agent failed" (failure clusters → findings). The engine is
+`analyzeRuns()` + the analyst registry (`src/contract/analyze-runs.ts`). It is used in
+three places — this is the answer to "if GEPA does its own thing, what is trace
+analysis *for*?":
+
+1. **Ships to customers** — `analyzeRuns()` → `InsightReport`, the Intelligence product.
+2. **Feeds the optimizer** — `gepaDriver` calls `renderAnalystEvidence(ctx.findings,
+   ctx.report)` (`src/campaign/drivers/gepa.ts`). This is the EYES→HANDS wire: GEPA's
+   rewrites are grounded in the diagnosis instead of guessing blind. Trace analysis
+   **is** on the GEPA side.
+3. **Races HALO** — wrapped as `traceAnalystDriver` so our analysis competes
+   head-to-head with the external SOTA inside `compareDrivers`.
+
+## Where HALO fits (and why it feels "removed")
+
+`haloDriver` is alive (`src/campaign/drivers/halo.ts`, exported from the campaign
+barrel) but it is **never in the product loop**. It shells out to an *external* engine
+(`halo-engine`) — so the analysis genuinely lives outside this repo; we only wrap it.
+
+Its only job is the **bake-off**. HALO's real opponent is **not** `gepaDriver` — it is
+`traceAnalystDriver`. `compareDrivers` holds the apply step identical (same
+`APPLY_SYSTEM`, same `traces.jsonl`, same held-out scoring) so the only variable is
+**analysis quality: HALO vs ours.** A measuring stick, like a benchmark baseline.
+
+## `gepa-refine.ts` is the loop on a test bench, not a second loop
+
+`agent-runtime/bench/src/gepa-refine.ts` runs **this same loop** against a *public
+benchmark* (AppWorld, CAD, …) instead of product data. Why a separate rig:
+
+- On product traces, "+4 lift" can be model noise or a judge flattering itself — no
+  ground truth.
+- On a benchmark the score is **objective and ungameable** (AppWorld runs the agent's
+  code against its own unit tests). If a GEPA-optimized directive beats a deliberately
+  weak baseline **on held-out tasks it never trained on**, with a CI excluding zero,
+  that is a *certified* proof the loop produces real lift.
+
+Products run the loop to get **better**. `gepa-refine` runs the identical loop to
+**prove the loop works at all**.
+
+## Where the "mess" feeling actually comes from
+
+The code is well-factored; the confusion is narrative:
+
+- **Surface sprawl reads as chaos.** Seven drivers with overlapping shapes *look* like
+  seven competing loops. They are pluggable strategies for one loop — `guide.ts` says
+  so, but it was buried. (This doc surfaces it.)
+- **The real gap is the missing proof, not the design.** The loop kept being proved on
+  benchmarks too easy to show value: when a capable model ceilings an extraction task,
+  **0 findings fire** and the whole trace-analysis→optimizer apparatus is inert. It
+  earns its keep only on **hard agentic tasks** — which is why the AppWorld REPL run
+  (multi-turn, real tool execution, unbounded turns) is the one that can finally
+  separate the evidence-grounded optimizer from baseline.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.79.0",
-  "description": "Substrate for self-improving agents: traces, verifiable rewards, preferences, GEPA / reflective mutation, auto-research, replay, sequential anytime-valid stats, and release gates.",
+  "version": "0.81.0",
+  "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {
     "type": "git",
@@ -119,6 +119,11 @@
       "import": "./dist/authenticity/index.js",
       "default": "./dist/authenticity/index.js"
     },
+    "./experimental/belief-state": {
+      "types": "./dist/belief-state/index.d.ts",
+      "import": "./dist/belief-state/index.js",
+      "default": "./dist/belief-state/index.js"
+    },
     "./workflow": {
       "types": "./dist/workflow/index.d.ts",
       "import": "./dist/workflow/index.js",

package/dist/chunk-IHDHUN2X.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/llm-client.ts"],"sourcesContent":["/**\n * LLM client with graceful degrade.\n *\n * OpenAI-compatible `/v1/chat/completions` client with:\n *   - Exponential-backoff retry on 429 + 5xx gateway errors (502/503/504).\n *   - Retry on transient network errors (fetch failed, AbortError, ECONNRESET).\n *   - Graceful json_schema → json_object degrade on 400 with schema-reject body.\n *   - Fenced-JSON stripping (```json ... ```) for models that wrap structured output.\n *   - Configurable base URL + api key / bearer, works with LiteLLM proxies, OpenAI\n *     directly, cli-bridge subscriptions, and any router that speaks the spec.\n *\n * Usage:\n *   const { value, result } = await callLlmJson<MyType>(\n *     { model: 'gpt-4o', messages: [...], jsonSchema: { name: 'x', schema: {...} } },\n *     { baseUrl: 'https://router.tangle.tools/v1', apiKey: process.env.KEY },\n *   )\n *\n * This is THE llm-calling seam for agent-eval primitives that need structured\n * output (semantic concept judge, reviewer directives, critic scores). Primitives\n * that need free-form text use `callLlm` and parse output themselves.\n */\n\nimport { AgentEvalError, CaptureIntegrityError } from './errors'\nimport {\n  defaultProviderRedactor,\n  type ProviderRedactor,\n  providerFromBaseUrl,\n  type RawProviderEvent,\n  type RawProviderSink,\n} from './trace/raw-provider-sink'\n\n// ─── Types ──────────────────────────────────────────────────────────────\n\nexport interface LlmMessage {\n  role: 'system' | 'user' | 'assistant'\n  /**\n   * Either a plain text content string OR a multimodal content array\n   * (text + image_url parts) for vision-capable models.\n   */\n  content:\n    | string\n    | Array<\n        | { type: 'text'; text: string }\n        | { type: 'image_url'; image_url: { url: string; detail?: 'auto' | 'low' | 'high' } }\n      >\n}\n\nexport interface LlmCallRequest {\n  model: string\n  messages: LlmMessage[]\n  /** Optional JSON-mode response format (response_format: json_object). */\n  jsonMode?: boolean\n  /** Optional structured output via JSON Schema. Falls back to json_object on 400. */\n  jsonSchema?: { name: string; schema: Record<string, unknown> }\n  temperature?: number\n  maxTokens?: number\n  /** Per-call timeout, default 60s. */\n  timeoutMs?: number\n}\n\nexport interface LlmUsage {\n  promptTokens: number\n  completionTokens: number\n  totalTokens: number\n  /** Proxies populate this when prompt caching is on. */\n  cachedPromptTokens?: number\n}\n\nexport interface LlmCallResult {\n  /** The text content of the first choice. Empty string if none. */\n  content: string\n  usage: LlmUsage\n  /**\n   * Cost in USD. Pulled from proxy's `_response_cost` field when present;\n   * `null` when neither the proxy nor the caller can derive it.\n   */\n  costUsd: number | null\n  /** Model name actually used (echoed from response). */\n  model: string\n  /** Wall-clock duration of the HTTP call (last attempt, if retried). */\n  durationMs: number\n  /** Raw response body. */\n  raw: Record<string, unknown>\n}\n\nexport class LlmCallError extends AgentEvalError {\n  constructor(\n    message: string,\n    public readonly status: number,\n    public readonly body: string,\n    public readonly model: string,\n  ) {\n    super('judge', message)\n  }\n}\n\nexport interface LlmClientOptions {\n  /** Base URL (without trailing slash). Must end at the `/v1` prefix. */\n  baseUrl?: string\n  /** Bearer token — either `apiKey` or `bearer` populates `Authorization: Bearer ...`. */\n  apiKey?: string\n  bearer?: string\n  /** Override for the `Authorization` header (e.g. `X-Auth: ...`). Takes precedence over apiKey/bearer. */\n  authHeader?: { name: string; value: string }\n  /** Default timeout in ms. Per-call can override. */\n  defaultTimeoutMs?: number\n  /** Max retry attempts on retriable errors. Default 3 (1 initial + 2 retries). */\n  maxRetries?: number\n  /** Fetch implementation — defaults to global `fetch`. Override for custom transport (e.g. tests). */\n  fetch?: typeof fetch\n  /**\n   * Optional raw HTTP capture sink. When provided, every request, response,\n   * and error (across all retry attempts) is recorded to the sink, with auth\n   * headers and credential-shaped body fields redacted by default. This is\n   * the layer-1 forensics primitive: structured `LlmSpan`s record intent,\n   * raw events record what actually crossed the wire.\n   */\n  rawSink?: RawProviderSink\n  /**\n   * Logical provider id attached to raw events. When omitted, derived from\n   * `baseUrl` via `providerFromBaseUrl`.\n   */\n  provider?: string\n  /** Trace context attached to raw events; populated by emitter-aware callers. */\n  traceContext?: { runId?: string; spanId?: string }\n  /** Override the redaction strategy for this call. Defaults to `defaultProviderRedactor`. */\n  redactor?: ProviderRedactor\n}\n\n// ─── Internals ──────────────────────────────────────────────────────────\n\nconst DEFAULT_BASE_URL = 'https://router.tangle.tools/v1'\nconst DEFAULT_TIMEOUT_MS = 60_000\nconst DEFAULT_MAX_RETRIES = 3\n\nconst RETRYABLE_STATUS = new Set([429, 502, 503, 504])\n\n/**\n * Transient transport/network error signatures, matched against an error's\n * name, message, and `code`. Covers fetch/undici network failures, aborts\n * and timeouts, and — critically — HTTP/2 transport faults a keep-alive\n * connection raises mid-response: `terminated`, `NGHTTP2_INTERNAL_ERROR`,\n * `UND_ERR_*`, `other side closed`. Those last ones carry no clean HTTP\n * status; unrecognised, they escape the retry loop and surface as an\n * uncaught rejection.\n */\nconst TRANSIENT_ERROR_PATTERNS: readonly RegExp[] = [\n  /AbortError/i,\n  /TimeoutError/i,\n  /this operation was aborted/i,\n  /fetch failed/i,\n  /ECONNRESET/i,\n  /ETIMEDOUT/i,\n  /EAI_AGAIN/i,\n  /socket hang up/i,\n  /stream.*ended.*unexpectedly/i,\n  /terminated/i,\n  /other side closed/i,\n  /NGHTTP2/i,\n  /UND_ERR/i,\n]\n\n/**\n * True when an error is a transient transport/network fault worth retrying,\n * as opposed to a deterministic failure (4xx schema reject, JSON parse) that\n * a retry cannot fix. Inspects `LlmCallError.status`, then the error's\n * name/message/code, then recurses into `error.cause` — undici nests the\n * real socket fault one or more levels under `.cause`.\n *\n * This is THE retry classifier for the package: `callLlm` and\n * `withJudgeRetry` both route through it, so a connection-class error is\n * treated identically whether it surfaces in the HTTP client or a\n * TCloud-backed judge.\n */\nexport function isTransientLlmError(err: unknown): boolean {\n  return classifyTransient(err, 0)\n}\n\nfunction classifyTransient(err: unknown, depth: number): boolean {\n  if (err instanceof LlmCallError) return RETRYABLE_STATUS.has(err.status)\n  if (!(err instanceof Error)) return false\n  // Foreign errors (e.g. a TCloud judge SDK error) can carry a numeric HTTP\n  // status without being an LlmCallError — a retryable status is decisive.\n  const status = (err as { status?: unknown }).status\n  if (typeof status === 'number' && RETRYABLE_STATUS.has(status)) return true\n  const code = (err as { code?: unknown }).code\n  const haystack = `${err.name}\\n${err.message}\\n${typeof code === 'string' ? code : ''}`\n  if (TRANSIENT_ERROR_PATTERNS.some((p) => p.test(haystack))) return true\n  const cause = (err as { cause?: unknown }).cause\n  if (depth < 4 && cause instanceof Error && cause !== err) {\n    return classifyTransient(cause, depth + 1)\n  }\n  return false\n}\n\nfunction parseRetryAfter(headers: Headers): number | null {\n  const h = headers.get('retry-after')\n  if (!h) return null\n  const asNumber = Number(h)\n  if (Number.isFinite(asNumber) && asNumber > 0) return asNumber * 1000\n  const asDate = Date.parse(h)\n  if (Number.isFinite(asDate)) return Math.max(0, asDate - Date.now())\n  return null\n}\n\n/** Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 16s. Attempt is 0-indexed. */\nexport function backoffMs(attempt: number): number {\n  return Math.min(500 * 2 ** attempt, 16_000)\n}\n\nfunction buildHeaders(opts: LlmClientOptions): Record<string, string> {\n  const headers: Record<string, string> = {\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n  }\n  if (opts.authHeader) {\n    headers[opts.authHeader.name] = opts.authHeader.value\n  } else if (opts.bearer || opts.apiKey) {\n    headers.Authorization = `Bearer ${opts.bearer ?? opts.apiKey}`\n  }\n  return headers\n}\n\nfunction isSchemaRejection(status: number, body: string): boolean {\n  if (status !== 400) return false\n  const lower = body.toLowerCase()\n  return (\n    lower.includes('response_format') ||\n    lower.includes('json_schema') ||\n    lower.includes('is unavailable') ||\n    lower.includes('not supported')\n  )\n}\n\nfunction buildBody(req: LlmCallRequest, forceJsonObject: boolean): Record<string, unknown> {\n  const body: Record<string, unknown> = {\n    model: req.model,\n    messages: req.messages,\n    temperature: req.temperature ?? 0,\n  }\n  if (req.maxTokens != null) {\n    if (usesMaxCompletionTokens(req.model)) body.max_completion_tokens = req.maxTokens\n    else body.max_tokens = req.maxTokens\n  }\n\n  if (req.jsonSchema && !forceJsonObject) {\n    body.response_format = {\n      type: 'json_schema',\n      json_schema: { name: req.jsonSchema.name, schema: req.jsonSchema.schema, strict: true },\n    }\n  } else if (req.jsonMode || req.jsonSchema) {\n    body.response_format = { type: 'json_object' }\n  }\n\n  return body\n}\n\nfunction usesMaxCompletionTokens(model: string): boolean {\n  return /^gpt-5(?:[.-]|$)/i.test(model)\n}\n\nasync function sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\n// ─── Public API ─────────────────────────────────────────────────────────\n\n/**\n * Strip a ```json / ``` code fence if the model emitted one.\n * Idempotent for naked JSON. Some models (claude-code via router, certain\n * deepseek models) wrap output even under json_object.\n */\nexport function stripFencedJson(raw: string): string {\n  const trimmed = raw.trim()\n  const m = trimmed.match(/^```(?:json)?\\s*\\n?([\\s\\S]*?)\\n?```\\s*$/)\n  return m ? m[1]!.trim() : trimmed\n}\n\nexport function extractJsonPayload(raw: string): string {\n  const stripped = stripFencedJson(raw)\n  try {\n    JSON.parse(stripped)\n    return stripped\n  } catch {\n    // Continue with balanced extraction below.\n  }\n\n  const starts = [...stripped.matchAll(/[[{]/g)]\n    .map((match) => match.index)\n    .filter((index) => index != null)\n  for (const start of starts) {\n    const candidate = extractBalancedJson(stripped, start)\n    if (!candidate) continue\n    try {\n      JSON.parse(candidate)\n      return candidate\n    } catch {\n      // Keep scanning; earlier braces may belong to prose.\n    }\n  }\n\n  return stripped\n}\n\nfunction extractBalancedJson(input: string, start: number): string | null {\n  const opener = input[start]\n  const closer = opener === '{' ? '}' : opener === '[' ? ']' : null\n  if (!closer) return null\n\n  const stack: string[] = [closer]\n  let isInString = false\n  let isEscaped = false\n\n  for (let i = start + 1; i < input.length; i++) {\n    const char = input[i]!\n    if (isEscaped) {\n      isEscaped = false\n      continue\n    }\n    if (char === '\\\\') {\n      isEscaped = isInString\n      continue\n    }\n    if (char === '\"') {\n      isInString = !isInString\n      continue\n    }\n    if (isInString) continue\n\n    if (char === '{') stack.push('}')\n    else if (char === '[') stack.push(']')\n    else if (char === stack[stack.length - 1]) {\n      stack.pop()\n      if (stack.length === 0) return input.slice(start, i + 1)\n    }\n  }\n\n  return null\n}\n\n/**\n * Low-level call. Returns raw content + usage + cost. Retries on transient\n * failures; does NOT degrade schema here — callers that want graceful\n * degrade use `callLlmJson`.\n */\nexport async function callLlm(\n  req: LlmCallRequest,\n  opts: LlmClientOptions = {},\n): Promise<LlmCallResult> {\n  const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\\/+$/, '')\n  const url = `${baseUrl}/chat/completions`\n  const endpoint = '/chat/completions'\n  const timeoutMs = req.timeoutMs ?? opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS\n  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES\n  const fetchFn = opts.fetch ?? globalThis.fetch\n  const headers = buildHeaders(opts)\n  const provider = opts.provider ?? providerFromBaseUrl(baseUrl)\n  const sink = opts.rawSink\n  const redactor = opts.redactor ?? defaultProviderRedactor\n  const traceContext = opts.traceContext\n\n  let lastErr: unknown\n  for (let attempt = 0; attempt < maxRetries; attempt++) {\n    const controller = new AbortController()\n    const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs)\n    const started = Date.now()\n    const requestBody = buildBody(req, false)\n    let attemptErrorRecorded = false\n    if (sink) {\n      await recordRaw(sink, redactor, {\n        eventId: cryptoEventId(),\n        runId: traceContext?.runId,\n        spanId: traceContext?.spanId,\n        provider,\n        model: req.model,\n        endpoint,\n        baseUrl,\n        attemptIndex: attempt,\n        direction: 'request',\n        timestamp: started,\n        requestHeaders: headers,\n        requestBody,\n        redactedFields: [],\n      })\n    }\n\n    try {\n      const res = await fetchFn(url, {\n        method: 'POST',\n        headers,\n        body: JSON.stringify(requestBody),\n        signal: controller.signal,\n      })\n      clearTimeout(timeoutHandle)\n      const responseHeaders = sink ? headersToObject(res.headers) : undefined\n\n      if (!res.ok) {\n        const body = await res.text()\n        if (sink) {\n          await recordRaw(sink, redactor, {\n            eventId: cryptoEventId(),\n            runId: traceContext?.runId,\n            spanId: traceContext?.spanId,\n            provider,\n            model: req.model,\n            endpoint,\n            baseUrl,\n            attemptIndex: attempt,\n            direction: 'error',\n            timestamp: Date.now(),\n            durationMs: Date.now() - started,\n            statusCode: res.status,\n            responseHeaders,\n            responseBody: body,\n            errorMessage: `HTTP ${res.status}`,\n            redactedFields: [],\n          })\n          attemptErrorRecorded = true\n        }\n        const err = new LlmCallError(\n          `LLM call ${res.status}: ${body.slice(0, 300)}`,\n          res.status,\n          body,\n          req.model,\n        )\n        if (RETRYABLE_STATUS.has(res.status) && attempt < maxRetries - 1) {\n          lastErr = err\n          const retryAfter = parseRetryAfter(res.headers)\n          await sleep(retryAfter ?? backoffMs(attempt))\n          continue\n        }\n        throw err\n      }\n\n      const text = await res.text()\n      let json: Record<string, unknown>\n      try {\n        json = JSON.parse(text) as Record<string, unknown>\n      } catch (parseErr) {\n        if (sink) {\n          await recordRaw(sink, redactor, {\n            eventId: cryptoEventId(),\n            runId: traceContext?.runId,\n            spanId: traceContext?.spanId,\n            provider,\n            model: req.model,\n            endpoint,\n            baseUrl,\n            attemptIndex: attempt,\n            direction: 'error',\n            timestamp: Date.now(),\n            durationMs: Date.now() - started,\n            statusCode: res.status,\n            responseHeaders,\n            responseBody: text,\n            errorMessage: `non-JSON response: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`,\n            redactedFields: [],\n          })\n          attemptErrorRecorded = true\n        }\n        throw parseErr\n      }\n      if (sink) {\n        await recordRaw(sink, redactor, {\n          eventId: cryptoEventId(),\n          runId: traceContext?.runId,\n          spanId: traceContext?.spanId,\n          provider,\n          model: req.model,\n          endpoint,\n          baseUrl,\n          attemptIndex: attempt,\n          direction: 'response',\n          timestamp: Date.now(),\n          durationMs: Date.now() - started,\n          statusCode: res.status,\n          responseHeaders,\n          responseBody: json,\n          redactedFields: [],\n        })\n      }\n      const choice = (json.choices as Array<{ message?: { content?: string } }> | undefined)?.[0]\n      const usageRaw = (json.usage as Record<string, unknown> | undefined) ?? {}\n      const costFromProxy = (json._response_cost ?? json.cost_usd) as number | undefined\n\n      return {\n        content: choice?.message?.content ?? '',\n        usage: {\n          promptTokens: Number(usageRaw.prompt_tokens ?? 0),\n          completionTokens: Number(usageRaw.completion_tokens ?? 0),\n          totalTokens: Number(usageRaw.total_tokens ?? 0),\n          cachedPromptTokens:\n            usageRaw.prompt_tokens_details && typeof usageRaw.prompt_tokens_details === 'object'\n              ? Number(\n                  (usageRaw.prompt_tokens_details as Record<string, unknown>).cached_tokens ?? 0,\n                )\n              : undefined,\n        },\n        costUsd: typeof costFromProxy === 'number' ? costFromProxy : null,\n        model: (json.model as string) ?? req.model,\n        durationMs: Date.now() - started,\n        raw: json,\n      }\n    } catch (err) {\n      clearTimeout(timeoutHandle)\n      lastErr = err\n      if (sink && !attemptErrorRecorded) {\n        // Record only if neither the !res.ok branch nor the JSON.parse catch\n        // already produced an error event for this attempt. Covers network\n        // failures, timeouts, and aborts.\n        await recordRaw(sink, redactor, {\n          eventId: cryptoEventId(),\n          runId: traceContext?.runId,\n          spanId: traceContext?.spanId,\n          provider,\n          model: req.model,\n          endpoint,\n          baseUrl,\n          attemptIndex: attempt,\n          direction: 'error',\n          timestamp: Date.now(),\n          durationMs: Date.now() - started,\n          errorMessage: err instanceof Error ? err.message : String(err),\n          redactedFields: [],\n        })\n      }\n      if (attempt < maxRetries - 1 && isTransientLlmError(err)) {\n        await sleep(backoffMs(attempt))\n        continue\n      }\n      throw err\n    }\n  }\n  throw lastErr instanceof Error ? lastErr : new Error(String(lastErr))\n}\n\nasync function recordRaw(\n  sink: RawProviderSink,\n  redactor: ProviderRedactor,\n  event: RawProviderEvent,\n): Promise<void> {\n  // Errors from sinks must not crash the LLM call. Forensic capture is\n  // best-effort; the structured trace is the system of record.\n  try {\n    await sink.record(redactor(event))\n  } catch {\n    // Intentionally swallowed.\n  }\n}\n\nfunction headersToObject(h: Headers): Record<string, string> {\n  const out: Record<string, string> = {}\n  h.forEach((value, key) => {\n    out[key] = value\n  })\n  return out\n}\n\nfunction cryptoEventId(): string {\n  if (typeof globalThis.crypto?.randomUUID === 'function') return globalThis.crypto.randomUUID()\n  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`\n}\n\n/**\n * Structured-output call. Returns parsed JSON plus the raw result envelope.\n * Degrades `jsonSchema` → `jsonMode` on a 400 that names the schema param —\n * critical for deepseek-v3/v4, kimi-k2.6, and other models that don't accept\n * the `response_format.json_schema` shape but DO accept `json_object`.\n */\nexport async function callLlmJson<T = unknown>(\n  req: LlmCallRequest,\n  opts: LlmClientOptions = {},\n): Promise<{ value: T; result: LlmCallResult }> {\n  try {\n    const result = await callLlm({ ...req, jsonMode: req.jsonMode ?? !req.jsonSchema }, opts)\n    const value = parseJsonSafely<T>(result.content, result.model)\n    return { value, result }\n  } catch (err) {\n    if (err instanceof LlmCallError && isSchemaRejection(err.status, err.body) && req.jsonSchema) {\n      // Degrade to json_object + retry.\n      const degradedReq: LlmCallRequest = { ...req, jsonMode: true, jsonSchema: undefined }\n      const result = await callLlm(degradedReq, opts)\n      const value = parseJsonSafely<T>(result.content, result.model)\n      return { value, result }\n    }\n    throw err\n  }\n}\n\nfunction parseJsonSafely<T>(content: string, model: string): T {\n  const stripped = extractJsonPayload(content)\n  try {\n    return JSON.parse(stripped) as T\n  } catch (err) {\n    throw new Error(\n      `LLM returned non-JSON content (model=${model}): ${\n        err instanceof Error ? err.message : String(err)\n      }\\n--- raw content ---\\n${content.slice(0, 800)}`,\n    )\n  }\n}\n\n// ─── Route assertion ────────────────────────────────────────────────────\n\nexport type LlmRouteAssertionReason =\n  | 'no_explicit_base_url'\n  | 'base_url_blocked'\n  | 'base_url_not_allowed'\n  | 'no_auth'\n  | 'wrong_provider'\n\nexport class LlmRouteAssertionError extends CaptureIntegrityError {\n  constructor(\n    message: string,\n    public readonly reason: LlmRouteAssertionReason,\n    public readonly baseUrl: string,\n  ) {\n    super(message)\n  }\n}\n\nexport interface LlmRouteRequirements {\n  /**\n   * Throw if `opts.baseUrl` is undefined, i.e. the call would fall back to\n   * `DEFAULT_BASE_URL`. Set this for evaluation runs where silently using\n   * the public/free-tier router is a defect — the launch reviewer needs to\n   * know exactly which provider answered.\n   */\n  requireExplicitBaseUrl?: boolean\n  /**\n   * Allowlist of acceptable base URLs. Strings match by prefix\n   * (case-insensitive); RegExps test against the full base URL.\n   */\n  allowedBaseUrls?: Array<string | RegExp>\n  /** Blocklist that takes precedence over `allowedBaseUrls`. */\n  blockedBaseUrls?: Array<string | RegExp>\n  /** Throw if no auth header / api key is configured. */\n  requireAuth?: boolean\n  /**\n   * Logical provider id the configured `baseUrl` is expected to match (via\n   * `providerFromBaseUrl`). Mainly useful when paired with `requireExplicitBaseUrl`.\n   */\n  expectedProvider?: string\n}\n\n/**\n * Fail-loud assertion that the configured LLM client points at the route\n * the caller intends. Designed for the matrix-runner preflight: invoke\n * once before any LLM call to catch misconfiguration before a sweep burns\n * dollars on the wrong provider.\n *\n * Throws `LlmRouteAssertionError`. Pure — no I/O — so it's safe to call\n * from constructors and CI gates.\n */\nexport function assertLlmRoute(opts: LlmClientOptions, req: LlmRouteRequirements = {}): void {\n  const baseUrlExplicit = opts.baseUrl !== undefined\n  const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\\/+$/, '')\n\n  if (req.requireExplicitBaseUrl && !baseUrlExplicit) {\n    throw new LlmRouteAssertionError(\n      `assertLlmRoute: requireExplicitBaseUrl set but opts.baseUrl is undefined; would fall back to ${DEFAULT_BASE_URL}.`,\n      'no_explicit_base_url',\n      baseUrl,\n    )\n  }\n\n  if (req.blockedBaseUrls?.some((p) => matchUrl(baseUrl, p))) {\n    throw new LlmRouteAssertionError(\n      `assertLlmRoute: baseUrl ${baseUrl} matches a blocked pattern.`,\n      'base_url_blocked',\n      baseUrl,\n    )\n  }\n\n  if (req.allowedBaseUrls && req.allowedBaseUrls.length > 0) {\n    const ok = req.allowedBaseUrls.some((p) => matchUrl(baseUrl, p))\n    if (!ok) {\n      throw new LlmRouteAssertionError(\n        `assertLlmRoute: baseUrl ${baseUrl} is not in the allowed list (${req.allowedBaseUrls.map(describePattern).join(', ')}).`,\n        'base_url_not_allowed',\n        baseUrl,\n      )\n    }\n  }\n\n  if (req.requireAuth && !opts.apiKey && !opts.bearer && !opts.authHeader) {\n    throw new LlmRouteAssertionError(\n      `assertLlmRoute: requireAuth set but no apiKey, bearer, or authHeader was supplied.`,\n      'no_auth',\n      baseUrl,\n    )\n  }\n\n  if (req.expectedProvider) {\n    const actual = opts.provider ?? providerFromBaseUrl(baseUrl)\n    if (actual !== req.expectedProvider) {\n      throw new LlmRouteAssertionError(\n        `assertLlmRoute: expected provider ${req.expectedProvider} but baseUrl ${baseUrl} resolves to ${actual}.`,\n        'wrong_provider',\n        baseUrl,\n      )\n    }\n  }\n}\n\nfunction matchUrl(url: string, pattern: string | RegExp): boolean {\n  if (pattern instanceof RegExp) return pattern.test(url)\n  return url.toLowerCase().startsWith(pattern.toLowerCase())\n}\n\nfunction describePattern(p: string | RegExp): string {\n  return p instanceof RegExp ? p.source : p\n}\n\n/**\n * Probe whether a model is reachable. Returns latency + null error on\n * success; `ok=false` + error message on any failure (HTTP, timeout,\n * network, parse). Designed for sweep preflights — fail loud at the\n * boundary before burning a 30-leaf run on a misconfigured router.\n *\n * Sends a tiny `ping` message with `maxTokens=64`. Reasoning models\n * (glm-5.1, deepseek-v4) can burn the entire budget on internal reasoning\n * for short prompts, so don't tighten this further. We don't validate\n * content; HTTP 200 means reachable.\n */\nexport async function probeLlm(\n  model: string,\n  opts: LlmClientOptions & { timeoutMs?: number } = {},\n): Promise<{ ok: boolean; latencyMs: number; error: string | null }> {\n  const start = Date.now()\n  try {\n    await callLlm(\n      {\n        model,\n        messages: [{ role: 'user', content: 'ping' }],\n        maxTokens: 64,\n        timeoutMs: opts.timeoutMs ?? 30_000,\n      },\n      opts,\n    )\n    return { ok: true, latencyMs: Date.now() - start, error: null }\n  } catch (err) {\n    return {\n      ok: false,\n      latencyMs: Date.now() - start,\n      error: err instanceof Error ? err.message : String(err),\n    }\n  }\n}\n\n/**\n * Stateful client — construct once with defaults, call many times.\n * Thin wrapper around the free functions; exists for callers that want\n * to inject a single configured instance into multiple primitives.\n */\nexport class LlmClient {\n  constructor(private readonly opts: LlmClientOptions = {}) {}\n\n  call(req: LlmCallRequest, per?: LlmClientOptions): Promise<LlmCallResult> {\n    return callLlm(req, { ...this.opts, ...per })\n  }\n\n  callJson<T = unknown>(\n    req: LlmCallRequest,\n    per?: LlmClientOptions,\n  ): Promise<{ value: T; result: LlmCallResult }> {\n    return callLlmJson<T>(req, { ...this.opts, ...per })\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ITBRCT73.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/judge-calibration.ts","../src/statistics.ts"],"sourcesContent":["/**\n * Judge calibration — measure judge quality against human gold + bias.\n *\n * Workflow:\n *   1. Build a golden set: {itemId, humanScore}[].\n *   2. Run candidate judges; each produces {itemId, score}.\n *   3. `calibrateJudge(golden, candidate)` reports κ + Pearson + MAE.\n *   4. `calibrateJudgeContinuous(golden, candidate)` adds quadratic-weighted\n *      κ over the un-rounded [0,1] scores plus ICC(2,1), Pearson, Spearman,\n *      and bootstrap CIs — use this for fine-grained judges where rounding\n *      to int discards information (e.g. 0.78 vs 0.81 both round to 1 and\n *      look \"perfectly agreed\" to integer κ).\n *   5. Run bias probes (positional, verbosity, self-preference) to\n *      detect systematic score inflation.\n *   6. For N≥2 judges on the same items, `continuousAgreement(scores)`\n *      reports ICC(2,1) + κ_w + Pearson + Spearman with bootstrap CIs.\n *\n * Returns actionable diagnostics, not a single number. Consumers then\n * decide whether to trust the judge, retrain it, or add a tie-breaker.\n */\n\nexport interface GoldenItem {\n  itemId: string\n  humanScore: number\n  /** Optional group used for per-group bias audits (e.g. model-of-output family). */\n  group?: string\n}\n\nexport interface CandidateScore {\n  itemId: string\n  score: number\n  /** Optional — enables positional-bias analysis (did order matter?). */\n  positionOfAInput?: 'first' | 'second'\n}\n\nexport interface CalibrationResult {\n  n: number\n  pearson: number\n  /** Cohen's κ with quadratic weights over integer-rounded scores. */\n  kappa: number\n  /** Mean absolute error vs human. */\n  mae: number\n  /** Worst-5 miscalibrations (largest |judge - human|). */\n  worstItems: Array<{ itemId: string; judge: number; human: number; delta: number }>\n}\n\nexport function calibrateJudge(\n  golden: GoldenItem[],\n  candidate: CandidateScore[],\n): CalibrationResult {\n  const map = new Map<string, { h: number; j: number }>()\n  for (const g of golden) map.set(g.itemId, { h: g.humanScore, j: NaN })\n  for (const c of candidate) {\n    const entry = map.get(c.itemId)\n    if (entry) entry.j = c.score\n  }\n  const common = [...map.values()].filter((v) => Number.isFinite(v.j))\n  const n = common.length\n  if (n < 2) {\n    return { n, pearson: NaN, kappa: NaN, mae: NaN, worstItems: [] }\n  }\n  const humans = common.map((c) => c.h)\n  const judges = common.map((c) => c.j)\n  const pearson = pearsonR(humans, judges)\n  const kappa = weightedKappa(humans.map(Math.round), judges.map(Math.round))\n  const absDiffs = common.map((c) => Math.abs(c.j - c.h))\n  const mae = absDiffs.reduce((a, b) => a + b, 0) / n\n  const worst = [...map.entries()]\n    .filter(([, v]) => Number.isFinite(v.j))\n    .map(([itemId, v]) => ({ itemId, judge: v.j, human: v.h, delta: Math.abs(v.j - v.h) }))\n    .sort((a, b) => b.delta - a.delta)\n    .slice(0, 5)\n  return { n, pearson, kappa, mae, worstItems: worst }\n}\n\nexport interface PositionalBiasResult {\n  /**\n   * Score delta (first-position - second-position) averaged across items\n   * presented in both positions. Non-zero = positional bias.\n   */\n  avgDelta: number\n  n: number\n}\n\n/**\n * Feed the same items to the judge twice with A/B swapped and pass all\n * results here. Items that don't appear in both positions are ignored.\n */\nexport function positionalBias(scores: CandidateScore[]): PositionalBiasResult {\n  const pairs = new Map<string, { first?: number; second?: number }>()\n  for (const s of scores) {\n    const slot = pairs.get(s.itemId) ?? {}\n    if (s.positionOfAInput === 'first') slot.first = s.score\n    else if (s.positionOfAInput === 'second') slot.second = s.score\n    pairs.set(s.itemId, slot)\n  }\n  const deltas: number[] = []\n  for (const { first, second } of pairs.values()) {\n    if (first !== undefined && second !== undefined) deltas.push(first - second)\n  }\n  if (deltas.length === 0) return { avgDelta: 0, n: 0 }\n  return { avgDelta: deltas.reduce((a, b) => a + b, 0) / deltas.length, n: deltas.length }\n}\n\nexport interface VerbosityBiasResult {\n  /** Pearson correlation between output length and score. Strong positive = verbosity bias. */\n  pearson: number\n  n: number\n}\n\nexport function verbosityBias(\n  samples: Array<{ outputLen: number; score: number }>,\n): VerbosityBiasResult {\n  const n = samples.length\n  if (n < 3) return { pearson: NaN, n }\n  return {\n    pearson: pearsonR(\n      samples.map((s) => s.outputLen),\n      samples.map((s) => s.score),\n    ),\n    n,\n  }\n}\n\nexport interface SelfPreferenceResult {\n  /** Mean judge score when judge's family matches output's family. */\n  inFamilyMean: number\n  outOfFamilyMean: number\n  deltaMean: number\n  n: number\n}\n\n/**\n * Pass the same scenarios scored with judge-model X grading outputs from\n * model X (in-family) and model Y (out-of-family). Non-zero delta\n * indicates self-preference.\n */\nexport function selfPreference(\n  samples: Array<{ score: number; inFamily: boolean }>,\n): SelfPreferenceResult {\n  const inF = samples.filter((s) => s.inFamily).map((s) => s.score)\n  const outF = samples.filter((s) => !s.inFamily).map((s) => s.score)\n  if (inF.length === 0 || outF.length === 0)\n    return { inFamilyMean: 0, outOfFamilyMean: 0, deltaMean: 0, n: 0 }\n  const inMean = inF.reduce((a, b) => a + b, 0) / inF.length\n  const outMean = outF.reduce((a, b) => a + b, 0) / outF.length\n  return {\n    inFamilyMean: inMean,\n    outOfFamilyMean: outMean,\n    deltaMean: inMean - outMean,\n    n: samples.length,\n  }\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────\n\nfunction pearsonR(a: number[], b: number[]): number {\n  if (a.length !== b.length || a.length < 2) return NaN\n  const mA = a.reduce((s, v) => s + v, 0) / a.length\n  const mB = b.reduce((s, v) => s + v, 0) / b.length\n  let num = 0,\n    dA = 0,\n    dB = 0\n  for (let i = 0; i < a.length; i++) {\n    const da = a[i]! - mA\n    const db = b[i]! - mB\n    num += da * db\n    dA += da * da\n    dB += db * db\n  }\n  if (dA === 0 || dB === 0) return dA === 0 && dB === 0 ? 1 : 0\n  return num / Math.sqrt(dA * dB)\n}\n\n/** Quadratic weighted Cohen's κ over bounded integer scores. */\nfunction weightedKappa(a: number[], b: number[]): number {\n  if (a.length !== b.length || a.length === 0) return NaN\n  const min = Math.min(...a, ...b)\n  const max = Math.max(...a, ...b)\n  const K = max - min + 1\n  if (K < 2) return 1\n  const observed: number[][] = Array.from({ length: K }, () => new Array(K).fill(0))\n  const rowMarg = new Array(K).fill(0)\n  const colMarg = new Array(K).fill(0)\n  for (let i = 0; i < a.length; i++) {\n    const ai = a[i]! - min\n    const bi = b[i]! - min\n    const row = observed[ai]!\n    row[bi] = (row[bi] ?? 0) + 1\n    rowMarg[ai]++\n    colMarg[bi]++\n  }\n  let num = 0\n  let den = 0\n  for (let i = 0; i < K; i++) {\n    for (let j = 0; j < K; j++) {\n      const w = (i - j) ** 2 / (K - 1) ** 2\n      const expected = (rowMarg[i] * colMarg[j]) / a.length\n      num += w * observed[i]![j]!\n      den += w * expected\n    }\n  }\n  if (den === 0) return 1\n  return 1 - num / den\n}\n\n// ── Continuous-value inter-rater agreement ──────────────────────────\n//\n// `weightedKappa` above quantises to integers. For [0,1] judges that is\n// lossy: 0.78 and 0.81 both round to 1 and look identical to integer κ.\n// `continuousAgreement` keeps the original magnitudes:\n//\n//   - κ_w   : Cohen's weighted κ generalised to continuous scores. For two\n//             raters, weighted κ = 1 − Σ w_ij·o_ij / Σ w_ij·e_ij collapses\n//             into the closed form below when each \"category\" is the score\n//             itself (Janson & Olsson 2001; Cohen 1968 quadratic weights).\n//   - ICC   : Intraclass Correlation Coefficient, ICC(2,1) per Shrout &\n//             Fleiss (1979) — two-way random effects, absolute agreement,\n//             single rater. The right reliability coefficient when judges\n//             are a random sample of the judge population.\n//   - r, ρ  : Pearson + Spearman for sanity-check. Pearson catches linear\n//             association regardless of scale; Spearman catches monotone\n//             association regardless of distribution.\n//   - CIs   : Bootstrap percentile CIs over items (rows). Bias is preserved\n//             because we resample the full row, i.e. a judge's vector\n//             stays internally consistent within each bootstrap replicate.\n//\n// References:\n//   - Shrout, P. E. & Fleiss, J. L. (1979). Intraclass correlations: uses\n//     in assessing rater reliability. Psychological Bulletin, 86(2), 420.\n//   - McGraw, K. O. & Wong, S. P. (1996). Forming inferences about some\n//     intraclass correlation coefficients. Psychological Methods, 1, 30.\n//   - Janson, H. & Olsson, U. (2001). A measure of agreement for interval\n//     or nominal multivariate observations. Educ. Psychol. Meas., 61, 277.\n\nexport interface ContinuousAgreement {\n  /** Cohen's κ_w with quadratic weights, computed on raw [0,1] scores. */\n  weightedKappa: number\n  /** ICC(2,1): two-way random effects, absolute agreement, single rater. */\n  icc: number\n  /** Pearson product-moment correlation (averaged over rater pairs if N>2). */\n  pearson: number\n  /** Spearman rank correlation (averaged over rater pairs if N>2). */\n  spearman: number\n  /** 95% bootstrap percentile CIs over items. */\n  ci: {\n    icc: [number, number]\n    weightedKappa: [number, number]\n  }\n  /** Number of complete items (no NaN across raters). */\n  n: number\n  /** Number of raters. */\n  raters: number\n}\n\nexport interface ContinuousAgreementOptions {\n  /** Bootstrap iterations. Default 1000. Set to 0 to skip CIs (CI = [NaN, NaN]). */\n  bootstrap?: number\n  /** κ weighting scheme. Default 'quadratic'. */\n  weights?: 'linear' | 'quadratic'\n  /** PRNG seed for reproducible bootstrap. Default 0xC0FFEE. */\n  seed?: number\n  /** Confidence level for percentile CI. Default 0.95. */\n  ciLevel?: number\n}\n\n/**\n * Inter-rater agreement on continuous (typically [0,1]) scores.\n *\n * `scores` has shape [n_items][n_raters]. Rows with any non-finite entry\n * are dropped. Returns NaN metrics if fewer than 2 raters or 2 complete\n * items remain.\n */\nexport function continuousAgreement(\n  scores: number[][],\n  opts: ContinuousAgreementOptions = {},\n): ContinuousAgreement {\n  const bootstrap = opts.bootstrap ?? 1000\n  const weights = opts.weights ?? 'quadratic'\n  const seed = opts.seed ?? 0xc0ffee\n  const ciLevel = opts.ciLevel ?? 0.95\n\n  const matrix = scores.filter((row) => row.length >= 2 && row.every((v) => Number.isFinite(v)))\n  const raters = matrix[0]?.length ?? 0\n  // All rows must have the same rater count, else drop the offenders.\n  const clean = matrix.filter((row) => row.length === raters)\n  const nClean = clean.length\n\n  if (nClean < 2 || raters < 2) {\n    return {\n      weightedKappa: NaN,\n      icc: NaN,\n      pearson: NaN,\n      spearman: NaN,\n      ci: { icc: [NaN, NaN], weightedKappa: [NaN, NaN] },\n      n: nClean,\n      raters,\n    }\n  }\n\n  const kappa = continuousWeightedKappa(clean, weights)\n  const icc = icc21(clean)\n  const pearson = avgPairwise(clean, pearsonR)\n  const spearman = avgPairwise(clean, spearmanR)\n\n  const ciIcc: [number, number] = [NaN, NaN]\n  const ciKappa: [number, number] = [NaN, NaN]\n  if (bootstrap > 0) {\n    const rng = mulberry32(seed)\n    const iccs: number[] = []\n    const kappas: number[] = []\n    for (let b = 0; b < bootstrap; b++) {\n      const sample: number[][] = new Array(nClean)\n      for (let i = 0; i < nClean; i++) {\n        sample[i] = clean[Math.floor(rng() * nClean)]!\n      }\n      const iccB = icc21(sample)\n      const kB = continuousWeightedKappa(sample, weights)\n      if (Number.isFinite(iccB)) iccs.push(iccB)\n      if (Number.isFinite(kB)) kappas.push(kB)\n    }\n    const [lo, hi] = percentileBounds(ciLevel)\n    if (iccs.length > 0) {\n      iccs.sort((a, b) => a - b)\n      ciIcc[0] = quantile(iccs, lo)\n      ciIcc[1] = quantile(iccs, hi)\n    }\n    if (kappas.length > 0) {\n      kappas.sort((a, b) => a - b)\n      ciKappa[0] = quantile(kappas, lo)\n      ciKappa[1] = quantile(kappas, hi)\n    }\n  }\n\n  return {\n    weightedKappa: kappa,\n    icc,\n    pearson,\n    spearman,\n    ci: { icc: ciIcc, weightedKappa: ciKappa },\n    n: nClean,\n    raters,\n  }\n}\n\nexport interface ContinuousCalibrationResult extends CalibrationResult {\n  /** Cohen's κ_w computed on raw (un-rounded) scores. */\n  weightedKappaContinuous: number\n  /** ICC(2,1) treating golden + candidate as two raters. */\n  icc: number\n  spearman: number\n  ci: {\n    icc: [number, number]\n    weightedKappa: [number, number]\n  }\n}\n\n/**\n * Drop-in superset of `calibrateJudge` that adds continuous-value\n * agreement metrics. The old fields (n, pearson, kappa, mae, worstItems)\n * are preserved unchanged so existing callers continue to work.\n */\nexport function calibrateJudgeContinuous(\n  golden: GoldenItem[],\n  candidate: CandidateScore[],\n  opts: ContinuousAgreementOptions = {},\n): ContinuousCalibrationResult {\n  const base = calibrateJudge(golden, candidate)\n  const map = new Map<string, { h: number; j: number }>()\n  for (const g of golden) map.set(g.itemId, { h: g.humanScore, j: NaN })\n  for (const c of candidate) {\n    const entry = map.get(c.itemId)\n    if (entry) entry.j = c.score\n  }\n  const rows: number[][] = []\n  for (const v of map.values()) {\n    if (Number.isFinite(v.j)) rows.push([v.h, v.j])\n  }\n  const agreement = continuousAgreement(rows, opts)\n  return {\n    ...base,\n    weightedKappaContinuous: agreement.weightedKappa,\n    icc: agreement.icc,\n    spearman: agreement.spearman,\n    ci: agreement.ci,\n  }\n}\n\n// ── Continuous-agreement internals ──────────────────────────────────\n\n/**\n * Quadratic-weighted κ on continuous scores. With weights w(x,y) = (x-y)^2\n * (or |x-y| for linear) the formula collapses to:\n *\n *   κ_w = 1 − E_obs[w] / E_exp[w]\n *\n * where E_obs averages w over paired (a_i, b_i) and E_exp averages w over\n * the independent product distribution (sum_{i,j} w(a_i, b_j) / n^2).\n * The normalisation by (max-min)^2 in the integer version cancels in the\n * ratio, so we don't need it here. Generalises to N raters by averaging κ_w\n * over all rater pairs (mean pairwise weighted agreement).\n */\nfunction continuousWeightedKappa(rows: number[][], scheme: 'linear' | 'quadratic'): number {\n  if (rows.length === 0) return NaN\n  const raters = rows[0]!.length\n  if (raters < 2) return NaN\n  const wFn =\n    scheme === 'linear'\n      ? (x: number, y: number) => Math.abs(x - y)\n      : (x: number, y: number) => (x - y) ** 2\n  let sum = 0\n  let pairs = 0\n  for (let r1 = 0; r1 < raters; r1++) {\n    for (let r2 = r1 + 1; r2 < raters; r2++) {\n      const a = rows.map((row) => row[r1]!)\n      const b = rows.map((row) => row[r2]!)\n      const n = a.length\n      let obs = 0\n      for (let i = 0; i < n; i++) obs += wFn(a[i]!, b[i]!)\n      obs /= n\n      // Expected under independence: average of w over all i,j cross pairs.\n      let exp = 0\n      for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) exp += wFn(a[i]!, b[j]!)\n      }\n      exp /= n * n\n      if (exp === 0) {\n        // Degenerate: at least one rater is constant. Convention: perfect\n        // agreement iff observed disagreement is also zero, else 0.\n        sum += obs === 0 ? 1 : 0\n      } else {\n        sum += 1 - obs / exp\n      }\n      pairs++\n    }\n  }\n  return pairs === 0 ? NaN : sum / pairs\n}\n\n/**\n * ICC(2,1) — two-way random effects, absolute agreement, single rater.\n *\n *   ICC(2,1) = (MSR − MSE) / (MSR + (k−1)·MSE + k·(MSC − MSE)/n)\n *\n * where MSR = between-rows MS, MSC = between-columns MS, MSE = residual MS,\n * n = rows (items), k = columns (raters).\n */\nfunction icc21(rows: number[][]): number {\n  const n = rows.length\n  if (n < 2) return NaN\n  const k = rows[0]!.length\n  if (k < 2) return NaN\n\n  // Row means.\n  const rowMeans = rows.map((row) => row.reduce((s, v) => s + v, 0) / k)\n  // Column means.\n  const colMeans = new Array(k).fill(0)\n  for (let j = 0; j < k; j++) {\n    let s = 0\n    for (let i = 0; i < n; i++) s += rows[i]![j]!\n    colMeans[j] = s / n\n  }\n  // Grand mean.\n  let grand = 0\n  for (let i = 0; i < n; i++) grand += rowMeans[i]!\n  grand /= n\n\n  let ssR = 0\n  for (let i = 0; i < n; i++) ssR += (rowMeans[i]! - grand) ** 2\n  ssR *= k\n  let ssC = 0\n  for (let j = 0; j < k; j++) ssC += (colMeans[j]! - grand) ** 2\n  ssC *= n\n  let ssT = 0\n  for (let i = 0; i < n; i++) {\n    for (let j = 0; j < k; j++) ssT += (rows[i]![j]! - grand) ** 2\n  }\n  const ssE = ssT - ssR - ssC\n\n  const dfR = n - 1\n  const dfC = k - 1\n  const dfE = (n - 1) * (k - 1)\n  const msR = ssR / dfR\n  const msC = ssC / dfC\n  const msE = dfE > 0 ? ssE / dfE : 0\n\n  const denom = msR + (k - 1) * msE + (k * (msC - msE)) / n\n  if (denom === 0) {\n    // Degenerate (all values equal): convention = 1 if rows identical,\n    // else 0. Identical rows ⇒ msR = 0 too, so msR − msE near 0.\n    return msR === 0 && msE === 0 ? 1 : 0\n  }\n  return (msR - msE) / denom\n}\n\n/** Average pairwise statistic over all rater pairs. */\nfunction avgPairwise(rows: number[][], fn: (a: number[], b: number[]) => number): number {\n  const k = rows[0]?.length ?? 0\n  if (k < 2) return NaN\n  let sum = 0\n  let pairs = 0\n  for (let i = 0; i < k; i++) {\n    for (let j = i + 1; j < k; j++) {\n      const a = rows.map((row) => row[i]!)\n      const b = rows.map((row) => row[j]!)\n      const r = fn(a, b)\n      if (Number.isFinite(r)) {\n        sum += r\n        pairs++\n      }\n    }\n  }\n  return pairs === 0 ? NaN : sum / pairs\n}\n\n/** Spearman rank correlation. Ties get average ranks. */\nfunction spearmanR(a: number[], b: number[]): number {\n  if (a.length !== b.length || a.length < 2) return NaN\n  return pearsonR(rankWithTies(a), rankWithTies(b))\n}\n\nfunction rankWithTies(xs: number[]): number[] {\n  const n = xs.length\n  const indexed = xs.map((v, i) => ({ v, i }))\n  indexed.sort((x, y) => x.v - y.v)\n  const ranks = new Array(n).fill(0)\n  let i = 0\n  while (i < n) {\n    let j = i\n    while (j + 1 < n && indexed[j + 1]!.v === indexed[i]!.v) j++\n    // Average rank for ties (ranks are 1-indexed).\n    const avg = (i + j) / 2 + 1\n    for (let k = i; k <= j; k++) ranks[indexed[k]!.i] = avg\n    i = j + 1\n  }\n  return ranks\n}\n\n/** Seeded PRNG — Mulberry32. Deterministic across platforms. */\nfunction mulberry32(seed: number): () => number {\n  let a = seed >>> 0\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0\n    let t = a\n    t = Math.imul(t ^ (t >>> 15), t | 1)\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\n  }\n}\n\nfunction percentileBounds(ciLevel: number): [number, number] {\n  const tail = (1 - ciLevel) / 2\n  return [tail, 1 - tail]\n}\n\n/** Linear-interpolated quantile of a pre-sorted ascending array. */\nfunction quantile(sorted: number[], q: number): number {\n  if (sorted.length === 0) return NaN\n  if (sorted.length === 1) return sorted[0]!\n  const pos = q * (sorted.length - 1)\n  const lo = Math.floor(pos)\n  const hi = Math.ceil(pos)\n  if (lo === hi) return sorted[lo]!\n  const frac = pos - lo\n  return sorted[lo]! * (1 - frac) + sorted[hi]! * frac\n}\n","import { ValidationError } from './errors'\nimport {\n  type ContinuousAgreement,\n  type ContinuousAgreementOptions,\n  continuousAgreement,\n} from './judge-calibration'\nimport type { JudgeScore } from './types'\n\n/** Dimensions where lower raw score = better outcome (inverted semantics) */\nconst INVERTED_DIMENSIONS = new Set(['hallucination', 'false_confidence', 'worst_failure'])\n\n/**\n * Normalize scores so all dimensions follow \"higher = better\".\n * Inverted dimensions (hallucination, false_confidence, worst_failure)\n * already use inverted scoring in the prompt (10 = no hallucination),\n * but this function ensures consistency if raw scores leak through.\n */\nexport function normalizeScores(scores: JudgeScore[]): JudgeScore[] {\n  return scores.map((s) => {\n    if (INVERTED_DIMENSIONS.has(s.dimension)) {\n      return s\n    }\n    return s\n  })\n}\n\n/** Weighted mean — falls back to uniform weights when omitted */\nexport function weightedMean(scores: { score: number; weight?: number }[]): number {\n  if (scores.length === 0) return 0\n  let totalWeight = 0\n  let weightedSum = 0\n  for (const { score, weight } of scores) {\n    const w = weight ?? 1\n    weightedSum += score * w\n    totalWeight += w\n  }\n  return totalWeight > 0 ? weightedSum / totalWeight : 0\n}\n\n/** Bootstrap confidence interval */\nexport function confidenceInterval(\n  scores: number[],\n  confidence = 0.95,\n  opts: { seed?: number; resamples?: number } = {},\n): { mean: number; lower: number; upper: number } {\n  if (scores.length === 0) return { mean: 0, lower: 0, upper: 0 }\n  if (scores.length === 1) return { mean: scores[0]!, lower: scores[0]!, upper: scores[0]! }\n\n  const n = scores.length\n  const mean = scores.reduce((a, b) => a + b, 0) / n\n\n  const B = opts.resamples ?? 1000\n  const rng = makeRng(opts.seed)\n  const bootstrapMeans: number[] = []\n\n  for (let i = 0; i < B; i++) {\n    let sum = 0\n    for (let j = 0; j < n; j++) {\n      sum += scores[Math.floor(rng() * n)]!\n    }\n    bootstrapMeans.push(sum / n)\n  }\n\n  bootstrapMeans.sort((a, b) => a - b)\n\n  const alpha = 1 - confidence\n  const lowerIdx = Math.floor((alpha / 2) * B)\n  const upperIdx = Math.floor((1 - alpha / 2) * B) - 1\n\n  return {\n    mean,\n    lower: bootstrapMeans[lowerIdx]!,\n    upper: bootstrapMeans[Math.min(upperIdx, B - 1)]!,\n  }\n}\n\n/**\n * Inter-rater reliability — simplified Krippendorff's alpha.\n *\n * Each inner array is one judge's scores for all items.\n * All arrays must have the same length (same items scored).\n */\nexport function interRaterReliability(judgeScores: JudgeScore[][]): number {\n  if (judgeScores.length < 2) return 1\n\n  // Group scores by dimension across judges\n  const dimensionMap = new Map<string, number[][]>()\n  for (const judgeSet of judgeScores) {\n    for (const s of judgeSet) {\n      if (!dimensionMap.has(s.dimension)) dimensionMap.set(s.dimension, [])\n      const arr = dimensionMap.get(s.dimension)!\n      if (arr.length === 0 || arr[arr.length - 1]!.length >= judgeScores.length) {\n        arr.push([s.score])\n      } else {\n        arr[arr.length - 1]!.push(s.score)\n      }\n    }\n  }\n\n  // Collect all paired ratings\n  const allValues: number[] = []\n  const pairDiffs: number[] = []\n\n  for (const items of dimensionMap.values()) {\n    for (const ratings of items) {\n      if (ratings.length < 2) continue\n      for (const v of ratings) allValues.push(v)\n      for (let i = 0; i < ratings.length; i++) {\n        for (let j = i + 1; j < ratings.length; j++) {\n          pairDiffs.push((ratings[i]! - ratings[j]!) ** 2)\n        }\n      }\n    }\n  }\n\n  if (pairDiffs.length === 0 || allValues.length < 2) return 1\n\n  const observedDisagreement = pairDiffs.reduce((a, b) => a + b, 0) / pairDiffs.length\n\n  // Expected disagreement from all possible pairings of values\n  let expectedDisagreement = 0\n  let expectedCount = 0\n  for (let i = 0; i < allValues.length; i++) {\n    for (let j = i + 1; j < allValues.length; j++) {\n      expectedDisagreement += (allValues[i]! - allValues[j]!) ** 2\n      expectedCount++\n    }\n  }\n  expectedDisagreement = expectedCount > 0 ? expectedDisagreement / expectedCount : 0\n\n  if (expectedDisagreement === 0) return 1\n  return 1 - observedDisagreement / expectedDisagreement\n}\n\n/**\n * Mann-Whitney U test for comparing two independent groups.\n * Returns U statistic and approximate p-value (normal approximation).\n */\nexport function mannWhitneyU(a: number[], b: number[]): { u: number; p: number } {\n  if (a.length === 0 || b.length === 0) return { u: 0, p: 1 }\n\n  const n1 = a.length\n  const n2 = b.length\n\n  // Rank all values together\n  const combined = [\n    ...a.map((v) => ({ v, group: 'a' as const })),\n    ...b.map((v) => ({ v, group: 'b' as const })),\n  ].sort((x, y) => x.v - y.v)\n\n  // Assign ranks with tie handling\n  const ranks: number[] = new Array(combined.length)\n  let i = 0\n  while (i < combined.length) {\n    let j = i\n    while (j < combined.length && combined[j]!.v === combined[i]!.v) j++\n    const avgRank = (i + 1 + j) / 2\n    for (let k = i; k < j; k++) ranks[k] = avgRank\n    i = j\n  }\n\n  // Sum ranks for group a\n  let r1 = 0\n  for (let k = 0; k < combined.length; k++) {\n    if (combined[k]!.group === 'a') r1 += ranks[k]!\n  }\n\n  const u1 = r1 - (n1 * (n1 + 1)) / 2\n  const u2 = n1 * n2 - u1\n  const u = Math.min(u1, u2)\n\n  // Normal approximation for p-value\n  const mu = (n1 * n2) / 2\n  const sigma = Math.sqrt((n1 * n2 * (n1 + n2 + 1)) / 12)\n\n  if (sigma === 0) return { u, p: 1 }\n\n  const z = Math.abs(u - mu) / sigma\n  // Two-tailed p-value from z-score (approximation)\n  const p = 2 * (1 - normalCdf(z))\n\n  return { u, p }\n}\n\n/** Partial credit: returns 0-1 ratio of current toward target */\nexport function partialCredit(current: number, target: number): number {\n  if (target <= 0) return 1\n  return Math.min(1, Math.max(0, current / target))\n}\n\n/**\n * Paired t-test — before/after measurements on the SAME items.\n * Pairing removes inter-item variance, giving tighter significance than\n * an unpaired test when comparing prompt v1 vs prompt v2 on identical\n * scenarios.\n */\nexport function pairedTTest(\n  before: number[],\n  after: number[],\n): { t: number; df: number; p: number } {\n  if (before.length !== after.length) {\n    throw new ValidationError(\n      `pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`,\n    )\n  }\n  const n = before.length\n  if (n < 2) return { t: 0, df: 0, p: 1 }\n\n  const diffs = before.map((b, i) => after[i]! - b)\n  const mean = diffs.reduce((a, b) => a + b, 0) / n\n  const variance = diffs.reduce((acc, d) => acc + (d - mean) ** 2, 0) / (n - 1)\n  const se = Math.sqrt(variance / n)\n  if (se === 0) return { t: mean === 0 ? 0 : Infinity, df: n - 1, p: mean === 0 ? 1 : 0 }\n\n  const t = mean / se\n  const df = n - 1\n  const p = 2 * (1 - studentTCdf(Math.abs(t), df))\n  return { t, df, p }\n}\n\n/**\n * Wilcoxon signed-rank test — paired non-parametric alternative.\n * Use when the differences aren't normally distributed.\n */\nexport function wilcoxonSignedRank(before: number[], after: number[]): { w: number; p: number } {\n  if (before.length !== after.length) {\n    throw new ValidationError(\n      `wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`,\n    )\n  }\n  const diffs = before.map((b, i) => after[i]! - b).filter((d) => d !== 0)\n  const n = diffs.length\n  if (n < 6) return { w: 0, p: 1 }\n\n  const absRanks = diffs\n    .map((d, i) => ({ abs: Math.abs(d), sign: Math.sign(d), i }))\n    .sort((a, b) => a.abs - b.abs)\n  const ranks: number[] = new Array(n)\n  let i = 0\n  while (i < n) {\n    let j = i\n    while (j < n && absRanks[j]!.abs === absRanks[i]!.abs) j++\n    const avg = (i + 1 + j) / 2\n    for (let k = i; k < j; k++) ranks[absRanks[k]!.i] = avg\n    i = j\n  }\n  let wPlus = 0\n  for (let k = 0; k < n; k++) if (diffs[k]! > 0) wPlus += ranks[k]!\n\n  const mean = (n * (n + 1)) / 4\n  const variance = (n * (n + 1) * (2 * n + 1)) / 24\n  const z = (wPlus - mean) / Math.sqrt(variance)\n  const p = 2 * (1 - normalCdf(Math.abs(z)))\n  return { w: wPlus, p }\n}\n\n/**\n * Cohen's d — standardized effect size for two independent groups.\n * Positive d means group b has higher mean than group a.\n * Rule of thumb: |d| < 0.2 negligible, 0.2–0.5 small, 0.5–0.8 medium, > 0.8 large.\n */\nexport function cohensD(a: number[], b: number[]): number {\n  if (a.length < 2 || b.length < 2) return 0\n  const meanA = a.reduce((x, y) => x + y, 0) / a.length\n  const meanB = b.reduce((x, y) => x + y, 0) / b.length\n  const varA = a.reduce((acc, x) => acc + (x - meanA) ** 2, 0) / (a.length - 1)\n  const varB = b.reduce((acc, x) => acc + (x - meanB) ** 2, 0) / (b.length - 1)\n  const pooled = Math.sqrt(\n    ((a.length - 1) * varA + (b.length - 1) * varB) / (a.length + b.length - 2),\n  )\n  if (pooled === 0) return 0\n  return (meanB - meanA) / pooled\n}\n\nexport type CliffsMagnitude = 'negligible' | 'small' | 'medium' | 'large'\n\n/**\n * Cliff's delta — a non-parametric effect size for two independent samples.\n * `δ = (#(after > before) − #(after < before)) / (n_before · n_after)`,\n * ranging [-1, 1]. Positive ⇒ `after` tends to exceed `before` (improvement).\n *\n * Distribution-free counterpart to Cohen's d: no normality assumption, robust\n * to the bounded/skewed score distributions judges produce. Pairs with\n * `pairedBootstrap` / `wilcoxonSignedRank` for the non-parametric reporting\n * path. Returns 0 when either sample is empty.\n */\nexport function cliffsDelta(before: number[], after: number[]): number {\n  const n = before.length * after.length\n  if (n === 0) return 0\n  let dominance = 0\n  for (const a of after) {\n    for (const b of before) {\n      if (a > b) dominance += 1\n      else if (a < b) dominance -= 1\n    }\n  }\n  return dominance / n\n}\n\n/**\n * Map a Cliff's delta to a qualitative magnitude using the standard\n * Romano et al. thresholds (|δ|): <0.147 negligible, <0.33 small,\n * <0.474 medium, else large.\n */\nexport function interpretCliffs(delta: number): CliffsMagnitude {\n  const d = Math.abs(delta)\n  if (d < 0.147) return 'negligible'\n  if (d < 0.33) return 'small'\n  if (d < 0.474) return 'medium'\n  return 'large'\n}\n\nexport interface WeightedCompositeInput {\n  /** Per-dimension scores (typically 0..1). */\n  dims: Record<string, number>\n  /** Weight per dimension. Every weighted dimension MUST be present in\n   *  `dims` — a weight for an absent dimension is a config error and throws,\n   *  because silently dropping it would renormalise the composite onto a\n   *  different denominator than intended. */\n  weights: Record<string, number>\n  /** Optional pass threshold; when set, the result reports `pass`. */\n  threshold?: number\n}\n\nexport interface WeightedCompositeResult {\n  composite: number\n  pass?: boolean\n}\n\n/**\n * Weighted composite over judge dimensions: `Σ(score_d · w_d) / Σ(w_d)` across\n * the weighted dimensions. The canonical replacement for the per-consumer\n * hand-rolled composite math (tax/legal/creative/gtm each ship a copy).\n *\n * Fail-loud: throws if a weighted dimension is missing from `dims`, if any\n * weight is negative, or if the weights sum to 0 — none of which can produce\n * a meaningful composite.\n */\nexport function weightedComposite(input: WeightedCompositeInput): WeightedCompositeResult {\n  const entries = Object.entries(input.weights)\n  if (entries.length === 0) {\n    throw new Error('weightedComposite: `weights` is empty — nothing to combine')\n  }\n  let weightedSum = 0\n  let weightTotal = 0\n  for (const [dim, weight] of entries) {\n    if (weight < 0) {\n      throw new Error(`weightedComposite: weight for '${dim}' is negative (${weight})`)\n    }\n    if (!(dim in input.dims)) {\n      throw new Error(\n        `weightedComposite: weighted dimension '${dim}' is absent from \\`dims\\` — ` +\n          'refusing to renormalise onto a different denominator',\n      )\n    }\n    weightedSum += input.dims[dim]! * weight\n    weightTotal += weight\n  }\n  if (weightTotal === 0) {\n    throw new Error('weightedComposite: weights sum to 0 — composite is undefined')\n  }\n  const composite = weightedSum / weightTotal\n  return input.threshold === undefined\n    ? { composite }\n    : { composite, pass: composite >= input.threshold }\n}\n\n// ── Corpus-wide inter-rater agreement ──────────────────────────────\n//\n// The legacy `interRaterReliability(judgeScores)` computes a within-item\n// Krippendorff α — multiple judges score *the same item* and we ask\n// \"how much do their scores agree on that item?\" Useful for a single\n// scenario, but it cannot answer \"how reliable are these judges across\n// the whole evaluation corpus?\"\n//\n// `corpusInterRaterAgreement` does the corpus-wide question properly.\n// Inputs are flat per-(item, judge, dimension) score records. For each\n// dimension we pivot to a complete [n_items × n_judges] matrix and feed\n// it to the ICC(2,1) + κ_w machinery already validated in\n// `judge-calibration.ts`. An overall pooled metric averages the\n// per-dimension ICC/κ across dimensions.\n\nexport interface CorpusScoreRecord {\n  /** Stable identifier for the rated item (scenario, span, turn, …). */\n  itemId: string\n  /** Identifier for the judge that produced this score. */\n  judgeName: string\n  /** Dimension name (matches `JudgeScore.dimension`). */\n  dimension: string\n  /** Numeric score; must be finite. */\n  score: number\n}\n\nexport interface CorpusAgreementPerDimension extends ContinuousAgreement {\n  dimension: string\n  /** Item IDs that contributed to this dimension's matrix (every judge scored them). */\n  itemIds: string[]\n  /** Judge IDs that contributed to this dimension's matrix. */\n  judgeIds: string[]\n}\n\nexport interface CorpusAgreementReport {\n  /** Per-dimension ICC(2,1) + κ_w + Pearson + Spearman + bootstrap CIs. */\n  perDimension: CorpusAgreementPerDimension[]\n  /** Mean ICC across dimensions (NaN if no dimension yielded a finite ICC). */\n  overallIcc: number\n  /** Mean weighted κ across dimensions (NaN if none finite). */\n  overallWeightedKappa: number\n  /** Dimensions evaluated (sorted). */\n  dimensions: string[]\n  /** Judges seen across the corpus (sorted). */\n  judgeIds: string[]\n}\n\nexport interface CorpusAgreementOptions extends ContinuousAgreementOptions {\n  /**\n   * Restrict the audit to these dimensions. Default = every dimension\n   * that appears in the input. A dimension named here but absent from\n   * the input throws — silent omission would corrupt the overall metric.\n   */\n  dimensions?: string[]\n  /**\n   * Restrict the audit to these judges. Default = every judge that\n   * appears in the input. A judge named here but absent from a\n   * dimension throws (see \"fail loud\" below).\n   */\n  judges?: string[]\n}\n\n/**\n * Corpus-wide inter-rater agreement across N items × M judges × D dimensions.\n *\n * For each dimension, builds the [n_items][n_judges] matrix of scores\n * (keeping only items every judge rated on that dimension), then runs\n * `continuousAgreement` to get ICC(2,1), κ_w, Pearson, Spearman, and\n * bootstrap CIs. Reports a pooled mean across dimensions as a single\n * \"is this judge panel reliable on this corpus?\" number.\n *\n * Fail-loud contract:\n *   - Empty input throws.\n *   - Fewer than 2 judges or fewer than 2 items per dimension throws.\n *   - A judge present in some dimensions but with zero scored items on\n *     another dimension throws (would silently shrink the matrix).\n *   - Duplicate (itemId, judgeName, dimension) records throw.\n */\nexport function corpusInterRaterAgreement(\n  records: CorpusScoreRecord[],\n  opts: CorpusAgreementOptions = {},\n): CorpusAgreementReport {\n  if (records.length === 0) {\n    throw new ValidationError('corpusInterRaterAgreement: no score records supplied')\n  }\n\n  const judgesSeen = new Set<string>()\n  const dimsSeen = new Set<string>()\n  // dimension → judge → itemId → score\n  const grid = new Map<string, Map<string, Map<string, number>>>()\n\n  for (const r of records) {\n    if (!Number.isFinite(r.score)) {\n      throw new ValidationError(\n        `corpusInterRaterAgreement: non-finite score for (item=${r.itemId}, judge=${r.judgeName}, dim=${r.dimension})`,\n      )\n    }\n    judgesSeen.add(r.judgeName)\n    dimsSeen.add(r.dimension)\n    const byJudge = grid.get(r.dimension) ?? new Map<string, Map<string, number>>()\n    const byItem = byJudge.get(r.judgeName) ?? new Map<string, number>()\n    if (byItem.has(r.itemId)) {\n      throw new ValidationError(\n        `corpusInterRaterAgreement: duplicate record for (item=${r.itemId}, judge=${r.judgeName}, dim=${r.dimension})`,\n      )\n    }\n    byItem.set(r.itemId, r.score)\n    byJudge.set(r.judgeName, byItem)\n    grid.set(r.dimension, byJudge)\n  }\n\n  const targetDims = opts.dimensions ?? [...dimsSeen].sort()\n  for (const d of targetDims) {\n    if (!dimsSeen.has(d)) {\n      throw new ValidationError(\n        `corpusInterRaterAgreement: dimension '${d}' was requested but no records carry it`,\n      )\n    }\n  }\n  const targetJudges = opts.judges ? [...opts.judges] : [...judgesSeen].sort()\n  for (const j of targetJudges) {\n    if (!judgesSeen.has(j)) {\n      throw new ValidationError(\n        `corpusInterRaterAgreement: judge '${j}' was requested but produced no records`,\n      )\n    }\n  }\n  if (targetJudges.length < 2) {\n    throw new ValidationError(\n      `corpusInterRaterAgreement: need ≥2 judges, got ${targetJudges.length}`,\n    )\n  }\n\n  const perDimension: CorpusAgreementPerDimension[] = []\n  const iccs: number[] = []\n  const kappas: number[] = []\n\n  for (const dim of targetDims) {\n    const byJudge = grid.get(dim)!\n    // Fail loud: every requested judge must have scored ≥1 item on this dim.\n    const judgeItemCounts: Record<string, number> = {}\n    for (const j of targetJudges) {\n      const m = byJudge.get(j)\n      judgeItemCounts[j] = m?.size ?? 0\n    }\n    const emptyJudges = targetJudges.filter((j) => judgeItemCounts[j] === 0)\n    if (emptyJudges.length > 0) {\n      throw new ValidationError(\n        `corpusInterRaterAgreement: dimension '${dim}' has no scores from judge(s) ${emptyJudges.join(', ')} (counts: ${JSON.stringify(judgeItemCounts)})`,\n      )\n    }\n\n    // Items rated by *every* requested judge on this dim.\n    let commonItems: Set<string> | null = null\n    for (const j of targetJudges) {\n      const ids = new Set(byJudge.get(j)!.keys())\n      if (commonItems === null) {\n        commonItems = ids\n      } else {\n        const prev: Set<string> = commonItems\n        commonItems = new Set([...prev].filter((x) => ids.has(x)))\n      }\n    }\n    const sortedItems = [...(commonItems ?? new Set<string>())].sort()\n    if (sortedItems.length < 2) {\n      throw new ValidationError(\n        `corpusInterRaterAgreement: dimension '${dim}' has ${sortedItems.length} item(s) rated by all ${targetJudges.length} judges (need ≥2)`,\n      )\n    }\n\n    const matrix: number[][] = sortedItems.map((itemId) =>\n      targetJudges.map((j) => byJudge.get(j)!.get(itemId)!),\n    )\n    const agreement = continuousAgreement(matrix, opts)\n    perDimension.push({\n      ...agreement,\n      dimension: dim,\n      itemIds: sortedItems,\n      judgeIds: [...targetJudges],\n    })\n    if (Number.isFinite(agreement.icc)) iccs.push(agreement.icc)\n    if (Number.isFinite(agreement.weightedKappa)) kappas.push(agreement.weightedKappa)\n  }\n\n  const mean = (xs: number[]) =>\n    xs.length === 0 ? Number.NaN : xs.reduce((a, b) => a + b, 0) / xs.length\n  return {\n    perDimension,\n    overallIcc: mean(iccs),\n    overallWeightedKappa: mean(kappas),\n    dimensions: targetDims,\n    judgeIds: targetJudges,\n  }\n}\n\n/**\n * Convenience adapter for `JudgeScore[]` data keyed externally by item.\n *\n * Use when you have per-item arrays of `JudgeScore[]` (e.g. one\n * `ScenarioResult.judgeScores` per scenario) and want corpus-wide\n * agreement without manually flattening. `itemId` must be unique per\n * row of `itemsScores`.\n */\nexport function corpusInterRaterAgreementFromJudgeScores(\n  itemsScores: Array<{ itemId: string; scores: JudgeScore[] }>,\n  opts: CorpusAgreementOptions = {},\n): CorpusAgreementReport {\n  const records: CorpusScoreRecord[] = []\n  const seen = new Set<string>()\n  for (const { itemId, scores } of itemsScores) {\n    if (seen.has(itemId)) {\n      throw new ValidationError(\n        `corpusInterRaterAgreementFromJudgeScores: duplicate itemId '${itemId}'`,\n      )\n    }\n    seen.add(itemId)\n    for (const s of scores) {\n      records.push({\n        itemId,\n        judgeName: s.judgeName,\n        dimension: s.dimension,\n        score: s.score,\n      })\n    }\n  }\n  return corpusInterRaterAgreement(records, opts)\n}\n\n/** Student-t CDF approximation via Abramowitz-Stegun series. */\nfunction studentTCdf(t: number, df: number): number {\n  if (df <= 0) return 0.5\n  if (df > 100) return normalCdf(t)\n  const x = df / (df + t * t)\n  const a = df / 2\n  const b = 0.5\n  const ib = incompleteBeta(x, a, b)\n  return t >= 0 ? 1 - 0.5 * ib : 0.5 * ib\n}\n\n/** Regularized incomplete beta function via continued fraction (Lentz). */\nfunction incompleteBeta(x: number, a: number, b: number): number {\n  if (x <= 0) return 0\n  if (x >= 1) return 1\n  const lnBeta = lnGamma(a) + lnGamma(b) - lnGamma(a + b)\n  const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - lnBeta) / a\n  const maxIter = 200\n  const eps = 3e-7\n  let c = 1\n  let d = 1 - ((a + b) * x) / (a + 1)\n  if (Math.abs(d) < 1e-30) d = 1e-30\n  d = 1 / d\n  let f = d\n  for (let m = 1; m <= maxIter; m++) {\n    const m2 = 2 * m\n    let num = (m * (b - m) * x) / ((a + m2 - 1) * (a + m2))\n    d = 1 + num * d\n    if (Math.abs(d) < 1e-30) d = 1e-30\n    c = 1 + num / c\n    if (Math.abs(c) < 1e-30) c = 1e-30\n    d = 1 / d\n    f *= d * c\n    num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1))\n    d = 1 + num * d\n    if (Math.abs(d) < 1e-30) d = 1e-30\n    c = 1 + num / c\n    if (Math.abs(c) < 1e-30) c = 1e-30\n    d = 1 / d\n    const delta = d * c\n    f *= delta\n    if (Math.abs(delta - 1) < eps) break\n  }\n  return front * f\n}\n\n/** Lanczos approximation to ln Γ(z). */\nfunction lnGamma(z: number): number {\n  const g = 7\n  const coefs = [\n    0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313,\n    -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6,\n    1.5056327351493116e-7,\n  ]\n  if (z < 0.5) {\n    return Math.log(Math.PI / Math.sin(Math.PI * z)) - lnGamma(1 - z)\n  }\n  z -= 1\n  let x = coefs[0]!\n  for (let i = 1; i < g + 2; i++) x += coefs[i]! / (z + i)\n  const t = z + g + 0.5\n  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x)\n}\n\n// Standard normal CDF approximation (Abramowitz and Stegun)\nfunction normalCdf(x: number): number {\n  const a1 = 0.254829592\n  const a2 = -0.284496736\n  const a3 = 1.421413741\n  const a4 = -1.453152027\n  const a5 = 1.061405429\n  const p = 0.3275911\n\n  const sign = x < 0 ? -1 : 1\n  const absX = Math.abs(x)\n  const t = 1 / (1 + p * absX)\n  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp((-absX * absX) / 2)\n\n  return 0.5 * (1 + sign * y)\n}\n\n// ── Power analysis + multiple-comparison correction ──────────────────\n\n/**\n * Required N per arm for a two-sample comparison at target effect size,\n * alpha, and power. Normal-approximation formula:\n *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2\n * where d is Cohen's d. Returns Infinity for effect ≤ 0.\n */\nexport function requiredSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n = 2 * ((zAlpha + zBeta) / effect) ** 2\n  return Math.ceil(n)\n}\n\n/**\n * Minimum detectable paired effect (standardised units) for a target paired\n * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by\n * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap\n * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.\n */\nexport function pairedMde(opts: {\n  nPaired: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return (zAlpha + zBeta) / Math.sqrt(opts.nPaired)\n}\n\n/** Bonferroni adjustment: multiply every p-value by the test count, clamp at 1. */\nexport function bonferroni(\n  pValues: number[],\n  alpha = 0.05,\n): { adjusted: number[]; significant: boolean[] } {\n  const k = pValues.length\n  const adjusted = pValues.map((p) => Math.min(1, p * k))\n  const significant = adjusted.map((p) => p < alpha)\n  return { adjusted, significant }\n}\n\n/**\n * Benjamini–Hochberg false discovery rate. Returns adjusted q-values and\n * significance at the target FDR; handles ties and preserves q monotonicity.\n */\nexport function benjaminiHochberg(\n  pValues: number[],\n  fdr = 0.05,\n): { qValues: number[]; significant: boolean[] } {\n  const n = pValues.length\n  if (n === 0) return { qValues: [], significant: [] }\n  const indexed = pValues.map((p, i) => ({ p, i })).sort((a, b) => a.p - b.p)\n  const q = new Array<number>(n)\n  let minRight = 1\n  for (let k = n - 1; k >= 0; k--) {\n    const rank = k + 1\n    const entry = indexed[k]!\n    const raw = (entry.p * n) / rank\n    const bounded = Math.min(minRight, raw)\n    minRight = bounded\n    q[entry.i] = Math.min(1, bounded)\n  }\n  const significant = q.map((v) => v < fdr)\n  return { qValues: q, significant }\n}\n\n// ── Paired bootstrap (promotion-gate effect size) ────────────────────\n\nexport interface PairedBootstrapResult {\n  /** Number of paired observations. */\n  n: number\n  /** Median of paired deltas (after − before). */\n  median: number\n  /** Mean of paired deltas. */\n  mean: number\n  /** Lower bound of the bootstrap CI on the chosen statistic. */\n  low: number\n  /** Upper bound of the bootstrap CI on the chosen statistic. */\n  high: number\n  /** Confidence level used (e.g. 0.95). */\n  confidence: number\n  /** Number of bootstrap resamples used. */\n  resamples: number\n}\n\nexport interface PairedBootstrapOptions {\n  /** Confidence level. Default 0.95. */\n  confidence?: number\n  /** Bootstrap resample count. Default 2000. */\n  resamples?: number\n  /** Statistic to bootstrap. Default 'median'. */\n  statistic?: 'median' | 'mean'\n  /** Deterministic seed. If omitted, uses Math.random(). */\n  seed?: number\n}\n\n/**\n * Paired bootstrap on (after − before) deltas. Returns a CI on the chosen\n * statistic (median by default); pairs are resampled with replacement. The\n * lower bound is what the promotion gate checks — `low > threshold` means the\n * gain is real at the confidence level. Throws on unequal sample sizes.\n */\nexport function pairedBootstrap(\n  before: number[],\n  after: number[],\n  opts: PairedBootstrapOptions = {},\n): PairedBootstrapResult {\n  if (before.length !== after.length) {\n    throw new Error(`pairedBootstrap: unequal sample sizes (${before.length} vs ${after.length})`)\n  }\n  const confidence = opts.confidence ?? 0.95\n  const resamples = opts.resamples ?? 2000\n  const statistic = opts.statistic ?? 'median'\n  if (confidence <= 0 || confidence >= 1) {\n    throw new Error(`pairedBootstrap: confidence must be in (0,1), got ${confidence}`)\n  }\n\n  const n = before.length\n  const deltas = before.map((b, i) => after[i]! - b)\n  if (n === 0) {\n    return { n: 0, median: 0, mean: 0, low: 0, high: 0, confidence, resamples }\n  }\n  if (n === 1) {\n    const d = deltas[0]!\n    return { n: 1, median: d, mean: d, low: d, high: d, confidence, resamples }\n  }\n\n  const rng = makeRng(opts.seed)\n  const samples = new Array<number>(resamples)\n  for (let b = 0; b < resamples; b++) {\n    if (statistic === 'mean') {\n      let sum = 0\n      for (let k = 0; k < n; k++) {\n        sum += deltas[Math.floor(rng() * n)]!\n      }\n      samples[b] = sum / n\n    } else {\n      const acc = new Array<number>(n)\n      for (let k = 0; k < n; k++) {\n        acc[k] = deltas[Math.floor(rng() * n)]!\n      }\n      samples[b] = medianInPlace(acc)\n    }\n  }\n  samples.sort((a, b) => a - b)\n\n  const alpha = 1 - confidence\n  const lowIdx = Math.floor((alpha / 2) * resamples)\n  const highIdx = Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1)\n\n  return {\n    n,\n    median: medianInPlace([...deltas]),\n    mean: deltas.reduce((s, x) => s + x, 0) / n,\n    low: samples[lowIdx]!,\n    high: samples[Math.max(highIdx, lowIdx)]!,\n    confidence,\n    resamples,\n  }\n}\n\n// ── private stats helpers ────────────────────────────────────────────\n\n/** Standard-normal inverse CDF (Acklam approximation). */\nfunction zQuantile(p: number): number {\n  if (p <= 0 || p >= 1) {\n    if (p === 0) return -Infinity\n    if (p === 1) return Infinity\n    return NaN\n  }\n  const a = [\n    -3.969683028665376e1, 2.209460984245205e2, -2.759285104469687e2, 1.38357751867269e2,\n    -3.066479806614716e1, 2.506628277459239,\n  ]\n  const b = [\n    -5.447609879822406e1, 1.615858368580409e2, -1.556989798598866e2, 6.680131188771972e1,\n    -1.328068155288572e1,\n  ]\n  const c = [\n    -7.784894002430293e-3, -3.223964580411365e-1, -2.400758277161838, -2.549732539343734,\n    4.374664141464968, 2.938163982698783,\n  ]\n  const d = [7.784695709041462e-3, 3.224671290700398e-1, 2.445134137142996, 3.754408661907416]\n  const pLow = 0.02425\n  const pHigh = 1 - pLow\n  let q: number\n  let r: number\n  if (p < pLow) {\n    q = Math.sqrt(-2 * Math.log(p))\n    return (\n      (((((c[0]! * q + c[1]!) * q + c[2]!) * q + c[3]!) * q + c[4]!) * q + c[5]!) /\n      ((((d[0]! * q + d[1]!) * q + d[2]!) * q + d[3]!) * q + 1)\n    )\n  }\n  if (p <= pHigh) {\n    q = p - 0.5\n    r = q * q\n    return (\n      ((((((a[0]! * r + a[1]!) * r + a[2]!) * r + a[3]!) * r + a[4]!) * r + a[5]!) * q) /\n      (((((b[0]! * r + b[1]!) * r + b[2]!) * r + b[3]!) * r + b[4]!) * r + 1)\n    )\n  }\n  q = Math.sqrt(-2 * Math.log(1 - p))\n  return (\n    -(((((c[0]! * q + c[1]!) * q + c[2]!) * q + c[3]!) * q + c[4]!) * q + c[5]!) /\n    ((((d[0]! * q + d[1]!) * q + d[2]!) * q + d[3]!) * q + 1)\n  )\n}\n\nfunction medianInPlace(xs: number[]): number {\n  if (xs.length === 0) return 0\n  xs.sort((a, b) => a - b)\n  const mid = Math.floor(xs.length / 2)\n  return xs.length % 2 === 0 ? (xs[mid - 1]! + xs[mid]!) / 2 : xs[mid]!\n}\n\n/** Tiny seedable PRNG (mulberry32) — deterministic bootstrap resampling, not cryptographic. */\nfunction makeRng(seed: number | undefined): () => number {\n  if (seed === undefined) return Math.random\n  let s = seed | 0 || 0x9e3779b9\n  return () => {\n    s = (s + 0x6d2b79f5) | 0\n    let t = s\n    t = Math.imul(t ^ (t >>> 15), t | 1)\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\n  }\n}\n"],"mappings":"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","names":["i","i"]}

package/dist/chunk-LB2UOI5F.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/metrics.ts","../src/completion-verifier.ts","../src/produced-state.ts","../src/agent-profile.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","/**\n * Completion verifier — the task-completion oracle.\n *\n * Answers the only eval question that is not a proxy: did the agent actually\n * COMPLETE the task — produce every required deliverable, persisted and\n * correct — rather than describe what should be done. A fluent transcript\n * that never produces the artifact scores zero here.\n *\n * Per requirement, a two-stage check:\n *   1. Structural — a produced item (vault artifact / approved proposal /\n *      tool call) of the right kind is matched against the requirement and\n *      carries non-empty content. Deterministic; no LLM.\n *   2. Correctness — only if structurally present AND the matched item\n *      carries content, one targeted check decides whether that item\n *      actually fulfils the requirement. A hallucinated artifact fails here;\n *      an absent one already failed stage 1.\n *\n * `completionRate` is satisfied / total. Quality dimensions are meaningless\n * on an incomplete task — callers gate on `fullyComplete` / `completionRate`\n * before scoring quality.\n */\n\nimport type { TCloud } from '@tangle-network/tcloud'\nimport type { Artifact } from './artifact-validator'\n\n/** What kind of produced state can satisfy a requirement structurally. */\nexport type SatisfiedBy = 'artifact' | 'proposal' | 'tool-call' | 'any'\n\nexport interface CompletionRequirement {\n  /** Stable id from the task gold (e.g. a persona's `expected_requirements[].req_id`). */\n  reqId: string\n  /** Human-readable description of the required deliverable. */\n  title: string\n  /** Optional kind/category hint, matched against a produced item's kind. */\n  category?: string\n  /** What produced state satisfies this requirement. Defaults to 'any'. */\n  satisfiedBy?: SatisfiedBy\n}\n\nexport interface TaskGold {\n  taskId: string\n  requirements: CompletionRequirement[]\n}\n\nexport interface ProducedProposal {\n  id: string\n  title: string\n  status: 'pending' | 'approved' | 'rejected'\n  /** Optional persisted body — when present, enables a correctness check. */\n  content?: string\n}\n\n/** Everything observable about what a run actually produced. */\nexport interface ProducedState {\n  /** Persisted vault artifacts. Reuses the shared `Artifact` shape. */\n  artifacts: Artifact[]\n  /** Proposals / filings the agent created. */\n  proposals: ProducedProposal[]\n  /** Names of tools the agent invoked. */\n  toolCalls: string[]\n}\n\nexport interface RequirementCheck {\n  reqId: string\n  title: string\n  /** A produced item of the right kind matched the requirement, non-empty. */\n  structurallyPresent: boolean\n  /**\n   * Whether the matched item actually fulfils the requirement. `null` when\n   * not structurally present, or when the matched item carries no content\n   * to assess.\n   */\n  correct: boolean | null\n  /** structurallyPresent && correct !== false. */\n  satisfied: boolean\n  /** Human-readable evidence for the verdict. */\n  evidence: string[]\n}\n\nexport interface CompletionVerdict {\n  taskId: string\n  requirements: RequirementCheck[]\n  /** satisfied / total requirements. */\n  completionRate: number\n  /** Every requirement satisfied. */\n  fullyComplete: boolean\n}\n\n/**\n * Decides whether a produced item's content actually fulfils a requirement.\n * Injected so the structural verifier stays pure and unit-testable; the\n * production implementation is `createLlmCorrectnessChecker`.\n */\nexport type CorrectnessChecker = (\n  requirement: CompletionRequirement,\n  content: string,\n) => Promise<{ correct: boolean; reason: string }>\n\nconst STOPWORDS = new Set([\n  'the',\n  'a',\n  'an',\n  'of',\n  'for',\n  'and',\n  'or',\n  'to',\n  'in',\n  'on',\n  'with',\n  'by',\n])\n\nconst MATCH_THRESHOLD = 0.5\nconst MIN_CONTENT_CHARS = 50\n\nfunction tokens(s: string): Set<string> {\n  return new Set(\n    s\n      .toLowerCase()\n      .split(/[^a-z0-9]+/)\n      .filter((t) => t.length > 1 && !STOPWORDS.has(t)),\n  )\n}\n\n/**\n * Recall of the requirement's tokens within a candidate's identifying text.\n * Recall, not Jaccard — a candidate's path/id legitimately carries extra\n * tokens the requirement does not name.\n */\nfunction tokenRecall(requirementText: string, candidateText: string): number {\n  const req = tokens(requirementText)\n  if (req.size === 0) return 0\n  const cand = tokens(candidateText)\n  let hit = 0\n  for (const t of req) if (cand.has(t)) hit++\n  return hit / req.size\n}\n\ninterface Candidate {\n  reqIndex: number\n  /** Unique key for a produced item — each item satisfies at most one requirement. */\n  itemKey: string\n  score: number\n  evidence: string\n  /** Content to correctness-check, or null when the matched item has none. */\n  content: string | null\n}\n\nfunction artifactCandidates(\n  req: CompletionRequirement,\n  reqIndex: number,\n  artifacts: Artifact[],\n): Candidate[] {\n  const reqText = `${req.title} ${req.category ?? ''}`\n  const out: Candidate[] = []\n  artifacts.forEach((a, i) => {\n    if ((a.content ?? '').trim().length < MIN_CONTENT_CHARS) return\n    let score = tokenRecall(reqText, `${a.path ?? ''} ${a.kind}`)\n    if (req.category && a.kind && req.category.toLowerCase() === a.kind.toLowerCase()) {\n      score = Math.max(score, 1)\n    }\n    if (score < MATCH_THRESHOLD) return\n    out.push({\n      reqIndex,\n      itemKey: `artifact:${i}`,\n      score,\n      evidence: `artifact '${a.path ?? a.kind}' matched (token recall ${score.toFixed(2)})`,\n      content: a.content ?? null,\n    })\n  })\n  return out\n}\n\nfunction proposalCandidates(\n  req: CompletionRequirement,\n  reqIndex: number,\n  proposals: ProducedProposal[],\n): Candidate[] {\n  const reqText = `${req.title} ${req.category ?? ''}`\n  const out: Candidate[] = []\n  for (const p of proposals) {\n    // Pending or rejected work is not a completed deliverable.\n    if (p.status !== 'approved') continue\n    const score = tokenRecall(reqText, p.title)\n    if (score < MATCH_THRESHOLD) continue\n    const body = p.content ?? ''\n    out.push({\n      reqIndex,\n      itemKey: `proposal:${p.id}`,\n      score,\n      evidence: `approved proposal '${p.title}' matched (token recall ${score.toFixed(2)})`,\n      content: body.trim().length >= MIN_CONTENT_CHARS ? body : null,\n    })\n  }\n  return out\n}\n\nfunction toolCallCandidates(\n  req: CompletionRequirement,\n  reqIndex: number,\n  toolCalls: string[],\n): Candidate[] {\n  const out: Candidate[] = []\n  toolCalls.forEach((name, i) => {\n    const score = tokenRecall(req.title, name)\n    if (score < MATCH_THRESHOLD) return\n    out.push({\n      reqIndex,\n      itemKey: `tool:${i}`,\n      score,\n      evidence: `tool call '${name}' matched (token recall ${score.toFixed(2)})`,\n      content: null,\n    })\n  })\n  return out\n}\n\n/**\n * Verify whether a run completed the task. `checkCorrectness` is injected —\n * `createLlmCorrectnessChecker` for production, a deterministic stub in tests.\n *\n * Throws on a gold spec with no requirements: an eval task that requires\n * nothing is a misconfiguration, not a vacuously-complete task.\n */\nexport async function verifyCompletion(\n  gold: TaskGold,\n  state: ProducedState,\n  checkCorrectness: CorrectnessChecker,\n): Promise<CompletionVerdict> {\n  if (gold.requirements.length === 0) {\n    throw new Error(\n      `verifyCompletion: task '${gold.taskId}' has no requirements — malformed gold spec`,\n    )\n  }\n\n  // Collect every above-threshold (requirement, produced-item) candidate, then\n  // assign greedily by descending score: each requirement and each produced\n  // item is used at most once. One deliverable fulfils one requirement.\n  const candidates: Candidate[] = []\n  gold.requirements.forEach((req, i) => {\n    const by = req.satisfiedBy ?? 'any'\n    if (by === 'artifact' || by === 'any') {\n      candidates.push(...artifactCandidates(req, i, state.artifacts))\n    }\n    if (by === 'proposal' || by === 'any') {\n      candidates.push(...proposalCandidates(req, i, state.proposals))\n    }\n    if (by === 'tool-call' || by === 'any') {\n      candidates.push(...toolCallCandidates(req, i, state.toolCalls))\n    }\n  })\n  candidates.sort((a, b) => b.score - a.score)\n\n  const assigned = new Map<number, Candidate>()\n  const itemTaken = new Set<string>()\n  for (const c of candidates) {\n    if (assigned.has(c.reqIndex) || itemTaken.has(c.itemKey)) continue\n    assigned.set(c.reqIndex, c)\n    itemTaken.add(c.itemKey)\n  }\n\n  const requirements: RequirementCheck[] = []\n  for (let i = 0; i < gold.requirements.length; i++) {\n    const req = gold.requirements[i]!\n    const match = assigned.get(i)\n    const evidence: string[] = []\n    let correct: boolean | null = null\n\n    if (match) {\n      evidence.push(match.evidence)\n      if (match.content !== null) {\n        const r = await checkCorrectness(req, match.content)\n        correct = r.correct\n        evidence.push(`correctness: ${r.correct ? 'pass' : 'fail'} — ${r.reason}`)\n      } else {\n        evidence.push('correctness: not assessed — matched item carries no content')\n      }\n    } else {\n      const by = req.satisfiedBy ?? 'any'\n      const kind = by === 'any' ? 'artifact/proposal/tool-call' : by\n      evidence.push(`no produced ${kind} matched this requirement`)\n    }\n\n    const structurallyPresent = match !== undefined\n    const satisfied = structurallyPresent && correct !== false\n    requirements.push({\n      reqId: req.reqId,\n      title: req.title,\n      structurallyPresent,\n      correct,\n      satisfied,\n      evidence,\n    })\n  }\n\n  const satisfiedCount = requirements.filter((r) => r.satisfied).length\n  return {\n    taskId: gold.taskId,\n    requirements,\n    completionRate: satisfiedCount / requirements.length,\n    fullyComplete: satisfiedCount === requirements.length,\n  }\n}\n\nexport interface LlmCorrectnessCheckerOpts {\n  model?: string\n  /** Max chars of artifact content sent to the checker. */\n  maxContentChars?: number\n}\n\n/** Parse the correctness checker's model response. Fails loud on a bad shape. */\nexport function parseCorrectnessResponse(raw: string): { correct: boolean; reason: string } {\n  const match = raw.match(/\\{[\\s\\S]*\\}/)\n  if (!match) {\n    throw new Error(`correctness checker: no JSON object in model response: ${raw.slice(0, 200)}`)\n  }\n  const parsed = JSON.parse(match[0]) as { correct?: unknown; reason?: unknown }\n  if (typeof parsed.correct !== 'boolean') {\n    throw new Error(`correctness checker: 'correct' is not a boolean in: ${match[0].slice(0, 200)}`)\n  }\n  return { correct: parsed.correct, reason: typeof parsed.reason === 'string' ? parsed.reason : '' }\n}\n\n/**\n * Production `CorrectnessChecker` — one LLM call per matched artifact,\n * deterministic (temperature 0), structured JSON out. Judges fulfilment\n * only: a plan, a gesture, or a description of what should be done does not\n * fulfil a requirement — the artifact must BE the deliverable.\n */\nexport function createLlmCorrectnessChecker(\n  tc: TCloud,\n  opts: LlmCorrectnessCheckerOpts = {},\n): CorrectnessChecker {\n  const model = opts.model ?? 'claude-sonnet-4-6'\n  const maxContentChars = opts.maxContentChars ?? 8000\n  return async (requirement, content) => {\n    const resp = await tc.chat({\n      model,\n      messages: [\n        {\n          role: 'system',\n          content:\n            'You verify whether a produced work artifact actually fulfils a stated requirement. Judge fulfilment only — is the deliverable substantively present and on-point — not polish. A plan to do it later, a vague gesture, or a description of what should be done does NOT fulfil a requirement; the artifact must BE the deliverable. Respond with a single JSON object: {\"correct\": boolean, \"reason\": string (<= 30 words)}.',\n        },\n        {\n          role: 'user',\n          content: `Requirement: ${requirement.title}\\n${\n            requirement.category ? `Category: ${requirement.category}\\n` : ''\n          }\\nProduced artifact:\\n${content.slice(0, maxContentChars)}`,\n        },\n      ],\n      temperature: 0,\n      maxTokens: 200,\n    })\n    const raw =\n      (resp as { choices?: { message?: { content?: string } }[] }).choices?.[0]?.message?.content ??\n      ''\n    return parseCorrectnessResponse(raw)\n  }\n}\n","/**\n * Produced-state extraction — normalize a run's runtime event stream into the\n * typed `ProducedState` the completion oracle consumes.\n *\n * `ProducedState` answers \"what did the agent actually produce\" — vault\n * artifacts, proposals, tool calls. The runtime emits these as a stream of\n * events; this module is the single normalization point from that stream to\n * the shape `verifyCompletion` expects.\n *\n * Input is structurally typed (`RuntimeEventLike`) so this module does not\n * depend on agent-runtime — agent-runtime's `RuntimeStreamEvent` satisfies it\n * structurally. The `content` on `ArtifactEventLike` and the whole\n * `proposal_created` variant are the runtime-side enrichments this contract\n * requires; the runtime emits them, this module consumes them.\n */\n\nimport type { Artifact } from './artifact-validator'\nimport type { ProducedProposal, ProducedState } from './completion-verifier'\n\n/** A tool the agent invoked. */\nexport interface ToolCallEventLike {\n  type: 'tool_call'\n  toolName: string\n}\n\n/**\n * An artifact the agent produced. `content` is the enriched field — the\n * runtime's base `artifact` event carries only metadata; the completion\n * oracle needs the body to verify the deliverable, so the runtime emits it.\n */\nexport interface ArtifactEventLike {\n  type: 'artifact'\n  artifactId: string\n  name?: string\n  mimeType?: string\n  uri?: string\n  content?: string\n}\n\n/** A proposal / filing the agent created. */\nexport interface ProposalEventLike {\n  type: 'proposal_created'\n  proposalId: string\n  title: string\n  status?: 'pending' | 'approved' | 'rejected'\n}\n\n/**\n * The subset of runtime stream events `extractProducedState` consumes.\n * agent-runtime's full `RuntimeStreamEvent` union satisfies this structurally;\n * the `{ type: string }` catch-all keeps the input permissive so callers can\n * pass the whole unfiltered telemetry stream — unrecognized events are skipped.\n */\nexport type RuntimeEventLike =\n  | ToolCallEventLike\n  | ArtifactEventLike\n  | ProposalEventLike\n  | { type: string }\n\nfunction artifactKind(mimeType: string | undefined): string {\n  if (!mimeType) return 'file'\n  if (mimeType.includes('json')) return 'json'\n  if (mimeType.startsWith('text/')) return 'text'\n  return 'file'\n}\n\n/**\n * Normalize a run's runtime event stream into `ProducedState`.\n *\n * Pure and total — unrecognized event types are skipped. `toolCalls` is\n * deduplicated by name in first-seen order (completion cares about a tool's\n * presence, not its call count). An artifact with neither a name nor a uri\n * still yields an entry keyed by its `artifactId` so it is never silently\n * dropped; an artifact with no `content` yields empty content, which the\n * completion oracle's structural check then rejects on its own.\n */\nexport function extractProducedState(events: readonly RuntimeEventLike[]): ProducedState {\n  const artifacts: Artifact[] = []\n  const proposals: ProducedProposal[] = []\n  const toolCalls: string[] = []\n  const seenTools = new Set<string>()\n\n  for (const ev of events) {\n    if (ev.type === 'tool_call') {\n      const name = (ev as ToolCallEventLike).toolName\n      if (name && !seenTools.has(name)) {\n        seenTools.add(name)\n        toolCalls.push(name)\n      }\n    } else if (ev.type === 'artifact') {\n      const a = ev as ArtifactEventLike\n      artifacts.push({\n        kind: artifactKind(a.mimeType),\n        path: a.name ?? a.uri ?? a.artifactId,\n        content: a.content ?? '',\n      })\n    } else if (ev.type === 'proposal_created') {\n      const p = ev as ProposalEventLike\n      proposals.push({ id: p.proposalId, title: p.title, status: p.status ?? 'pending' })\n    }\n  }\n\n  return { artifacts, proposals, toolCalls }\n}\n","/**\n * @stable\n *\n * AgentProfile — the eval harness's unit of variation.\n *\n * A profile pins everything that changes agent behaviour for a benchmark\n * cell: the model, the active skills, the prompt version, the available\n * tools. Vary the profile — swap a model, add a skill — and re-run the suite\n * to benchmark the change. The scorecard keys a cell on\n * `(scenarioId, profileHash)`, so the model is not a separate axis: it lives\n * inside the profile, and two profiles with the same model but different\n * skills are different cells.\n *\n * `agentProfileHash` is the profile's behaviour identity. Two profiles that\n * produce the same agent behaviour share a hash (and a scorecard cell);\n * reordering `skills` or `tools` does not change it; the human-facing `id`\n * label does not affect it.\n */\n\nimport { createHash } from 'node:crypto'\nimport { ValidationError } from './errors'\nimport { canonicalize } from './pre-registration'\n\nexport interface AgentProfile {\n  /** Human-facing label, e.g. `sonnet-legal-skills-v3`. Not part of the hash. */\n  id: string\n  /** Model snapshot id this profile pins, e.g. `claude-sonnet-4-6@2025-04-15`. */\n  model: string\n  /** Skill ids/versions active in this profile — the primary behaviour lever. */\n  skills?: string[]\n  /** Prompt version identifier. */\n  promptVersion?: string\n  /** Tool ids available to the agent. */\n  tools?: string[]\n  /** Any other behaviour-bearing knobs that should fingerprint into the hash. */\n  metadata?: Record<string, string | number | boolean>\n}\n\n/**\n * Deterministic behaviour identity of a profile — a sha256 over the\n * behaviour-bearing fields. `skills` and `tools` are order-insensitive; the\n * `id` label is excluded. Throws on a profile with no `model` — an unkeyable\n * profile must fail loud rather than collapse into a blank-model cell.\n */\nexport function agentProfileHash(profile: AgentProfile): string {\n  if (typeof profile.model !== 'string' || profile.model.trim().length === 0) {\n    throw new ValidationError(`AgentProfile \"${profile.id}\" has no model — cannot hash`)\n  }\n  const behaviour = {\n    model: profile.model.trim(),\n    skills: [...(profile.skills ?? [])].sort(),\n    promptVersion: profile.promptVersion ?? null,\n    tools: [...(profile.tools ?? [])].sort(),\n    metadata: profile.metadata ?? {},\n  }\n  return createHash('sha256')\n    .update(JSON.stringify(canonicalize(behaviour)))\n    .digest('hex')\n}\n"],"mappings":"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","names":[]}