@tangle-network/agent-eval 0.136.0 → 0.138.0

package/dist/proposal-findings-DCawte-y.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"proposal-findings-DCawte-y.js","names":[],"sources":["../src/analyst/types.ts","../src/abort-signal.ts","../src/run-score.ts","../src/analyst/proposal-findings.ts"],"sourcesContent":["/**\n * Analyst contract — the missing orchestration layer over agent-eval's\n * existing analyzers (analyzeTraces, MultiLayerVerifier, RunCritic,\n * SemanticConceptJudge, JudgeFn, ...).\n *\n * Each existing primitive returns its own output shape. The Analyst\n * contract is the single envelope every primitive lifts into, so a\n * registry can run N analysts against a run and a single renderer can\n * compose findings without knowing which analyzer produced them.\n *\n * The contract is intentionally domain-agnostic: nothing here knows\n * about code, voice, RAG, or any particular agent stack. Analysts\n * declare what INPUT KIND they need (a trace store, an artifact dir,\n * a RunRecord, a JudgeInput, or `custom`), and the registry routes\n * the matching input from `AnalystRunInputs`.\n */\n\nimport { createHash } from 'node:crypto'\nimport type { CostLedgerHandle } from '../cost-ledger'\nimport type { RunCostProvenance, RunRecord, RunTokenUsage } from '../run-record'\nimport type { TraceAnalysisStore } from '../trace-analyst/store'\nimport type { JudgeInput } from '../types'\nimport type { ChatClient } from './chat-client'\n\n/**\n * Unified envelope every analyst emits. Schema-versioned so renderers\n * and time-series diffs survive future field additions.\n */\nexport interface AnalystFinding {\n  schema_version: '1.0.0'\n  /**\n   * Stable hash over identity-defining fields (analyst_id + canonical\n   * claim + area + optional subject). Two findings from two runs that\n   * \"are the same finding\" share this id — that's what `diffFindings`\n   * uses to compute appeared/disappeared sets across runs.\n   */\n  finding_id: string\n  analyst_id: string\n  produced_at: string\n  severity: AnalystSeverity\n  /**\n   * Coarse classification. Renderers group by this. Free-form so\n   * domain-specific analysts can introduce categories without a\n   * schema change ('agent-reasoning', 'verification', 'cost',\n   * 'tool-use', 'safety', 'latency', 'data-quality', ...).\n   */\n  area: string\n  claim: string\n  rationale?: string\n  evidence_refs: EvidenceRef[]\n  recommended_action?: string\n  validation_plan?: string\n  /** 0..1 — the analyst's own confidence. Not calibrated across analysts. */\n  confidence: number\n  /**\n   * Optional subject the finding is about — leaf id, agent id, request\n   * id. Included in finding_id when present so per-subject findings\n   * diff cleanly across runs.\n   */\n  subject?: string\n  /** True when this finding was lifted from a judge result rather than observed\n   *  directly in a trace or artifact. Descriptive only: proposal access is\n   *  controlled by `ProposalFinding.proposal_origin`. */\n  derived_from_judge?: boolean\n  /** Analyst-private extras; renderers ignore unless they know the analyst. */\n  metadata?: Record<string, unknown>\n}\n\nexport type AnalystSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info'\n\n/** Data sources that candidate generation may intentionally learn from. */\nexport type ProposalFindingOrigin = 'search' | 'production'\n\n/** A finding explicitly admitted as candidate-generation input. */\nexport type ProposalFinding = AnalystFinding & {\n  readonly proposal_origin: ProposalFindingOrigin\n}\n\nexport interface EvidenceRef {\n  /**\n   * Where the evidence lives. `span` and `event` refer to OTLP trace\n   * elements; `artifact` to a file inside the run's artifact tree;\n   * `finding` to another AnalystFinding (cross-analyst chaining);\n   * `metric` to a named scalar reading the renderer knows how to read.\n   */\n  kind: 'span' | 'event' | 'artifact' | 'finding' | 'metric'\n  uri: string\n  excerpt?: string\n}\n\n// ── Analyst contract ─────────────────────────────────────────────────\n\n/**\n * The discriminator the registry uses to pass the right input.\n * `custom` is the escape hatch — analysts that need something else\n * (e.g. an embedding cache, a partner SDK handle) read it from\n * `AnalystRunInputs.custom[<analyst id>]`.\n */\nexport type AnalystInputKind =\n  | 'trace-store'\n  | 'artifact-dir'\n  | 'run-record'\n  | 'judge-input'\n  | 'custom'\n\nexport interface AnalystCost {\n  /** `deterministic` analysts MUST NOT call the LLM. */\n  kind: 'deterministic' | 'llm'\n  /** Optional declared upper bound; the registry can enforce a budget. */\n  est_usd_per_run?: number\n  /** Models the analyst expects to use (informational). */\n  models?: string[]\n  /** Maximum post-cancellation wait for provider usage. Model analysts default to 5 seconds. */\n  settlement_timeout_ms?: number\n}\n\nexport interface AnalystRequirements {\n  /** Min number of shots / samples the analyst needs to produce signal. */\n  min_shots?: number\n  /** Capabilities the runtime must supply (e.g. ['network', 'gpu']). */\n  capabilities?: string[]\n}\n\n/**\n * What's passed to every analyst call. The registry resolves which\n * field the analyst's `inputKind` selects and asserts it's present.\n */\nexport interface AnalystRunInputs {\n  traceStore?: TraceAnalysisStore\n  artifactDir?: string\n  runRecord?: RunRecord\n  judgeInput?: JudgeInput\n  /** Keyed by analyst id; populated by callers that registered custom analysts. */\n  custom?: Record<string, unknown>\n}\n\nexport interface AnalystContext {\n  runId: string\n  /** Stable correlation id so logs from a single registry.run() share a tag. */\n  correlationId: string\n  /** Enforced wall-clock deadline (epoch ms). */\n  deadlineMs?: number\n  /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */\n  budgetUsd?: number\n  /** Shared paid-call account when the analyst runs inside a larger campaign. */\n  costLedger?: CostLedgerHandle\n  /** Attribution phase used when writing to the shared paid-call account. */\n  costPhase?: string\n  /**\n   * Shared chat client. Analysts that call an LLM go through this so\n   * the operator picks transport (sandbox-sdk | router | cli-bridge |\n   * direct-provider | mock) at the registry boundary without touching\n   * analyst code.\n   */\n  chat?: ChatClient\n  /**\n   * Findings from a prior run the operator wants the analyst to see as\n   * retrieval context. Kinds that take advantage of cross-run memory\n   * (failure-mode \"I saw this cluster last run\", knowledge-gap \"the wiki\n   * page I asked for is still missing\") render these into the actor's\n   * working set. Filtering is the operator's job: pass the slice that\n   * matches the analyst's id, or pass everything and let the kind\n   * filter. Empty / absent means no cross-run context.\n   */\n  priorFindings?: ReadonlyArray<AnalystFinding>\n  /**\n   * Findings emitted by analysts that completed earlier in this registry run.\n   * This is separate from `priorFindings`: upstream findings are dependency\n   * context for the current pass, while prior findings are cross-run memory.\n   * The registry populates this only when `RegistryRunOpts.chainFindings` is on.\n   */\n  upstreamFindings?: ReadonlyArray<AnalystFinding>\n  /**\n   * Report metered work independently of findings. This keeps an empty finding\n   * set from erasing token/cost telemetry. Multiple receipts are accumulated.\n   */\n  recordUsage?: (receipt: AnalystUsageReceipt) => void\n  /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */\n  tags?: Record<string, string>\n  /** Logger callback — analysts SHOULD prefer this over console.* for testability. */\n  log?: (msg: string, fields?: Record<string, unknown>) => void\n  /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */\n  signal?: AbortSignal\n}\n\n/**\n * The minimal contract. Concrete analysts can refine `TInput` so\n * implementations stay type-safe (e.g. a trace analyst's `TInput` is\n * `TraceAnalysisStore`); the registry passes the right field from\n * `AnalystRunInputs` based on `inputKind`.\n */\nexport interface Analyst<TInput = unknown> {\n  /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */\n  readonly id: string\n  /** Human-readable. One sentence. */\n  readonly description: string\n  readonly inputKind: AnalystInputKind\n  readonly cost: AnalystCost\n  readonly requires?: AnalystRequirements\n  /** Bump on breaking changes to claim wording or area so old finding_ids don't collide. */\n  readonly version: string\n  analyze(input: TInput, ctx: AnalystContext): Promise<AnalystFinding[]>\n}\n\n/** Metered work performed by one analyst call. */\nexport interface AnalystUsageReceipt {\n  /** Number of model-usage records observed at the provider boundary. */\n  calls: number | null\n  /** Null when the provider did not return token accounting. */\n  tokens: RunTokenUsage | null\n  /** Observed, estimated, or explicitly uncaptured dollar cost. */\n  cost: RunCostProvenance\n  /** Known lower bound when one or more calls have uncaptured cost. */\n  knownCostUsd?: number\n}\n\n// ── finding_id stability ─────────────────────────────────────────────\n\n/**\n * Compute the stable finding_id from the identity-defining fields.\n * Default implementation hashes {analyst_id, area, subject, normalized claim}.\n * Analysts that emit findings whose claim text varies per run (timestamps,\n * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,\n * or (b) move the variable part into `rationale`/`metadata` and keep the\n * `claim` static.\n */\nexport function computeFindingId(input: {\n  analyst_id: string\n  area: string\n  subject?: string\n  claim: string\n  /** Override the claim for hashing — use when the displayed claim has run-specific bits. */\n  id_basis?: string\n}): string {\n  const basis = JSON.stringify({\n    a: input.analyst_id,\n    r: input.area,\n    s: input.subject ?? '',\n    c: normalizeClaim(input.id_basis ?? input.claim),\n  })\n  return `f_${createHash('sha256').update(basis).digest('hex').slice(0, 20)}`\n}\n\nfunction normalizeClaim(c: string): string {\n  // Lowercase, collapse whitespace, strip trailing punctuation. Goal:\n  // \"Leaf X failed install\" and \"Leaf X failed install.\" hash the same.\n  return c\n    .toLowerCase()\n    .replace(/\\s+/g, ' ')\n    .replace(/[.!?;:,]+$/g, '')\n    .trim()\n}\n\n/**\n * Convenience factory: produce a fully-formed AnalystFinding with the\n * id computed automatically. Analyst code stays terse.\n */\nexport function makeFinding(\n  init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {\n    id_basis?: string\n    produced_at?: string\n  },\n): AnalystFinding {\n  const { id_basis, produced_at, ...rest } = init\n  return {\n    schema_version: '1.0.0',\n    finding_id: computeFindingId({\n      analyst_id: rest.analyst_id,\n      area: rest.area,\n      subject: rest.subject,\n      claim: rest.claim,\n      id_basis,\n    }),\n    produced_at: produced_at ?? new Date().toISOString(),\n    ...rest,\n  }\n}\n\n/** Build a finding whose source is explicitly allowed during candidate generation. */\nexport function makeProposalFinding(\n  init: Omit<ProposalFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {\n    id_basis?: string\n    produced_at?: string\n  },\n): ProposalFinding {\n  const { proposal_origin, ...finding } = init\n  return { ...makeFinding(finding), proposal_origin }\n}\n\n// ── Registry result envelope ────────────────────────────────────────\n\nexport interface AnalystRunSummary {\n  analyst_id: string\n  status: 'ok' | 'skipped' | 'failed'\n  /** Why skipped — missing input, budget exceeded, capability unmet. */\n  reason?: string\n  findings_count: number\n  latency_ms: number\n  /** Additive model usage and cost provenance for this analyst. */\n  usage: AnalystUsageReceipt\n  /** When `status='failed'`: the error class + message, never the full stack. */\n  error?: { class: string; message: string }\n}\n\nexport interface AnalystRunResult {\n  run_id: string\n  correlation_id: string\n  started_at: string\n  ended_at: string\n  findings: AnalystFinding[]\n  per_analyst: AnalystRunSummary[]\n  /** Total LLM cost in USD across all analysts in this registry.run(). */\n  total_cost_usd: number\n  /**\n   * Provenance for `total_cost_usd`. When uncaptured, the numeric field is only\n   * the known subtotal and must not be treated as the run's total spend.\n   */\n  total_cost_provenance?: RunCostProvenance\n}\n\n// ── Streaming event envelope ────────────────────────────────────────\n\n/**\n * Events emitted by `AnalystRegistry.runStream(...)` in real time as\n * the registry executes. UIs subscribe via `for await (const ev of\n * registry.runStream(...))`; `registry.run(...)` is a thin collector\n * over the same stream, so the two surfaces share their invariants.\n *\n * Per-finding events are intentionally omitted — analyzers are batch\n * operations (an Ax actor returns the full `findings:json[]` at the\n * end of the responder), so streaming inside one analyst would only\n * emit partial JSON consumers can't render. The kind-completion event\n * is the right granularity; subscribers wanting per-finding rendering\n * iterate `event.findings` themselves.\n */\nexport type AnalystRunEvent =\n  | {\n      type: 'run-started'\n      run_id: string\n      correlation_id: string\n      started_at: string\n      /** The ordered list of analyst ids the registry will run. */\n      analyst_ids: ReadonlyArray<string>\n    }\n  | {\n      type: 'analyst-skipped'\n      summary: AnalystRunSummary\n    }\n  | {\n      type: 'analyst-started'\n      analyst_id: string\n      started_at: string\n    }\n  | {\n      type: 'analyst-completed'\n      /** `summary.status` is `'ok'` for clean completion or `'failed'` for thrown analysts. */\n      summary: AnalystRunSummary\n      findings: ReadonlyArray<AnalystFinding>\n    }\n  | {\n      type: 'run-completed'\n      result: AnalystRunResult\n    }\n","/** Combine active cancellation sources without wrapping a single source. */\nexport function combineAbortSignals(\n  ...signals: Array<AbortSignal | undefined>\n): AbortSignal | undefined {\n  const active = [\n    ...new Set(signals.filter((signal): signal is AbortSignal => signal !== undefined)),\n  ]\n  if (active.length === 0) return undefined\n  if (active.length === 1) return active[0]\n  return AbortSignal.any(active)\n}\n","export interface RunScore {\n  success: number\n  goalProgress: number\n  repoGroundedness: number\n  driftPenalty: number\n  toolUseQuality: number\n  patchQuality: number\n  testReality: number\n  finalGate: number\n  reviewerBlockers: number\n  costUsd: number\n  wallSeconds: number\n  notes?: string[]\n}\n\nexport interface RunScoreWeights {\n  success: number\n  goalProgress: number\n  repoGroundedness: number\n  driftPenalty: number\n  toolUseQuality: number\n  patchQuality: number\n  testReality: number\n  finalGate: number\n  reviewerBlockers: number\n  costUsd: number\n  wallSeconds: number\n}\n\nexport const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights = {\n  success: 4,\n  goalProgress: 2,\n  repoGroundedness: 1.5,\n  driftPenalty: -1.5,\n  toolUseQuality: 1,\n  patchQuality: 1.25,\n  testReality: 1.5,\n  finalGate: 3,\n  reviewerBlockers: -2,\n  costUsd: -0.2,\n  wallSeconds: -0.1,\n}\n\nexport function aggregateRunScore(score: RunScore, weights: Partial<RunScoreWeights> = {}): number {\n  const w = { ...DEFAULT_RUN_SCORE_WEIGHTS, ...weights }\n  return (\n    w.success * clamp01(score.success) +\n    w.goalProgress * clamp01(score.goalProgress) +\n    w.repoGroundedness * clamp01(score.repoGroundedness) +\n    w.driftPenalty * clamp01(score.driftPenalty) +\n    w.toolUseQuality * clamp01(score.toolUseQuality) +\n    w.patchQuality * clamp01(score.patchQuality) +\n    w.testReality * clamp01(score.testReality) +\n    w.finalGate * clamp01(score.finalGate) +\n    w.reviewerBlockers * clamp01(score.reviewerBlockers) +\n    w.costUsd * Math.max(0, finiteOrZero(score.costUsd)) +\n    w.wallSeconds * Math.max(0, finiteOrZero(score.wallSeconds) / 60)\n  )\n}\n\nexport function clamp01(value: number): number {\n  if (!Number.isFinite(value)) return 0\n  return Math.max(0, Math.min(1, value))\n}\n\nfunction finiteOrZero(value: number): number {\n  return Number.isFinite(value) ? value : 0\n}\n","import { z } from 'zod'\nimport type { ProposalFinding } from './types'\n\nconst ProposalFindingSchema = z\n  .object({\n    schema_version: z.literal('1.0.0'),\n    finding_id: z.string().min(1),\n    analyst_id: z.string().min(1),\n    produced_at: z.string().min(1),\n    severity: z.enum(['critical', 'high', 'medium', 'low', 'info']),\n    area: z.string().min(1),\n    claim: z.string().min(1),\n    rationale: z.string().optional(),\n    evidence_refs: z.array(\n      z\n        .object({\n          kind: z.enum(['span', 'event', 'artifact', 'finding', 'metric']),\n          uri: z.string().min(1),\n          excerpt: z.string().optional(),\n        })\n        .strict(),\n    ),\n    recommended_action: z.string().optional(),\n    validation_plan: z.string().optional(),\n    confidence: z.number().min(0).max(1),\n    subject: z.string().optional(),\n    derived_from_judge: z.boolean().optional(),\n    metadata: z.record(z.string(), z.unknown()).optional(),\n    proposal_origin: z.enum(['search', 'production']),\n  })\n  .strict() satisfies z.ZodType<ProposalFinding>\n\n/** True when a finding names a source candidate generation may learn from. */\nexport function isProposalFinding(finding: unknown): finding is ProposalFinding {\n  return ProposalFindingSchema.safeParse(finding).success\n}\n\n/**\n * Reject findings whose source has not been explicitly admitted for candidate\n * generation. Search feedback and observed production behavior are allowed;\n * final evaluation data has no allowed origin.\n */\nexport function assertProposalFindings(\n  findings: unknown,\n  context = 'proposal findings',\n): ReadonlyArray<ProposalFinding> {\n  if (!Array.isArray(findings)) {\n    throw new TypeError(`${context}: expected an array`)\n  }\n  const rejected = findings.flatMap((finding, index) =>\n    isProposalFinding(finding) ? [] : [findingLabel(finding, index)],\n  )\n  if (rejected.length > 0) {\n    throw new Error(\n      `${context}: every finding must match AnalystFinding and declare ` +\n        `proposal_origin as search or production. ` +\n        `Rejected findings: [${rejected.join(', ')}].`,\n    )\n  }\n  return findings as ReadonlyArray<ProposalFinding>\n}\n\nfunction findingLabel(finding: unknown, index: number): string {\n  if (typeof finding !== 'object' || finding === null) return `index ${index}`\n  const id = (finding as { finding_id?: unknown }).finding_id\n  return typeof id === 'string' && id.length > 0 ? id : `index ${index}`\n}\n"],"mappings":"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"}

