@tangle-network/agent-eval 1.0.22 → 1.0.24

package/dist/eval-campaign-Dq8DEKmy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"eval-campaign-Dq8DEKmy.js","names":[],"sources":["../src/eval-campaign.ts"],"sourcesContent":["/**\n * EvalCampaign — opinionated matrix runner that wires the four\n * capture-integrity directives by construction.\n *\n * The canonical benchmark shape — matrix runner → for each\n * (variant, scenario, seed) → start a TraceEmitter → call LLMs → end the\n * run → analyze — has a bug class at the integration boundary: raw\n * events not captured, route silently wrong, integrity not asserted,\n * analyst never run. The directives in `SKILL.md § Capture integrity`\n * are the mitigations.\n *\n * `EvalCampaign` is the structural fix — consumers don't wire the\n * integrity surface themselves; the campaign owns it. Specifically:\n *\n *   - constructs a per-run `TraceStore` and `RawProviderSink` via factories\n *   - builds the run's `ChatClient` through `chatFactory`, handing it the\n *     run's raw sink and trace context — a transport built any other way has\n *     no raw HTTP envelope, and `assertRunCaptured` says so\n *   - calls `assertRunCaptured` after every `endRun` and routes failures\n *     through a configurable policy (`throw` / `mark_failed` / `log`)\n *   - assembles per-run `RunRecord`s and runs `researchReport` at the end\n *     so the campaign artifact is launch-decision-grade by default\n *   - embeds the campaign fingerprint (a SHA-256 over the canonicalised\n *     run set) and optional `preregistrationHash` in the report\n *\n * The runner contract is intentionally narrow: produce a `CampaignRunOutcome`\n * given a fully-wired `CampaignRunContext`. Everything orchestration-shaped\n * lives in the campaign. This is the inversion-of-control point — consumers\n * stop writing matrix runners and start writing scenario-runners.\n *\n * Out of scope for v1 (tracked in `docs/research-report-methodology.md`):\n *\n *   - Distributed/cluster execution (concurrency is local async)\n *   - Adaptive sampling / sequential interim looks\n *   - Resume from partial state across crashes\n *   - LLM-call retry beyond what the caller's transport already does\n */\n\nimport {\n  type AgentProfileCell,\n  type AgentProfileCellInput,\n  buildAgentProfileCell,\n  verifyAgentProfileCell,\n} from './agent-profile-cell'\nimport type { ChatClient } from './analyst/chat-client'\nimport { hashJson } from './pre-registration'\nimport type {\n  JudgeScoresRecord,\n  RunCostProvenance,\n  RunJudgeMetadata,\n  RunOutcome,\n  RunRecord,\n  RunSplitTag,\n  RunTaskFailure,\n  RunTokenUsage,\n} from './run-record'\nimport { validateRunRecord } from './run-record'\nimport { type ResearchReport, type ResearchReportOptions, researchReport } from './summary-report'\nimport type { RunCompleteHook } from './trace/emitter'\nimport { TraceEmitter } from './trace/emitter'\nimport {\n  assertRunCaptured,\n  RunIntegrityError,\n  type RunIntegrityExpectations,\n  type RunIntegrityReport,\n} from './trace/integrity'\nimport { FileSystemRawProviderSink, type RawProviderSink } from './trace/raw-provider-sink'\nimport type { TraceStore } from './trace/store'\n\n// ── Public types ─────────────────────────────────────────────────────────\n\nexport interface CampaignVariant<V> {\n  id: string\n  payload: V\n}\n\nexport interface CampaignScenario {\n  scenarioId: string\n  /** Free-form metadata propagated to runs and reports. */\n  tags?: Record<string, string>\n}\n\nexport interface CampaignRunContext<V> {\n  /** Stable run id. The campaign generates this; the runner does not. */\n  runId: string\n  /** Logical experiment id (campaignId by default; overridable per-run via opts). */\n  experimentId: string\n  variant: V\n  variantId: string\n  scenarioId: string\n  scenarioTags: Record<string, string>\n  seed: number\n  splitTag: RunSplitTag\n  /**\n   * The TraceEmitter for this run, with `onRunComplete` hooks pre-wired\n   * (analyst auto-execution if configured, plus integrity check). The\n   * runner MUST call `emitter.startRun` before doing any work and either\n   * `emitter.endRun` or `emitter.abortRun` before returning.\n   */\n  emitter: TraceEmitter\n  store: TraceStore\n  rawSink: RawProviderSink\n  /**\n   * The run's model transport, built by `chatFactory` with this run's\n   * `rawSink` and `runId` already bound.\n   */\n  chat: ChatClient\n}\n\n/** What the campaign binds into the run's transport. */\nexport interface CampaignChatWiring {\n  /**\n   * Raw provider sink for this run. Bind it into the transport: the campaign's\n   * integrity check requires every LLM span to carry a matching raw request\n   * event, so a transport built without it fails `assertRunCaptured`.\n   */\n  rawSink: RawProviderSink\n  runId: string\n}\n\ninterface CampaignRunOutcomeFields {\n  /** Did the run pass? Mirrors `RunOutcome.pass` semantics. */\n  pass: boolean\n  /** Score for the run on its split. Maps to `searchScore` or `holdoutScore`. */\n  score: number\n  /** Cost in USD, or null when the runner could not capture it. */\n  costUsd: number | null\n  /** Source of the cost amount. */\n  costProvenance: RunCostProvenance\n  tokenUsage: RunTokenUsage\n  /** Snapshot model id (e.g. `claude-sonnet-4-6@2025-04-15`). */\n  model: string\n  /** sha256 of the effective prompt sent to the model. */\n  promptHash: string\n  /** sha256 of the effective config (model, temperature, tools, judges, splits). */\n  configHash: string\n  /** Optional extra numeric metrics to land in `outcome.raw`. */\n  raw?: Record<string, number>\n  /** Optional judge metadata when a judge was used. */\n  judgeMetadata?: RunJudgeMetadata\n  /**\n   * Optional per-judge / per-dim breakdown for ensemble-judged runs.\n   * Propagated to `outcome.judgeScores` on the resulting `RunRecord`.\n   * Single-judge or scalar-only runs leave this unset.\n   */\n  judgeScores?: JudgeScoresRecord\n  /**\n   * Agent profile cell observed by the runner. When supplied, it overrides\n   * `EvalCampaignOptions.agentProfile` for this run and must match the\n   * outcome's `model` and `promptHash`.\n   */\n  agentProfile?: AgentProfileCell | AgentProfileCellInput\n}\n\n/** Campaign result with the same task-failure invariant as `RunRecord`. */\nexport type CampaignRunOutcome = CampaignRunOutcomeFields & RunTaskFailure\n\nexport type CampaignRunner<V> = (ctx: CampaignRunContext<V>) => Promise<CampaignRunOutcome>\n\nexport type CampaignIntegrityPolicy = 'throw' | 'mark_failed' | 'log'\n\nexport interface EvalCampaignOptions<V> {\n  /**\n   * Stable id for the campaign. Used as the default `experimentId` on\n   * every run, and folded into the campaign fingerprint.\n   */\n  campaignId: string\n  variants: CampaignVariant<V>[]\n  scenarios: CampaignScenario[]\n  /** Default `[0, 1, 2]`. */\n  seeds?: number[]\n  /** Default `'holdout'` — the split that anchors a launch decision. */\n  splitTag?: RunSplitTag\n  /** Git SHA the campaign is run against. Mandatory; `RunRecord` rejects unset. */\n  commitSha: string\n  /**\n   * Build the model transport for one run. agent-eval executes no paid model:\n   * the caller owns the transport and the credential never enters this\n   * package. The campaign calls this once per run and passes the run's raw\n   * provider sink and `runId`, so a transport that binds them captures the\n   * raw HTTP envelope `assertRunCaptured` checks for.\n   */\n  chatFactory: (wiring: CampaignChatWiring) => ChatClient\n  /**\n   * Caller-declared identity of the execution route, folded into the campaign\n   * fingerprint so two campaigns run against different endpoints do not share\n   * one identity. agent-eval no longer knows the endpoint; the owner of\n   * execution names it.\n   */\n  executionRef?: string\n  /**\n   * Per-run TraceStore factory. Common shape: a fresh store per run keyed\n   * on `runId`. Implementations that share a store across the campaign\n   * are valid — the campaign only writes through `emitter`.\n   */\n  storeFactory: (params: CampaignFactoryParams) => TraceStore\n  /**\n   * Per-run RawProviderSink factory. Defaults to `FileSystemRawProviderSink`\n   * rooted at `${workDir}/raw-events/${runId}` if `workDir` is supplied;\n   * otherwise required. Forensic capture is non-negotiable in a campaign\n   * run — pass `NoopRawProviderSink` explicitly if you want to opt out.\n   */\n  rawSinkFactory?: (params: CampaignFactoryParams) => RawProviderSink\n  /**\n   * Filesystem root for default `rawSinkFactory`. Ignored if\n   * `rawSinkFactory` is supplied.\n   */\n  workDir?: string\n  /**\n   * Extra `onRunComplete` hooks the campaign appends (after its own\n   * integrity-check hook). Pass `traceAnalystOnRunComplete(...)` here.\n   */\n  onRunComplete?: RunCompleteHook[]\n  /**\n   * Per-run integrity expectations. Defaults to:\n   *   `{ llmSpansMin: 1, requireRawCoverageOfLlmSpans: true, requireOutcome: true }`.\n   * Override (e.g. `{ llmSpansMin: 0 }`) for runs that don't call LLMs.\n   */\n  integrity?: RunIntegrityExpectations\n  /** Behaviour when integrity fails. Default `'mark_failed'`. */\n  onIntegrityFailure?: CampaignIntegrityPolicy\n  /**\n   * Per-run runner. Receives a fully-wired context; produces an outcome\n   * the campaign converts into a `RunRecord`.\n   */\n  runner: CampaignRunner<V>\n  /**\n   * If set, the campaign computes `researchReport` at the end. `comparator`\n   * is a `variantId`. Other fields are forwarded verbatim.\n   */\n  report?: { comparator?: string } & Omit<\n    ResearchReportOptions,\n    'comparator' | 'preregistrationHash' | 'generatedAt'\n  >\n  /**\n   * Hash of a signed `HypothesisManifest` (see `pre-registration.ts`).\n   * Embedded in the campaign fingerprint and the research report.\n   */\n  preregistrationHash?: string\n  /** Local concurrency. Default `1` (sequential). */\n  concurrency?: number\n  /**\n   * Override the time source. Tests pass a mock to make wallMs deterministic.\n   */\n  now?: () => number\n  /** Override the runId generator. Tests pin this. */\n  runId?: (params: CampaignFactoryParams) => string\n  /**\n   * Agent profile cell for campaign runs. Static profiles can pass an object;\n   * routers or variant-specific harnesses can pass a factory. The campaign\n   * stamps the built cell onto every `RunRecord` and rejects profile/model or\n   * profile/prompt contradictions.\n   */\n  agentProfile?:\n    | AgentProfileCell\n    | AgentProfileCellInput\n    | ((\n        params: CampaignFactoryParams & {\n          variant: V\n          scenarioTags: Record<string, string>\n        },\n      ) =>\n        | AgentProfileCell\n        | AgentProfileCellInput\n        | Promise<AgentProfileCell | AgentProfileCellInput>)\n}\n\nexport interface CampaignFactoryParams {\n  campaignId: string\n  runId: string\n  variantId: string\n  scenarioId: string\n  seed: number\n}\n\nexport interface FailedRun {\n  runId: string\n  variantId: string\n  scenarioId: string\n  seed: number\n  reason: string\n  error?: string\n}\n\nexport interface EvalCampaignResult {\n  campaignId: string\n  /** SHA-256 over canonicalised `(variantIds, scenarioIds, seeds, comparator, splitTag, executionRef, preregistrationHash)`. */\n  campaignFingerprint: string\n  preregistrationHash: string | null\n  /** Successful runs only. Failed runs land in `failedRuns`. */\n  runs: RunRecord[]\n  /** Integrity reports for every successful run. */\n  integrityReports: RunIntegrityReport[]\n  failedRuns: FailedRun[]\n  /** Computed when `report` is set on options. */\n  report?: ResearchReport\n  startedAt: string\n  endedAt: string\n}\n\n// ── Implementation ───────────────────────────────────────────────────────\n\nconst DEFAULT_INTEGRITY: RunIntegrityExpectations = {\n  llmSpansMin: 1,\n  requireRawCoverageOfLlmSpans: true,\n  requireOutcome: true,\n}\n\ntype CampaignCell<V> = { variant: CampaignVariant<V>; scenario: CampaignScenario; seed: number }\n\ntype CampaignRunResult = { record: RunRecord; integrity: RunIntegrityReport }\n\n/** Resolved options shared by every step of one campaign. */\ninterface CampaignSettings {\n  seeds: number[]\n  splitTag: RunSplitTag\n  concurrency: number\n  integrity: RunIntegrityExpectations\n  onIntegrityFailure: CampaignIntegrityPolicy\n  now: () => number\n  executionRef: string | null\n  preregistrationHash: string | null\n  rawSinkFactory: (params: CampaignFactoryParams) => RawProviderSink\n}\n\n/**\n * Mutable state of one campaign's worker pool.\n *\n * A genuine (non-CellExecutionError) error from any worker is a bug, not a\n * run-level failure. We must NOT let `Promise.all` reject mid-flight and\n * orphan the other workers' in-progress runs (emitters never finalized,\n * sinks/handles leak, partial work silently discarded). Instead: capture the\n * first genuine error, stop dispatching new cells so in-flight workers wind\n * down, finalize every still-open run, then re-throw the aggregated error.\n */\ninterface CampaignPool<V> {\n  opts: EvalCampaignOptions<V>\n  settings: CampaignSettings\n  cells: CampaignCell<V>[]\n  cursor: number\n  aborting: boolean\n  genuineErrors: unknown[]\n  /**\n   * Emitters for runs that are currently mid-flight, keyed by runId. A worker\n   * registers its emitter before invoking the runner and removes it once the\n   * run is finalized (via endRun/abortRun, success or failure). Anything left\n   * here after the pool settles is an orphan we must abort.\n   */\n  openRuns: Map<string, TraceEmitter>\n  runs: RunRecord[]\n  integrityReports: RunIntegrityReport[]\n  failedRuns: FailedRun[]\n}\n\nexport async function runEvalCampaign<V>(\n  opts: EvalCampaignOptions<V>,\n): Promise<EvalCampaignResult> {\n  assertCampaignPreflight(opts)\n  const settings = resolveCampaignSettings(opts)\n  const campaignFingerprint = await fingerprintCampaign(opts, settings)\n\n  const startedAt = new Date(settings.now()).toISOString()\n  const pool: CampaignPool<V> = {\n    opts,\n    settings,\n    cells: planCampaignCells(opts, settings.seeds),\n    cursor: 0,\n    aborting: false,\n    genuineErrors: [],\n    openRuns: new Map(),\n    runs: [],\n    integrityReports: [],\n    failedRuns: [],\n  }\n  await drainCampaignPool(pool)\n\n  const report = await buildCampaignReport(opts, settings, pool.runs)\n  const endedAt = new Date(settings.now()).toISOString()\n\n  return {\n    campaignId: opts.campaignId,\n    campaignFingerprint,\n    preregistrationHash: settings.preregistrationHash,\n    runs: pool.runs,\n    integrityReports: pool.integrityReports,\n    failedRuns: pool.failedRuns,\n    report,\n    startedAt,\n    endedAt,\n  }\n}\n\n/** Reject structurally invalid campaigns before any work starts. */\nfunction assertCampaignPreflight<V>(opts: EvalCampaignOptions<V>): void {\n  if (opts.variants.length === 0) {\n    throw new Error('runEvalCampaign: variants must be non-empty.')\n  }\n  if (opts.scenarios.length === 0) {\n    throw new Error('runEvalCampaign: scenarios must be non-empty.')\n  }\n  const variantIds = new Set<string>()\n  for (const v of opts.variants) {\n    if (variantIds.has(v.id)) {\n      throw new Error(`runEvalCampaign: duplicate variant id \"${v.id}\".`)\n    }\n    variantIds.add(v.id)\n  }\n  const scenarioIds = new Set<string>()\n  for (const s of opts.scenarios) {\n    if (scenarioIds.has(s.scenarioId)) {\n      throw new Error(`runEvalCampaign: duplicate scenarioId \"${s.scenarioId}\".`)\n    }\n    scenarioIds.add(s.scenarioId)\n  }\n  if (opts.report?.comparator && !variantIds.has(opts.report.comparator)) {\n    throw new Error(\n      `runEvalCampaign: report.comparator \"${opts.report.comparator}\" is not a configured variantId.`,\n    )\n  }\n  if (!opts.commitSha) {\n    throw new Error('runEvalCampaign: commitSha is required (every RunRecord needs it).')\n  }\n}\n\n/** Apply defaults to the optional campaign options. */\nfunction resolveCampaignSettings<V>(opts: EvalCampaignOptions<V>): CampaignSettings {\n  return {\n    seeds: opts.seeds ?? [0, 1, 2],\n    splitTag: opts.splitTag ?? 'holdout',\n    concurrency: Math.max(1, opts.concurrency ?? 1),\n    integrity: { ...DEFAULT_INTEGRITY, ...(opts.integrity ?? {}) },\n    onIntegrityFailure: opts.onIntegrityFailure ?? 'mark_failed',\n    now: opts.now ?? (() => Date.now()),\n    executionRef: opts.executionRef ?? null,\n    preregistrationHash: opts.preregistrationHash ?? null,\n    rawSinkFactory: opts.rawSinkFactory ?? defaultRawSinkFactory(opts.workDir),\n  }\n}\n\n/** SHA-256 over the canonicalised matrix definition. */\nfunction fingerprintCampaign<V>(\n  opts: EvalCampaignOptions<V>,\n  settings: CampaignSettings,\n): Promise<string> {\n  return hashJson({\n    campaignId: opts.campaignId,\n    variants: opts.variants.map((v) => v.id).sort(),\n    scenarios: opts.scenarios.map((s) => s.scenarioId).sort(),\n    seeds: [...settings.seeds].sort((a, b) => a - b),\n    splitTag: settings.splitTag,\n    comparator: opts.report?.comparator ?? null,\n    executionRef: settings.executionRef,\n    preregistrationHash: settings.preregistrationHash,\n  })\n}\n\n/** Expand variants x scenarios x seeds, variant-major. */\nfunction planCampaignCells<V>(opts: EvalCampaignOptions<V>, seeds: number[]): CampaignCell<V>[] {\n  const cells: CampaignCell<V>[] = []\n  for (const variant of opts.variants) {\n    for (const scenario of opts.scenarios) {\n      for (const seed of seeds) {\n        cells.push({ variant, scenario, seed })\n      }\n    }\n  }\n  return cells\n}\n\n/**\n * Run the bounded-concurrency worker pool to completion, finalize any run left\n * open, and re-throw the genuine errors the workers captured.\n */\nasync function drainCampaignPool<V>(pool: CampaignPool<V>): Promise<void> {\n  const workers = Array.from(\n    { length: Math.min(pool.settings.concurrency, pool.cells.length) },\n    () => campaignWorker(pool),\n  )\n  // allSettled (not all): a genuine error in one worker must not reject the\n  // pool mid-flight and orphan the others. Each worker captures its own\n  // genuine error into `genuineErrors` and returns; we re-throw below.\n  await Promise.allSettled(workers)\n\n  // Finalize any run still open after the pool wound down. With the\n  // stop-dispatch flag these are the runs that were mid-flight in peer workers\n  // when the first genuine error fired — abort them so their emitters finalize\n  // (hooks fire, store records a terminal status) instead of leaking.\n  for (const [runId, emitter] of pool.openRuns) {\n    await finalizeAbort(emitter, runId, 'campaign aborted: genuine error in a sibling run')\n  }\n  pool.openRuns.clear()\n\n  if (pool.genuineErrors.length > 0) {\n    throw pool.genuineErrors.length === 1\n      ? pool.genuineErrors[0]\n      : new AggregateError(\n          pool.genuineErrors,\n          `runEvalCampaign: ${pool.genuineErrors.length} runs failed with genuine (non-run-level) errors`,\n        )\n  }\n}\n\n/** Pull cells off the shared cursor until none remain or the pool is aborting. */\nasync function campaignWorker<V>(pool: CampaignPool<V>): Promise<void> {\n  while (!pool.aborting) {\n    const i = pool.cursor++\n    if (i >= pool.cells.length) return\n    const cell = pool.cells[i]!\n    try {\n      const result = await runCampaignCell(pool, cell)\n      pool.runs.push(result.record)\n      pool.integrityReports.push(result.integrity)\n    } catch (err) {\n      if (err instanceof CellExecutionError) {\n        pool.failedRuns.push(err.failed)\n        if (err.integrity) pool.integrityReports.push(err.integrity)\n      } else {\n        // Genuine bug — not a runner failure, not an integrity failure.\n        // Capture it and stop dispatching so peers wind down gracefully;\n        // re-thrown after the pool settles. Do not surface here — that would\n        // reject Promise.all and orphan the other workers' runs.\n        pool.genuineErrors.push(err)\n        pool.aborting = true\n        return\n      }\n    }\n  }\n}\n\n/** Run one matrix cell: runner, integrity check, then the validated RunRecord. */\nasync function runCampaignCell<V>(\n  pool: CampaignPool<V>,\n  cell: CampaignCell<V>,\n): Promise<CampaignRunResult> {\n  const { opts, settings } = pool\n  const runId = (opts.runId ?? defaultRunId)({\n    campaignId: opts.campaignId,\n    runId: '', // unused by default generator\n    variantId: cell.variant.id,\n    scenarioId: cell.scenario.scenarioId,\n    seed: cell.seed,\n  })\n  const factoryParams: CampaignFactoryParams = {\n    campaignId: opts.campaignId,\n    runId,\n    variantId: cell.variant.id,\n    scenarioId: cell.scenario.scenarioId,\n    seed: cell.seed,\n  }\n  const store = opts.storeFactory(factoryParams)\n  const rawSink = settings.rawSinkFactory(factoryParams)\n\n  const emitter = new TraceEmitter(store, {\n    runId,\n    now: opts.now,\n    onRunComplete: opts.onRunComplete,\n  })\n  // Track this run as open so a genuine error elsewhere in the pool can\n  // finalize it instead of orphaning it. Removed in the finally below.\n  pool.openRuns.set(runId, emitter)\n\n  const chat = opts.chatFactory({ rawSink, runId })\n\n  const ctx: CampaignRunContext<V> = {\n    runId,\n    experimentId: opts.campaignId,\n    variant: cell.variant.payload,\n    variantId: cell.variant.id,\n    scenarioId: cell.scenario.scenarioId,\n    scenarioTags: cell.scenario.tags ?? {},\n    seed: cell.seed,\n    splitTag: settings.splitTag,\n    emitter,\n    store,\n    rawSink,\n    chat,\n  }\n\n  try {\n    const wallStart = settings.now()\n    const outcome = await invokeCampaignRunner(opts, cell, ctx)\n    const wallMs = settings.now() - wallStart\n\n    const integrityReport = await assertRunCaptured(store, runId, {\n      ...settings.integrity,\n      rawSink,\n    })\n    if (!integrityReport.ok) admitOrRejectIntegrity(settings, cell, runId, integrityReport)\n\n    const record = buildCampaignRunRecord(opts, settings, cell, runId, outcome, wallMs)\n    await stampAgentProfile(opts, cell, record, runId, outcome)\n    return { record: validateRunRecord(record), integrity: integrityReport }\n  } finally {\n    // This run's worker has finished with it (success, run-level failure, or\n    // genuine error). It is no longer the pool's job to finalize — drop it so\n    // the post-settle sweep doesn't double-abort a finalized run.\n    pool.openRuns.delete(runId)\n  }\n}\n\n/** Invoke the runner; a throw aborts the run and becomes a run-level failure. */\nasync function invokeCampaignRunner<V>(\n  opts: EvalCampaignOptions<V>,\n  cell: CampaignCell<V>,\n  ctx: CampaignRunContext<V>,\n): Promise<CampaignRunOutcome> {\n  try {\n    return await opts.runner(ctx)\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err)\n    // The runner threw mid-execution. Abort the run so the emitter\n    // finalizes. The only benign abortRun failure is \"the runner never\n    // started the run\" (nothing to finalize). A store-write failure (disk\n    // full, FS error) is a genuine diagnostic — surface it rather than\n    // masking it as a plain runner failure.\n    await finalizeAbort(ctx.emitter, ctx.runId, message)\n    throw new CellExecutionError({\n      runId: ctx.runId,\n      variantId: cell.variant.id,\n      scenarioId: cell.scenario.scenarioId,\n      seed: cell.seed,\n      reason: 'runner_threw',\n      error: message,\n    })\n  }\n}\n\n/** Apply the integrity-failure policy to a report that is not ok. */\nfunction admitOrRejectIntegrity<V>(\n  settings: CampaignSettings,\n  cell: CampaignCell<V>,\n  runId: string,\n  integrityReport: RunIntegrityReport,\n): void {\n  switch (settings.onIntegrityFailure) {\n    case 'throw':\n      throw new RunIntegrityError(integrityReport)\n    case 'mark_failed':\n      throw new CellExecutionError(\n        {\n          runId,\n          variantId: cell.variant.id,\n          scenarioId: cell.scenario.scenarioId,\n          seed: cell.seed,\n          reason: 'integrity_failed',\n          error: integrityReport.issues.map((i) => i.code).join(', '),\n        },\n        integrityReport,\n      )\n    case 'log':\n      // Caller wants the run admitted with a flagged report; fall through.\n      break\n  }\n}\n\n/** Assemble the RunRecord for a successful run, before profile stamping. */\nfunction buildCampaignRunRecord<V>(\n  opts: EvalCampaignOptions<V>,\n  settings: CampaignSettings,\n  cell: CampaignCell<V>,\n  runId: string,\n  outcome: CampaignRunOutcome,\n  wallMs: number,\n): RunRecord {\n  const recordOutcome: RunOutcome = {\n    raw: outcome.raw ?? {},\n  }\n  if (settings.splitTag === 'holdout') recordOutcome.holdoutScore = outcome.score\n  else recordOutcome.searchScore = outcome.score\n  if (outcome.judgeScores !== undefined) recordOutcome.judgeScores = outcome.judgeScores\n\n  return {\n    runId,\n    experimentId: opts.campaignId,\n    candidateId: cell.variant.id,\n    seed: cell.seed,\n    model: outcome.model,\n    promptHash: outcome.promptHash,\n    configHash: outcome.configHash,\n    commitSha: opts.commitSha,\n    wallMs,\n    costUsd: outcome.costUsd,\n    costProvenance: outcome.costProvenance,\n    tokenUsage: outcome.tokenUsage,\n    terminalOutcome: 'succeeded',\n    judgeMetadata: outcome.judgeMetadata,\n    outcome: recordOutcome,\n    ...(outcome.failureClass ? { failureClass: outcome.failureClass } : {}),\n    failureMode: outcome.failureMode,\n    splitTag: settings.splitTag,\n    scenarioId: cell.scenario.scenarioId,\n  }\n}\n\n/** Resolve the run's agent profile (outcome first, then options) and stamp it on the record. */\nasync function stampAgentProfile<V>(\n  opts: EvalCampaignOptions<V>,\n  cell: CampaignCell<V>,\n  record: RunRecord,\n  runId: string,\n  outcome: CampaignRunOutcome,\n): Promise<void> {\n  const profileSource =\n    outcome.agentProfile ??\n    (typeof opts.agentProfile === 'function'\n      ? await opts.agentProfile({\n          campaignId: opts.campaignId,\n          runId,\n          variantId: cell.variant.id,\n          scenarioId: cell.scenario.scenarioId,\n          seed: cell.seed,\n          variant: cell.variant.payload,\n          scenarioTags: cell.scenario.tags ?? {},\n        })\n      : opts.agentProfile)\n  if (profileSource !== undefined) {\n    const agentProfile = await resolveAgentProfileCell(profileSource)\n    assertAgentProfileMatchesRun(agentProfile, outcome.model, outcome.promptHash)\n    record.agentProfile = agentProfile\n  }\n}\n\n/** Build the optional research report over the successful runs. */\nasync function buildCampaignReport<V>(\n  opts: EvalCampaignOptions<V>,\n  settings: CampaignSettings,\n  runs: RunRecord[],\n): Promise<ResearchReport | undefined> {\n  if (!opts.report) return undefined\n  const reportOpts: ResearchReportOptions = {\n    ...opts.report,\n    comparator: opts.report.comparator,\n    split: settings.splitTag === 'dev' ? 'search' : settings.splitTag,\n    generatedAt: new Date(settings.now()).toISOString(),\n    preregistrationHash: settings.preregistrationHash ?? undefined,\n  }\n  return researchReport(runs, reportOpts)\n}\n\n// ── Internal ─────────────────────────────────────────────────────────────\n\nclass CellExecutionError extends Error {\n  readonly failed: FailedRun\n  readonly integrity?: RunIntegrityReport\n  constructor(failed: FailedRun, integrity?: RunIntegrityReport) {\n    super(`cell ${failed.variantId}/${failed.scenarioId}@${failed.seed} failed: ${failed.reason}`)\n    this.failed = failed\n    this.integrity = integrity\n  }\n}\n\n/**\n * Abort a run whose owning work threw or was orphaned by a sibling's genuine\n * error, finalizing the emitter so hooks fire and the store records a terminal\n * status. Safe to call unconditionally: it only aborts runs that are still\n * `running`. Two no-op cases are intentional and benign:\n *\n *   - the run was never started (absent from the store) — nothing to finalize\n *   - the run is already terminal (`completed` / `failed` / `aborted`) —\n *     finalizing again would overwrite the real outcome (e.g. flip a passed run\n *     to `aborted` with `{ pass: false, notes: reason }`), so we leave it alone\n *\n * Any OTHER failure of the store read or the abort write (disk full, FS fault,\n * backend down) is a genuine diagnostic and propagates rather than being\n * swallowed.\n */\nasync function finalizeAbort(emitter: TraceEmitter, runId: string, reason: string): Promise<void> {\n  const existing = await emitter.traceStore.getRun(runId)\n  if (existing === undefined) return // run never started; nothing to abort\n  if (existing.status !== 'running') return // already finalized; never overwrite a real outcome\n  // The emitter never throws on a failed store write; it counts it. A failed\n  // abort write is a genuine diagnostic here, so read the count and surface it.\n  const droppedBefore = emitter.captureStats().dropped\n  await emitter.abortRun(reason)\n  const after = emitter.captureStats()\n  if (after.dropped > droppedBefore) {\n    throw new Error(`finalizeAbort: run ${runId} could not be finalized: ${after.lastError}`)\n  }\n}\n\nfunction defaultRawSinkFactory(workDir: string | undefined) {\n  return (params: CampaignFactoryParams): RawProviderSink => {\n    if (!workDir) {\n      throw new Error(\n        'runEvalCampaign: rawSinkFactory not supplied and workDir not set. Pass either to enable raw provider capture, or pass `new NoopRawProviderSink()` via rawSinkFactory to opt out explicitly.',\n      )\n    }\n    return new FileSystemRawProviderSink({\n      dir: `${workDir}/raw-events/${params.runId}`,\n    })\n  }\n}\n\nasync function resolveAgentProfileCell(\n  input: AgentProfileCell | AgentProfileCellInput,\n): Promise<AgentProfileCell> {\n  if (isAgentProfileCell(input)) {\n    if (!(await verifyAgentProfileCell(input))) {\n      throw new Error(`runEvalCampaign: agentProfile.cellId does not match its content`)\n    }\n    return input\n  }\n  return buildAgentProfileCell(input)\n}\n\nfunction isAgentProfileCell(\n  input: AgentProfileCell | AgentProfileCellInput,\n): input is AgentProfileCell {\n  return 'schemaVersion' in input && 'cellId' in input\n}\n\nfunction assertAgentProfileMatchesRun(\n  profile: AgentProfileCell,\n  model: string,\n  promptHash: string,\n): void {\n  if (profile.model !== undefined && profile.model !== model) {\n    throw new Error(\n      `runEvalCampaign: agentProfile.model \"${profile.model}\" does not match outcome.model \"${model}\"`,\n    )\n  }\n  if (profile.promptHash !== undefined && profile.promptHash !== promptHash) {\n    throw new Error(\n      `runEvalCampaign: agentProfile.promptHash \"${profile.promptHash}\" does not match outcome.promptHash \"${promptHash}\"`,\n    )\n  }\n}\n\nfunction defaultRunId(params: CampaignFactoryParams): string {\n  // Stable across re-runs: fingerprint of (campaignId, variantId, scenarioId, seed).\n  // Caller can override via opts.runId for non-deterministic IDs.\n  const base = `${params.campaignId}::${params.variantId}::${params.scenarioId}::${params.seed}`\n  // TWO 32-bit FNV-1a accumulators with different offsets, concatenated for a\n  // 64-bit-wide id. Not crypto-grade; stability and uniqueness are what this\n  // needs. Frozen: the value names a persisted cell, and the second\n  // accumulator's offset is part of the identity, so no single-accumulator\n  // helper can replace it.\n  let h1 = 0x811c9dc5\n  let h2 = 0x12345678\n  for (let i = 0; i < base.length; i++) {\n    const c = base.charCodeAt(i)\n    h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0\n    h2 = Math.imul(h2 ^ c, 0x9e3779b1) >>> 0\n  }\n  return `run-${h1.toString(16).padStart(8, '0')}${h2.toString(16).padStart(8, '0')}`\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-YS58LHlx.d.ts","names":[],"sources":["../src/cost-ledger/errors.ts","../src/cost-ledger/pricing.ts","../src/llm-client/accounting.ts","../src/llm-client/errors.ts","../src/llm-client/json.ts","../src/llm-client/resilience.ts","../src/analyst/policy-edit.ts","../src/capability-headroom.ts","../src/cost-tracker.ts","../src/detectors/index.ts","../src/error-count-extractor.ts","../src/knowledge/types.ts","../src/leaderboard.ts","../src/paired-delta-test.ts","../src/partition-held-out.ts","../src/product-benchmark/export.ts","../src/product-benchmark/index.ts","../src/runtime-trajectory.ts","../src/active-learning.ts","../src/bounded-process.ts","../src/command-runner.ts","../src/discover-personas.ts","../src/improvement-verdict.ts","../src/propose-review.ts","../src/reflective-mutation.ts","../src/eval-trace-store.ts","../src/integrity/preflight.ts","../src/model-seats.ts","../src/prompt-registry.ts","../src/reference-replay.ts","../src/steering.ts","../src/run-score.ts","../src/steering-optimizer.ts","../src/counterfactual.ts","../src/scorecard.ts","../src/trace-contracts/types.ts","../src/trace-contracts/builder.ts","../src/trace-contracts/evaluate.ts","../src/trace-contracts/explain.ts","../src/trace-contracts/spec.ts","../src/action-policy.ts","../src/contamination-guard.ts","../src/deploy-gate-layer.ts","../src/hidden-criteria-grading.ts","../src/integrity/single-backend.ts","../src/intent-match-judge.ts","../src/judge-ensemble.ts","../src/judge-retry.ts","../src/judge-panel.ts","../src/keyword-coverage-judge.ts","../src/oracle.ts","../src/paired-promotion-power.ts","../src/treatment-gate.ts","../src/verdict-cache.ts","../src/profile/baselines.ts","../src/profile/index.ts","../src/budget-guard.ts","../src/client.ts","../src/control-runtime.ts","../src/control-runtime/policy.ts","../src/knowledge/readiness.ts","../src/metrics.ts","../src/anti-slop.ts","../src/sandbox-assertions.ts"],"mappings":"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"}

