@tangle-network/agent-eval 0.163.2 → 0.171.0

package/dist/index-fNXZMCzX.d.ts

@@ -0,0 +1,704 @@
+import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
+import { a as RunRecord, n as RunCostProvenance, s as RunSplitTag } from "./run-record-DQjRcYwA.js";
+import "./types-DMoNFDWi.js";
+import "./provenance-CafMdZKM.js";
+import { _ as GateDecision } from "./types-JHMOqZI4.js";
+import "./heldout-gate-Dh2b62w8.js";
+import "./promotion-policy-WSXtBgBb.js";
+import { o as InsightReport } from "./insight-report-08F022xN.js";
+import { c as EvalRunGenerationSnapshot, g as TraceSpanEvent, o as EvalRunCellScore, s as EvalRunEvent } from "./client-CDtcZ3p9.js";
+import "./define-agent-eval-Cjy2yhqP.js";
+import "./default-registry-B0s2zU-s.js";
+import { _ as AnalyzeRunsOptions } from "./engine-CAmTUk52.js";
+import { AgentCandidateBenchmarkCellRef, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkTaskMaterial, AgentCandidateBundle, AgentCandidateEvaluationPolicy, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentImprovementCost, AgentImprovementMeasuredComparison, AgentProfileImprovementExperiment, AgentProfileImprovementExperimentMaterial, AgentProfileImprovementMeasuredComparison, AgentProfileImprovementMeasurement, AgentProfileImprovementRunCell, AgentProfileImprovementRunReceipt, AgentProfileImprovementSuiteInputs, AgentProfileImprovementTask, AgentProfileImprovementTaskMaterial, CandidateExecutionEvidence, Sha256Digest } from "@tangle-network/agent-interface";
+//#region src/contract/measured-comparison.d.ts
+interface SealCandidateBenchmarkSuiteOptions {
+  tasks: [AgentCandidateBenchmarkTask, ...AgentCandidateBenchmarkTask[]];
+  reps: number;
+  seeds: [number, ...number[]];
+}
+interface CandidateExperimentExecutionInput {
+  experiment: AgentCandidateExperiment;
+  arm: 'baseline' | 'candidate';
+  bundle: AgentCandidateBundle;
+  task: AgentCandidateBenchmarkTask;
+  benchmarkCell: AgentCandidateBenchmarkCellRef;
+  seed: number;
+  signal?: AbortSignal;
+}
+interface RunCandidateExperimentOptions {
+  experiment: AgentCandidateExperiment;
+  execute(input: CandidateExperimentExecutionInput): Promise<CandidateExecutionEvidence>;
+  /** Maximum number of simultaneous execute calls across both arms. */
+  maxConcurrency?: number;
+  /** Shared run budget that also accounts for analysis and candidate search. */
+  costLedger?: CostLedgerHandle;
+  signal?: AbortSignal;
+}
+interface CandidateExperimentRun {
+  measurements: AgentCandidateExperimentMeasurement[];
+  measurement: {
+    wallDurationMs: number;
+    cost: AgentImprovementCost;
+  };
+}
+interface CompareCandidateExperimentOptions {
+  experiment: AgentCandidateExperiment;
+  measurements: AgentCandidateExperimentMeasurement[];
+  preparation: {
+    wallDurationMs: number;
+    cost: AgentImprovementCost;
+  };
+  measurement: CandidateExperimentRun['measurement'];
+  runId: string;
+  candidate?: AgentImprovementMeasuredComparison['candidate'];
+  generationsExplored?: number;
+  metadata?: AgentImprovementMeasuredComparison['metadata'];
+}
+/** One exact baseline/candidate observation of the same held-out cell. */
+interface PairedMeasurement<TRun> {
+  cellId: string;
+  baseline: TRun;
+  candidate: TRun;
+}
+/** Maps a product-owned run receipt into the measurements required for a fair paired decision. */
+interface PairedMeasurementAdapter<TRun> {
+  score(run: TRun): number;
+  dimensions(run: TRun): readonly {
+    name: string;
+    score: number;
+  }[];
+  costUsd(run: TRun): number;
+  costProvenance(run: TRun): AgentImprovementCost['provenance'];
+  latencyMs(run: TRun): number;
+  completed(run: TRun): boolean;
+  passed(run: TRun): boolean;
+}
+interface EvaluatePairedMeasurementsOptions<TRun> {
+  measurements: readonly PairedMeasurement<TRun>[];
+  policy: AgentCandidateEvaluationPolicy;
+  adapter: PairedMeasurementAdapter<TRun>;
+  /** Whether both arms use the same scorer family as the promotion decision. */
+  sharedScorerChannel: boolean;
+  /** Analysis and candidate-search spend that belongs to the same frozen budget. */
+  preparationCost?: AgentImprovementCost;
+  /** Settled aggregate receipt for this exact paired suite, when an executor provides one. */
+  measurementCost?: AgentImprovementCost;
+}
+/** Statistical and operational result derived from complete paired receipts. */
+type PairedMeasurementEvaluation = Pick<AgentImprovementMeasuredComparison, 'overall' | 'objectives' | 'decision' | 'power'> & {
+  measurementCost: AgentImprovementCost;
+  totalCost: AgentImprovementCost;
+  measurementWorkDurationMs: number;
+};
+/** Content-address one task before any measured execution can see it. */
+declare function sealCandidateBenchmarkTask(material: AgentCandidateBenchmarkTaskMaterial): AgentCandidateBenchmarkTask;
+/** Freeze task order, repetitions, and every seed before either arm runs. */
+declare function sealCandidateBenchmarkSuite(options: SealCandidateBenchmarkSuiteOptions): AgentCandidateBenchmarkSuiteInputs;
+/** Freeze both complete agent states and their exact held-out work. */
+declare function sealCandidateExperiment(material: AgentCandidateExperimentMaterial): AgentCandidateExperiment;
+declare function verifyCandidateExperiment(input: unknown): AgentCandidateExperiment;
+/** Execute each signed cell for both arms. The callback is Runtime's one executor. */
+declare function runCandidateExperiment(options: RunCandidateExperimentOptions): Promise<CandidateExperimentRun>;
+/**
+ * Calculate the shared paired decision from any complete receipt shape.
+ *
+ * Callers still own sealing their tasks, verifying each receipt against its
+ * expected arm and state, and proving every expected cell exists. This function
+ * only validates the projected measurements and derives their shared decision.
+ */
+declare function evaluatePairedMeasurements<TRun>(options: EvaluatePairedMeasurementsOptions<TRun>): PairedMeasurementEvaluation;
+/** Build the only publishable comparison: paired statistics over Runtime receipts. */
+declare function measuredComparisonFromCandidateExperiment(options: CompareCandidateExperimentOptions): AgentImprovementMeasuredComparison;
+/** Recompute every statistic and decision from the signed experiment receipts. */
+declare function verifyCandidateExperimentComparison(input: unknown): AgentImprovementMeasuredComparison;
+//#endregion
+//#region src/contract/profile-measured-comparison.d.ts
+interface SealAgentProfileImprovementSuiteOptions {
+  splitDigest: Sha256Digest;
+  tasks: [AgentProfileImprovementTask, ...AgentProfileImprovementTask[]];
+  reps: number;
+  seeds: [number, ...number[]];
+}
+interface AgentProfileImprovementExperimentExecutionInput {
+  experiment: AgentProfileImprovementExperiment;
+  arm: 'baseline' | 'candidate';
+  stateDigest: Sha256Digest;
+  task: AgentProfileImprovementTask;
+  runCell: AgentProfileImprovementRunCell;
+  seed: number;
+  signal?: AbortSignal;
+}
+interface RunAgentProfileImprovementExperimentOptions {
+  experiment: AgentProfileImprovementExperiment;
+  execute(input: AgentProfileImprovementExperimentExecutionInput): Promise<AgentProfileImprovementRunReceipt>;
+  /** Maximum number of simultaneous execute calls across both arms. */
+  maxConcurrency?: number;
+  /** Shared run budget that also accounts for analysis and candidate search. */
+  costLedger?: CostLedgerHandle;
+  signal?: AbortSignal;
+}
+interface AgentProfileImprovementExperimentRun {
+  measurements: AgentProfileImprovementMeasurement[];
+  measurement: {
+    wallDurationMs: number;
+    cost: AgentImprovementCost;
+  };
+}
+interface CompareAgentProfileImprovementExperimentOptions {
+  experiment: AgentProfileImprovementExperiment;
+  measurements: AgentProfileImprovementMeasurement[];
+  preparation: {
+    wallDurationMs: number;
+    cost: AgentImprovementCost;
+  };
+  measurement: AgentProfileImprovementExperimentRun['measurement'];
+  runId: string;
+  candidate?: AgentProfileImprovementMeasuredComparison['candidate'];
+  generationsExplored?: number;
+  metadata?: AgentProfileImprovementMeasuredComparison['metadata'];
+}
+/** Content-address one held-out profile task before either state can execute it. */
+declare function sealAgentProfileImprovementTask(material: AgentProfileImprovementTaskMaterial): AgentProfileImprovementTask;
+/** Freeze profile task order, repetitions, seeds, and the held-out split. */
+declare function sealAgentProfileImprovementSuite(options: SealAgentProfileImprovementSuiteOptions): AgentProfileImprovementSuiteInputs;
+/** Freeze the two host-owned profile states and their exact held-out work. */
+declare function sealAgentProfileImprovementExperiment(material: AgentProfileImprovementExperimentMaterial): AgentProfileImprovementExperiment;
+/**
+ * Execute each signed profile cell through the host's one exact-state executor.
+ * Eval owns only the cell schedule and receipt checks; the host resolves each
+ * state digest and captures its own run, billing, trace, and grader evidence.
+ */
+declare function runAgentProfileImprovementExperiment(options: RunAgentProfileImprovementExperimentOptions): Promise<AgentProfileImprovementExperimentRun>;
+/** Build the only publishable profile comparison from complete host receipts. */
+declare function measuredComparisonFromAgentProfileImprovementExperiment(options: CompareAgentProfileImprovementExperimentOptions): AgentProfileImprovementMeasuredComparison;
+/** Recompute a profile comparison from the exact sealed experiment and receipts. */
+declare function verifyAgentProfileImprovementExperimentComparison(input: unknown): AgentProfileImprovementMeasuredComparison;
+//#endregion
+//#region src/contract/intake/run-record-dir.d.ts
+/** A record that failed boundary validation, with enough context to fix it. */
+interface RunRecordRejection {
+  /** Absolute or caller-relative path to the file the record came from. */
+  file: string;
+  /** Zero-based position within the file (array index or JSONL line number). */
+  index: number;
+  /** The validator's message. */
+  reason: string;
+}
+interface FromRunRecordDirOptions {
+  /**
+   * How to treat a record that fails `parseRunRecordSafe`:
+   *   - `'throw'` (default) — fail loud on the first invalid record.
+   *   - `'collect'` — drop it, keep the rest, and return it under `rejected`.
+   */
+  onInvalid?: 'throw' | 'collect';
+  /**
+   * When the input is a directory, only files matching this predicate are
+   * read. Default: any file ending in `.json` or `.jsonl`. The `analysis.json`
+   * artifact `evalReportingSuite` writes is always skipped so a re-run never
+   * ingests its own output.
+   */
+  include?: (fileName: string) => boolean;
+  /**
+   * Recurse into subdirectories when the input is a directory. Default false —
+   * a flat run directory is the common case and recursion can silently pull in
+   * unrelated corpora.
+   */
+  recursive?: boolean;
+}
+interface FromRunRecordDirResult {
+  /** Records that passed boundary validation, in file-then-index order. */
+  runs: RunRecord[];
+  /** Records that failed validation. Empty unless `onInvalid: 'collect'`. */
+  rejected: RunRecordRejection[];
+  /** The files that were read, in the order they were processed. */
+  files: string[];
+}
+/**
+ * Resolve a file or directory path into validated `RunRecord[]`.
+ *
+ * A `.json` file must parse to a top-level array; a `.jsonl` file is one
+ * record per non-empty line. Directories are read shallowly by default
+ * (set `recursive` to descend); the `analysis.json` output artifact is
+ * always excluded.
+ */
+declare function fromRunRecordDir(path: string, options?: FromRunRecordDirOptions): Promise<FromRunRecordDirResult>;
+//#endregion
+//#region src/contract/eval-reporting-suite.d.ts
+/** Either records in hand or a path to a `.json` / `.jsonl` file or a
+ *  directory of them. */
+type EvalReportingSuiteInput = RunRecord[] | string;
+interface EvalReportingSuiteOptions {
+  /** Forwarded verbatim to `analyzeRuns` (everything except `runs`, which the
+   *  suite supplies from the resolved input). Use this for split selection,
+   *  baseline/candidate ids, canaries, prior-period runs, the analyst registry,
+   *  etc. */
+  analyze?: Omit<AnalyzeRunsOptions, 'runs'>;
+  /** Loader options used only when the input is a path. */
+  load?: FromRunRecordDirOptions;
+  /**
+   * Write the suite result as a single `analysis.json`.
+   *   - `true` — write to `<dir>/analysis.json` when the input is a directory,
+   *     or alongside the input file; throws if the input is in-memory records
+   *     (no directory to anchor to — pass an explicit path instead).
+   *   - a string — write to exactly this path (a directory path gets
+   *     `analysis.json` appended; any other path is used verbatim).
+   *   - omitted / false — do not write.
+   */
+  write?: boolean | string;
+}
+/** The suite artifact — the `analyzeRuns` report plus provenance. This is the
+ *  exact shape serialized to `analysis.json`. */
+interface EvalReportingSuiteResult {
+  /** The analysis itself — distributions, paired stats/lift, failure rollup,
+   *  recommendations. Produced by `analyzeRuns`. */
+  report: InsightReport;
+  /** How the suite was run, so a reader can verify provenance. */
+  provenance: {
+    /** ISO timestamp the suite ran. */
+    generatedAt: string;
+    /** Number of records analyzed (mirrors `report.n`). */
+    runCount: number;
+    /** The source path when the input was a directory/file; null for
+     *  in-memory records. */
+    sourcePath: string | null;
+    /** Files read when loading from disk; empty for in-memory input. */
+    files: string[];
+    /** Records dropped at the validation boundary. Always empty unless
+     *  `load.onInvalid` was set to `'collect'`. */
+    rejected: FromRunRecordDirResult['rejected'];
+  };
+  /** The path `analysis.json` was written to, or null when `write` was unset. */
+  writtenTo: string | null;
+}
+/**
+ * Resolve runs (or a run dir/file), run `analyzeRuns`, and optionally persist a
+ * single `analysis.json`. The only analysis logic lives in `analyzeRuns`; this
+ * function is composition + I/O.
+ */
+declare function evalReportingSuite(input: EvalReportingSuiteInput, options?: EvalReportingSuiteOptions): Promise<EvalReportingSuiteResult>;
+//#endregion
+//#region src/contract/diff.d.ts
+/** Per-dimension delta. `before` / `after` are null when the judge did not
+ *  emit a value for that side. `delta` is `after - before`; null when
+ *  either side is null. */
+interface EvalDimensionDelta {
+  before: number | null;
+  after: number | null;
+  delta: number | null;
+}
+/** Per-cell delta, keyed on `(scenarioId, rep)`. */
+interface EvalCellScoreDelta {
+  scenarioId: string;
+  rep: number;
+  compositeBefore: number | null;
+  compositeAfter: number | null;
+  compositeDelta: number | null;
+  /** Per-judge → per-dimension deltas. Outer key = judge name from
+   *  `EvalRunCellScore.dimensions`; inner key = dimension name. */
+  dimensions: Record<string, Record<string, EvalDimensionDelta>>;
+}
+/** Diff between two generation snapshots — the unit the dashboard renders
+ *  for a single "v3 vs v4" comparison. */
+interface EvalGenerationDiff {
+  beforeIndex: number;
+  afterIndex: number;
+  beforeSurfaceHash: string;
+  afterSurfaceHash: string;
+  surfaceChanged: boolean;
+  /** Cells present in both snapshots, matched on `(scenarioId, rep)`. */
+  matched: EvalCellScoreDelta[];
+  /** Cells present in `before` but missing from `after`. */
+  removed: EvalRunCellScore[];
+  /** Cells present in `after` but missing from `before`. */
+  added: EvalRunCellScore[];
+  /** Aggregate composite mean, null when that snapshot was unscored. */
+  compositeBefore: number | null;
+  compositeAfter: number | null;
+  compositeDelta: number | null;
+  costUsdBefore: number;
+  costUsdAfter: number;
+  costUsdDelta: number;
+  durationMsBefore: number;
+  durationMsAfter: number;
+  durationMsDelta: number;
+}
+/** Diff between two full eval-runs. Includes both baseline-vs-baseline and
+ *  winner-vs-winner generation diffs when both sides expose them, plus
+ *  run-level metadata. */
+interface EvalRunDiff {
+  beforeRunId: string;
+  afterRunId: string;
+  beforeTimestamp: string;
+  afterTimestamp: string;
+  beforeGateDecision: GateDecision | null;
+  afterGateDecision: GateDecision | null;
+  beforeHoldoutLift: number | null;
+  afterHoldoutLift: number | null;
+  holdoutLiftDelta: number | null;
+  beforeTotalCostUsd: number;
+  afterTotalCostUsd: number;
+  totalCostUsdDelta: number;
+  beforeTotalDurationMs: number;
+  afterTotalDurationMs: number;
+  totalDurationMsDelta: number;
+  /** Baseline-vs-baseline diff. Null when either run has no baseline. */
+  baselineDiff: EvalGenerationDiff | null;
+  /** Highest-index-generation comparison. Null when either run has no
+   *  recorded generations (e.g. baseline-only or errored before any
+   *  generation completed). */
+  winnersDiff: EvalGenerationDiff | null;
+}
+/**
+ * Diff two generation snapshots. Cells are matched on `(scenarioId, rep)`;
+ * unmatched cells surface in `added` / `removed`. Aggregate fields are
+ * recomputed from the snapshot's stored fields, not re-derived from cells —
+ * this keeps the diff consistent with whatever aggregation the substrate
+ * actually reported.
+ */
+declare function diffGenerations(before: EvalRunGenerationSnapshot, after: EvalRunGenerationSnapshot): EvalGenerationDiff;
+/**
+ * Diff two full eval-runs. Produces baseline-vs-baseline and
+ * winner-vs-winner generation diffs when both sides expose them, plus
+ * run-level cost / lift / gate-decision deltas.
+ */
+declare function diffRuns(before: EvalRunEvent, after: EvalRunEvent): EvalRunDiff;
+/**
+ * Within-run baseline → winning-generation diff. The natural "what did the
+ * improvement loop produce" view for a single run. Returns null when the
+ * run never reached a generation past baseline (errored early, or the gate
+ * shipped the baseline as-is).
+ */
+declare function diffRunBaselineToWinner(run: EvalRunEvent): EvalGenerationDiff | null;
+//#endregion
+//#region src/contract/intake/agent-trace.d.ts
+type AgentTraceContributorType = 'human' | 'ai' | 'mixed' | 'unknown';
+interface AgentTraceContributor {
+  type: AgentTraceContributorType;
+  /** models.dev id, e.g. `anthropic/claude-opus-4-5-20251101`. */
+  model_id?: string;
+}
+interface AgentTraceRange {
+  start_line: number;
+  end_line: number;
+  content_hash?: string;
+  /** Per-range contributor override (agent handoffs). Wins over the
+   *  conversation-level contributor for these lines. */
+  contributor?: AgentTraceContributor;
+}
+interface AgentTraceConversation {
+  url?: string;
+  contributor?: AgentTraceContributor;
+  ranges: AgentTraceRange[];
+}
+interface AgentTraceFile {
+  path: string;
+  conversations: AgentTraceConversation[];
+}
+interface AgentTraceRecord {
+  version: string;
+  id: string;
+  timestamp: string;
+  vcs?: {
+    type: string;
+    revision: string;
+  };
+  tool?: {
+    name?: string;
+    version?: string;
+  };
+  files: AgentTraceFile[];
+}
+/** Authorship provenance for one VCS revision, aggregated across the record's
+ *  files/conversations/ranges. */
+interface AuthoringProvenance {
+  commitSha: string;
+  /** Unique AI model ids that authored code in this commit (type ai|mixed). */
+  aiModels: string[];
+  /** Tools that produced the records (e.g. `cursor`). */
+  tools: string[];
+  conversationCount: number;
+  fileCount: number;
+  /** Total attributed lines (sum of range spans). */
+  lineCount: number;
+  /** True if any range was authored (in whole or part) by a human. */
+  humanInvolved: boolean;
+}
+type AgentTraceIndex = Map<string, AuthoringProvenance>;
+/**
+ * Build a commit → provenance index from Agent Trace records. Multiple records
+ * for the same revision are merged. Records without `vcs.revision` are skipped
+ * (the SHA is the join key — without it there is nothing to correlate against).
+ */
+declare function parseAgentTrace(records: AgentTraceRecord[]): AgentTraceIndex;
+interface PartitionByAuthoringModelResult {
+  /** Runs grouped by each AI model that authored code in the run's commit. A
+   *  run whose commit had multiple authoring models appears under EACH — the
+   *  cohorts overlap by construction at commit granularity. */
+  byModel: Map<string, RunRecord[]>;
+  /** Runs whose `commitSha` had no Agent Trace provenance (no record, or no
+   *  AI authorship). Kept separate — never silently folded into a cohort. */
+  unattributed: RunRecord[];
+}
+/**
+ * Partition runs by the AI model(s) that authored the code at each run's
+ * `commitSha`. Feed `byModel.get(modelId)` to `analyzeRuns`, or compare two
+ * model cohorts via `analyzeRuns({ runs: a, baselineRuns: b })` for a lift CI
+ * on "model A's code vs model B's code".
+ */
+declare function partitionRunsByAuthoringModel(runs: RunRecord[], index: AgentTraceIndex): PartitionByAuthoringModelResult;
+//#endregion
+//#region src/contract/intake/code-agent-observation.d.ts
+type CodeAgentSessionSource = 'codex' | 'claude-code' | 'opencode' | 'kimi-code' | 'pi';
+type CodeAgentSessionTerminalStatus = 'completed' | 'failed' | 'unknown';
+type CodeAgentSessionActionKind = 'tool' | 'patch' | 'terminal' | 'graph-completion';
+type CodeAgentSessionActionSurface = 'tool' | 'mcp' | 'subagent' | 'skill' | 'hook' | 'web' | 'code';
+type CodeAgentSessionActionStatus = 'started' | 'completed' | 'failed' | 'unknown';
+interface CodeAgentSessionExecutionReceipt {
+  exitCode: number;
+  startedAtMs?: number;
+  completedAtMs?: number;
+}
+interface CodeAgentSessionAction {
+  id: string;
+  stepIndex: number;
+  kind: CodeAgentSessionActionKind;
+  surface: CodeAgentSessionActionSurface;
+  name: string;
+  status: CodeAgentSessionActionStatus;
+  timestampMs?: number;
+  costUsd?: number;
+  metadata: Record<string, unknown>;
+}
+interface CodeAgentSessionObservation {
+  source: CodeAgentSessionSource;
+  sessionId: string;
+  finalText: string | null;
+  terminal: {
+    status: CodeAgentSessionTerminalStatus;
+    explicit: boolean;
+  };
+  actions: CodeAgentSessionAction[];
+}
+interface ObserveCodeAgentSessionOptions {
+  source: CodeAgentSessionSource;
+  entries: unknown[];
+  sourcePath?: string;
+  execution?: CodeAgentSessionExecutionReceipt;
+}
+/**
+ * Project one provider session into the exact user-visible answer and a
+ * provider-neutral action stream. Raw prompts, tool inputs, and tool outputs
+ * stay out of this projection; callers retain the source JSONL as evidence.
+ */
+declare function observeCodeAgentSession(options: ObserveCodeAgentSessionOptions): CodeAgentSessionObservation;
+//#endregion
+//#region src/contract/intake/code-agent-session.d.ts
+interface ParsedCodeAgentJsonl {
+  entries: unknown[];
+  malformedLines: number;
+}
+interface CodeAgentSessionMetrics {
+  entries: number;
+  userMessages: number;
+  assistantMessages: number;
+  reasoningItems: number;
+  toolCalls: number;
+  toolOutputs: number;
+  toolErrors: number;
+  unclassifiedErrors: number;
+  patchAttempts: number;
+  patchSuccesses: number;
+  patchFailures: number;
+  turnsStarted: number;
+  turnsCompleted: number;
+  turnsAborted: number;
+  contextCompactions: number;
+  mcpCalls: number;
+  subagentCalls: number;
+  skillCalls: number;
+  hookCalls: number;
+  webCalls: number;
+  codeActions: number;
+  prLinks: number;
+  fileSnapshots: number;
+  graphNodes: number;
+  graphEdges: number;
+  actionCandidates: number;
+  verificationReports: number;
+  completionDecisions: number;
+  reliabilityRows: number;
+  reliabilityLift: number;
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+  cachedTokens: number;
+  cacheWriteTokens: number;
+  observedCostUsd: number;
+  observedCostCaptured?: boolean;
+  wallMs: number;
+  processScore: number;
+}
+interface CodeAgentSessionDiagnostic {
+  source: CodeAgentSessionSource;
+  sessionId: string;
+  sourcePath?: string;
+  entries: number;
+  malformedLines: number;
+  hasExplicitTerminalSignal: boolean;
+  hasFinalOutput: boolean;
+  hasQualityLabel: boolean;
+  hasTokenUsage: boolean;
+  hasCost: boolean;
+  costKind?: RunCostProvenance['kind'];
+  warnings: string[];
+}
+interface CodeAgentSessionIntakeResult {
+  runs: RunRecord[];
+  diagnostics: CodeAgentSessionDiagnostic[];
+  metrics: CodeAgentSessionMetrics[];
+  observations: CodeAgentSessionObservation[];
+}
+interface CodeAgentSessionIntakeOptions {
+  entries: unknown[];
+  malformedLines?: number;
+  sourcePath?: string;
+  experimentId?: string;
+  candidateId?: string;
+  seed?: number;
+  splitTag?: RunSplitTag;
+  scenarioId?: string;
+  model?: string;
+  promptHash?: string;
+  configHash?: string;
+  commitSha?: string;
+  score?: number;
+  /** Explicit cost receipt. When omitted, source-reported cost wins, then a
+   *  token-priced estimate, then uncaptured. */
+  costProvenance?: RunCostProvenance;
+  /** Exact executor-owned process result. This is required when a provider's
+   * JSON stream has no terminal event, as with `opencode run --format json`. */
+  execution?: CodeAgentSessionExecutionReceipt;
+}
+/** One transcript line after the intake rule ran on it. A blank line produces
+ *  nothing, so every value here is either a parsed entry or a counted defect. */
+type CodeAgentJsonlLine = {
+  kind: 'entry';
+  lineNumber: number;
+  entry: unknown;
+} | {
+  kind: 'malformed';
+  lineNumber: number;
+};
+declare function parseCodeAgentJsonl(jsonl: string): ParsedCodeAgentJsonl;
+/** Reads a transcript one line at a time and never holds the file as a single
+ *  string. `parseCodeAgentJsonl` needs the whole file in one string, so a
+ *  session above V8's ~512MB string ceiling throws `ERR_STRING_TOO_LONG` and
+ *  cannot be ingested at all; the largest real Codex rollout on record is 695MB.
+ *
+ *  Lines break on `\n` only, which is what the string path's `split('\n')` does.
+ *  `node:readline` also breaks on a bare `\r`, so it is deliberately not used
+ *  here: a lone carriage return inside a line must stay inside that line for the
+ *  two paths to report the same malformed count. */
+declare function streamCodeAgentJsonlFile(path: string): AsyncGenerator<CodeAgentJsonlLine>;
+/** Streaming counterpart to `parseCodeAgentJsonl` for a transcript on disk.
+ *  It returns the same shape, so a caller that holds every entry keeps working
+ *  above the string ceiling. The entry array still grows with the transcript;
+ *  consume `streamCodeAgentJsonlFile` directly when memory must stay flat. */
+declare function parseCodeAgentJsonlFile(path: string): Promise<ParsedCodeAgentJsonl>;
+declare function fromCodexSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
+declare function fromClaudeCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
+declare function fromOpenCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
+declare function fromKimiCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
+declare function fromPiSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
+//#endregion
+//#region src/contract/intake/feedback-table.d.ts
+interface FeedbackTableRow {
+  /** Stable id for this run — the unit a rater scored. Drives pairing
+   *  across analysis primitives. */
+  runId: string;
+  /** Identifier of the rater that produced this rating. */
+  rater: string;
+  /** The rating itself. Accepts boolean (approve/reject), 0..1 scalar,
+   *  or any numeric scale — see `scale`. */
+  rating: number | boolean;
+  /** Optional metadata carried through to `RunRecord.outcome.raw` and the
+   *  custom-shape metadata bag. */
+  metadata?: Record<string, unknown>;
+}
+interface FeedbackTableMeta {
+  runId: string;
+  /** When omitted, defaults to `'feedback-corpus'`. Used to group related
+   *  runs in `analyzeRuns()` lift analysis. */
+  experimentId?: string;
+  /** When omitted, defaults to `runId` — each run is its own candidate. */
+  candidateId?: string;
+  /** Observed cost in USD, when available. */
+  costUsd?: number;
+  /** Stable scenario identity. Defaults to `runId`. */
+  scenarioId?: string;
+  /** Wall-clock ms, when available. Defaults to 0. */
+  wallMs?: number;
+  /** Model identifier including snapshot. Default `unknown@unknown`. */
+  model?: string;
+  /** Optional sha256 of the prompt; default `'sha256:unknown'`. */
+  promptHash?: string;
+  /** Default `'sha256:unknown'`. */
+  configHash?: string;
+  /** Default `'unknown'`. */
+  commitSha?: string;
+  /** Default `'holdout'` — feedback corpora are by nature the holdout
+   *  signal a closed-loop improvement aims at. */
+  splitTag?: RunSplitTag;
+  /** Free-form metadata available to consumers via the cast-out path on
+   *  the resulting RunRecord. */
+  extras?: Record<string, unknown>;
+}
+interface FromFeedbackTableOptions {
+  /** Per-(run, rater) ratings. */
+  ratings: FeedbackTableRow[];
+  /** Per-run metadata. When a runId appears in `ratings` but not here, the
+   *  adapter synthesises minimal metadata with defaults documented above. */
+  meta?: FeedbackTableMeta[];
+  /** Rating scale. Provide `{ min, max }` for non-0..1 numeric scales.
+   *  Booleans are normalised: true → 1, false → 0. Default: assumes
+   *  ratings are already 0..1. */
+  scale?: {
+    min: number;
+    max: number;
+  };
+  /** When true, the rater scores are emitted into `raterScores` (a sibling
+   *  array `analyzeRuns()` accepts) in addition to the aggregate run score.
+   *  Default `true` preserves rater-level signal for inter-rater analysis. */
+  emitRaterScores?: boolean;
+}
+interface FromFeedbackTableResult {
+  runs: RunRecord[];
+  /** Rater-level scores ready to pass into `analyzeRuns({ raterScores })`
+   *  for inter-rater agreement + disagreement triage. */
+  raterScores: Array<{
+    runId: string;
+    rater: string;
+    score: number;
+  }>;
+}
+declare function fromFeedbackTable(opts: FromFeedbackTableOptions): FromFeedbackTableResult;
+//#endregion
+//#region src/contract/intake/otel-spans.d.ts
+interface FromOtelSpansOptions {
+  spans: TraceSpanEvent[];
+  /** Default split tag for synthesized records. Defaults to `'holdout'`. */
+  defaultSplit?: RunSplitTag;
+  /** Default `experimentId` when not present on any span. */
+  experimentId?: string;
+  /**
+   * Explicit task-quality score for a logical run. The callback receives
+   * spans in deterministic time/id order. Its value must agree with any
+   * designated score attributes present on root or `EVALUATOR` spans.
+   */
+  scoreForRun?: (runId: string, spans: readonly TraceSpanEvent[]) => number | undefined;
+}
+declare function fromOtelSpans(opts: FromOtelSpansOptions): RunRecord[];
+//#endregion
+export { FromRunRecordDirOptions as $, observeCodeAgentSession as A, verifyCandidateExperimentComparison as At, parseAgentTrace as B, CodeAgentSessionActionKind as C, evaluatePairedMeasurements as Ct, CodeAgentSessionObservation as D, sealCandidateBenchmarkTask as Dt, CodeAgentSessionExecutionReceipt as E, sealCandidateBenchmarkSuite as Et, AgentTraceIndex as F, EvalRunDiff as G, EvalCellScoreDelta as H, AgentTraceRange as I, diffRuns as J, diffGenerations as K, AgentTraceRecord as L, AgentTraceContributorType as M, AgentTraceConversation as N, CodeAgentSessionSource as O, sealCandidateExperiment as Ot, AgentTraceFile as P, evalReportingSuite as Q, AuthoringProvenance as R, CodeAgentSessionAction as S, SealCandidateBenchmarkSuiteOptions as St, CodeAgentSessionActionSurface as T, runCandidateExperiment as Tt, EvalDimensionDelta as U, partitionRunsByAuthoringModel as V, EvalGenerationDiff as W, EvalReportingSuiteOptions as X, EvalReportingSuiteInput as Y, EvalReportingSuiteResult as Z, fromOpenCodeSession as _, EvaluatePairedMeasurementsOptions as _t, FromFeedbackTableOptions as a, CompareAgentProfileImprovementExperimentOptions as at, parseCodeAgentJsonlFile as b, PairedMeasurementEvaluation as bt, CodeAgentJsonlLine as c, measuredComparisonFromAgentProfileImprovementExperiment as ct, CodeAgentSessionIntakeResult as d, sealAgentProfileImprovementSuite as dt, FromRunRecordDirResult as et, CodeAgentSessionMetrics as f, sealAgentProfileImprovementTask as ft, fromKimiCodeSession as g, CompareCandidateExperimentOptions as gt, fromCodexSession as h, CandidateExperimentRun as ht, FeedbackTableRow as i, AgentProfileImprovementExperimentRun as it, AgentTraceContributor as j, CodeAgentSessionTerminalStatus as k, verifyCandidateExperiment as kt, CodeAgentSessionDiagnostic as l, runAgentProfileImprovementExperiment as lt, fromClaudeCodeSession as m, CandidateExperimentExecutionInput as mt, fromOtelSpans as n, fromRunRecordDir as nt, FromFeedbackTableResult as o, RunAgentProfileImprovementExperimentOptions as ot, ParsedCodeAgentJsonl as p, verifyAgentProfileImprovementExperimentComparison as pt, diffRunBaselineToWinner as q, FeedbackTableMeta as r, AgentProfileImprovementExperimentExecutionInput as rt, fromFeedbackTable as s, SealAgentProfileImprovementSuiteOptions as st, FromOtelSpansOptions as t, RunRecordRejection as tt, CodeAgentSessionIntakeOptions as u, sealAgentProfileImprovementExperiment as ut, fromPiSession as v, PairedMeasurement as vt, CodeAgentSessionActionStatus as w, measuredComparisonFromCandidateExperiment as wt, streamCodeAgentJsonlFile as x, RunCandidateExperimentOptions as xt, parseCodeAgentJsonl as y, PairedMeasurementAdapter as yt, PartitionByAuthoringModelResult as z };
+//# sourceMappingURL=index-fNXZMCzX.d.ts.map