package/dist/raw-provider-sink-BU29Sh8h.d.ts

@@ -1,134 +0,0 @@
-//#region src/trace/raw-provider-sink.d.ts
-/**
- * RawProviderSink — first-class persistence for the actual HTTP-level
- * request/response bodies of every LLM provider call.
- *
- * Why this is a separate sink from the structured `LlmSpan`:
- *
- *   - `LlmSpan` records the *intent* — model name, messages, output text,
- *     usage. It's what dashboards read; it's NOT enough for forensics.
- *   - When a downstream consumer reports "the verifier used the wrong route"
- *     or "tokens look right but reasoning was missing," the only way to
- *     answer is the raw HTTP body. Span fields can lie (a proxy can echo
- *     a different `model` value than what actually answered); the raw
- *     response is ground truth.
- *
- * Default behaviour: opt-in. Pass `rawSink` to `LlmClientOptions` (or the
- * matrix runner / BuilderSession sets it up automatically) and every
- * request, response, and error is recorded — including retries, with the
- * attempt index attached so a flaky call's full event chain is recoverable.
- *
- * Redaction is enforced at sink time. The default redactor strips
- * `Authorization`, `X-Api-Key`, `X-Auth-Token`, `Cookie` headers and any
- * payload field whose key matches `apiKey | api_key | bearer | password |
- * secret | token` (case-insensitive). Override via the sink constructor or
- * the per-call `redactor`. The `redactedFields` array on the persisted
- * event lets a reviewer see what was stripped without exposing the values.
- */
-type RawProviderDirection = 'request' | 'response' | 'error';
-interface RawProviderEvent {
-  /** Stable id. Generated by the sink if omitted. */
-  eventId: string;
-  /** Trace context populated by `LlmClient` when the call is wrapped in a span. */
-  runId?: string;
-  spanId?: string;
-  /**
-   * Logical provider name. Free-form so callers can use whatever id matches
-   * their topology (`'openai'`, `'anthropic'`, `'tangle-router'`, …). When
-   * omitted, derived from `baseUrl` in `LlmClientOptions`.
-   */
-  provider: string;
-  model: string;
-  /** Endpoint path, e.g. `'/v1/chat/completions'`. */
-  endpoint: string;
-  /** Base URL used for the call (already-normalised — no trailing slash). */
-  baseUrl: string;
-  /** 0-indexed retry attempt. The first attempt is 0; a retried call gets 1, 2, … */
-  attemptIndex: number;
-  direction: RawProviderDirection;
-  /** Unix ms. */
-  timestamp: number;
-  /** Wall-clock duration of the call leg. Set on `response` and `error` events; null on `request`. */
-  durationMs?: number;
-  statusCode?: number;
-  requestHeaders?: Record<string, string>;
-  requestBody?: unknown;
-  responseHeaders?: Record<string, string>;
-  responseBody?: unknown;
-  /** Set on `direction: 'error'` events. */
-  errorMessage?: string;
-  /** Field paths the redactor stripped from this event ('header:Authorization', 'body.apiKey', …). */
-  redactedFields: string[];
-}
-interface RawProviderSinkFilter {
-  runId?: string;
-  spanId?: string;
-  direction?: RawProviderDirection;
-  attemptIndex?: number;
-}
-interface RawProviderSink {
-  record(event: RawProviderEvent): Promise<void>;
-  /** Optional listing — implementations that durably persist (file, db) should support this. */
-  list?(filter?: RawProviderSinkFilter): Promise<RawProviderEvent[]>;
-  /** Optional teardown for backed implementations. */
-  close?(): Promise<void>;
-}
-type ProviderRedactor = (event: RawProviderEvent) => RawProviderEvent;
-/**
- * Default redactor — strips well-known auth headers and any body field whose
- * key matches the credential pattern. Records every redacted path on
- * `event.redactedFields` so a downstream reviewer can see what was removed.
- */
-declare function defaultProviderRedactor(event: RawProviderEvent): RawProviderEvent;
-interface InMemoryRawProviderSinkOptions {
-  redactor?: ProviderRedactor;
-}
-declare class InMemoryRawProviderSink implements RawProviderSink {
-  private events;
-  private redactor;
-  constructor(opts?: InMemoryRawProviderSinkOptions);
-  record(event: RawProviderEvent): Promise<void>;
-  list(filter?: RawProviderSinkFilter): Promise<RawProviderEvent[]>;
-  size(): number;
-}
-declare class NoopRawProviderSink implements RawProviderSink {
-  record(): Promise<void>;
-  /**
-   * Returns an empty array. Implemented so `assertRunCaptured` does not
-   * trip the `no_raw_sink` issue when a caller explicitly opts out of
-   * capture by passing this sink — opt-out is a deliberate choice, not a
-   * misconfiguration.
-   */
-  list(): Promise<RawProviderEvent[]>;
-}
-interface FileSystemRawProviderSinkOptions {
-  /** Directory the NDJSON file is written into. Created if missing. */
-  dir: string;
-  /** File name; default `'raw-provider-events.ndjson'`. */
-  fileName?: string;
-  /** Bytes after which the writer rolls over to a new file (default 32 MiB). */
-  rollAtBytes?: number;
-  redactor?: ProviderRedactor;
-}
-declare class FileSystemRawProviderSink implements RawProviderSink {
-  private dir;
-  private fileName;
-  private rollAtBytes;
-  private redactor;
-  private bytesWritten;
-  private rollIndex;
-  private initPromise;
-  constructor(opts: FileSystemRawProviderSinkOptions);
-  private ensureInit;
-  private currentPath;
-  record(event: RawProviderEvent): Promise<void>;
-  list(filter?: RawProviderSinkFilter): Promise<RawProviderEvent[]>;
-}
-/**
- * Best-effort provider id from a base URL. Falls back to the URL host when
- * none of the well-known patterns match.
- */
-declare function providerFromBaseUrl(baseUrl: string): string;
-//#endregion
-export { NoopRawProviderSink as a, RawProviderEvent as c, defaultProviderRedactor as d, providerFromBaseUrl as f, InMemoryRawProviderSinkOptions as i, RawProviderSink as l, FileSystemRawProviderSinkOptions as n, ProviderRedactor as o, InMemoryRawProviderSink as r, RawProviderDirection as s, FileSystemRawProviderSink as t, RawProviderSinkFilter as u };
-//# sourceMappingURL=raw-provider-sink-BU29Sh8h.d.ts.map

package/dist/raw-provider-sink-BU29Sh8h.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"raw-provider-sink-BU29Sh8h.d.ts","names":[],"sources":["../src/trace/raw-provider-sink.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BY;UAEK;;EAEf;;EAEA;EACA;;;;;;EAMA;EACA;;EAEA;;EAEA;;EAEA;EACA,WAAW;;EAEX;;EAEA;EACA;EACA,iBAAiB;EACjB;EACA,kBAAkB;EAClB;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA,YAAY;EACZ;;UAGe;EACf,OAAO,OAAO,mBAAmB;;EAEjC,MAAM,SAAS,wBAAwB,QAAQ;;EAE/C,UAAU;;KAGA,oBAAoB,OAAO,qBAAqB;;;;;;iBAmB5C,wBAAwB,OAAO,mBAAmB;UA8CjD;EACf,WAAW;;cAGA,mCAAmC;UACtC;UACA;EAER,YAAY,OAAM;EAIZ,OAAO,OAAO,mBAAmB;EAIjC,KAAK,SAAQ,wBAA6B,QAAQ;EAUxD;;cAKW,+BAA+B;EACpC,UAAU;;;;;;;EASV,QAAQ,QAAQ;;UAOP;;EAEf;;EAEA;;EAEA;EACA,WAAW;;cAGA,qCAAqC;UACxC;UACA;UACA;UACA;UACA;UACA;UACA;EAER,YAAY,MAAM;UAOJ;UAON;EAKF,OAAO,OAAO,mBAAmB;EAYjC,KAAK,SAAQ,wBAA6B,QAAQ;;;;;;iBAkC1C,oBAAoB"}

package/dist/replay-BRfMIs81.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replay-BRfMIs81.d.ts","names":[],"sources":["../src/trace/otel.ts","../src/trace/otlp-attributes.ts","../src/trace/otel-export.ts","../src/trace/otel-bridge.ts","../src/trace/redact.ts","../src/trace/store-to-otlp.ts","../src/trace-analyst/hook.ts","../src/trace-analyst/insights.ts","../src/trace/otlp-flat.ts","../src/trace-analyst/otlp-flatten.ts","../src/trace-analyst/otlp-span.ts","../src/trace-analyst/otlp-to-run-records.ts","../src/trace-analyst/prompts.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/tools.ts","../src/replay.ts"],"mappings":"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"}