package/dist/matrix-C-GxIgeJ.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"matrix-C-GxIgeJ.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAAA,YAAA;;cAMjB,gCAAgC;EAC/B,YAAA;;;;;;;;;;;;;;;;;;;iBAgCE,0BAA0B,yBAAyB,SAAS;cCvI/D;UAEI,qBAAqB;;EAEpC;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,qBAAqB,SAC5B,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBAkBS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;UClEM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,qBAAqB,uBAAuB;;EAE1D,aAAa,qBAAqB,mBAAmB;;EAErD,iBAAiB,qBAAqB,mBAAmB;;EAEzD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}

package/dist/metrics-zALlR17s.js

@@ -1,146 +0,0 @@
-// src/metrics.ts
-/** Per-1K token pricing for exact model ids. */
-const MODEL_PRICING = {
-	"gpt-4o": {
-		input: .0025,
-		output: .01
-	},
-	"gpt-4o-mini": {
-		input: 15e-5,
-		output: 6e-4
-	},
-	"gpt-4-turbo": {
-		input: .01,
-		output: .03
-	},
-	"claude-sonnet-4-20250514": {
-		input: .003,
-		output: .015
-	},
-	"claude-opus-4-20250514": {
-		input: .015,
-		output: .075
-	},
-	"claude-3-haiku-20240307": {
-		input: 25e-5,
-		output: .00125
-	},
-	"glm-5.3": {
-		input: .00168,
-		output: .00528
-	},
-	"gpt-6-luna": {
-		input: 1e-4,
-		output: 5e-4
-	},
-	"gpt-5-mini": {
-		input: 25e-5,
-		output: .002
-	}
-};
-/** Family-level pricing fallbacks (per-1K), matched against a normalized id
-*  after exact lookup misses. Ordered — first match wins. Covers the model
-*  ids actually used through the Tangle router + cli-bridge harnesses, none
-*  of which appear in the exact table above — without this they priced to a
-*  silent $0, blanking every cost/Pareto axis downstream. */
-const FAMILY_PRICING = [
-	[/^stealth\//, {
-		input: 0,
-		output: 0
-	}],
-	[/claude.*opus/, {
-		input: .015,
-		output: .075
-	}],
-	[/claude.*haiku/, {
-		input: 8e-4,
-		output: .004
-	}],
-	[/claude.*sonnet|claude-code|claude-sonnet/, {
-		input: .003,
-		output: .015
-	}],
-	[/gpt-4o-mini/, {
-		input: 15e-5,
-		output: 6e-4
-	}],
-	[/gpt-5|gpt-4\.1|o[134]\b/, {
-		input: .00125,
-		output: .01
-	}],
-	[/gpt-4o|gpt-4/, {
-		input: .0025,
-		output: .01
-	}],
-	[/deepseek/, {
-		input: 3e-4,
-		output: .0011
-	}],
-	[/glm|zhipu|zai/, {
-		input: 6e-4,
-		output: .0022
-	}],
-	[/kimi|moonshot/, {
-		input: 6e-4,
-		output: .0025
-	}],
-	[/qwen/, {
-		input: 4e-4,
-		output: .0012
-	}],
-	[/gemini.*flash/, {
-		input: 1e-4,
-		output: 4e-4
-	}],
-	[/gemini/, {
-		input: .00125,
-		output: .005
-	}],
-	[/llama/, {
-		input: 2e-4,
-		output: 6e-4
-	}]
-];
-/** Normalize a model id for pricing: drop `@snapshot` and trailing
-*  `-YYYY-MM-DD` dated-snapshot suffixes, lowercase, and return the complete
-*  id plus its final served-model segment for exact-row lookup. */
-function normalizedModelIds(model) {
-	const id = (model.split("@")[0] ?? model).trim().toLowerCase().replace(/-(?:19|20)\d{2}-\d{2}-\d{2}$/, "");
-	const finalSegment = id.slice(id.lastIndexOf("/") + 1);
-	return finalSegment === id ? [id] : [id, finalSegment];
-}
-/** Resolve pricing for a model id: exact table, then family fallback.
-*  Returns null when the id matches nothing (caller decides — never a
-*  silent-zero masquerading as a real $0 cost). */
-function resolveModelPricing(model) {
-	if (MODEL_PRICING[model]) return MODEL_PRICING[model];
-	const ids = normalizedModelIds(model);
-	for (const id of ids) if (MODEL_PRICING[id]) return MODEL_PRICING[id];
-	for (const [pattern, price] of FAMILY_PRICING) if (ids.some((id) => pattern.test(id))) return price;
-	return null;
-}
-/** True when `model` has known pricing: distinguishes a real $0 from unpriced. */
-function isModelPriced(model) {
-	return resolveModelPricing(model) !== null;
-}
-const warnedUnpricedModels = /* @__PURE__ */ new Set();
-/** Estimate token count from string length (chars / 4 approximation) */
-function estimateTokens(text) {
-	return Math.ceil(text.length / 4);
-}
-/** Calculate cost in USD from token counts and model. Unknown models warn once
-*  (not a silent zero) and return 0; cost-sensitive callers gate on {@link isModelPriced}. */
-function estimateCost(inputTokens, outputTokens, model) {
-	const pricing = resolveModelPricing(model);
-	if (!pricing) {
-		if (!warnedUnpricedModels.has(model)) {
-			warnedUnpricedModels.add(model);
-			console.warn(`estimateCost: no pricing for "${model}" — returning 0; add it to MODEL_PRICING`);
-		}
-		return 0;
-	}
-	return inputTokens / 1e3 * pricing.input + outputTokens / 1e3 * pricing.output;
-}
-export { resolveModelPricing as a, isModelPriced as i, estimateCost as n, estimateTokens as r, MODEL_PRICING as t };
-
-//# sourceMappingURL=metrics-zALlR17s.js.map

