@tangle-network/agent-eval 0.95.0 → 0.95.1

package/dist/{trace-analyst/types.d.ts → store-C1YxJDEK.d.ts}

@@ -13,12 +13,12 @@
  * `ViewTraceOversized`.
  */
 /** OTLP span kind (subset we actually use). */
-export type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
-export type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
+type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
+type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
 /** Subset of OTLP span fields the analyst exposes to the agent. The
  *  store's job is to project upstream's full span shape down to this
  *  view — the analyst never sees vendor extensions directly. */
-export interface TraceAnalystSpan {
+interface TraceAnalystSpan {
     trace_id: string;
     span_id: string;
     parent_span_id: string | null;
@@ -37,7 +37,7 @@ export interface TraceAnalystSpan {
      *  callers must respect the per-attribute byte cap. */
     attributes: Record<string, unknown>;
 }
-export interface TraceAnalystTraceSummary {
+interface TraceAnalystTraceSummary {
     trace_id: string;
     service_name: string | null;
     agent_name: string | null;
@@ -50,7 +50,7 @@ export interface TraceAnalystTraceSummary {
     models: string[];
     tools: string[];
 }
-export interface TraceAnalystFilters {
+interface TraceAnalystFilters {
     /** Restrict to traces that contain at least one error span. */
     has_errors?: boolean;
     /** Match if any span's `service.name` is in this list. */
@@ -74,7 +74,7 @@ export interface TraceAnalystFilters {
  *  paths, durations) out of the span `status_message` so semantically identical
  *  failures collapse into one cluster. An analyst that accounts for every
  *  cluster has, by construction, covered every distinct failure mode. */
-export interface ErrorCluster {
+interface ErrorCluster {
     /** Normalized status_message — the cluster key. */
     signature: string;
     /** A verbatim, un-normalized exemplar message (for exact-string citation). */
@@ -92,7 +92,7 @@ export interface ErrorCluster {
     /** Real span ids carrying this signature (capped). */
     exemplar_span_ids: string[];
 }
-export interface DatasetOverview {
+interface DatasetOverview {
     total_traces: number;
     raw_jsonl_bytes: number;
     services: string[];
@@ -115,7 +115,7 @@ export interface DatasetOverview {
         latest: string;
     } | null;
 }
-export interface QueryTracesPage {
+interface QueryTracesPage {
     traces: TraceAnalystTraceSummary[];
     total: number;
     has_more: boolean;
@@ -123,12 +123,12 @@ export interface QueryTracesPage {
 /** Full-trace view. When the response would exceed the per-call byte
  *  budget, `oversized` is populated INSTEAD of `spans` so the agent
  *  knows to switch to `searchTrace` / `viewSpans`. */
-export interface ViewTraceResult {
+interface ViewTraceResult {
     trace_id: string;
     spans?: TraceAnalystSpan[];
     oversized?: ViewTraceOversized;
 }
-export interface ViewTraceOversized {
+interface ViewTraceOversized {
     span_count: number;
     /** Names with their counts, sorted desc. Capped at 20 entries. */
     top_span_names: Array<[string, number]>;
@@ -136,7 +136,7 @@ export interface ViewTraceOversized {
     span_response_bytes_max: number;
     error_span_count: number;
 }
-export interface ViewSpansResult {
+interface ViewSpansResult {
     trace_id: string;
     spans: TraceAnalystSpan[];
     /** Number of requested span ids that were not found in the trace. */
@@ -144,7 +144,7 @@ export interface ViewSpansResult {
     /** Number of attribute fields truncated to fit the per-attribute cap. */
     truncated_attribute_count: number;
 }
-export interface SpanMatchRecord {
+interface SpanMatchRecord {
     trace_id: string;
     span_id: string;
     span_name: string;
@@ -157,13 +157,13 @@ export interface SpanMatchRecord {
     context_after: string;
     match_offset: number;
 }
-export interface SearchTraceResult {
+interface SearchTraceResult {
     trace_id: string;
     hits: SpanMatchRecord[];
     total_matches: number;
     has_more: boolean;
 }
-export interface SearchSpanResult {
+interface SearchSpanResult {
     trace_id: string;
     span_id: string;
     hits: SpanMatchRecord[];
@@ -171,7 +171,7 @@ export interface SearchSpanResult {
     has_more: boolean;
 }
 /** Tunable byte budgets for bounded RLM tool output. */
-export interface TraceAnalystByteBudgets {
+interface TraceAnalystByteBudgets {
     /** Max bytes any single tool response may emit. Hard ceiling enforced
      *  by the store; oversized → summary. Default 150_000. */
     perCallByteCeiling: number;
@@ -185,8 +185,64 @@ export interface TraceAnalystByteBudgets {
      *  context window. Default 1024. */
     perMatchTextBudget: number;
 }
-export declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
+declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
 /** Marker substituted in place of truncated string payloads. Callers
  *  parsing tool output can detect it deterministically. */
-export declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
-//# sourceMappingURL=types.d.ts.map
+declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
+
+/**
+ * `TraceAnalysisStore` — read-side interface the trace-analyst calls
+ * through. Six operations, all bounded:
+ *
+ *   - `getOverview(filters?)` — dataset rollup + sample trace ids.
+ *   - `queryTraces(filters?, limit, offset)` — paginated summaries.
+ *   - `countTraces(filters?)` — cheap count without materialisation.
+ *   - `viewTrace(trace_id, perAttrCap)` — full span list, oversized → summary.
+ *   - `viewSpans(trace_id, span_ids, perAttrCap)` — surgical span fetch.
+ *   - `searchTrace(trace_id, regex, max_matches)` — bounded regex hits.
+ *   - `searchSpan(trace_id, span_id, regex, max_matches)` — single-span search.
+ *
+ * Multiple implementations ship in the core (`OtlpFileTraceStore`).
+ * Downstream callers can supply their own — e.g. a DuckDB-backed
+ * adapter or an in-memory adapter for tests — by implementing this
+ * interface.
+ *
+ * Filters compose with AND semantics. Empty/undefined fields impose
+ * no constraint. `regex_pattern` is the only opt-in raw-bytes scan —
+ * implementations may skip it via `count`/`overview` when not set.
+ */
+
+interface TraceAnalysisStore {
+    getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
+    queryTraces(opts: {
+        filters?: TraceAnalystFilters;
+        limit: number;
+        offset?: number;
+    }): Promise<QueryTracesPage>;
+    countTraces(filters?: TraceAnalystFilters): Promise<number>;
+    viewTrace(opts: {
+        trace_id: string;
+        /** Override per-attribute byte cap. Defaults to discovery budget. */
+        per_attribute_byte_cap?: number;
+    }): Promise<ViewTraceResult>;
+    viewSpans(opts: {
+        trace_id: string;
+        span_ids: readonly string[];
+        /** Override per-attribute byte cap. Defaults to surgical budget. */
+        per_attribute_byte_cap?: number;
+    }): Promise<ViewSpansResult>;
+    searchTrace(opts: {
+        trace_id: string;
+        regex_pattern: string;
+        /** Hard cap on matches returned. Default 50. */
+        max_matches?: number;
+    }): Promise<SearchTraceResult>;
+    searchSpan(opts: {
+        trace_id: string;
+        span_id: string;
+        regex_pattern: string;
+        max_matches?: number;
+    }): Promise<SearchSpanResult>;
+}
+
+export { DEFAULT_TRACE_ANALYST_BUDGETS as D, type ErrorCluster as E, type QueryTracesPage as Q, type SearchSpanResult as S, type TraceAnalysisStore as T, type ViewSpansResult as V, type TraceAnalystSpan as a, type DatasetOverview as b, type SearchTraceResult as c, type SpanMatchRecord as d, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as e, type TraceAnalystByteBudgets as f, type TraceAnalystFilters as g, type TraceAnalystSpanKind as h, type TraceAnalystSpanStatus as i, type TraceAnalystTraceSummary as j, type ViewTraceOversized as k, type ViewTraceResult as l };

package/dist/storyboard/index.d.ts

@@ -1,3 +1,68 @@
+import { S as Span } from '../schema-m0gsnbt3.js';
+
+/**
+ * Code-edit extraction + the "watch the agent write code" animation.
+ *
+ * The base storyboard (./index) compresses a run into scenes but keeps scenes
+ * payload-free (title + narration + evidence span ids). To actually SHOW the
+ * code an agent wrote, this module pulls the concrete edit (path, diff,
+ * before/after, language) out of the raw edit-tool spans and renders a
+ * self-contained HTML replay that types each file out, character by character,
+ * like an editor recording.
+ *
+ * Additive on purpose: it reuses the canonical `Span` (trace/schema) and the
+ * `Storyboard` IR (./index) without modifying the reducer/compiler — so it
+ * composes with the existing pipeline and a Remotion consumer can read the same
+ * `CodeEdit[]` to render an MP4.
+ */
+
+/** A concrete code change lifted from a tool span. */
+interface CodeEdit {
+    /** Span the edit came from — back-reference into the trace. */
+    spanId: string;
+    path: string;
+    language?: string;
+    /** Unified diff, when the tool carried one. */
+    diff?: string;
+    /** Full file body before / after, when present — enables true keystroke
+     *  animation rather than only flashing a diff. */
+    before?: string;
+    after?: string;
+    additions: number;
+    deletions: number;
+    startedAt: number;
+}
+/** Extract a CodeEdit from a single span, or undefined if it is not an edit. */
+declare function codeEditFromSpan(span: Span): CodeEdit | undefined;
+/** All code edits in a run, in chronological order. */
+declare function extractCodeEdits(spans: readonly Span[]): CodeEdit[];
+/** Pair each code-edit (`diff`) scene with its concrete edit, matched via the
+ *  scene's evidence span ids. Scenes without a recoverable edit are dropped. */
+declare function codeEditsForStoryboard(storyboard: Storyboard, spans: readonly Span[]): Array<{
+    scene: Scene;
+    edit: CodeEdit;
+}>;
+/** The text the animation types for an edit: prefer the full new file body,
+ *  then the added lines of a diff, then a minimal placeholder so the scene is
+ *  never blank. */
+declare function editAnimationText(edit: CodeEdit): string;
+interface CodeAnimationOptions {
+    /** Page title. Default "Agent writing code". */
+    title?: string;
+    /** Characters typed per animation tick. Higher = faster. Default 4. */
+    charsPerTick?: number;
+    /** Pause between files, ms. Default 900. */
+    pauseBetweenMs?: number;
+}
+/**
+ * Render a self-contained HTML page that animates the agent writing each file,
+ * character by character, with a filename tab, line numbers, and a blinking
+ * cursor — the shareable "watch it build" clip. No build step, no assets, no
+ * deps. The same `CodeEdit[]` feeds a Remotion MP4 renderer in a consumer
+ * package; this is the dependency-free baseline.
+ */
+declare function renderCodeAnimationHtml(source: readonly Span[] | readonly CodeEdit[], opts?: CodeAnimationOptions): string;
+
 /**
  * Storyboard — compile a raw agent trace into a small set of meaningful scenes,
  * then render them as a shareable, watchable replay.
@@ -17,12 +82,12 @@
  * the structure + visuals do not depend on one. Renderers that need a browser
  * (Remotion, React) live in consumers; this module only emits strings.
  */
-import type { Span } from '../trace/schema';
+
 /** What the agent meaningfully did — the compressed vocabulary. */
-export type SemanticKind = 'understood_task' | 'user_message' | 'agent_reply' | 'reasoned' | 'ran_command' | 'read_file' | 'edited_code' | 'searched' | 'used_browser' | 'used_computer' | 'called_api' | 'called_tool' | 'evaluated' | 'observed_failure' | 'completed';
+type SemanticKind = 'understood_task' | 'user_message' | 'agent_reply' | 'reasoned' | 'ran_command' | 'read_file' | 'edited_code' | 'searched' | 'used_browser' | 'used_computer' | 'called_api' | 'called_tool' | 'evaluated' | 'observed_failure' | 'completed';
 /** The modality-typed payload a scene shows. This is what makes any agent
  *  action — screen, browser, shell, code, API — actually viewable. */
-export type SceneVisual = {
+type SceneVisual = {
     type: 'screenshot';
     src: string;
     caption?: string;
@@ -56,7 +121,7 @@ export type SceneVisual = {
 } | {
     type: 'none';
 };
-export interface SemanticEvent {
+interface SemanticEvent {
     kind: SemanticKind;
     /** One-line headline (the ticket/scene title). */
     title: string;
@@ -71,7 +136,7 @@ export interface SemanticEvent {
     startTs: number;
     endTs: number;
 }
-export interface ReduceOptions {
+interface ReduceOptions {
     /** Collapse adjacent same-kind moments into one. Default true. */
     collapseAdjacent?: boolean;
 }
@@ -83,9 +148,9 @@ export interface ReduceOptions {
  * compression step), carrying the latest visual; failures and conversation
  * turns never collapse.
  */
-export declare function reduceToSemanticEvents(spans: readonly Span[], opts?: ReduceOptions): SemanticEvent[];
-export type SceneType = 'title_card' | 'prompt' | 'reply' | 'reasoning' | 'terminal' | 'file' | 'diff' | 'search' | 'browser' | 'computer' | 'api' | 'tool' | 'eval' | 'error' | 'summary';
-export interface Scene {
+declare function reduceToSemanticEvents(spans: readonly Span[], opts?: ReduceOptions): SemanticEvent[];
+type SceneType = 'title_card' | 'prompt' | 'reply' | 'reasoning' | 'terminal' | 'file' | 'diff' | 'search' | 'browser' | 'computer' | 'api' | 'tool' | 'eval' | 'error' | 'summary';
+interface Scene {
     sceneType: SceneType;
     title: string;
     narration: string;
@@ -94,12 +159,12 @@ export interface Scene {
     durationMs: number;
     evidenceSpanIds: string[];
 }
-export interface Storyboard {
+interface Storyboard {
     title: string;
     totalMs: number;
     scenes: Scene[];
 }
-export interface CompileOptions {
+interface CompileOptions {
     /** Headline for the title card. Default "Agent run". */
     title?: string;
     /** Max action scenes between the title + summary cards. Default 16. */
@@ -110,10 +175,10 @@ export interface CompileOptions {
  * (importance 5) and edit (4) is always kept; the rest fill the budget by
  * importance, then re-sort chronological. A title card opens, a summary closes.
  */
-export declare function compileStoryboard(events: readonly SemanticEvent[], opts?: CompileOptions): Storyboard;
+declare function compileStoryboard(events: readonly SemanticEvent[], opts?: CompileOptions): Storyboard;
 /** Render the storyboard as a Markdown timeline — the human-readable shot list. */
-export declare function renderStoryboardMarkdown(storyboard: Storyboard): string;
-export interface HtmlRenderOptions {
+declare function renderStoryboardMarkdown(storyboard: Storyboard): string;
+interface HtmlRenderOptions {
     /** Document title + on-page heading. Defaults to the storyboard title. */
     title?: string;
 }
@@ -124,6 +189,6 @@ export interface HtmlRenderOptions {
  * / browser / prose); controls let a viewer scrub. This is the "free clip" a
  * run produces; an MP4 is the same storyboard fed to Remotion in a consumer.
  */
-export declare function renderStoryboardHtml(storyboard: Storyboard, opts?: HtmlRenderOptions): string;
-export * from './code-edit';
-//# sourceMappingURL=index.d.ts.map
+declare function renderStoryboardHtml(storyboard: Storyboard, opts?: HtmlRenderOptions): string;
+
+export { type CodeAnimationOptions, type CodeEdit, type CompileOptions, type HtmlRenderOptions, type ReduceOptions, type Scene, type SceneType, type SceneVisual, type SemanticEvent, type SemanticKind, type Storyboard, codeEditFromSpan, codeEditsForStoryboard, compileStoryboard, editAnimationText, extractCodeEdits, reduceToSemanticEvents, renderCodeAnimationHtml, renderStoryboardHtml, renderStoryboardMarkdown };

package/dist/{summary-report.d.ts → summary-report-CInXwsza.d.ts}

@@ -1,3 +1,141 @@
+import { R as RunRecord } from './run-record-CP2ObebC.js';
+import { F as FailureClusterReport } from './failure-cluster-DH9Flgcf.js';
+
+/**
+ * HeldOutGate — first-class held-out paired-delta promotion gate.
+ *
+ * Encodes the "honesty override" pattern that lived inline in
+ * `~/webb/redteam/scripts/agent-eval-autoresearch.ts:138–171`.
+ * The optimizer's best-guess is one thing; what we should actually
+ * ship is another. The gate is the line between them.
+ *
+ * A candidate is promoted iff ALL three pass:
+ *
+ *   1. **Productive runs**: the candidate has at least
+ *      `minProductiveRuns` paired observations on items where BOTH
+ *      candidate and baseline produced a real (non-silent) score.
+ *   2. **Paired delta**: the lower bound of the bootstrap CI on the
+ *      median per-item delta (candidate − baseline) on the HOLDOUT
+ *      split is strictly greater than `pairedDeltaThreshold`.
+ *   3. **Overfit gap**: the candidate's gap between search-split
+ *      score and holdout-split score is no worse (more positive)
+ *      than the baseline's gap by more than `overfitGapThreshold`.
+ *      "Better on search, worse on holdout" is the canonical
+ *      overfit pattern; this catches it.
+ *
+ * The decision carries a machine-readable `rejectionCode` plus an
+ * `evidence` block with every number the gate looked at, so the
+ * downstream researcher / paper / dashboard can re-derive the
+ * verdict without re-running.
+ *
+ * See also:
+ *   - `src/statistics.ts` for `pairedBootstrap` + `wilcoxonSignedRank`
+ *   - `src/run-record.ts` for the input row schema
+ *   - `src/reference-replay.ts` for the older, reference-replay-
+ *     specific promotion path (still useful for replay-style evals).
+ */
+
+type HeldOutGateRejectionCode = 'few_runs' | 'negative_delta' | 'overfit_gap' | 'cost_ceiling';
+interface HeldOutGateConfig {
+    /** Minimum number of paired (candidate, baseline) holdout observations
+     *  required before the gate will even consider promoting. Default 3. */
+    minProductiveRuns?: number;
+    /** The bootstrap-CI lower bound on the median paired holdout delta
+     *  must exceed this to promote. Default 0. */
+    pairedDeltaThreshold?: number;
+    /** Maximum allowed worsening of (search − holdout) gap relative to
+     *  baseline. Default 0.15 (i.e. candidate may overfit by up to 15
+     *  absolute score points more than baseline before rejection). */
+    overfitGapThreshold?: number;
+    /** Stable label of the baseline candidate. Required — paper-grade
+     *  evaluation never compares two unlabelled candidates. */
+    baselineKey: string;
+    /** Confidence level for the bootstrap CI. Default 0.95. */
+    confidence?: number;
+    /** Bootstrap resamples. Default 2000. */
+    bootstrapResamples?: number;
+    /** Optional deterministic seed for the bootstrap. Default undefined
+     *  (Math.random). */
+    seed?: number;
+    /**
+     * Hard ceiling on the candidate's median per-task USD cost. When the
+     * candidate clears the quality gates (paired-delta + overfit-gap) but
+     * its median cost exceeds this number, the gate rejects with
+     * `cost_ceiling`. Default `undefined` = no cost ceiling, behaving
+     * exactly like the pre-cost gate.
+     *
+     * This exists because "we ship the better prompt" is only an honest
+     * pitch when the better prompt also fits a customer-stated budget.
+     * Cost is read from `RunRecord.costUsd` (already mandatory on every
+     * run) so no new schema is required.
+     */
+    costPerTaskCeiling?: number;
+}
+interface GateEvidence {
+    /** Number of paired (candidate, baseline) holdout observations used. */
+    productiveRuns: number;
+    /** Median of (candidate − baseline) paired holdout deltas. */
+    medianPairedDelta: number;
+    /** Bootstrap CI on the median paired holdout delta. */
+    pairedCI: {
+        low: number;
+        high: number;
+    };
+    /** Wilcoxon signed-rank p-value on the paired holdout deltas. */
+    pairedPValue: number;
+    /** Mean candidate score on the search split (NaN if none). */
+    searchScore: number;
+    /** Mean candidate score on the holdout split (NaN if none). */
+    holdoutScore: number;
+    /** Candidate (search − holdout) gap. */
+    overfitGap: number;
+    /** Baseline (search − holdout) gap. */
+    baselineOverfitGap: number;
+    /** Median per-task USD cost across the candidate's runs. Recorded
+     *  even when no `costPerTaskCeiling` is configured so downstream
+     *  dashboards (intelligence.tangle.tools) can render \$/task per
+     *  generation regardless of gating policy. */
+    medianCandidateCost: number;
+    /** Median per-task USD cost across the baseline runs, for
+     *  symmetric reporting. */
+    medianBaselineCost: number;
+}
+interface GateDecision {
+    /** Final promote/no-promote verdict. */
+    promote: boolean;
+    /** The candidate that was evaluated. */
+    candidateId: string;
+    /** The baseline it was compared against. */
+    baselineId: string;
+    /** Every number the gate looked at, for audit + paper export. */
+    evidence: GateEvidence;
+    /** Human-readable reason. */
+    reason: string;
+    /** Machine-readable rejection code, or null on promote. */
+    rejectionCode: HeldOutGateRejectionCode | null;
+}
+/**
+ * Held-out paired-delta promotion gate. Construct once with config,
+ * call `evaluate(candidateRuns, baselineRuns)` per (candidate,
+ * baseline) pair. Stateless across calls.
+ */
+declare class HeldOutGate {
+    private readonly minProductiveRuns;
+    private readonly pairedDeltaThreshold;
+    private readonly overfitGapThreshold;
+    private readonly baselineKey;
+    private readonly confidence;
+    private readonly resamples;
+    private readonly seed?;
+    private readonly costPerTaskCeiling?;
+    constructor(config: HeldOutGateConfig);
+    /** Decide whether `candidate` should replace `baseline`. Pairing
+     *  is by (experimentId, seed) — identical experiment + seed pairs
+     *  the candidate run with the matching baseline run. Pairs without
+     *  a holdout score on both sides are dropped. */
+    evaluate(candidate: RunRecord[], baseline: RunRecord[]): GateDecision;
+}
+
 /**
  * Reporting helpers — production summaries and paper-quality figures — sit alongside `reporter.ts` rather
  * than replacing it.
@@ -22,10 +160,8 @@
  * what you'd hand to vega-lite, plotly, matplotlib, or your own
  * Canvas renderer to draw the actual figure.
  */
-import type { GateDecision } from './held-out-gate';
-import type { FailureClusterReport } from './pipelines/failure-cluster';
-import type { RunRecord } from './run-record';
-export interface SummaryTableOptions {
+
+interface SummaryTableOptions {
     /** Comparator candidate id. Wilcoxon + Cohen's d are computed
      *  versus this candidate. Required for paired stats columns. */
     comparator?: string;
@@ -36,7 +172,7 @@ export interface SummaryTableOptions {
     /** FDR for BH adjustment of the comparison p-values. Default 0.05. */
     fdr?: number;
 }
-export interface SummaryTableRow {
+interface SummaryTableRow {
     candidateId: string;
     n: number;
     mean: number;
@@ -47,7 +183,7 @@ export interface SummaryTableRow {
     /** Cohen's d vs comparator. NaN if no comparator. */
     cohensD: number;
 }
-export interface SummaryTable {
+interface SummaryTable {
     rows: SummaryTableRow[];
     comparator: string | null;
     split: 'search' | 'holdout';
@@ -59,8 +195,8 @@ export interface SummaryTable {
  * bootstrap CI on the chosen split, and (when a comparator is given)
  * BH-adjusted Wilcoxon p + Cohen's d versus that comparator.
  */
-export declare function summaryTable(runs: RunRecord[], opts?: SummaryTableOptions): SummaryTable;
-export interface ParetoPoint {
+declare function summaryTable(runs: RunRecord[], opts?: SummaryTableOptions): SummaryTable;
+interface ParetoPoint {
     candidateId: string;
     /** Mean USD cost per run on the chosen split. */
     cost: number;
@@ -75,7 +211,7 @@ export interface ParetoPoint {
      *  for it was passed in. */
     gate?: 'promote' | 'reject_few_runs' | 'reject_negative_delta' | 'reject_overfit_gap' | null;
 }
-export interface ParetoFigureSpec {
+interface ParetoFigureSpec {
     kind: 'pareto-cost-quality';
     split: 'search' | 'holdout';
     points: ParetoPoint[];
@@ -89,11 +225,11 @@ export interface ParetoFigureSpec {
  * candidate id; if present, every point picks up the gate verdict
  * for overlay.
  */
-export declare function paretoChart(runs: RunRecord[], opts?: {
+declare function paretoChart(runs: RunRecord[], opts?: {
     split?: 'search' | 'holdout';
     gateDecisions?: Record<string, GateDecision>;
 }): ParetoFigureSpec;
-export interface GainDistributionBin {
+interface GainDistributionBin {
     /** Inclusive lower edge. */
     lo: number;
     /** Exclusive upper edge (or inclusive if it's the last bin). */
@@ -101,7 +237,7 @@ export interface GainDistributionBin {
     /** Number of pairs whose delta lands in this bin. */
     count: number;
 }
-export interface GainDistributionFigureSpec {
+interface GainDistributionFigureSpec {
     kind: 'gain-distribution';
     candidateId: string;
     comparator: string;
@@ -115,7 +251,7 @@ export interface GainDistributionFigureSpec {
         high: number;
     };
 }
-export interface GainDistributionOptions {
+interface GainDistributionOptions {
     /** Number of histogram bins. Default 11 (so the centre is exact at 0). */
     bins?: number;
     /** Which split to use. Default 'holdout'. */
@@ -132,15 +268,15 @@ export interface GainDistributionOptions {
  * comparator), histogrammed. Includes the bootstrap CI on the median
  * delta — same primitive the promotion gate uses.
  */
-export declare function gainHistogram(runs: RunRecord[], candidateId: string, comparator: string, opts?: GainDistributionOptions): GainDistributionFigureSpec;
-export type ResearchReportDecision = 'promote' | 'hold' | 'reject' | 'equivalent' | 'needs_more_data';
+declare function gainHistogram(runs: RunRecord[], candidateId: string, comparator: string, opts?: GainDistributionOptions): GainDistributionFigureSpec;
+type ResearchReportDecision = 'promote' | 'hold' | 'reject' | 'equivalent' | 'needs_more_data';
 /**
  * Hard floor below which a paired comparison is treated as uninformative
  * regardless of `minPairs`. Mirrors the lower limit on Wilcoxon signed-rank
  * exact tables; below this the test has no power to separate effect sizes.
  */
-export declare const RESEARCH_REPORT_HARD_PAIR_FLOOR = 6;
-export interface ResearchReportOptions {
+declare const RESEARCH_REPORT_HARD_PAIR_FLOOR = 6;
+interface ResearchReportOptions {
     /** Human-readable report title. */
     title?: string;
     /** Comparator candidate id. Required for statistical decision guidance. */
@@ -197,14 +333,14 @@ export interface ResearchReportOptions {
      */
     preregistrationHash?: string;
 }
-export interface ResearchReportRecommendation {
+interface ResearchReportRecommendation {
     decision: ResearchReportDecision;
     candidateId: string | null;
     rationale: string[];
     risks: string[];
     nextActions: string[];
 }
-export interface ResearchReportCandidate {
+interface ResearchReportCandidate {
     candidateId: string;
     n: number;
     mean: number;
@@ -240,7 +376,7 @@ export interface ResearchReportCandidate {
     decision: ResearchReportDecision;
     decisionReason: string;
 }
-export interface ResearchReportMethodology {
+interface ResearchReportMethodology {
     /**
      * Plain-language assumptions the report depends on. Read these first when
      * deciding whether the verdict is load-bearing for a launch decision.
@@ -255,7 +391,7 @@ export interface ResearchReportMethodology {
     /** Citations for the methodological choices above. */
     citations: string[];
 }
-export interface ResearchReport {
+interface ResearchReport {
     kind: 'agent-eval-research-report';
     title: string;
     generatedAt: string;
@@ -304,5 +440,6 @@ export interface ResearchReport {
  * Async because the fingerprint uses Web Crypto via `hashJson`; deterministic
  * for any fixed `runs`, `seed`, and ROPE.
  */
-export declare function researchReport(runs: RunRecord[], opts?: ResearchReportOptions): Promise<ResearchReport>;
-//# sourceMappingURL=summary-report.d.ts.map
+declare function researchReport(runs: RunRecord[], opts?: ResearchReportOptions): Promise<ResearchReport>;
+
+export { type GainDistributionBin as G, HeldOutGate as H, type ParetoFigureSpec as P, RESEARCH_REPORT_HARD_PAIR_FLOOR as R, type SummaryTable as S, type GainDistributionFigureSpec as a, type GainDistributionOptions as b, type ParetoPoint as c, type ResearchReport as d, type ResearchReportCandidate as e, type ResearchReportDecision as f, type ResearchReportMethodology as g, type ResearchReportOptions as h, type ResearchReportRecommendation as i, type SummaryTableOptions as j, type SummaryTableRow as k, gainHistogram as l, type GateDecision as m, type GateEvidence as n, type HeldOutGateConfig as o, paretoChart as p, type HeldOutGateRejectionCode as q, researchReport as r, summaryTable as s };

package/dist/telemetry/{sink-file.d.ts → file.d.ts}

@@ -1,11 +1,12 @@
+import { c as TelemetrySink, e as TelemetryEnvelope } from '../sink-fetch-B1Yg4Til.js';
+
 /**
  * Node-only file sink. Imports `node:fs` — DO NOT import this from a Worker
  * or edge runtime; use `./sink-fetch` instead.
  */
-import type { TelemetryEnvelope } from './schema';
-import type { TelemetrySink } from './sink-fetch';
+
 /** Append envelopes to a JSONL file, partitioned by repo + date. */
-export declare class FileTelemetrySink implements TelemetrySink {
+declare class FileTelemetrySink implements TelemetrySink {
     private readonly baseDir;
     private streams;
     constructor(baseDir: string);
@@ -13,5 +14,6 @@ export declare class FileTelemetrySink implements TelemetrySink {
     close(): Promise<void>;
 }
 /** Default location for local telemetry, mirroring bad CLI's convention. */
-export declare function defaultTelemetryDir(homeDir: string, override?: string): string;
-//# sourceMappingURL=sink-file.d.ts.map
+declare function defaultTelemetryDir(homeDir: string, override?: string): string;
+
+export { FileTelemetrySink, defaultTelemetryDir };