package/dist/replay-C6wRg47C.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"replay-C6wRg47C.js","names":["toAttributes","padSpanId","msToNs","padTraceId","padSpanId"],"sources":["../src/trace-analyst/hook.ts","../src/trace-analyst/insights.ts","../src/trace-analyst/otlp-flatten.ts","../src/trace-analyst/otlp-to-run-records.ts","../src/trace/capture-fetch.ts","../src/trace/otel.ts","../src/trace/otel-bridge.ts","../src/trace/otel-export.ts","../src/trace/store-to-otlp.ts","../src/replay.ts"],"sourcesContent":["/**\n * Trace-analyst auto-execution hook.\n *\n * Wires `analyzeTraces` into a `TraceEmitter`'s `onRunComplete` so a\n * direct matrix run produces an analysis artifact without an out-of-band\n * step. Designed for the case where the consumer reports \"the analyst\n * never ran\" — the cause is almost always orchestration, not the analyst.\n *\n * Usage:\n *\n *   const emitter = new TraceEmitter(store, {\n *     onRunComplete: [traceAnalystOnRunComplete({ analyze: opts, save })],\n *   })\n *\n * Hooks are best-effort by default — they never crash the underlying run.\n * The caller decides whether to gate the run on the analysis result via\n * the `gateOn` callback.\n */\n\nimport type { RunCompleteHook, RunCompleteHookContext } from '../trace/emitter'\nimport { type AnalyzeTracesOptions, type AnalyzeTracesResult, analyzeTraces } from './analyst'\n\nexport interface TraceAnalystHookOptions {\n  /**\n   * Options forwarded to `analyzeTraces`. The hook supplies the question\n   * if you don't pass one — defaulting to a launch-grade prompt that asks\n   * for failure modes, surprising findings, and a recommendation.\n   */\n  analyze: Omit<AnalyzeTracesOptions, 'source'> & { source?: AnalyzeTracesOptions['source'] }\n  /**\n   * Override the question. The default is intentionally generic:\n   * \"Summarise what happened in this run, surface any failure modes,\n   *  surprising findings, or evidence the verdict is wrong.\"\n   */\n  question?: string\n  /**\n   * Persist the result. The hook calls this with the analysis output and\n   * the run context. Common implementations write to a TraceAnalysisStore\n   * or append to a per-run JSONL.\n   */\n  save?: (result: AnalyzeTracesResult, ctx: RunCompleteHookContext) => Promise<void>\n  /**\n   * Predicate gating execution per run. Default: every completed run.\n   * Use to skip aborted runs, debug runs, or runs without LLM activity.\n   */\n  shouldRun?: (ctx: RunCompleteHookContext) => boolean\n  /**\n   * Optional gate: if set and returns false, the hook records the failure\n   * as a log event on the run instead of staying quiet. The caller can\n   * then trigger downstream alerts off `analyst_gate_failed` log events.\n   */\n  gateOn?: (result: AnalyzeTracesResult, ctx: RunCompleteHookContext) => boolean\n}\n\nconst DEFAULT_QUESTION =\n  \"Summarise what happened in this run. Surface any failure modes, surprising findings, or evidence that the run's verdict is wrong.\"\n\nexport function traceAnalystOnRunComplete(opts: TraceAnalystHookOptions): RunCompleteHook {\n  return async (ctx: RunCompleteHookContext) => {\n    if (opts.shouldRun && !opts.shouldRun(ctx)) return\n    const source = opts.analyze.source\n    if (source === undefined) {\n      // The analyst needs a source. If the caller didn't supply one we don't\n      // run — but we do leave a breadcrumb so the absence is visible.\n      await ctx.store.appendEvent({\n        eventId: `analyst-skip-${ctx.runId}`,\n        runId: ctx.runId,\n        kind: 'log',\n        timestamp: Date.now(),\n        payload: { source: 'trace_analyst_hook', reason: 'no source configured' },\n      })\n      return\n    }\n    const result = await analyzeTraces({ question: opts.question ?? DEFAULT_QUESTION }, {\n      ...opts.analyze,\n      source,\n    } as AnalyzeTracesOptions)\n    if (opts.save) await opts.save(result, ctx)\n    if (opts.gateOn && !opts.gateOn(result, ctx)) {\n      await ctx.store.appendEvent({\n        eventId: `analyst-gate-${ctx.runId}`,\n        runId: ctx.runId,\n        kind: 'log',\n        timestamp: Date.now(),\n        payload: {\n          source: 'trace_analyst_hook',\n          reason: 'analyst_gate_failed',\n          findings: result.findings,\n        },\n      })\n    }\n  }\n}\n","export interface TraceInsightTask {\n  id: string\n  name: string\n  prompt?: string\n  difficulty?: string\n  tags?: string[]\n  outcome?: string\n  score?: number\n  gaps?: string[]\n}\n\nexport interface TraceInsightSuite {\n  name: string\n  collectionId?: string\n  tasks: TraceInsightTask[]\n}\n\nexport interface TraceInsightFinding {\n  kind: string\n  severity?: string\n  taskIds: string[]\n  evidence?: string\n  proposedFixClass?: string\n}\n\nexport interface TraceInsightQuestion {\n  id: string\n  question: string\n  why: string\n}\n\nexport interface TraceInsightPanelRole {\n  id: string\n  name: string\n  responsibility: string\n}\n\nexport interface TraceInsightPromptInput {\n  suite: TraceInsightSuite\n  findings?: TraceInsightFinding[]\n  agent?: Record<string, unknown>\n  totals?: Record<string, unknown>\n  maxRepresentativeTraces?: number\n}\n\nexport interface TraceInsightContext {\n  suite: TraceInsightSuite\n  scope: string\n  keywords: string[]\n  questions: TraceInsightQuestion[]\n  panel: TraceInsightPanelRole[]\n  findings: TraceInsightFinding[]\n  agent: Record<string, unknown> | null\n  totals: Record<string, unknown> | null\n}\n\nexport interface TraceInsightQualityGate {\n  id: string\n  label: string\n  passed: boolean\n  severity: 'critical' | 'high' | 'medium' | 'low'\n  detail: string\n}\n\nexport interface TraceInsightReadiness {\n  score: number\n  grade: 'external-ready' | 'internal-review' | 'raw-analysis'\n  gates: TraceInsightQualityGate[]\n}\n\nconst DOMAIN_STOP_WORDS = new Set([\n  'and',\n  'advanced',\n  'app',\n  'build',\n  'create',\n  'easy',\n  'expert',\n  'extreme',\n  'for',\n  'from',\n  'hard',\n  'implementation',\n  'integrate',\n  'medium',\n  'project',\n  'task',\n  'the',\n  'this',\n  'with',\n  'workflow',\n])\n\nexport function tokenizeDomainWords(value: string): string[] {\n  return [...value.matchAll(/[A-Za-z][A-Za-z0-9.+#-]{2,}/g)]\n    .map((match) => match[0].toLowerCase())\n    .filter((word) => !DOMAIN_STOP_WORDS.has(word))\n}\n\nexport function inferDomainKeywords(suite: TraceInsightSuite): string[] {\n  const suiteWords = new Set(tokenizeDomainWords(`${suite.name} ${suite.collectionId ?? ''}`))\n  const source = [\n    suite.name,\n    suite.collectionId ?? '',\n    ...suite.tasks.flatMap((task) => [\n      task.id,\n      task.name,\n      task.prompt ?? '',\n      task.difficulty ?? '',\n      ...(task.tags ?? []),\n      ...(task.gaps ?? []),\n    ]),\n  ].join(' ')\n  const counts = new Map<string, number>()\n  for (const word of tokenizeDomainWords(source)) counts.set(word, (counts.get(word) ?? 0) + 1)\n  return [...counts.entries()]\n    .filter(([word, count]) => count >= 2 || suiteWords.has(word))\n    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))\n    .map(([word]) => word)\n    .slice(0, 18)\n}\n\nexport function domainEvidencePattern(keywords: string[]): RegExp {\n  const escaped = keywords\n    .filter((keyword) => keyword.length >= 3)\n    .map((keyword) => keyword.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'))\n  return escaped.length > 0\n    ? new RegExp(`(?<![A-Za-z0-9])(?:${escaped.join('|')})(?![A-Za-z0-9])`, 'i')\n    : /(?<![A-Za-z0-9])(?:sdk|api|css|dns|xml|provider|client|service|integration|webhook|transaction|auth|oauth|graphql|rest)(?![A-Za-z0-9])/i\n}\n\nexport function describeTraceInsightScope(suite: TraceInsightSuite): string {\n  const taskLabel =\n    suite.tasks.length === 1\n      ? '1 implementation task'\n      : `${suite.tasks.length} implementation tasks`\n  const tags = new Map<string, number>()\n  for (const task of suite.tasks) {\n    for (const tag of task.tags ?? []) tags.set(tag, (tags.get(tag) ?? 0) + 1)\n  }\n  const topTags = [...tags.entries()]\n    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))\n    .slice(0, 8)\n    .map(([tag]) => tag)\n  if (topTags.length > 0) return `${taskLabel} across ${topTags.join(', ')}.`\n  const difficulties = [\n    ...new Set(\n      suite.tasks.map((task) => task.difficulty).filter((value): value is string => Boolean(value)),\n    ),\n  ].join(', ')\n  return `${taskLabel} across ${difficulties || 'the selected benchmark scope'}.`\n}\n\nexport function planTraceInsightQuestions(input: TraceInsightPromptInput): TraceInsightQuestion[] {\n  const hasFailures = input.suite.tasks.some((task) => task.outcome && task.outcome !== 'satisfied')\n  const hasMultipleShots = input.suite.tasks.some((task) =>\n    (task.gaps ?? []).some((gap) => /shot|review|retry|continue/i.test(gap)),\n  )\n  const questions: TraceInsightQuestion[] = [\n    {\n      id: 'execution-path',\n      question: 'What did the worker actually do before the first meaningful implementation edit?',\n      why: 'Separates grounded execution from polished but shallow output.',\n    },\n    {\n      id: 'research-grounding',\n      question:\n        'Did the worker inspect docs, source, examples, or package references before committing to an implementation path?',\n      why: 'Identifies whether failures came from weak retrieval, weak examples, or premature coding.',\n    },\n    {\n      id: 'domain-proof',\n      question:\n        'Which tasks produced executable domain proof versus UI copy, placeholders, or inferred behavior?',\n      why: 'Keeps product-quality claims tied to concrete evidence.',\n    },\n    {\n      id: 'root-cause',\n      question:\n        'For each major failure cluster, is the likely root cause prompt/scaffold, docs/examples, SDK/API ergonomics, evaluator, runtime, or model behavior?',\n      why: 'Turns trace observations into actionable ownership.',\n    },\n    {\n      id: 'evidence-quality',\n      question:\n        'Which external-facing claims are directly supported by trace ids, span ids, verifier findings, reviewer notes, or generated code?',\n      why: 'Prevents unsupported customer-report conclusions.',\n    },\n  ]\n  if (hasMultipleShots) {\n    questions.push({\n      id: 'reviewer-lift',\n      question: 'Where did reviewer feedback improve score, stall, or regress across shots?',\n      why: 'Shows whether the driver loop is learning or merely repeating work.',\n    })\n  }\n  if (hasFailures) {\n    questions.push({\n      id: 'optimization-targets',\n      question:\n        'Which prompt, evaluator, scaffold, or workflow changes should feed the next GEPA/autoresearch optimization run?',\n      why: 'Connects benchmark evidence to the optimization loop.',\n    })\n  }\n  return questions\n}\n\nexport function buildTraceInsightContext(input: TraceInsightPromptInput): TraceInsightContext {\n  return {\n    suite: input.suite,\n    scope: describeTraceInsightScope(input.suite),\n    keywords: inferDomainKeywords(input.suite),\n    questions: planTraceInsightQuestions(input),\n    panel: defaultTraceInsightPanel(),\n    findings: input.findings ?? [],\n    agent: input.agent ?? null,\n    totals: input.totals ?? null,\n  }\n}\n\nexport function scoreTraceInsightReadiness(context: TraceInsightContext): TraceInsightReadiness {\n  const failedTasks = context.suite.tasks.filter(\n    (task) => task.outcome && task.outcome !== 'satisfied',\n  )\n  const findingTaskIds = new Set(context.findings.flatMap((finding) => finding.taskIds))\n  const failedTasksWithFindings = failedTasks.filter((task) => findingTaskIds.has(task.id))\n  const tasksWithGaps = context.suite.tasks.filter((task) => (task.gaps ?? []).length > 0)\n  const gates: TraceInsightQualityGate[] = [\n    {\n      id: 'domain-context',\n      label: 'Domain context inferred',\n      passed: context.keywords.length > 0,\n      severity: 'high',\n      detail:\n        context.keywords.length > 0\n          ? `${context.keywords.length} domain terms inferred: ${context.keywords.slice(0, 8).join(', ')}`\n          : 'No domain terms were inferred from suite, tasks, prompts, tags, or gaps.',\n    },\n    {\n      id: 'panel-coverage',\n      label: 'Analyst panel planned',\n      passed: context.panel.length >= 4 && context.questions.length >= 5,\n      severity: 'high',\n      detail: `${context.panel.length} panel roles and ${context.questions.length} investigation questions planned.`,\n    },\n    {\n      id: 'failure-coverage',\n      label: 'Failures mapped to findings',\n      passed:\n        failedTasks.length === 0 || failedTasksWithFindings.length / failedTasks.length >= 0.5,\n      severity: 'critical',\n      detail:\n        failedTasks.length === 0\n          ? 'No failed tasks in suite.'\n          : `${failedTasksWithFindings.length}/${failedTasks.length} failed tasks appear in finding clusters.`,\n    },\n    {\n      id: 'gap-evidence',\n      label: 'Task gaps captured',\n      passed: failedTasks.length === 0 || tasksWithGaps.length / failedTasks.length >= 0.5,\n      severity: 'medium',\n      detail: `${tasksWithGaps.length} tasks include explicit evaluator or analyst gaps.`,\n    },\n  ]\n  const penalty = gates.reduce((sum, gate) => {\n    if (gate.passed) return sum\n    if (gate.severity === 'critical') return sum + 35\n    if (gate.severity === 'high') return sum + 20\n    if (gate.severity === 'medium') return sum + 10\n    return sum + 5\n  }, 0)\n  const score = Math.max(0, Math.min(1, 1 - penalty / 100))\n  return {\n    score,\n    grade: score >= 0.9 ? 'external-ready' : score >= 0.7 ? 'internal-review' : 'raw-analysis',\n    gates,\n  }\n}\n\nexport function defaultTraceInsightPanel(): TraceInsightPanelRole[] {\n  return [\n    {\n      id: 'trace-forensics',\n      name: 'Trace Forensics',\n      responsibility:\n        'Reconstruct what the worker did in order, including research, edits, reviewer interventions, verifier feedback, and stop reason.',\n    },\n    {\n      id: 'root-cause',\n      name: 'Root Cause',\n      responsibility:\n        'Map failures to prompt/scaffold, docs/examples, SDK/API/product ergonomics, evaluator, runtime, or model behavior.',\n    },\n    {\n      id: 'optimization',\n      name: 'Optimization',\n      responsibility:\n        'Identify prompt, reviewer, evaluator, scaffold, and GEPA/autoresearch changes that should be tested next.',\n    },\n    {\n      id: 'external-evidence',\n      name: 'External Evidence',\n      responsibility:\n        'Separate customer-safe claims from internal harness findings and reject conclusions without task, trace, span, code, reviewer, or verifier evidence.',\n    },\n  ]\n}\n\nexport function buildTraceInsightPrompt(input: TraceInsightPromptInput): string {\n  const context = buildTraceInsightContext(input)\n  const maxRepresentativeTraces = input.maxRepresentativeTraces ?? 6\n  return `Analyze this benchmark run and produce evidence-backed trace intelligence.\n\nAudience:\n- internal AI/product leadership\n- possible customer-facing report for ${input.suite.name}\n\nInvestigation plan:\n${context.questions.map((item, index) => `${index + 1}. ${item.question} (${item.why})`).join('\\n')}\n\nAnalyst panel:\n${context.panel.map((role) => `- ${role.name}: ${role.responsibility}`).join('\\n')}\n\nIf the task branches are independent, use subagents for the panel roles above and aggregate their findings. Do not run a panel role unless its answer will change the final report.\n\nRequired output:\n1. Executive verdict: what this run proves and does not prove.\n2. The investigation questions you answered and the evidence used.\n3. Failure taxonomy: agent prompting, evaluator/harness, docs/examples, SDK/API/product integration, infra.\n4. Evidence-backed examples with trace ids/task ids and concrete verifier findings.\n5. Highest-ROI fixes for the benchmark harness, prompt/GEPA optimization, and customer-facing product/docs surface.\n6. What is safe for an external report versus what must stay internal.\n7. One rerun plan that would validate lift after optimization.\n\nBudget:\n- Inspect the dataset overview, the failure summary, and at most ${maxRepresentativeTraces} representative traces.\n- Prefer traces named in the failure summary over broad exploration.\n- Do not do exhaustive trace sweeps.\n- Return the final report as soon as the taxonomy and examples are supported.\n\nRun summary:\n${JSON.stringify(\n  {\n    suite: input.suite.name,\n    scope: context.scope,\n    inferredKeywords: context.keywords,\n    agent: context.agent,\n    totals: context.totals,\n    findings: context.findings.map((finding) => ({\n      kind: finding.kind,\n      severity: finding.severity,\n      taskCount: finding.taskIds.length,\n      proposedFixClass: finding.proposedFixClass,\n    })),\n    failures: input.suite.tasks\n      .filter((task) => task.outcome && task.outcome !== 'satisfied')\n      .map((task) => ({\n        task: task.id,\n        difficulty: task.difficulty,\n        outcome: task.outcome,\n        score: task.score,\n        gaps: task.gaps ?? [],\n      })),\n  },\n  null,\n  2,\n)}\n\nUse the trace tools. Do not invent facts. Cite task ids. Separate customer-facing claims from internal harness/model findings.`\n}\n","/**\n * `flattenOtlpExportToNdjson` — flatten an `OtlpExport` (the shape\n * `exportRunAsOtlp` produces) into the per-line JSON the analyst's\n * `OtlpFileTraceStore` index reads. Replaces three per-consumer OTLP\n * flatteners with one canonical projection.\n *\n * Pure function, no I/O — the caller does `.map(JSON.stringify).join('\\n')`\n * and writes the file (consumers want control over rotation + naming).\n */\n\nimport type { OtlpExport, OtlpSpan } from '../trace/otel'\nimport {\n  LLM_INPUT_TOKENS,\n  LLM_MODEL_NAME,\n  LLM_OUTPUT_TOKENS,\n  OPENINFERENCE_SPAN_KIND,\n  TOOL_NAME,\n} from '../trace/otlp-attributes'\nimport { createOtlpFlatLine, type OtlpFlatLine } from '../trace/otlp-flat'\n\nexport type { OtlpFlatLine } from '../trace/otlp-flat'\n\nexport interface FlattenOtlpOptions {\n  /** `'openinference'` (default) maps source per-span attributes into the\n   *  canonical OpenInference vocabulary the analyst readers consume. `'none'`\n   *  passes attributes through untouched. */\n  attributeVocabulary?: 'openinference' | 'none'\n  /** Override the numeric-kind → otlp-string mapping. */\n  kindMap?: Partial<Record<number, string>>\n}\n\nconst DEFAULT_KIND_MAP: Record<number, string> = {\n  0: 'SPAN_KIND_UNSPECIFIED',\n  1: 'SPAN_KIND_INTERNAL',\n  2: 'SPAN_KIND_SERVER',\n  3: 'SPAN_KIND_CLIENT',\n  4: 'SPAN_KIND_PRODUCER',\n  5: 'SPAN_KIND_CONSUMER',\n}\n\nconst STATUS_MAP: Record<number, OtlpFlatLine['status']['code']> = {\n  0: 'STATUS_CODE_UNSET',\n  1: 'STATUS_CODE_OK',\n  2: 'STATUS_CODE_ERROR',\n}\n\n/** Unwrap an OTLP attribute-value union to a scalar. */\nfunction attrValue(v: OtlpSpan['attributes'][number]['value']): string | number | boolean {\n  if (v.stringValue !== undefined) return v.stringValue\n  if (v.intValue !== undefined) return Number(v.intValue)\n  if (v.doubleValue !== undefined) return v.doubleValue\n  if (v.boolValue !== undefined) return v.boolValue\n  return ''\n}\n\nfunction attrsToRecord(attrs: OtlpSpan['attributes']): Record<string, string | number | boolean> {\n  const out: Record<string, string | number | boolean> = {}\n  for (const a of attrs) out[a.key] = attrValue(a.value)\n  return out\n}\n\nfunction nanoToIso(nano: string): string {\n  const ms = Number(nano) / 1_000_000\n  return Number.isFinite(ms) ? new Date(ms).toISOString() : new Date(0).toISOString()\n}\n\n/** Mirror selected attributes into the OpenInference vocabulary in place. */\nfunction applyOpenInference(attrs: Record<string, string | number | boolean>): void {\n  if ('llm.model' in attrs && !(LLM_MODEL_NAME in attrs)) {\n    attrs[LLM_MODEL_NAME] = attrs['llm.model']!\n  }\n  if ('llm.input_tokens' in attrs && !(LLM_INPUT_TOKENS in attrs)) {\n    attrs[LLM_INPUT_TOKENS] = attrs['llm.input_tokens']!\n  }\n  if ('inference.llm.input_tokens' in attrs && !(LLM_INPUT_TOKENS in attrs)) {\n    attrs[LLM_INPUT_TOKENS] = attrs['inference.llm.input_tokens']!\n  }\n  if ('llm.output_tokens' in attrs && !(LLM_OUTPUT_TOKENS in attrs)) {\n    attrs[LLM_OUTPUT_TOKENS] = attrs['llm.output_tokens']!\n  }\n  if ('inference.llm.output_tokens' in attrs && !(LLM_OUTPUT_TOKENS in attrs)) {\n    attrs[LLM_OUTPUT_TOKENS] = attrs['inference.llm.output_tokens']!\n  }\n  if (TOOL_NAME in attrs && !('inference.tool.name' in attrs)) {\n    attrs['inference.tool.name'] = attrs[TOOL_NAME]!\n  }\n  if ('span.kind' in attrs && !(OPENINFERENCE_SPAN_KIND in attrs)) {\n    attrs[OPENINFERENCE_SPAN_KIND] = String(attrs['span.kind']).toUpperCase()\n  }\n}\n\nexport function flattenOtlpExportToNdjson(\n  otlpExport: OtlpExport,\n  opts: FlattenOtlpOptions = {},\n): OtlpFlatLine[] {\n  const vocab = opts.attributeVocabulary ?? 'openinference'\n  const kindMap = { ...DEFAULT_KIND_MAP, ...opts.kindMap }\n  const lines: OtlpFlatLine[] = []\n\n  for (const rs of otlpExport.resourceSpans ?? []) {\n    const resource = { attributes: attrsToRecord(rs.resource?.attributes ?? []) }\n    for (const scope of rs.scopeSpans ?? []) {\n      for (const span of scope.spans ?? []) {\n        const attributes = attrsToRecord(span.attributes ?? [])\n        if (vocab === 'openinference') applyOpenInference(attributes)\n        const line = createOtlpFlatLine({\n          traceId: span.traceId,\n          spanId: span.spanId,\n          parentSpanId: span.parentSpanId ?? null,\n          name: span.name,\n          kind: kindMap[span.kind] ?? 'SPAN_KIND_UNSPECIFIED',\n          startTime: nanoToIso(span.startTimeUnixNano),\n          endTime: nanoToIso(span.endTimeUnixNano),\n          statusCode: STATUS_MAP[span.status?.code ?? 0] ?? 'STATUS_CODE_UNSET',\n          statusMessage: span.status?.message,\n          resource,\n          attributes,\n          events: span.events?.map((e) => ({\n            name: e.name,\n            timeUnixNano: e.timeUnixNano,\n            ...(e.attributes ? { attributes: attrsToRecord(e.attributes) } : {}),\n          })),\n        })\n        lines.push(line)\n      }\n    }\n  }\n\n  return lines\n}\n","/**\n * `otlpToRunRecords` — fold an OTLP traces.jsonl (one OTLP span per line;\n * the form AppWorld / HALO emit via their OpenInference OTLP exporter, the\n * same shape `flattenOtlpExportToNdjson` produces) into validated\n * `RunRecord[]` — one record per `trace_id` by default, or per caller-defined\n * logical run when one task is fragmented across multiple OTLP traces.\n *\n * This is the offline ingestion primitive the AppWorld proposer bench and the\n * hosted Intelligence product both stand on: traces in, paper-grade rows\n * out, ready for `compareOptimizationMethods` / `analyzeRuns` / the promotion gate.\n *\n * Aggregation per trace:\n *   - tokenUsage: reconcile input, output, cache-read, and cache-write across\n *     nested model-call wrappers without double-counting parent aggregates.\n *   - costUsd: reconcile complete observed model-call cost when present; else priced via\n *     `opts.priceUsdPerToken` from the aggregated tokens; else `null` with a\n *     loud `raw.cost_unpriced = 1` marker.\n *   - task failure class and detail: read from process-root\n *     `tangle.task.failure_*` attributes; malformed or conflicting values throw.\n *   - terminalFailureReason: the failed root's normalized status message,\n *     when one unambiguous root supplies terminal failure evidence.\n *   - terminalOutcome: reduced from root-span status only. Child tool errors\n *     remain visible in `error_span_count` and `execution_error_count` without\n *     changing the run outcome. Root, guardrail, evaluator, propagated, and\n *     unknown errors retain separate counters.\n *   - model: the dominant LLM model in the trace (snapshot-padded to satisfy\n *     `validateRunRecord` when the trace's model is a bare alias).\n *   - outcome score: `opts.scoreForTrace` (AppWorld `world.evaluate()` →\n *     TGC/SGC) when supplied. Traces without an external task-quality signal\n *     remain unlabeled; execution errors never become a task score.\n *   - prompt / completion: carried into `raw` as token-count signals and,\n *     when the first/last LLM span exposes `input.value` / `output.value`,\n *     the verbatim text is preserved on the optional `promptText` /\n *     `completionText` of the returned `OtlpTraceRunRecord`.\n *\n * Fail-loud: an OTLP file with zero valid spans throws. A trace with no\n * spans is impossible (a trace exists only because a span referenced it).\n * `validateRunRecord` runs on every row — a malformed projection throws\n * rather than silently producing a half-record.\n */\n\nimport {\n  type RunCostProvenance,\n  type RunRecord,\n  type RunSplitTag,\n  type RunTerminalOutcome,\n  type RunTokenUsage,\n  validateRunRecord,\n} from '../run-record'\nimport { summarizeTraceErrors, type TraceErrorRole } from '../trace/error-classification'\nimport {\n  type MeasurementCoverage,\n  recordAggregateMeasurements,\n  summarizeExecutionMeasurements,\n} from '../trace/execution-measurements'\nimport {\n  classifyOtlpSpanRole,\n  isOtlpModelCall,\n  LLM_MODEL_ATTR_KEYS,\n} from '../trace/otlp-attributes'\nimport { readTaskFailureLabels } from '../trace/task-failure-attributes'\nimport {\n  compareSpanTime,\n  firstStringAttr,\n  type ProjectedOtlpSpan,\n  projectOtlpFlatLine,\n  spanEpochMillis,\n} from './otlp-span'\n\nexport interface OtlpToRunRecordsOptions {\n  /** Logical experiment grouping for every produced record. */\n  experimentId: string\n  /** Candidate (variant) id — the surface these traces exercised. The\n   *  bench passes the proposer label here so `compareOptimizationMethods` can pair rows. */\n  candidateId: string\n  /** Split assignment for every produced record. Default `'holdout'` —\n   *  ingested traces are evidence, not the optimizer's training pool. */\n  splitTag?: RunSplitTag\n  /** Git SHA the traces were produced from. Default `'unknown'`. */\n  commitSha?: string\n  /** sha256 of the effective prompt surface. Default `'unknown'`. */\n  promptHash?: string\n  /** sha256 of the effective config. Default `'unknown'`. */\n  configHash?: string\n  /** RNG seed recorded on every row. Default 0. */\n  seed?: number\n  /**\n   * Fallback model snapshot when the trace exposes no LLM model attribute\n   * OR exposes a bare alias `validateRunRecord` would reject. The trace's\n   * own model wins when it already carries a snapshot. Default\n   * `'unknown@otlp'` (opaque-snapshot form the validator accepts).\n   */\n  fallbackModel?: string\n  /**\n   * USD per total token (input+output) used to price a trace when no\n   * per-span cost attribute is present. When unset, an unpriced trace\n   * records `costUsd: null` and `raw.cost_unpriced = 1`.\n   */\n  priceUsdPerToken?: number\n  /**\n   * Map each OTLP `trace_id` to the logical run it belongs to. Use this when a\n   * provider emits several traces for one task attempt. All mapped traces are\n   * aggregated into one record; duplicate span ids remain isolated by their\n   * source trace. The callback must return a non-empty id for every trace.\n   *\n   * When omitted, every `trace_id` remains an independent run.\n   */\n  logicalRunIdForTrace?: (traceId: string) => string\n  /**\n   * Score for a produced run's outcome (AppWorld `world.evaluate()` →\n   * TGC/SGC, or\n   * any [0,1] task-success signal). Keyed by the logical run id when\n   * `logicalRunIdForTrace` is supplied, otherwise by `trace_id`. When the map\n   * has no entry or the function returns undefined, the record remains\n   * unlabeled.\n   */\n  scoreForTrace?: (runId: string, span: TraceAggregate) => number | undefined\n  /**\n   * Per-record judge metadata when an external judge produced the score.\n   * Keyed by the logical run id when supplied, otherwise by `trace_id`.\n   */\n  judgeMetadataForTrace?: (runId: string) => RunRecord['judgeMetadata'] | undefined\n}\n\n/** A `RunRecord` plus the verbatim prompt/completion text when the trace's\n *  LLM spans exposed it. The text is NOT on the validated `RunRecord`\n *  (`outcome.raw` is numeric-only) but consumers ingesting full traces want\n *  it — so it rides alongside. */\nexport interface OtlpTraceRunRecord {\n  record: RunRecord\n  /** Verbatim first-LLM-span `input.value`, when present. */\n  promptText?: string\n  /** Verbatim last-LLM-span `output.value`, when present. */\n  completionText?: string\n}\n\n/** Per-trace rollup the score callback can inspect. */\nexport interface TraceAggregate {\n  traceId: string\n  /** Number of source OTLP traces folded into this run. */\n  sourceTraceCount: number\n  /** Source OTLP trace ids folded into this run, sorted for deterministic audit output. */\n  sourceTraceIds: readonly string[]\n  spanCount: number\n  llmSpanCount: number\n  toolSpanCount: number\n  agentSpanCount: number\n  errorSpanCount: number\n  executionErrorCount: number\n  processErrorCount: number\n  guardrailErrorCount: number\n  judgeErrorCount: number\n  propagatedErrorCount: number\n  unclassifiedErrorCount: number\n  tokenUsage: RunTokenUsage\n  /** First error span's normalized status message, if any. */\n  firstErrorMessage?: string\n  model: string\n  startTime: string\n  endTime: string\n  wallMs: number\n  /** Root-span terminal result. Child span errors do not change this value. */\n  terminalOutcome: RunTerminalOutcome\n}\n\ninterface AggregatedTrace extends TraceAggregate {\n  callSpanIds: string[]\n  costMeasurement: MeasurementCoverage\n  aggregateMeasurement?: ReturnType<typeof summarizeExecutionMeasurements>['aggregate']\n  terminalFailureMessage?: string\n}\n\n/**\n * Parse + aggregate an OTLP traces.jsonl string into validated\n * `RunRecord[]` (one per trace). Use {@link otlpToTraceRunRecords} when you\n * also want the verbatim prompt/completion text alongside each record.\n */\nexport function otlpToRunRecords(otlpJsonl: string, opts: OtlpToRunRecordsOptions): RunRecord[] {\n  return otlpToTraceRunRecords(otlpJsonl, opts).map((r) => r.record)\n}\n\n/**\n * Aggregate already-parsed OTLP flat rows without serializing them back to\n * JSONL. This is the in-memory counterpart to {@link otlpToRunRecords}; both\n * paths share projection, reconciliation, validation, and ordering.\n */\nexport function otlpRowsToRunRecords(\n  rows: Iterable<object>,\n  opts: OtlpToRunRecordsOptions,\n): RunRecord[] {\n  return otlpRowsToTraceRunRecords(rows, opts).map((row) => row.record)\n}\n\n/** As {@link otlpToRunRecords} but returns the prompt/completion text too. */\nexport function otlpToTraceRunRecords(\n  otlpJsonl: string,\n  opts: OtlpToRunRecordsOptions,\n): OtlpTraceRunRecord[] {\n  return traceRunRecordsFromSpans(\n    groupSpansByLogicalRun(groupJsonlSpansByTrace(otlpJsonl), opts.logicalRunIdForTrace),\n    opts,\n  )\n}\n\n/** Parsed-row counterpart to {@link otlpToTraceRunRecords}. */\nexport function otlpRowsToTraceRunRecords(\n  rows: Iterable<object>,\n  opts: OtlpToRunRecordsOptions,\n): OtlpTraceRunRecord[] {\n  return traceRunRecordsFromSpans(\n    groupSpansByLogicalRun(groupRowsByTrace(rows), opts.logicalRunIdForTrace),\n    opts,\n  )\n}\n\nfunction traceRunRecordsFromSpans(\n  byTrace: Map<string, ProjectedOtlpSpan[]>,\n  opts: OtlpToRunRecordsOptions,\n): OtlpTraceRunRecord[] {\n  const splitTag = opts.splitTag ?? 'holdout'\n  const commitSha = opts.commitSha ?? 'unknown'\n  const promptHash = opts.promptHash ?? 'unknown'\n  const configHash = opts.configHash ?? 'unknown'\n  const seed = opts.seed ?? 0\n  const fallbackModel = opts.fallbackModel ?? 'unknown@otlp'\n\n  if (byTrace.size === 0) {\n    throw new Error(\n      'otlpToRunRecords: OTLP input produced zero valid spans — every row was empty, malformed, or missing trace_id/span_id',\n    )\n  }\n\n  // Stable trace order (insertion order of first appearance is preserved by\n  // Map; sort by trace_id for determinism across producers).\n  const traceIds = [...byTrace.keys()].sort()\n  const out: OtlpTraceRunRecord[] = []\n\n  for (const traceId of traceIds) {\n    const spans = byTrace.get(traceId)!\n    const agg = aggregateTrace(traceId, spans, fallbackModel)\n\n    const score = resolveScore(opts, traceId, agg)\n    const { costUsd, costProvenance } = resolveCost(opts, agg)\n\n    const raw: Record<string, number> = {\n      source_trace_count: agg.sourceTraceCount,\n      span_count: agg.spanCount,\n      llm_span_count: agg.llmSpanCount,\n      tool_span_count: agg.toolSpanCount,\n      agent_span_count: agg.agentSpanCount,\n      error_span_count: agg.errorSpanCount,\n      execution_error_count: agg.executionErrorCount,\n      process_error_count: agg.processErrorCount,\n      guardrail_error_count: agg.guardrailErrorCount,\n      judge_error_count: agg.judgeErrorCount,\n      propagated_error_count: agg.propagatedErrorCount,\n      unclassified_error_count: agg.unclassifiedErrorCount,\n      prompt_tokens: agg.tokenUsage.input,\n      completion_tokens: agg.tokenUsage.output,\n    }\n    if (agg.tokenUsage.reasoning !== undefined) raw.reasoning_tokens = agg.tokenUsage.reasoning\n    if (agg.tokenUsage.cached !== undefined) raw.cached_tokens = agg.tokenUsage.cached\n    if (agg.tokenUsage.cacheWrite !== undefined) {\n      raw.cache_write_tokens = agg.tokenUsage.cacheWrite\n    }\n    if (agg.costMeasurement.value !== undefined && !agg.costMeasurement.complete) {\n      raw.partial_observed_cost_usd = agg.costMeasurement.value\n    }\n    recordAggregateMeasurements(raw, agg.aggregateMeasurement)\n    if (costProvenance.kind === 'uncaptured') raw.cost_unpriced = 1\n\n    const outcome: RunRecord['outcome'] = { raw }\n    if (score !== undefined) {\n      if (splitTag === 'holdout') outcome.holdoutScore = score\n      else outcome.searchScore = score\n    }\n\n    const { promptText, completionText } = extractPromptCompletion(spans, agg.callSpanIds)\n    const judgeMetadata = opts.judgeMetadataForTrace?.(traceId)\n    const taskFailure = readTaskFailureLabels(\n      spans.filter((span) => span.parent_span_id === null && isTerminalRootCandidate(span)),\n      `otlpToRunRecords: run '${traceId}'`,\n    )\n\n    const record = validateRunRecord({\n      runId: `otlp:${opts.experimentId}:${opts.candidateId}:${traceId}`,\n      experimentId: opts.experimentId,\n      candidateId: opts.candidateId,\n      seed,\n      model: ensureSnapshot(agg.model, fallbackModel),\n      promptHash,\n      configHash,\n      commitSha,\n      wallMs: agg.wallMs,\n      costUsd,\n      costProvenance,\n      tokenUsage: agg.tokenUsage,\n      terminalOutcome: agg.terminalOutcome,\n      ...(agg.terminalFailureMessage ? { terminalFailureReason: agg.terminalFailureMessage } : {}),\n      ...(judgeMetadata ? { judgeMetadata } : {}),\n      outcome,\n      ...taskFailure,\n      splitTag,\n      scenarioId: traceId,\n    })\n\n    out.push({\n      record,\n      ...(promptText !== undefined ? { promptText } : {}),\n      ...(completionText !== undefined ? { completionText } : {}),\n    })\n  }\n\n  return out\n}\n\n// ── Internals ──────────────────────────────────────────────────────────\n\nfunction* yieldJsonlRows(otlpJsonl: string): Iterable<Record<string, unknown>> {\n  for (const line of otlpJsonl.split('\\n')) {\n    const trimmed = line.trim()\n    if (trimmed.length === 0) continue\n    let parsed: unknown\n    try {\n      parsed = JSON.parse(trimmed)\n    } catch {\n      // Tolerate a stray malformed line — mirrors the store's index, which\n      // skips unparseable lines rather than nuking a whole dataset. A file\n      // that is ENTIRELY malformed still throws (zero valid spans).\n      continue\n    }\n    if (parsed && typeof parsed === 'object') yield parsed as Record<string, unknown>\n  }\n}\n\nfunction groupJsonlSpansByTrace(otlpJsonl: string): Map<string, ProjectedOtlpSpan[]> {\n  return groupRowsByTrace(yieldJsonlRows(otlpJsonl))\n}\n\nfunction groupRowsByTrace(rows: Iterable<object>): Map<string, ProjectedOtlpSpan[]> {\n  const byTrace = new Map<string, ProjectedOtlpSpan[]>()\n  for (const row of rows) {\n    if (!row || typeof row !== 'object') continue\n    const span = projectOtlpFlatLine(row as Record<string, unknown>)\n    if (!span) continue\n    const arr = byTrace.get(span.trace_id)\n    if (arr) arr.push(span)\n    else byTrace.set(span.trace_id, [span])\n  }\n  return byTrace\n}\n\nfunction groupSpansByLogicalRun(\n  byTrace: Map<string, ProjectedOtlpSpan[]>,\n  logicalRunIdForTrace: OtlpToRunRecordsOptions['logicalRunIdForTrace'],\n): Map<string, ProjectedOtlpSpan[]> {\n  if (!logicalRunIdForTrace) return byTrace\n\n  const byRun = new Map<string, ProjectedOtlpSpan[]>()\n  for (const [traceId, spans] of byTrace) {\n    const suppliedRunId = logicalRunIdForTrace(traceId)\n    if (typeof suppliedRunId !== 'string' || suppliedRunId.trim().length === 0) {\n      throw new Error(\n        `otlpToRunRecords: logicalRunIdForTrace('${traceId}') returned an empty run id`,\n      )\n    }\n    const runId = suppliedRunId.trim()\n    const target = byRun.get(runId) ?? []\n    for (const span of spans) {\n      target.push({\n        ...span,\n        span_id: qualifySpanId(traceId, span.span_id),\n        parent_span_id: span.parent_span_id ? qualifySpanId(traceId, span.parent_span_id) : null,\n      })\n    }\n    byRun.set(runId, target)\n  }\n  return byRun\n}\n\nfunction qualifySpanId(traceId: string, spanId: string): string {\n  const prefix = `${traceId}:`\n  return spanId.startsWith(prefix) ? spanId : `${prefix}${spanId}`\n}\n\nfunction aggregateTrace(\n  traceId: string,\n  spans: ProjectedOtlpSpan[],\n  fallbackModel: string,\n): AggregatedTrace {\n  // Span order within a trace is by start time (epoch-aware across ISO/epoch\n  // dialects), then a stable tiebreak.\n  const ordered = [...spans].sort(\n    (a, b) => compareSpanTime(a.start_time, b.start_time) || a.span_id.localeCompare(b.span_id),\n  )\n\n  const measurements = summarizeExecutionMeasurements(\n    ordered.map((span) => ({\n      id: span.span_id,\n      ...(span.parent_span_id ? { parentId: span.parent_span_id } : {}),\n      attributes: span.attributes,\n      modelCall: isOtlpModelCall({\n        kind: span.kind,\n        name: span.name,\n        attributes: span.attributes,\n      }),\n      aggregate: span.kind !== 'LLM' && span.kind !== 'UNKNOWN',\n    })),\n  )\n  let toolSpanCount = 0\n  let agentSpanCount = 0\n  let firstErrorMessage: string | undefined\n  const modelVotes = new Map<string, number>()\n  let earliest = ordered[0]?.start_time ?? ''\n  let latest = ordered[0]?.end_time ?? ''\n\n  for (const s of ordered) {\n    if (s.start_time && (!earliest || compareSpanTime(s.start_time, earliest) < 0))\n      earliest = s.start_time\n    if (s.end_time && (!latest || compareSpanTime(s.end_time, latest) > 0)) latest = s.end_time\n\n    if (s.kind === 'TOOL') {\n      toolSpanCount += 1\n    } else if (s.kind === 'AGENT') {\n      agentSpanCount += 1\n    }\n\n    if (s.status === 'ERROR') {\n      if (firstErrorMessage === undefined) {\n        firstErrorMessage = (s.status_message ?? `${s.name} — STATUS_CODE_ERROR`).slice(0, 500)\n      }\n    }\n  }\n\n  const callSpanIds = new Set(measurements.callSpanIds)\n  for (const span of ordered) {\n    if (!callSpanIds.has(span.span_id)) continue\n    const model = firstStringAttr(span.attributes, LLM_MODEL_ATTR_KEYS) ?? span.model_name\n    if (model) modelVotes.set(model, (modelVotes.get(model) ?? 0) + 1)\n  }\n\n  // Dominant model across LLM spans; falls back to any model attribute on a\n  // non-LLM span, then the supplied fallback snapshot.\n  const model = topVote(modelVotes) ?? firstModelAttr(ordered) ?? fallbackModel\n\n  let wallMs = 0\n  // epoch-aware: Date.parse returns NaN for a bare epoch-millis string, which\n  // silently zeroed wallMs for traces emitted with epoch timestamps.\n  const a = spanEpochMillis(earliest)\n  const b = spanEpochMillis(latest)\n  if (a !== null && b !== null) wallMs = Math.max(0, b - a)\n\n  const sourceTraceIds = [...new Set(spans.map((span) => span.trace_id))].sort()\n\n  const terminal = terminalEvidenceFromRoots(ordered)\n  const errorSummary = summarizeTraceErrors(\n    ordered.map((span) => ({\n      id: span.span_id,\n      ...(span.parent_span_id ? { parentId: span.parent_span_id } : {}),\n      role: errorRoleForProjectedSpan(span),\n      error: span.status === 'ERROR',\n      processRoot: span.parent_span_id === null && isTerminalRootCandidate(span),\n    })),\n  )\n  return {\n    traceId,\n    sourceTraceCount: sourceTraceIds.length,\n    sourceTraceIds,\n    spanCount: spans.length,\n    llmSpanCount: measurements.modelCallCount,\n    toolSpanCount,\n    agentSpanCount,\n    errorSpanCount: errorSummary.total,\n    executionErrorCount: errorSummary.execution,\n    processErrorCount: errorSummary.process,\n    guardrailErrorCount: errorSummary.guardrail,\n    judgeErrorCount: errorSummary.evaluation,\n    propagatedErrorCount: errorSummary.propagated,\n    unclassifiedErrorCount: errorSummary.unclassified,\n    tokenUsage: measurements.tokenUsage,\n    firstErrorMessage,\n    model,\n    startTime: earliest,\n    endTime: latest,\n    wallMs,\n    terminalOutcome: terminal.outcome,\n    ...(terminal.failureMessage ? { terminalFailureMessage: terminal.failureMessage } : {}),\n    callSpanIds: measurements.callSpanIds,\n    costMeasurement: measurements.cost,\n    ...(measurements.aggregate ? { aggregateMeasurement: measurements.aggregate } : {}),\n  }\n}\n\nfunction terminalEvidenceFromRoots(spans: ProjectedOtlpSpan[]): {\n  outcome: RunTerminalOutcome\n  failureMessage?: string\n} {\n  const roots = spans.filter(\n    (span) => span.parent_span_id === null && isTerminalRootCandidate(span),\n  )\n  if (roots.length !== 1) return { outcome: 'unknown' }\n  const root = roots[0]!\n  if (root.status === 'ERROR') {\n    return {\n      outcome: 'failed',\n      failureMessage: (root.status_message ?? `${root.name} — STATUS_CODE_ERROR`).slice(0, 500),\n    }\n  }\n  if (root.status === 'OK') return { outcome: 'succeeded' }\n  return { outcome: 'unknown' }\n}\n\nfunction isTerminalRootCandidate(span: ProjectedOtlpSpan): boolean {\n  const role = errorRoleForProjectedSpan(span)\n  return role !== 'LLM' && role !== 'TOOL' && role !== 'EVALUATOR' && role !== 'GUARDRAIL'\n}\n\nfunction errorRoleForProjectedSpan(span: ProjectedOtlpSpan): TraceErrorRole {\n  return classifyOtlpSpanRole({\n    kind: span.kind,\n    name: span.name,\n    attributes: span.attributes,\n  })\n}\n\nfunction resolveScore(\n  opts: OtlpToRunRecordsOptions,\n  traceId: string,\n  agg: TraceAggregate,\n): number | undefined {\n  const supplied = opts.scoreForTrace?.(traceId, agg)\n  if (supplied !== undefined) {\n    if (!Number.isFinite(supplied)) {\n      throw new Error(\n        `otlpToRunRecords: scoreForTrace('${traceId}') returned non-finite ${supplied}`,\n      )\n    }\n    return supplied\n  }\n  return undefined\n}\n\nfunction resolveCost(\n  opts: OtlpToRunRecordsOptions,\n  agg: AggregatedTrace,\n): { costUsd: number | null; costProvenance: RunCostProvenance } {\n  const observedCost = agg.costMeasurement\n  if (observedCost.complete && observedCost.value !== undefined) {\n    return {\n      costUsd: observedCost.value,\n      costProvenance: { kind: 'observed', usd: observedCost.value },\n    }\n  }\n  if (agg.aggregateMeasurement?.costUsd !== undefined) {\n    return {\n      costUsd: agg.aggregateMeasurement.costUsd,\n      costProvenance: { kind: 'observed', usd: agg.aggregateMeasurement.costUsd },\n    }\n  }\n\n  if (opts.priceUsdPerToken !== undefined) {\n    const totalTokens = agg.tokenUsage.input + agg.tokenUsage.output\n    const costUsd = totalTokens * opts.priceUsdPerToken\n    return { costUsd, costProvenance: { kind: 'estimated', usd: costUsd } }\n  }\n\n  return { costUsd: null, costProvenance: { kind: 'uncaptured', usd: null } }\n}\n\nfunction extractPromptCompletion(\n  spans: ProjectedOtlpSpan[],\n  callSpanIds: string[],\n): {\n  promptText?: string\n  completionText?: string\n} {\n  const callIds = new Set(callSpanIds)\n  const measuredCalls = spans.filter((span) => callIds.has(span.span_id))\n  const llm = (\n    measuredCalls.length > 0 ? measuredCalls : spans.filter((s) => s.kind === 'LLM')\n  ).sort(\n    (a, b) => compareSpanTime(a.start_time, b.start_time) || a.span_id.localeCompare(b.span_id),\n  )\n  if (llm.length === 0) return {}\n  const promptText =\n    firstStringAttr(llm[0]!.attributes, ['input.value', 'llm.input_messages', 'gen_ai.prompt']) ??\n    undefined\n  const last = llm[llm.length - 1]!\n  const completionText =\n    firstStringAttr(last.attributes, [\n      'output.value',\n      'llm.output_messages',\n      'gen_ai.completion',\n    ]) ?? undefined\n  return {\n    ...(promptText !== undefined ? { promptText } : {}),\n    ...(completionText !== undefined ? { completionText } : {}),\n  }\n}\n\nfunction topVote(votes: Map<string, number>): string | null {\n  let best: string | null = null\n  let bestN = 0\n  for (const [k, n] of votes) {\n    // Strict > keeps the higher count; lexicographic tie-break makes the winner\n    // independent of Map insertion order (reproducible across producers).\n    if (n > bestN || (n === bestN && best !== null && k < best)) {\n      best = k\n      bestN = n\n    }\n  }\n  return best\n}\n\nfunction firstModelAttr(spans: ProjectedOtlpSpan[]): string | null {\n  for (const s of spans) {\n    const m = firstStringAttr(s.attributes, LLM_MODEL_ATTR_KEYS) ?? s.model_name\n    if (m) return m\n  }\n  return null\n}\n\n/**\n * `validateRunRecord` rejects bare model aliases (`gpt-4o`) that remap\n * silently. AppWorld/HALO traces frequently carry such bare ids (or a null\n * model). When the model already encodes a snapshot we keep it; otherwise we\n * append the fallback snapshot token so the row is admissible without lying\n * about the model — the bare base name is preserved verbatim before `@`.\n */\nfunction ensureSnapshot(model: string, fallbackModel: string): string {\n  if (modelHasSnapshot(model)) return model\n  const fallbackTag = fallbackModel.includes('@')\n    ? fallbackModel.slice(fallbackModel.indexOf('@'))\n    : '@otlp'\n  return `${model}${fallbackTag}`\n}\n\nfunction modelHasSnapshot(model: string): boolean {\n  if (model.includes('@')) return true\n  if (/-\\d{8}$/.test(model)) return true\n  if (/-\\d{4}-\\d{2}-\\d{2}$/.test(model)) return true\n  if (/:date-/.test(model)) return true\n  return false\n}\n","/**\n * Wrap a provider `fetch` and record request, response, and error events.\n *\n * The returned value is a plain `typeof fetch`. Capture is best-effort by\n * default; set `failClosed` when telemetry loss must stop the provider call.\n */\n\nimport {\n  type ExtractedUsage,\n  extractUsage,\n  extractUsageFromSse,\n  type SseUsageMode,\n} from './extract-usage'\nimport {\n  defaultProviderRedactor,\n  type ProviderRedactor,\n  providerFromBaseUrl,\n  type RawProviderDirection,\n  type RawProviderEvent,\n  type RawProviderSink,\n} from './raw-provider-sink'\n\nexport interface CaptureFetchContext {\n  /** Logical run id stamped on every captured event. Required — without it\n   *  the raw events can't be paired with their parent `Run`. */\n  runId: string\n  /** Optional logical span id (enables span-level sink filtering). */\n  spanId?: string\n  /** Resolved base URL (normalised, no trailing slash). Used for the event's\n   *  `baseUrl` and for endpoint-path extraction. */\n  baseUrl: string\n  /** Model id the caller intends to invoke. Stamped on every event. */\n  model: string\n  /** Provider override. When omitted, `providerFromBaseUrl(baseUrl)`. */\n  provider?: string\n}\n\nexport interface CaptureFetchOptions {\n  /** Override the capture-time redactor. Default `defaultProviderRedactor`. */\n  redactor?: ProviderRedactor\n  /** Cap on captured response-body bytes; beyond it the body is truncated and\n   *  `body_truncated` is added to `redactedFields`. Default 2 MiB. */\n  responseBodyByteCap?: number\n  /** When true, a sink-write failure propagates to the caller. Default false\n   *  — capture is best-effort so a sink failure never kills the LLM call. */\n  failClosed?: boolean\n  /**\n   * Invoked with the token usage parsed off each successful response (JSON or\n   * SSE), keyed by the captured context. Lets a caller fold usage → cost without\n   * re-cloning the response themselves. Not called when the response carries no\n   * usage. Best-effort: a throw here is swallowed (it never kills the LLM call)\n   * unless `failClosed` is set.\n   */\n  onUsage?: (usage: ExtractedUsage, ctx: CaptureFetchContext) => void\n  /** How repeated SSE usage events should be reconciled. Default `cumulative`. */\n  sseUsageMode?: SseUsageMode\n}\n\nconst DEFAULT_BODY_CAP = 2 * 1024 * 1024\n\nfunction headersToRecord(headers: Headers | undefined): Record<string, string> | undefined {\n  if (!headers) return undefined\n  const out: Record<string, string> = {}\n  headers.forEach((value, key) => {\n    out[key.toLowerCase()] = value\n  })\n  return Object.keys(out).length > 0 ? out : undefined\n}\n\nfunction parseMaybeJson(text: string): unknown {\n  if (text.length === 0) return undefined\n  try {\n    return JSON.parse(text)\n  } catch {\n    return text\n  }\n}\n\n/** Best-effort request-body read across the `fetch` input forms. */\nasync function readRequestBody(\n  input: RequestInfo | URL,\n  init: RequestInit | undefined,\n): Promise<unknown> {\n  if (typeof init?.body === 'string') return parseMaybeJson(init.body)\n  if (init?.body != null) return undefined // streams / FormData / Blob — not captured\n  if (input instanceof Request) {\n    try {\n      return parseMaybeJson(await input.clone().text())\n    } catch {\n      return undefined\n    }\n  }\n  return undefined\n}\n\nfunction endpointFromUrl(url: string, baseUrl: string): string {\n  const normalisedBase = baseUrl.replace(/\\/+$/, '')\n  if (url.startsWith(normalisedBase)) return url.slice(normalisedBase.length) || '/'\n  try {\n    return new URL(url).pathname\n  } catch {\n    return url\n  }\n}\n\nexport function captureFetchToRawSink(\n  fetch: typeof globalThis.fetch,\n  sink: RawProviderSink,\n  ctx: CaptureFetchContext,\n  opts: CaptureFetchOptions = {},\n): typeof globalThis.fetch {\n  const provider = ctx.provider ?? providerFromBaseUrl(ctx.baseUrl)\n  const redactor = opts.redactor ?? defaultProviderRedactor\n  const bodyCap = opts.responseBodyByteCap ?? DEFAULT_BODY_CAP\n  let warned = false\n\n  const baseEvent = (direction: RawProviderDirection, endpoint: string): RawProviderEvent => ({\n    eventId: crypto.randomUUID(),\n    runId: ctx.runId,\n    spanId: ctx.spanId,\n    provider,\n    model: ctx.model,\n    endpoint,\n    baseUrl: ctx.baseUrl,\n    attemptIndex: 0, // retries are re-invocations one layer up; documented in 0.x\n    direction,\n    timestamp: Date.now(),\n    redactedFields: [],\n  })\n\n  const record = async (event: RawProviderEvent): Promise<void> => {\n    try {\n      await sink.record(redactor(event))\n    } catch (err) {\n      if (opts.failClosed) throw err\n      if (!warned) {\n        warned = true\n        console.warn(\n          `captureFetchToRawSink: sink.record failed (capture is best-effort) — ${\n            err instanceof Error ? err.message : String(err)\n          }`,\n        )\n      }\n    }\n  }\n\n  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {\n    const url =\n      typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url\n    const method = (init?.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase()\n    const endpoint = endpointFromUrl(url, ctx.baseUrl)\n\n    const reqHeaders = new Headers(\n      init?.headers ?? (input instanceof Request ? input.headers : undefined),\n    )\n    await record({\n      ...baseEvent('request', endpoint),\n      requestHeaders: { ...headersToRecord(reqHeaders), 'x-http-method': method },\n      requestBody: await readRequestBody(input, init),\n    })\n\n    const start = Date.now()\n    let response: Response\n    try {\n      response = await fetch(input, init)\n    } catch (err) {\n      await record({\n        ...baseEvent('error', endpoint),\n        durationMs: Date.now() - start,\n        errorMessage: err instanceof Error ? err.message : String(err),\n      })\n      throw err\n    }\n\n    // Read the body off a clone so the caller still consumes the original.\n    let responseBody: unknown\n    let rawText: string | undefined\n    const redactedFields: string[] = []\n    try {\n      rawText = await response.clone().text()\n      if (rawText.length > bodyCap) {\n        responseBody = rawText.slice(0, bodyCap)\n        redactedFields.push('body_truncated')\n      } else {\n        responseBody = parseMaybeJson(rawText)\n      }\n    } catch {\n      responseBody = undefined\n    }\n\n    if (opts.onUsage && rawText !== undefined) {\n      // Reuse the body already read for capture; no extra clone. JSON first,\n      // then SSE accumulation. A throw in the consumer's callback is swallowed\n      // (best-effort) unless failClosed is set — the LLM call must not die here.\n      try {\n        const parsedForUsage = parseMaybeJson(rawText)\n        const usage =\n          extractUsage(parsedForUsage) ??\n          (typeof parsedForUsage === 'string'\n            ? extractUsageFromSse(rawText, { mode: opts.sseUsageMode })\n            : null)\n        if (usage) opts.onUsage(usage, ctx)\n      } catch (err) {\n        if (opts.failClosed) throw err\n      }\n    }\n\n    await record({\n      ...baseEvent('response', endpoint),\n      durationMs: Date.now() - start,\n      statusCode: response.status,\n      responseHeaders: headersToRecord(response.headers),\n      responseBody,\n      redactedFields,\n    })\n\n    return response\n  }\n}\n","/**\n * OpenTelemetry JSON export — maps TraceSchema v1 to OTLP/JSON so\n * traces render natively in Jaeger / Honeycomb / Langfuse / Grafana.\n *\n * Wire format only. We do NOT depend on the @opentelemetry SDK — that\n * would drag in polyfills incompatible with Workers/Edge. Consumers\n * push the JSON to their collector of choice via HTTP.\n *\n * Reference: OTLP 1.3.2 (ResourceSpans / ScopeSpans / Span).\n */\n\nimport {\n  applyLlmSpanOtlpAttributes,\n  applyToolSpanOtlpAttributes,\n  OPENINFERENCE_SPAN_KIND,\n  traceSpanKindToOpenInferenceKind,\n} from './otlp-attributes'\nimport type { Run, Span, TraceEvent } from './schema'\nimport type { TraceStore } from './store'\n\nexport const OTEL_AGENT_EVAL_SCOPE = { name: '@tangle-network/agent-eval', version: '0.3.0' }\n\nexport interface OtlpSpan {\n  traceId: string\n  spanId: string\n  parentSpanId?: string\n  name: string\n  kind: number\n  startTimeUnixNano: string\n  endTimeUnixNano: string\n  attributes: Array<{\n    key: string\n    value: { stringValue?: string; intValue?: string; doubleValue?: number; boolValue?: boolean }\n  }>\n  events?: Array<{ timeUnixNano: string; name: string; attributes?: OtlpSpan['attributes'] }>\n  status?: { code: number; message?: string }\n}\n\nexport interface OtlpResourceSpans {\n  resource: { attributes: OtlpSpan['attributes'] }\n  scopeSpans: Array<{ scope: typeof OTEL_AGENT_EVAL_SCOPE; spans: OtlpSpan[] }>\n}\n\nexport interface OtlpExport {\n  resourceSpans: OtlpResourceSpans[]\n}\n\n/** Export a single run's spans + events in OTLP/JSON. */\nexport async function exportRunAsOtlp(\n  store: TraceStore,\n  runId: string,\n  resourceAttrs: Record<string, string | number | boolean> = {},\n): Promise<OtlpExport> {\n  const run = await store.getRun(runId)\n  if (!run) throw new Error(`run ${runId} not found`)\n  const spans = await store.spans({ runId })\n  const events = await store.events({ runId })\n  const eventsBySpan = new Map<string, TraceEvent[]>()\n  for (const e of events) {\n    if (!e.spanId) continue\n    const arr = eventsBySpan.get(e.spanId) ?? []\n    arr.push(e)\n    eventsBySpan.set(e.spanId, arr)\n  }\n  const traceId = runToTraceId(run)\n  const otlpSpans: OtlpSpan[] = spans.map((s) =>\n    spanToOtlp(s, traceId, eventsBySpan.get(s.spanId) ?? []),\n  )\n  return {\n    resourceSpans: [\n      {\n        resource: {\n          attributes: toAttributes({\n            'service.name': 'agent-eval',\n            'run.id': run.runId,\n            'run.scenario_id': run.scenarioId,\n            'run.variant_id': run.variantId ?? '',\n            'run.dataset_version': run.datasetVersion ?? '',\n            'run.code_sha': run.codeSha ?? '',\n            'run.model_fingerprint': run.modelFingerprint ?? '',\n            ...resourceAttrs,\n          }),\n        },\n        scopeSpans: [{ scope: OTEL_AGENT_EVAL_SCOPE, spans: otlpSpans }],\n      },\n    ],\n  }\n}\n\nfunction spanToOtlp(span: Span, traceId: string, events: TraceEvent[]): OtlpSpan {\n  const endedAt = span.endedAt ?? span.startedAt\n  return {\n    traceId,\n    spanId: padSpanId(span.spanId),\n    parentSpanId: span.parentSpanId ? padSpanId(span.parentSpanId) : undefined,\n    name: span.name,\n    kind: 1, // SPAN_KIND_INTERNAL\n    startTimeUnixNano: msToNs(span.startedAt),\n    endTimeUnixNano: msToNs(endedAt),\n    attributes: toAttributes(flattenSpanAttributes(span)),\n    events: events.map((e) => ({\n      timeUnixNano: msToNs(e.timestamp),\n      name: e.kind,\n      attributes: toAttributes(flattenPayload(e.payload)),\n    })),\n    status: span.status === 'error' ? { code: 2, message: span.error } : { code: 1 },\n  }\n}\n\nfunction flattenSpanAttributes(span: Span): Record<string, string | number | boolean> {\n  const base: Record<string, string | number | boolean> = {}\n  if (span.attributes) {\n    for (const [k, v] of Object.entries(span.attributes)) {\n      if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') base[k] = v\n    }\n  }\n  base[OPENINFERENCE_SPAN_KIND] = traceSpanKindToOpenInferenceKind(span.kind)\n  if (span.kind === 'llm') {\n    applyLlmSpanOtlpAttributes(base, span)\n  } else if (span.kind === 'tool') {\n    applyToolSpanOtlpAttributes(base, span)\n  } else if (span.kind === 'retrieval') {\n    base['retrieval.query'] = span.query\n    base['retrieval.hits'] = span.hits.length\n  } else if (span.kind === 'judge') {\n    base['judge.id'] = span.judgeId\n    base['judge.dimension'] = span.dimension\n    base['judge.score'] = span.score\n    base['judge.target_span_id'] = span.targetSpanId\n  } else if (span.kind === 'sandbox') {\n    if (span.image) base['sandbox.image'] = span.image\n    if (span.exitCode !== undefined) base['sandbox.exit_code'] = span.exitCode\n    if (span.testsPassed !== undefined) base['sandbox.tests_passed'] = span.testsPassed\n    if (span.testsTotal !== undefined) base['sandbox.tests_total'] = span.testsTotal\n  }\n  return base\n}\n\nfunction flattenPayload(\n  payload: Record<string, unknown>,\n): Record<string, string | number | boolean> {\n  const out: Record<string, string | number | boolean> = {}\n  for (const [k, v] of Object.entries(payload)) {\n    if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') out[k] = v\n    else out[k] = JSON.stringify(v)\n  }\n  return out\n}\n\nfunction toAttributes(record: Record<string, string | number | boolean>): OtlpSpan['attributes'] {\n  return Object.entries(record).map(([key, value]) => ({\n    key,\n    value:\n      typeof value === 'number'\n        ? Number.isInteger(value)\n          ? { intValue: value.toString() }\n          : { doubleValue: value }\n        : typeof value === 'boolean'\n          ? { boolValue: value }\n          : { stringValue: value },\n  }))\n}\n\nfunction msToNs(ms: number): string {\n  return (BigInt(Math.floor(ms)) * 1_000_000n).toString()\n}\n\nfunction padSpanId(id: string): string {\n  // OTLP wants 16-hex spanIds. UUIDs are 32-hex; strip dashes and take first 16.\n  const cleaned = id.replace(/-/g, '')\n  return cleaned.slice(0, 16).padEnd(16, '0')\n}\n\nfunction runToTraceId(run: Run): string {\n  // OTLP wants 32-hex traceIds. Use runId directly when it's 32-hex already,\n  // else SHA-ish truncate.\n  const cleaned = run.runId.replace(/-/g, '')\n  return cleaned.slice(0, 32).padEnd(32, '0')\n}\n","/**\n * OTEL bridge — connects TraceEmitter span lifecycle to the OtelExporter.\n *\n * When an OtelExporter is active, every span that closes through the\n * TraceEmitter is also pushed to the exporter for real-time streaming to\n * the user's OTEL collector.\n *\n * The bridge is opt-in: attach via `otelRunCompleteHook(exporter)` as a\n * RunCompleteHook, or wrap the store with `createOtelTracingStore` for\n * real-time per-span export.\n */\n\nimport type { RunCompleteHook } from './emitter'\nimport type { ExportableSpan, OtelExporter } from './otel-export'\nimport type { LlmSpan, Span, ToolSpan } from './schema'\nimport type { TraceStore } from './store'\n\n/**\n * Create a RunCompleteHook that exports all spans from the completed run\n * to the OTEL exporter, then flushes.\n */\nexport function otelRunCompleteHook(exporter: OtelExporter): RunCompleteHook {\n  return async (ctx) => {\n    const spans = await ctx.store.spans({ runId: ctx.runId })\n    for (const span of spans) {\n      if (span.endedAt) {\n        exporter.exportSpan(storeSpanToExportable(span, ctx.runId))\n      }\n    }\n    await exporter.flush()\n  }\n}\n\n/**\n * Create an auto-exporting TraceStore wrapper that intercepts updateSpan\n * calls. When a span gets an endedAt, it's exported immediately. This\n * gives real-time streaming instead of batch-at-end.\n *\n * This is the preferred integration path: wrap the store before\n * constructing the TraceEmitter.\n */\nexport function createOtelTracingStore(\n  inner: TraceStore,\n  exporter: OtelExporter,\n  traceId: string,\n): TraceStore {\n  return {\n    async appendRun(run) {\n      return inner.appendRun(run)\n    },\n    async updateRun(runId, patch) {\n      return inner.updateRun(runId, patch)\n    },\n    async appendSpan(span) {\n      if (span.endedAt) {\n        exporter.exportSpan(storeSpanToExportable(span, traceId))\n      }\n      return inner.appendSpan(span)\n    },\n    async updateSpan(spanId, patch) {\n      await inner.updateSpan(spanId, patch)\n      if (patch.endedAt) {\n        const spans = await inner.spans({ runId: traceId })\n        const found = spans.find((s) => s.spanId === spanId)\n        if (found) {\n          exporter.exportSpan(storeSpanToExportable(found, traceId))\n        }\n      }\n    },\n    async appendEvent(event) {\n      return inner.appendEvent(event)\n    },\n    async appendBudgetEntry(entry) {\n      return inner.appendBudgetEntry(entry)\n    },\n    async appendArtifact(artifact) {\n      return inner.appendArtifact(artifact)\n    },\n    getRun: inner.getRun.bind(inner),\n    listRuns: inner.listRuns.bind(inner),\n    spans: inner.spans.bind(inner),\n    events: inner.events.bind(inner),\n    budget: inner.budget.bind(inner),\n    artifacts: inner.artifacts.bind(inner),\n  }\n}\n\nfunction storeSpanToExportable(span: Span, traceId: string): ExportableSpan {\n  const llm = span.kind === 'llm' ? (span as LlmSpan) : undefined\n  const tool = span.kind === 'tool' ? (span as ToolSpan) : undefined\n  return {\n    traceId,\n    spanId: span.spanId,\n    parentSpanId: span.parentSpanId,\n    name: span.name,\n    kind: span.kind,\n    startedAt: span.startedAt,\n    endedAt: span.endedAt,\n    status: span.status,\n    error: span.error,\n    model: llm?.model,\n    inputTokens: llm?.inputTokens,\n    outputTokens: llm?.outputTokens,\n    reasoningTokens: llm?.reasoningTokens,\n    cachedTokens: llm?.cachedTokens,\n    cacheWriteTokens: llm?.cacheWriteTokens,\n    costUsd: llm?.costUsd,\n    tool: tool\n      ? {\n          toolName: tool.toolName,\n          args: tool.args,\n          argsCaptured: tool.argsCaptured,\n          result: tool.result,\n          latencyMs: tool.latencyMs,\n        }\n      : undefined,\n    attributes: span.attributes as Record<string, unknown> | undefined,\n  }\n}\n","/**\n * OTEL span exporter — streams spans to an OTLP/HTTP collector.\n *\n * Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env\n * when no explicit config is given. Batches spans and flushes periodically\n * or when the batch fills. No @opentelemetry SDK dependency — minimal\n * OTLP/JSON serializer (~120 LOC) using the existing otel.ts helpers.\n */\n\nimport { OTEL_AGENT_EVAL_SCOPE, type OtlpExport, type OtlpSpan } from './otel'\nimport {\n  applyLlmSpanOtlpAttributes,\n  applyToolSpanOtlpAttributes,\n  OPENINFERENCE_SPAN_KIND,\n  type ToolSpanOtlpInput,\n  traceSpanKindToOpenInferenceKind,\n} from './otlp-attributes'\n\nexport interface OtelExportConfig {\n  /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */\n  endpoint?: string\n  /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */\n  headers?: Record<string, string>\n  /** Batch size before flush. Default 64. */\n  batchSize?: number\n  /** Flush interval ms. Default 5000. */\n  flushIntervalMs?: number\n  /** Resource attributes stamped on every export. */\n  resourceAttributes?: Record<string, string | number | boolean>\n  /** Service name. Default 'agent-eval'. */\n  serviceName?: string\n}\n\nexport interface OtelExporter {\n  /** Called by the TraceEmitter on every span close. */\n  exportSpan(span: ExportableSpan): void\n  /** Force flush pending spans. */\n  flush(): Promise<void>\n  /** Shutdown cleanly — flushes remaining spans and stops the timer. */\n  shutdown(): Promise<void>\n}\n\nexport interface ExportableSpan {\n  traceId: string\n  spanId: string\n  parentSpanId?: string\n  name: string\n  kind: string\n  startedAt: number\n  endedAt?: number\n  status?: string\n  error?: string\n  model?: string\n  inputTokens?: number\n  outputTokens?: number\n  reasoningTokens?: number\n  cachedTokens?: number\n  cacheWriteTokens?: number\n  costUsd?: number\n  tool?: ToolSpanOtlpInput\n  attributes?: Record<string, unknown>\n}\n\n/**\n * Create an OTEL exporter. Returns undefined when no endpoint is configured\n * (neither via config nor env) — callers should check before attaching.\n */\nexport function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined {\n  const resolvedEndpoint =\n    config?.endpoint ??\n    (typeof process !== 'undefined' ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : undefined)\n  if (!resolvedEndpoint) return undefined\n  const endpoint: string = resolvedEndpoint\n\n  const headers = config?.headers ?? parseHeadersFromEnv()\n  const batchSize = config?.batchSize ?? 64\n  const flushIntervalMs = config?.flushIntervalMs ?? 5000\n  const serviceName = config?.serviceName ?? 'agent-eval'\n  const resourceAttrs = config?.resourceAttributes ?? {}\n\n  const pending: OtlpSpan[] = []\n  let timer: ReturnType<typeof setInterval> | undefined\n  let stopped = false\n\n  const exporter: OtelExporter = {\n    exportSpan(span: ExportableSpan): void {\n      if (stopped) return\n      pending.push(toOtlpSpan(span))\n      if (pending.length >= batchSize) {\n        void doFlush()\n      }\n    },\n\n    async flush(): Promise<void> {\n      await doFlush()\n    },\n\n    async shutdown(): Promise<void> {\n      stopped = true\n      if (timer !== undefined) {\n        clearInterval(timer)\n        timer = undefined\n      }\n      await doFlush()\n    },\n  }\n\n  timer = setInterval(() => {\n    if (pending.length > 0) void doFlush()\n  }, flushIntervalMs)\n  // Unref so the timer doesn't keep the process alive.\n  if (typeof timer === 'object' && 'unref' in timer) {\n    ;(timer as NodeJS.Timeout).unref()\n  }\n\n  async function doFlush(): Promise<void> {\n    if (pending.length === 0) return\n    const batch = pending.splice(0)\n    const body: OtlpExport = {\n      resourceSpans: [\n        {\n          resource: {\n            attributes: toAttributes({\n              'service.name': serviceName,\n              ...resourceAttrs,\n            }),\n          },\n          scopeSpans: [{ scope: OTEL_AGENT_EVAL_SCOPE, spans: batch }],\n        },\n      ],\n    }\n    const url = `${endpoint.replace(/\\/+$/, '')}/v1/traces`\n    try {\n      await fetch(url, {\n        method: 'POST',\n        headers: {\n          'content-type': 'application/json',\n          ...headers,\n        },\n        body: JSON.stringify(body),\n      })\n    } catch {\n      // Best-effort — telemetry export must not crash the pipeline.\n    }\n  }\n\n  return exporter\n}\n\nfunction parseHeadersFromEnv(): Record<string, string> {\n  if (typeof process === 'undefined') return {}\n  const raw = process.env.OTEL_EXPORTER_OTLP_HEADERS\n  if (!raw) return {}\n  const out: Record<string, string> = {}\n  for (const pair of raw.split(',')) {\n    const eq = pair.indexOf('=')\n    if (eq < 0) continue\n    const key = pair.slice(0, eq).trim()\n    const value = pair.slice(eq + 1).trim()\n    if (key) out[key] = value\n  }\n  return out\n}\n\nfunction toOtlpSpan(span: ExportableSpan): OtlpSpan {\n  const endedAt = span.endedAt ?? span.startedAt\n  const attrs: Record<string, string | number | boolean> = {}\n  if (span.attributes) {\n    for (const [k, v] of Object.entries(span.attributes)) {\n      if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') attrs[k] = v\n    }\n  }\n  attrs[OPENINFERENCE_SPAN_KIND] = traceSpanKindToOpenInferenceKind(span.kind)\n  applyLlmSpanOtlpAttributes(attrs, span)\n  if (span.tool) applyToolSpanOtlpAttributes(attrs, span.tool)\n  return {\n    traceId: padTraceId(span.traceId),\n    spanId: padSpanId(span.spanId),\n    parentSpanId: span.parentSpanId ? padSpanId(span.parentSpanId) : undefined,\n    name: span.name,\n    kind: 1, // SPAN_KIND_INTERNAL\n    startTimeUnixNano: msToNs(span.startedAt),\n    endTimeUnixNano: msToNs(endedAt),\n    attributes: toAttributes(attrs),\n    status: span.status === 'error' ? { code: 2, message: span.error } : { code: 1 },\n  }\n}\n\nfunction toAttributes(record: Record<string, string | number | boolean>): OtlpSpan['attributes'] {\n  return Object.entries(record).map(([key, value]) => ({\n    key,\n    value:\n      typeof value === 'number'\n        ? Number.isInteger(value)\n          ? { intValue: value.toString() }\n          : { doubleValue: value }\n        : typeof value === 'boolean'\n          ? { boolValue: value }\n          : { stringValue: value },\n  }))\n}\n\nfunction msToNs(ms: number): string {\n  return (BigInt(Math.floor(ms)) * 1_000_000n).toString()\n}\n\nfunction padSpanId(id: string): string {\n  const cleaned = id.replace(/-/g, '')\n  return cleaned.slice(0, 16).padEnd(16, '0')\n}\n\nfunction padTraceId(id: string): string {\n  const cleaned = id.replace(/-/g, '')\n  return cleaned.slice(0, 32).padEnd(32, '0')\n}\n","/**\n * Convert agent-eval's internal trace shape (`FileSystemTraceStore` → `Run`,\n * `Span`, `TraceEvent`) into the OTLP-flat JSONL the trace analyst\n * (`analyzeTraces` + `OtlpFileTraceStore`) reads.\n *\n * Eval harnesses shard a `FileSystemTraceStore` per cell (persona / variant)\n * under a run directory. The analyst consumes a single OTLP-NDJSON file keyed\n * on `trace_id` + `span_id` with `start_time`/`end_time` in ISO-8601 and\n * resource + `attributes` rolled up per-span. This module walks every shard,\n * projects each `Span` (plus events pinned to it) into the flat OTLP shape,\n * and emits one NDJSON file.\n *\n * Generic OTLP/OpenInference fields are always emitted (`service.name`,\n * `agent.name`, `run.id`/`run.status`, `openinference.span.kind`,\n * `llm.model_name`, …). Domain attributes (`legal.*`, `tax.*`, …) are injected\n * per-run via {@link TraceStoreToOtlpOptions.resourceAttributes} /\n * {@link TraceStoreToOtlpOptions.runAttributes} so consumers don't re-roll the\n * walker.\n */\n\nimport { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'\nimport { join } from 'node:path'\nimport {\n  applyLlmSpanOtlpAttributes,\n  applyToolSpanOtlpAttributes,\n  OPENINFERENCE_SPAN_KIND,\n  traceSpanKindToOpenInferenceKind,\n} from './otlp-attributes'\nimport { createOtlpFlatLine, epochMillisToIso, spanStatusToOtlp } from './otlp-flat'\nimport type { Run, Span, TraceEvent } from './schema'\n\n/** Marker `FileSystemTraceStore` stamps on partial-update NDJSON rows. */\ninterface MaybeUpdate {\n  _update?: boolean\n}\n\nexport interface TracesToOtlpResult {\n  /** Total spans emitted across every cell. */\n  spanCount: number\n  /** Total run-anchor spans (one per Run) appended for analyst visibility. */\n  runCount: number\n  /** Cells whose shards parsed cleanly. */\n  cellCount: number\n  /** Cells that errored mid-conversion — surfaced so a partial conversion\n   *  isn't silently masked. */\n  cellErrorCount: number\n}\n\n/**\n * A trace source the analyst should ingest. Two layouts are supported:\n *\n *   - `celled` (default): the root holds one cell subdirectory per\n *     persona/variant, each a `FileSystemTraceStore` (`runs.ndjson`,\n *     `spans.ndjson`, `events.ndjson`).\n *   - `flat`: the root is itself a single `FileSystemTraceStore` (e.g. a\n *     production-ingestion sidecar that appends one ndjson set directly under\n *     the chosen directory).\n */\nexport interface TraceStoreSource {\n  /** Absolute path to the trace store root. */\n  root: string\n  /** Layout — `celled` (default) or `flat`. */\n  layout?: 'celled' | 'flat'\n  /** OTLP `service.name` for this source. Overrides the options default. */\n  serviceName?: string\n}\n\n/** Domain hooks. The walker is generic; consumers inject the namespaced\n *  attributes that ride along on every run + span for analyst discovery. */\nexport interface TraceStoreToOtlpOptions {\n  /** Default OTLP `service.name` when a source doesn't set its own.\n   *  Default `agent-eval`. */\n  serviceName?: string\n  /** Extra resource attributes per run, e.g.\n   *  `(run) => ({ 'legal.persona_id': run.tags?.personaId ?? '' })`. */\n  resourceAttributes?: (run: Run) => Record<string, unknown>\n  /** Extra attributes on the per-run anchor span, e.g. domain outcome fields. */\n  runAttributes?: (run: Run) => Record<string, unknown>\n}\n\n/**\n * Read every per-cell shard under each source root and write a flat OTLP-JSONL\n * view of the corpus to `outPath`. Each cell directory is a\n * `FileSystemTraceStore` — NDJSON append-only with size-based rotation;\n * `updateRun`/`updateSpan` append `{ id, ...patch, _update: true }` rows\n * rather than rewriting, so readers must merge those patches in (done here).\n *\n * A `string` source is treated as a celled root.\n */\nexport function convertTraceStoresToOtlp(\n  source: string | TraceStoreSource | readonly TraceStoreSource[],\n  outPath: string,\n  opts: TraceStoreToOtlpOptions = {},\n): TracesToOtlpResult {\n  const sources: TraceStoreSource[] = Array.isArray(source)\n    ? [...source]\n    : typeof source === 'string'\n      ? [{ root: source, layout: 'celled' }]\n      : [source as TraceStoreSource]\n\n  const defaultServiceName = opts.serviceName ?? 'agent-eval'\n  const resourceAttributes = opts.resourceAttributes ?? (() => ({}))\n  const runAttributes = opts.runAttributes ?? (() => ({}))\n\n  const lines: string[] = []\n  let spanCount = 0\n  let runCount = 0\n  let cellCount = 0\n  let cellErrorCount = 0\n\n  for (const src of sources) {\n    const serviceName = src.serviceName ?? defaultServiceName\n    const cellDirs: Array<{ label: string; dir: string }> =\n      src.layout === 'flat'\n        ? [{ label: '<root>', dir: src.root }]\n        : listCells(src.root).map((name) => ({ label: name, dir: join(src.root, name) }))\n\n    for (const cell of cellDirs) {\n      try {\n        const result = projectCell({\n          cellDir: cell.dir,\n          serviceName,\n          resourceAttributes,\n          runAttributes,\n        })\n        for (const line of result.lines) lines.push(line)\n        spanCount += result.spanCount\n        runCount += result.runCount\n        cellCount += 1\n      } catch (err) {\n        console.warn(\n          `[traces-to-otlp] cell ${cell.label} (${cell.dir}) skipped: ${err instanceof Error ? err.message : String(err)}`,\n        )\n        cellErrorCount += 1\n      }\n    }\n  }\n\n  writeFileSync(outPath, lines.join('\\n') + (lines.length > 0 ? '\\n' : ''))\n  return { spanCount, runCount, cellCount, cellErrorCount }\n}\n\ninterface ProjectCellResult {\n  lines: string[]\n  runCount: number\n  spanCount: number\n}\n\nfunction projectCell(args: {\n  cellDir: string\n  serviceName: string\n  resourceAttributes: (run: Run) => Record<string, unknown>\n  runAttributes: (run: Run) => Record<string, unknown>\n}): ProjectCellResult {\n  const { cellDir, serviceName, resourceAttributes, runAttributes } = args\n  const lines: string[] = []\n  let runCount = 0\n  let spanCount = 0\n\n  const runs = readMergedShards<Run & MaybeUpdate>(cellDir, 'runs', 'runId')\n  const spans = readMergedShards<Span & MaybeUpdate>(cellDir, 'spans', 'spanId')\n  const events = readShards<TraceEvent>(cellDir, 'events')\n\n  const runByRunId = new Map<string, Run>()\n  for (const r of runs) runByRunId.set(r.runId, r)\n  const spanBySpanId = new Map<string, Span>()\n  for (const s of spans) spanBySpanId.set(s.spanId, s)\n  const eventsBySpanId = new Map<string, TraceEvent[]>()\n\n  // An HTTP-backed trace store can only POST `TraceEvent`s through the wire;\n  // run/span lifecycle is projected into `state_mutation` events with\n  // `payload.entity ∈ { run, run.update, span, span.update }`. Fold those back\n  // so the analyst sees a complete Run + Span tree.\n  for (const e of events) {\n    if (e.kind === 'state_mutation' && e.payload && typeof e.payload === 'object') {\n      const entity = (e.payload as Record<string, unknown>).entity\n      if (entity === 'run') {\n        const run = (e.payload as { run?: Run }).run\n        if (run?.runId) runByRunId.set(run.runId, run)\n        continue\n      }\n      if (entity === 'run.update') {\n        const patch = (e.payload as { patch?: Partial<Run> }).patch\n        if (patch && e.runId) {\n          const prior = runByRunId.get(e.runId)\n          if (prior) runByRunId.set(e.runId, { ...prior, ...patch })\n        }\n        continue\n      }\n      if (entity === 'span') {\n        const span = (e.payload as { span?: Span }).span\n        if (span?.spanId) spanBySpanId.set(span.spanId, span)\n        continue\n      }\n      if (entity === 'span.update') {\n        const spanId = (e.payload as { spanId?: string }).spanId\n        const patch = (e.payload as { patch?: Partial<Span> }).patch\n        if (spanId && patch) {\n          const prior = spanBySpanId.get(spanId)\n          if (prior) spanBySpanId.set(spanId, { ...prior, ...patch } as Span)\n        }\n        continue\n      }\n    }\n    if (!e.spanId) continue\n    const arr = eventsBySpanId.get(e.spanId) ?? []\n    arr.push(e)\n    eventsBySpanId.set(e.spanId, arr)\n  }\n\n  for (const run of runByRunId.values()) {\n    const traceId = padTraceId(run.runId)\n    const agentName = run.variantId ?? run.scenarioId\n    const sharedResource = {\n      attributes: {\n        'service.name': serviceName,\n        'agent.name': agentName,\n        'run.id': run.runId,\n        'run.status': run.status,\n        ...resourceAttributes(run),\n      },\n    }\n\n    const runSpanId = padSpanId(`run-${run.runId}`)\n    const runStart = msToIso(run.startedAt)\n    const runEnd = msToIso(run.endedAt ?? run.startedAt)\n    const runStatus =\n      run.outcome?.failureClass && run.outcome.failureClass !== 'success'\n        ? 'STATUS_CODE_ERROR'\n        : 'STATUS_CODE_OK'\n    const runAttrs: Record<string, unknown> = {\n      [OPENINFERENCE_SPAN_KIND]: 'AGENT',\n      'agent.name': agentName,\n      'agent.workflow.name': serviceName,\n      ...runAttributes(run),\n    }\n    lines.push(\n      JSON.stringify(\n        toLine({\n          traceId,\n          spanId: runSpanId,\n          parentSpanId: '',\n          name: `run.${agentName}`,\n          kind: 'SPAN_KIND_INTERNAL',\n          startTime: runStart,\n          endTime: runEnd,\n          statusCode: runStatus,\n          statusMessage: run.outcome?.notes ?? '',\n          resource: sharedResource,\n          attributes: runAttrs,\n        }),\n      ),\n    )\n    runCount += 1\n\n    for (const span of spanBySpanId.values()) {\n      if (span.runId !== run.runId) continue\n      const spanAttrs = spanToAttributes(span, eventsBySpanId.get(span.spanId) ?? [])\n      const statusCode = spanStatusToOtlp(span.status, span.error, 'STATUS_CODE_OK')\n      lines.push(\n        JSON.stringify(\n          toLine({\n            traceId,\n            spanId: padSpanId(span.spanId),\n            parentSpanId: span.parentSpanId ? padSpanId(span.parentSpanId) : runSpanId,\n            name: span.name,\n            kind: spanKindToOtlpKind(span.kind),\n            startTime: msToIso(span.startedAt),\n            endTime: msToIso(span.endedAt ?? span.startedAt),\n            statusCode,\n            statusMessage: span.error ?? '',\n            resource: sharedResource,\n            attributes: spanAttrs,\n          }),\n        ),\n      )\n      spanCount += 1\n    }\n  }\n\n  return { lines, runCount, spanCount }\n}\n\nfunction listCells(root: string): string[] {\n  try {\n    return readdirSync(root, { withFileTypes: true })\n      .filter((d) => d.isDirectory())\n      .map((d) => d.name)\n      .sort()\n  } catch {\n    return []\n  }\n}\n\n/**\n * Read every NDJSON shard for `name` under `cellDir`, ordered by mtime so\n * rotated files apply before the active one. Yields raw rows including any\n * `_update: true` patches.\n */\nfunction readShards<T>(cellDir: string, name: string): T[] {\n  let entries: string[]\n  try {\n    entries = readdirSync(cellDir)\n  } catch {\n    return []\n  }\n  const shards = entries\n    .filter((f) => (f === `${name}.ndjson` || f.startsWith(`${name}.`)) && f.endsWith('.ndjson'))\n    .map((f) => ({ file: f, path: join(cellDir, f) }))\n    .map((s) => {\n      let mtime = 0\n      try {\n        mtime = statSync(s.path).mtimeMs\n      } catch {\n        /* skip stat errors */\n      }\n      return { ...s, mtime }\n    })\n    .sort((a, b) => a.mtime - b.mtime || a.file.localeCompare(b.file))\n\n  const rows: T[] = []\n  for (const shard of shards) {\n    let text: string\n    try {\n      text = readFileSync(shard.path, 'utf-8')\n    } catch {\n      continue\n    }\n    for (const line of text.split('\\n')) {\n      const trimmed = line.trim()\n      if (!trimmed) continue\n      try {\n        rows.push(JSON.parse(trimmed) as T)\n      } catch {\n        /* skip partial line */\n      }\n    }\n  }\n  return rows\n}\n\n/**\n * Read NDJSON shards and merge `{ ...patch, _update: true }` rows into the\n * prior record keyed on `idKey` — mirrors the in-memory merge\n * `FileSystemTraceStore` keeps but doesn't replay on cross-process load.\n */\nfunction readMergedShards<T extends { _update?: boolean }>(\n  cellDir: string,\n  name: string,\n  idKey: keyof T,\n): T[] {\n  const rows = readShards<T>(cellDir, name)\n  const byId = new Map<string, T>()\n  for (const row of rows) {\n    const id = row[idKey] as unknown as string\n    if (!id) continue\n    const prior = byId.get(id)\n    if (prior && row._update) {\n      byId.set(id, { ...prior, ...row, _update: undefined } as T)\n    } else {\n      byId.set(id, row)\n    }\n  }\n  return [...byId.values()]\n}\n\nfunction spanToAttributes(span: Span, events: TraceEvent[]): Record<string, unknown> {\n  const attrs: Record<string, unknown> = {\n    [OPENINFERENCE_SPAN_KIND]: traceSpanKindToOpenInferenceKind(span.kind),\n  }\n  if (span.kind === 'llm') {\n    applyLlmSpanOtlpAttributes(attrs, span)\n    if (Array.isArray(span.messages)) {\n      attrs['llm.input_messages'] = JSON.stringify(span.messages.slice(-6))\n    }\n    if (typeof span.output === 'string') {\n      attrs['llm.output_messages'] = JSON.stringify([{ role: 'assistant', content: span.output }])\n    }\n  } else if (span.kind === 'tool') {\n    applyToolSpanOtlpAttributes(attrs, span)\n  } else if (span.kind === 'judge') {\n    attrs['judge.id'] = span.judgeId\n    attrs['judge.dimension'] = span.dimension\n    attrs['judge.score'] = span.score\n    attrs['judge.target_span_id'] = span.targetSpanId\n  }\n  if (span.attributes) {\n    for (const [k, v] of Object.entries(span.attributes)) {\n      attrs[`agent_eval.${k}`] = v\n    }\n  }\n  if (events.length > 0) {\n    attrs['agent_eval.event_count'] = events.length\n    attrs['agent_eval.event_kinds'] = JSON.stringify(events.map((e) => e.kind))\n  }\n  return attrs\n}\n\nfunction spanKindToOtlpKind(kind: Span['kind']): string {\n  switch (kind) {\n    case 'llm':\n      return 'SPAN_KIND_CLIENT'\n    case 'retrieval':\n      return 'SPAN_KIND_CLIENT'\n    default:\n      return 'SPAN_KIND_INTERNAL'\n  }\n}\n\nconst toLine = createOtlpFlatLine\n\nfunction msToIso(ms: number): string {\n  if (ms <= 0) return new Date(0).toISOString()\n  return epochMillisToIso(ms) ?? new Date(0).toISOString()\n}\n\n/** OTLP wants 16-hex span ids; eval traces use UUID-ish strings. Hex-strip +\n *  take 16, else deterministic FNV fold. */\nfunction padSpanId(id: string): string {\n  const cleaned = id.replace(/[^a-f0-9]/gi, '').toLowerCase()\n  if (cleaned.length >= 16) return cleaned.slice(0, 16)\n  return foldTo16Hex(id)\n}\n\n/** OTLP wants 32-hex trace ids; fold deterministically when too short. */\nfunction padTraceId(id: string): string {\n  const cleaned = id.replace(/[^a-f0-9]/gi, '').toLowerCase()\n  if (cleaned.length >= 32) return cleaned.slice(0, 32)\n  return foldTo32Hex(id)\n}\n\nfunction foldTo16Hex(s: string): string {\n  let h1 = 0x811c9dc5\n  for (const ch of s) {\n    h1 ^= ch.charCodeAt(0)\n    h1 = Math.imul(h1, 0x01000193) >>> 0\n  }\n  const part = h1.toString(16).padStart(8, '0')\n  return (part + part).slice(0, 16)\n}\n\nfunction foldTo32Hex(s: string): string {\n  return foldTo16Hex(s) + foldTo16Hex(`${s}::trace`).slice(0, 16)\n}\n","/**\n * Replay-from-raw-events — turn every captured campaign run into a\n * re-runnable artifact.\n *\n * `RawProviderSink` captures every provider HTTP envelope; `runEvalCampaign`\n * makes that capture the default. Together they make every past run a\n * complete fingerprint of what happened on the wire — enough to replay\n * the run without burning new LLM cost.\n *\n * Three use cases this primitive enables:\n *\n *   1. **Post-hoc judging** — apply a new judge / rubric / scoring callback\n *      to last week's runs without re-calling any LLM. The cost of trying\n *      a new rubric drops from \"another full sweep\" to a CPU-bound replay.\n *   2. **Determinism audits** — replay the same campaign and verify the\n *      raw responses match byte-for-byte. Any drift is a non-determinism\n *      bug (in the harness, the prompt builder, the sandbox, …).\n *   3. **Free judge calibration** — run two judges on identical responses\n *      and measure inter-judge agreement without doubling LLM spend.\n *\n * The interface is deliberately fetch-shaped. Inject `createReplayFetch`\n * into `LlmClientOptions.fetch` and every `callLlm` transparently reads\n * from the cache instead of calling the network. No new code path through\n * the LLM client is needed; the cache hit is invisible to the runner.\n */\n\nimport { ReplayError } from './errors'\nimport { canonicalize, hashJson } from './pre-registration'\nimport type { RawProviderEvent, RawProviderSink } from './trace/raw-provider-sink'\n\nexport class ReplayCacheMissError extends ReplayError {\n  constructor(\n    public readonly url: string,\n    public readonly requestKey: string,\n    message?: string,\n  ) {\n    super(message ?? `replay cache miss for ${url} (key=${requestKey})`)\n  }\n}\n\nexport interface ReplayCacheEntry {\n  request: RawProviderEvent\n  response: RawProviderEvent\n}\n\nexport interface ReplayCacheStats {\n  total: number\n  byProvider: Record<string, number>\n  byModel: Record<string, number>\n  /** Spans for which we have a request but no response (run aborted mid-call). */\n  orphanRequests: number\n}\n\n/**\n * In-memory deterministic cache of (request → response) keyed on a stable\n * hash of the request body. Built from a `RawProviderSink` containing\n * paired `request` and `response` events from a previous run.\n *\n * The cache is the source of truth for replay; `createReplayFetch` is a\n * thin wrapper that reads from it.\n */\nexport class ReplayCache {\n  private byKey = new Map<string, ReplayCacheEntry>()\n  private orphans = 0\n  private byProvider: Record<string, number> = {}\n  private byModel: Record<string, number> = {}\n\n  /**\n   * Build a cache from a sink's events. The sink must implement `list()`.\n   * Filter by `runId` / `spanId` to scope to a specific replay.\n   */\n  static async fromSink(\n    sink: RawProviderSink,\n    filter: { runId?: string; spanId?: string } = {},\n  ): Promise<ReplayCache> {\n    if (!sink.list) {\n      throw new ReplayError('ReplayCache.fromSink: sink must implement list() to be replayable.')\n    }\n    const events = await sink.list(filter)\n    return ReplayCache.fromEvents(events)\n  }\n\n  /** Build a cache from an in-memory event list. */\n  static async fromEvents(events: RawProviderEvent[]): Promise<ReplayCache> {\n    const cache = new ReplayCache()\n    // Group by (runId, spanId, attemptIndex) so request/response/error pairs are matched.\n    // A cell can have many spans; each retry attempt within a span is a separate group.\n    type GroupKey = string\n    const groups = new Map<GroupKey, { req?: RawProviderEvent; res?: RawProviderEvent }>()\n    for (const e of events) {\n      const k = `${e.runId ?? ''}::${e.spanId ?? ''}::${e.attemptIndex}`\n      const g = groups.get(k) ?? {}\n      if (e.direction === 'request') g.req = e\n      else g.res = e\n      groups.set(k, g)\n    }\n    for (const g of groups.values()) {\n      if (!g.req) continue\n      if (!g.res) {\n        cache.orphans += 1\n        continue\n      }\n      const key = await requestKey(g.req)\n      cache.byKey.set(key, { request: g.req, response: g.res })\n      cache.byProvider[g.req.provider] = (cache.byProvider[g.req.provider] ?? 0) + 1\n      cache.byModel[g.req.model] = (cache.byModel[g.req.model] ?? 0) + 1\n    }\n    return cache\n  }\n\n  /** Number of cacheable (request, response) pairs in the cache. */\n  size(): number {\n    return this.byKey.size\n  }\n\n  stats(): ReplayCacheStats {\n    return {\n      total: this.byKey.size,\n      byProvider: { ...this.byProvider },\n      byModel: { ...this.byModel },\n      orphanRequests: this.orphans,\n    }\n  }\n\n  /** Iterate every cached `(request, response)` pair in insertion order. */\n  *entries(): IterableIterator<ReplayCacheEntry> {\n    for (const entry of this.byKey.values()) yield entry\n  }\n\n  /**\n   * Look up a cached response by hashing the (model, messages, temperature,\n   * maxTokens, response_format) shape. Returns `undefined` on miss; the\n   * caller decides whether to throw, fall back to the network, or skip.\n   */\n  async lookup(requestBody: unknown): Promise<ReplayCacheEntry | undefined> {\n    const key = await keyFromBody(requestBody)\n    return this.byKey.get(key)\n  }\n}\n\nexport interface ReplayFetchOptions {\n  /**\n   * Behaviour on cache miss. Default `'throw'`. `'fallback'` calls the\n   * `fallbackFetch` (typically `globalThis.fetch`) so a partial replay can\n   * still complete; `'fail-closed'` returns a synthetic 599 response so the\n   * call site sees a non-retriable failure.\n   */\n  onMiss?: 'throw' | 'fallback' | 'fail-closed'\n  fallbackFetch?: typeof fetch\n  /** Optional callback fired once per replayed call (for telemetry / counters). */\n  onHit?: (info: { url: string; provider: string; model: string }) => void\n  /** Optional callback fired on cache miss before the `onMiss` policy applies. */\n  onMissNotify?: (info: { url: string; requestBody: unknown }) => void\n}\n\n/**\n * Build a `fetch`-shaped function that serves cached responses out of a\n * `ReplayCache` for any URL ending in `/chat/completions`. Pass through\n * `LlmClientOptions.fetch` and `callLlm` becomes free.\n *\n * Non-`/chat/completions` URLs are passed straight to the fallback fetch\n * (default: `globalThis.fetch`). This matters because non-LLM HTTP work\n * (judge HTTP servers, sandbox callbacks) sometimes flows through the same\n * `fetch` and shouldn't be intercepted.\n */\nexport function createReplayFetch(cache: ReplayCache, opts: ReplayFetchOptions = {}): typeof fetch {\n  const onMiss = opts.onMiss ?? 'throw'\n  const fallback = opts.fallbackFetch ?? globalThis.fetch?.bind(globalThis)\n\n  return (async (input: RequestInfo | URL, init?: RequestInit) => {\n    const url =\n      typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url\n    if (!/\\/chat\\/completions(?:[?#].*)?$/.test(url)) {\n      if (!fallback)\n        throw new ReplayError(\n          `replay fetch: non-completions URL ${url} but no fallbackFetch configured`,\n        )\n      return fallback(input as RequestInfo, init)\n    }\n    let bodyParsed: unknown\n    if (init?.body && typeof init.body === 'string') {\n      try {\n        bodyParsed = JSON.parse(init.body)\n      } catch {\n        /* raw body, not JSON */\n      }\n    }\n    const hit = bodyParsed === undefined ? undefined : await cache.lookup(bodyParsed)\n    if (hit) {\n      opts.onHit?.({ url, provider: hit.request.provider, model: hit.request.model })\n      const status = hit.response.statusCode ?? 200\n      const headers = new Headers(\n        Object.entries(hit.response.responseHeaders ?? { 'Content-Type': 'application/json' }),\n      )\n      const bodyText =\n        typeof hit.response.responseBody === 'string'\n          ? hit.response.responseBody\n          : JSON.stringify(hit.response.responseBody ?? {})\n      return new Response(bodyText, { status, headers })\n    }\n    opts.onMissNotify?.({ url, requestBody: bodyParsed })\n    if (onMiss === 'throw') {\n      const key = bodyParsed === undefined ? '<unparseable>' : await keyFromBody(bodyParsed)\n      throw new ReplayCacheMissError(url, key)\n    }\n    if (onMiss === 'fail-closed') {\n      return new Response(JSON.stringify({ error: 'replay_cache_miss' }), { status: 599 })\n    }\n    if (!fallback)\n      throw new ReplayError('replay fetch: onMiss=fallback but no fallbackFetch configured')\n    return fallback(input as RequestInfo, init)\n  }) as typeof fetch\n}\n\n/**\n * Convenience iterator over `(request, response)` pairs in a sink — for\n * post-hoc scoring that doesn't need a `fetch` shim. The judge or scorer\n * runs purely in-process over cached LLM outputs.\n */\nexport async function* iterateRawCalls(\n  sink: RawProviderSink,\n  filter: { runId?: string; spanId?: string } = {},\n): AsyncGenerator<ReplayCacheEntry> {\n  if (!sink.list) {\n    throw new ReplayError('iterateRawCalls: sink must implement list().')\n  }\n  const events = await sink.list(filter)\n  const cache = await ReplayCache.fromEvents(events)\n  for (const entry of cache.entries()) yield entry\n}\n\n// ── Hashing ──────────────────────────────────────────────────────────────\n\n/**\n * Canonical request key.\n *\n * `model + messages + temperature + max_tokens|max_completion_tokens +\n * response_format` are the dimensions that affect the response shape.\n * Other fields (timestamp headers, provider-specific metadata) are\n * intentionally excluded so a request hashes the same across re-runs.\n */\nasync function requestKey(event: RawProviderEvent): Promise<string> {\n  return keyFromBody(event.requestBody)\n}\n\nasync function keyFromBody(body: unknown): Promise<string> {\n  if (body == null || typeof body !== 'object') return hashJson({ raw: String(body) })\n  const b = body as Record<string, unknown>\n  const reduced = canonicalize({\n    model: b.model ?? null,\n    messages: b.messages ?? null,\n    temperature: b.temperature ?? null,\n    max_tokens: b.max_tokens ?? null,\n    max_completion_tokens: b.max_completion_tokens ?? null,\n    response_format: b.response_format ?? null,\n  })\n  return hashJson(reduced)\n}\n"],"mappings":"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"}