package/dist/metrics-zALlR17s.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metrics-zALlR17s.js","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["interface 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  // Router response-header rates observed for the exact served model on\n  // 2026-08-15. Keep this exact row ahead of the deliberately coarse family\n  // fallback so glm-5.3 campaign costs are not understated by ~2.5x.\n  'glm-5.3': { input: 0.00168, output: 0.00528 },\n  // Tangle Router's published rate (`GET /v1/models`) on 2026-10-09:\n  // $0.10 / $0.50 per Mtok. Exact, because the coarse gpt-5 family row would\n  // overstate it 12x on input and 20x on output.\n  'gpt-6-luna': { input: 0.0001, output: 0.0005 },\n  // Router receipts for the served id `gpt-5-mini-2025-08-07` solve exactly\n  // to $0.25 / $2 per Mtok; the gpt-5 family row is 5x too high.\n  'gpt-5-mini': { input: 0.00025, output: 0.002 },\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, none\n *  of which appear in the exact table above — without this they priced to a\n *  silent $0, blanking every cost/Pareto axis downstream. */\nconst FAMILY_PRICING: Array<[RegExp, TokenPrice]> = [\n  // OpenRouter stealth previews (`stealth/union-alpha`, …) bill $0 during\n  // their preview window. A real zero row lets the budget ledger admit them;\n  // an unpriced id is refused before the first call.\n  [/^stealth\\//, { input: 0, output: 0 }],\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 `@snapshot` and trailing\n *  `-YYYY-MM-DD` dated-snapshot suffixes, lowercase, and return the complete\n *  id plus its final served-model segment for exact-row lookup. */\nfunction normalizedModelIds(model: string): string[] {\n  const stripped = (model.split('@')[0] ?? model).trim().toLowerCase()\n  const id = stripped.replace(/-(?:19|20)\\d{2}-\\d{2}-\\d{2}$/, '')\n  const finalSegment = id.slice(id.lastIndexOf('/') + 1)\n  return finalSegment === id ? [id] : [id, finalSegment]\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 ids = normalizedModelIds(model)\n  for (const id of ids) {\n    if (MODEL_PRICING[id]) return MODEL_PRICING[id]\n  }\n  for (const [pattern, price] of FAMILY_PRICING) {\n    if (ids.some((id) => pattern.test(id))) return price\n  }\n  return null\n}\n\n/** True when `model` has known pricing: distinguishes a real $0 from unpriced. */\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 once\n *  (not a silent zero) and return 0; cost-sensitive callers 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(`estimateCost: no pricing for \"${model}\" — returning 0; add it to MODEL_PRICING`)\n    }\n    return 0\n  }\n  return (inputTokens / 1000) * pricing.input + (outputTokens / 1000) * pricing.output\n}\n"],"mappings":";;AAMA,MAAa,gBAA4C;CACvD,UAAU;EAAE,OAAO;EAAQ,QAAQ;CAAK;CACxC,eAAe;EAAE,OAAO;EAAS,QAAQ;CAAO;CAChD,eAAe;EAAE,OAAO;EAAM,QAAQ;CAAK;CAC3C,4BAA4B;EAAE,OAAO;EAAO,QAAQ;CAAM;CAC1D,0BAA0B;EAAE,OAAO;EAAO,QAAQ;CAAM;CACxD,2BAA2B;EAAE,OAAO;EAAS,QAAQ;CAAQ;CAI7D,WAAW;EAAE,OAAO;EAAS,QAAQ;CAAQ;CAI7C,cAAc;EAAE,OAAO;EAAQ,QAAQ;CAAO;CAG9C,cAAc;EAAE,OAAO;EAAS,QAAQ;CAAM;AAChD;;;;;;AAOA,MAAM,iBAA8C;CAIlD,CAAC,cAAc;EAAE,OAAO;EAAG,QAAQ;CAAE,CAAC;CACtC,CAAC,gBAAgB;EAAE,OAAO;EAAO,QAAQ;CAAM,CAAC;CAChD,CAAC,iBAAiB;EAAE,OAAO;EAAQ,QAAQ;CAAM,CAAC;CAClD,CAAC,4CAA4C;EAAE,OAAO;EAAO,QAAQ;CAAM,CAAC;CAC5E,CAAC,eAAe;EAAE,OAAO;EAAS,QAAQ;CAAO,CAAC;CAClD,CAAC,2BAA2B;EAAE,OAAO;EAAS,QAAQ;CAAK,CAAC;CAC5D,CAAC,gBAAgB;EAAE,OAAO;EAAQ,QAAQ;CAAK,CAAC;CAChD,CAAC,YAAY;EAAE,OAAO;EAAQ,QAAQ;CAAO,CAAC;CAC9C,CAAC,iBAAiB;EAAE,OAAO;EAAQ,QAAQ;CAAO,CAAC;CACnD,CAAC,iBAAiB;EAAE,OAAO;EAAQ,QAAQ;CAAO,CAAC;CACnD,CAAC,QAAQ;EAAE,OAAO;EAAQ,QAAQ;CAAO,CAAC;CAC1C,CAAC,iBAAiB;EAAE,OAAO;EAAQ,QAAQ;CAAO,CAAC;CACnD,CAAC,UAAU;EAAE,OAAO;EAAS,QAAQ;CAAM,CAAC;CAC5C,CAAC,SAAS;EAAE,OAAO;EAAQ,QAAQ;CAAO,CAAC;AAC7C;;;;AAKA,SAAS,mBAAmB,OAAyB;CAEnD,MAAM,MADY,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,MAAA,CAAO,KAAK,CAAC,CAAC,YACrC,CAAC,CAAC,QAAQ,gCAAgC,EAAE;CAC9D,MAAM,eAAe,GAAG,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;CACrD,OAAO,iBAAiB,KAAK,CAAC,EAAE,IAAI,CAAC,IAAI,YAAY;AACvD;;;;AAKA,SAAgB,oBAAoB,OAAkC;CACpE,IAAI,cAAc,QAAQ,OAAO,cAAc;CAC/C,MAAM,MAAM,mBAAmB,KAAK;CACpC,KAAK,MAAM,MAAM,KACf,IAAI,cAAc,KAAK,OAAO,cAAc;CAE9C,KAAK,MAAM,CAAC,SAAS,UAAU,gBAC7B,IAAI,IAAI,MAAM,OAAO,QAAQ,KAAK,EAAE,CAAC,GAAG,OAAO;CAEjD,OAAO;AACT;;AAGA,SAAgB,cAAc,OAAwB;CACpD,OAAO,oBAAoB,KAAK,MAAM;AACxC;AAEA,MAAM,uCAAuB,IAAI,IAAY;;AAG7C,SAAgB,eAAe,MAAsB;CACnD,OAAO,KAAK,KAAK,KAAK,SAAS,CAAC;AAClC;;;AAIA,SAAgB,aAAa,aAAqB,cAAsB,OAAuB;CAC7F,MAAM,UAAU,oBAAoB,KAAK;CACzC,IAAI,CAAC,SAAS;EACZ,IAAI,CAAC,qBAAqB,IAAI,KAAK,GAAG;GACpC,qBAAqB,IAAI,KAAK;GAC9B,QAAQ,KAAK,iCAAiC,MAAM,yCAAyC;EAC/F;EACA,OAAO;CACT;CACA,OAAQ,cAAc,MAAQ,QAAQ,QAAS,eAAe,MAAQ,QAAQ;AAChF"}