package/dist/researcher-Doo95b50.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"researcher-Doo95b50.d.ts","names":[],"sources":["../src/eval-campaign.ts","../src/researcher.ts"],"mappings":";;;;;;;;;UAyEiB,gBAAgB;EAC/B;EACA,SAAS;;UAGM;EACf;;EAEA,OAAO;;UAGQ,mBAAmB;;EAElC;;EAEA;EACA,SAAS;EACT;EACA;EACA,cAAc;EACd;EACA,UAAU;;;;;;;EAOV,SAAS;EACT,OAAO;EACP,SAAS;;;;;;EAMT,SAAS;;UAGD;;EAER;;EAEA;;EAEA;;EAEA,gBAAgB;EAChB,YAAY;;EAEZ;;EAEA;;EAEA;;EAEA,MAAM;;EAEN,gBAAgB;;;;;;EAMhB,cAAc;;;;;;EAMd,eAAe,mBAAmB;;;KAIxB,qBAAqB,2BAA2B;KAEhD,eAAe,MAAM,KAAK,mBAAmB,OAAO,QAAQ;KAE5D;UAEK,oBAAoB;;;;;EAKnC;EACA,UAAU,gBAAgB;EAC1B,WAAW;;EAEX;;EAEA,WAAW;;EAEX;;;;;;EAMA,SAAS;;;;;;EAMT,oBAAoB;;;;;;EAMpB,eAAe,QAAQ,0BAA0B;;;;;;;EAOjD,kBAAkB,QAAQ,0BAA0B;;;;;EAKpD;;;;;EAKA,gBAAgB;;;;;;EAMhB,YAAY;;EAEZ,qBAAqB;;;;;EAKrB,QAAQ,eAAe;;;;;EAKvB;IAAW;MAAwB,KACjC;;;;;EAOF;;EAEA;;;;EAIA;;EAEA,SAAS,QAAQ;;;;;;;EAOjB,eACI,mBACA,0BAEE,QAAQ;IACN,SAAS;IACT,cAAc;QAGd,mBACA,wBACA,QAAQ,mBAAmB;;UAGpB;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;;EAEA;EACA;;EAEA,MAAM;;EAEN,kBAAkB;EAClB,YAAY;;EAEZ,SAAS;EACT;EACA;;iBAgBoB,gBAAgB,GACpC,MAAM,oBAAoB,KACzB,QAAQ;;;;UC5QM;;;EAGf;;EAEA;EACA;;;IAGE;;IAEA;;;;UAKa;EACf;;;;EAIA;;;EAGA;;EAEA;;;UAIe;EACf;EACA;EACA,SAAS;;;EAGT;;EAEA;IAAU;IAAkB;;;;UAIb;EACf,MAAM;EACN,MAAM;EACN,cAAc;;;;;;;;;;;;;;;;;;;UAoBC;EACf,gBAAgB,MAAM,cAAc,QAAQ;EAC5C,cAAc,UAAU,gBAAgB,QAAQ;EAChD,YAAY,SAAS,kBAAkB,UAAU,iBAAiB,QAAQ;EAC1E,eAAe,MAAM,iBAAiB,QAAQ;;UAG/B;EACf,iBAAiB;EACjB,eAAe;EACf,aAAa;EACb,gBAAgB;;;;;;cAOL,8BAA8B;mBACZ;EAA7B,YAA6B,WAAW;EAExC,gBAAgB,MAAM,cAAc,QAAQ;EAI5C,cAAc,UAAU,gBAAgB,QAAQ;EAIhD,YAAY,SAAS,kBAAkB,UAAU,iBAAiB,QAAQ;EAI1E,eAAe,MAAM,iBAAiB,QAAQ;;;;;;;;;cAYnC,0BAA0B;mBACpB;EAEjB,YAAY;EAIN,gBAAgB,OAAO,cAAc,QAAQ;EAI7C,cAAc,WAAW,gBAAgB,QAAQ;EAIjD,YACJ,UAAU,kBACV,WAAW,iBACV,QAAQ;EAIL,eAAe,OAAO,iBAAiB,QAAQ"}