@tangle-network/agent-eval 0.135.4 → 0.137.0

package/dist/{replay-BRfMIs81.d.ts → replay-K8FaC0CB.d.ts}

@@ -1,12 +1,14 @@
-import { o as NotFoundError, r as CaptureIntegrityError, s as ReplayError } from "./errors-CEk209JS.js";
+import { c as ReplayError, l as ValidationError, o as LimitExceededError, r as CaptureIntegrityError, s as NotFoundError, t as AgentEvalError } from "./errors-DkfjIDvD.js";
 import { S as ToolSpan, f as Run } from "./schema-BtVldJ3T.js";
-import { a as RunRecord, l as RunTerminalOutcome, s as RunSplitTag, u as RunTokenUsage } from "./run-record-DcObtIGh.js";
-import { c as RawProviderEvent, l as RawProviderSink } from "./raw-provider-sink-BU29Sh8h.js";
+import { a as RunRecord, l as RunTerminalOutcome, s as RunSplitTag, u as RunTokenUsage } from "./run-record-BPCa2rQ8.js";
+import { _t as RawProviderSink, gt as RawProviderEvent } from "./types-CTvKfr5F.js";
 import { s as TraceStore } from "./store-CT9YIIve.js";
 import { n as RunCompleteHookContext, t as RunCompleteHook } from "./emitter-DGQGoLyj.js";
-import { a as QueryTracesPage, d as TraceAnalystFilters, g as ViewSpansResult, m as TraceAnalystSpanStatus, o as SearchSpanResult, p as TraceAnalystSpanKind, r as DatasetOverview, s as SearchTraceResult, t as TraceAnalysisStore, v as ViewTraceResult } from "./store-CxJry_cs.js";
-import { n as AnalyzeTracesOptions, r as AnalyzeTracesResult } from "./analyst-BkTS3C58.js";
-import { AxFunction } from "@ax-llm/ax";
+import { D as SearchSpanResult, E as QueryTracesPage, F as TraceAnalystSpanStatus, L as ViewSpansResult, M as TraceAnalystFilters, O as SearchTraceResult, P as TraceAnalystSpanKind, S as TraceAnalysisStoreContext, w as DatasetOverview, x as TraceAnalysisStore, y as BoundedTraceAnalysisStoreOptions, z as ViewTraceResult } from "./types-CKswbJGO.js";
+import { S as JudgeConfig } from "./types-CTGbIm57.js";
+import { r as CorrectnessChecker } from "./completion-verifier-DSyRNVzU.js";
+import { t as AnalyzeRunsOptions } from "./analyze-runs-PVtnfjvA.js";
+import { AxAIService, AxAgentActorTurnCallbackArgs, AxFunction } from "@ax-llm/ax";
 //#region src/trace/otel.d.ts
 declare const OTEL_AGENT_EVAL_SCOPE: {
   name: string;
@@ -235,6 +237,145 @@ interface TraceStoreToOtlpOptions {
  */
 declare function convertTraceStoresToOtlp(source: string | TraceStoreSource | readonly TraceStoreSource[], outPath: string, opts?: TraceStoreToOtlpOptions): TracesToOtlpResult;
 //#endregion
+//#region src/trace-analyst/store-boundary.d.ts
+/** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
+declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, options?: BoundedTraceAnalysisStoreOptions): TraceAnalysisStore;
+//#endregion
+//#region src/trace-analyst/analyst.d.ts
+interface AnalyzeTracesInput {
+  /** The user-facing question. Domain framing belongs here, not in the
+   *  actor description. */
+  question: string;
+}
+interface AnalyzeTracesResult {
+  /** The actor's submitted prose answer. */
+  answer: string;
+  /** Bulleted findings from the actor's structured completion. */
+  findings: string[];
+  /** Per-turn snapshots captured via `actorTurnCallback`. */
+  turns: AnalyzeTracesTurnSnapshot[];
+  /** Total turns the actor took. */
+  turnCount: number;
+  /** Token usage by role. */
+  usage: TraceAnalystUsage;
+  /** Full system + assistant + tool message log by role. */
+  chatLog: TraceAnalystChatLog;
+  /** Prompt version that produced this run. */
+  actorPromptVersion: string;
+}
+interface TraceAnalystUsage {
+  actor: TraceAnalystUsageEntry[];
+  responder: TraceAnalystUsageEntry[];
+}
+interface TraceAnalystUsageEntry {
+  [key: string]: unknown;
+}
+interface TraceAnalystChatLog {
+  actor: TraceAnalystChatMessage[];
+  responder: TraceAnalystChatMessage[];
+}
+interface TraceAnalystChatMessage {
+  [key: string]: unknown;
+}
+interface AnalyzeTracesTurnSnapshot {
+  stage: AxAgentActorTurnCallbackArgs['stage'];
+  turn: number;
+  isError: boolean;
+  /** The JS code the actor produced for this turn. */
+  code: string;
+  /** The formatted action-log entry the actor sees on the next turn. */
+  output: string;
+  /** Provider thought (when `executorOptions.showThoughts` is true and the
+   *  provider returns it). */
+  thought?: string;
+}
+interface AnalyzeTracesOptions {
+  /** Trace data source. Pass either an OTLP-JSONL path or a custom store. */
+  source: string | TraceAnalysisStore;
+  /** Caller-provided AxAIService. */
+  ai: AxAIService;
+  /** Model id forwarded to the actor. */
+  model?: string;
+  /** Maximum model subqueries. 0 disables model fan-out. Default 4. */
+  maxSubqueries?: number;
+  /** Maximum actor turns. Default 12. */
+  maxTurns?: number;
+  /** Maximum parallel model subqueries. Default 2. */
+  maxParallelSubqueries?: number;
+  /** Cancels in-flight model and tool work. */
+  signal?: AbortSignal;
+  /** Override the actor description. */
+  actorDescription?: string;
+  /** Per-turn observability hook. */
+  onTurn?: (turn: AnalyzeTracesTurnSnapshot) => void | Promise<void>;
+  /** Override max runtime characters per turn. Default 6000. */
+  maxRuntimeChars?: number;
+  /** When set, every turn's snapshot is appended to this JSONL file
+   *  immediately. If the analyst crashes mid-loop (provider 503,
+   *  network error, validator reject) the partial reasoning is still
+   *  on disk for diagnosis and recovery. */
+  progressLogPath?: string;
+}
+/**
+ * Run the trace analyst.
+ *
+ * Throws:
+ *   - `TraceFileMissingError` if `source` is a path and doesn't exist.
+ *   - `AxAgentClarificationError` if the analyst asks for clarification.
+ *   - Provider errors (auth, rate limits) propagate from the AI service.
+ */
+declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
+//#endregion
+//#region src/trace-analyst/errors.d.ts
+/** Invalid trace-tool arguments, including malformed filters and regexes. */
+declare class TraceAnalysisValidationError extends ValidationError {
+  readonly code: 'validation';
+}
+/** A trace read cannot fit within a documented count or byte limit. */
+declare class TraceAnalysisLimitError extends LimitExceededError {
+  readonly code: 'limit_exceeded';
+  readonly operation: string;
+  readonly actual: number;
+  readonly limit: number;
+  constructor(operation: string, actual: number, limit: number, message?: string);
+}
+/** A supplied store returned a shape that violates the trace read contract. */
+declare class TraceAnalysisStoreContractError extends AgentEvalError {
+  readonly code: 'backend_integrity';
+  readonly operation: string;
+  constructor(operation: string, message: string, options?: {
+    cause?: unknown;
+  });
+}
+declare class TraceFileMissingError extends NotFoundError {
+  readonly code: 'not_found';
+  readonly path: string;
+  constructor(path: string);
+}
+declare class TraceFileTooLargeError extends TraceAnalysisLimitError {
+  readonly path: string;
+  readonly size_bytes: number;
+  readonly max_bytes: number;
+  constructor(path: string, size_bytes: number, max_bytes: number);
+}
+declare class TraceFileMalformedError extends CaptureIntegrityError {
+  readonly path: string;
+  readonly line_number: number;
+  readonly byte_offset: number;
+  constructor(path: string, line_number: number, byte_offset: number, cause?: unknown);
+}
+declare class TraceNotFoundError extends NotFoundError {
+  readonly code: 'not_found';
+  readonly trace_id: string;
+  constructor(trace_id: string);
+}
+declare class SpanNotFoundError extends NotFoundError {
+  readonly code: 'not_found';
+  readonly trace_id: string;
+  readonly span_id: string;
+  constructor(trace_id: string, span_id: string);
+}
+//#endregion
 //#region src/trace-analyst/hook.d.ts
 interface TraceAnalystHookOptions {
   /**
@@ -538,7 +679,7 @@ declare function otlpRowsToTraceRunRecords(rows: Iterable<object>, opts: OtlpToR
 //#endregion
 //#region src/trace-analyst/prompts.d.ts
 /** Ax RLM prompt for bounded trace discovery and evidence-backed analysis. */
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION = "You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the `traces` namespace.\n\nDISCOVERY → NARROW → DEEP-READ protocol — follow exactly:\n\n1. ALWAYS call `traces.getDatasetOverview({})` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids — never fabricate one).\n\n2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. `filters.regex_pattern` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces — narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.\n\n3. To list more traces than the sample, call `traces.queryTraces({ filters?, limit, offset? })`. Each summary carries raw_jsonl_bytes — use it to choose between viewTrace and searchTrace BEFORE calling either.\n\n4. Per-trace inspection:\n   - SMALL trace (raw_jsonl_bytes well under 150_000): call `traces.viewTrace({ trace_id })`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large `input.value` / `output.value` / `llm.input_messages` will show a `[trace-analyst truncated: N bytes]` marker.\n   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an `oversized` response): use `traces.searchTrace({ trace_id, regex_pattern })` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call `traces.viewSpans({ trace_id, span_ids: [...] })` for surgical reads (~16KB cap, 4× higher than discovery), or `traces.searchSpan({ trace_id, span_id, regex_pattern })` for one large span. Stays bounded regardless of trace size.\n   - Useful regex patterns: `STATUS_CODE_ERROR` (failures), tool names like `grep` or `view_trace`, error strings like `MaxTurnsExceeded`, model names, attribute keys.\n\n5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.\n\n5a. **Result-shape contract** — searchTrace and searchSpan return `{ trace_id, hits, total_matches, has_more }`. Iterate `result.hits` (NOT result.matches). Each hit has `{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }`. viewTrace returns `{ trace_id, spans }` (or `oversized`). viewSpans returns `{ trace_id, spans, missing_span_ids, truncated_attribute_count }`. Never assume a field name — log the result shape first if unsure.\n\n6. If viewTrace returns an `oversized` summary instead of `spans`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.\n\n7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.\n\n8. If a tool errors (invalid regex, range error), STOP and reconsider — don't retry with a guessed id or argument. Use the discovery tools above to recover.\n\n9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.\n\n10. If the question splits into independent reasoning branches, use bounded `llmQuery(...)` calls over evidence you already loaded. Subqueries cannot inspect the trace store, so pass the exact trace excerpts they need. Example:\n\n    const reviews = await llmQuery([\n      { query: 'Classify the failure mechanism in this excerpt.', context: traceAbcExcerpt },\n      { query: 'Classify the failure mechanism in this excerpt.', context: traceDefExcerpt },\n    ]);\n\nOBSERVABILITY rules:\n- Each discovery turn must emit at least one concise `console.log(...)` showing what evidence was learned.\n- Finish gathering evidence before submitting the analysis.\n- Reuse runtime variables across turns; don't recompute.\n\nOUTPUT contract — your final answer must include:\n- A clear prose conclusion answering the user's question.\n- Trace ids and span ids cited as evidence for each claim.\n- Failure modes named in the user's domain language, with frequency and concrete examples.\n- A concise findings array containing only claims supported by inspected evidence.\n\nDo NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.";
+declare const TRACE_ANALYST_ACTOR_DESCRIPTION = "You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the `traces` namespace.\n\nDISCOVERY → NARROW → DEEP-READ protocol — follow exactly:\n\n1. ALWAYS call `traces.getDatasetOverview({})` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids — never fabricate one).\n\n2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. `filters.regex_pattern` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces — narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.\n\n3. To list more traces than the sample, call `traces.queryTraces({ filters?, limit, offset? })`. Each summary carries raw_jsonl_bytes — use it to choose between viewTrace and searchTrace BEFORE calling either.\n\n4. Per-trace inspection:\n   - SMALL trace (raw_jsonl_bytes well under 150_000): call `traces.viewTrace({ trace_id })`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large `input.value` / `output.value` / `llm.input_messages` will show a `[trace-analyst truncated: N bytes]` marker.\n   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an `oversized` response): use `traces.searchTrace({ trace_id, regex_pattern })` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call `traces.viewSpans({ trace_id, span_ids: [...] })` for surgical reads (~16KB cap, 4× higher than discovery), or `traces.searchSpan({ trace_id, span_id, regex_pattern })` for one large span. Stays bounded regardless of trace size.\n   - Useful regex patterns: `STATUS_CODE_ERROR` (failures), tool names like `grep` or `view_trace`, error strings like `MaxTurnsExceeded`, model names, attribute keys.\n\n5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.\n\n5a. **Result-shape contract** — searchTrace and searchSpan return `{ trace_id, hits, has_more }`. Iterate `result.hits` (NOT result.matches). Each hit has `{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }`. viewTrace returns `{ trace_id, spans }` (or `oversized`). viewSpans returns `{ trace_id, spans, missing_span_ids, omitted_span_ids, has_more, truncated_attribute_count }`; retry only `omitted_span_ids`. Never assume a field name — log the result shape first if unsure.\n\n6. If viewTrace returns an `oversized` summary instead of `spans`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.\n\n7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.\n\n8. If a tool errors (invalid regex, range error), STOP and reconsider — don't retry with a guessed id or argument. Use the discovery tools above to recover.\n\n9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.\n\n10. If the question splits into independent reasoning branches, use bounded `llmQuery(...)` calls over evidence you already loaded. Subqueries cannot inspect the trace store, so pass the exact trace excerpts they need. Example:\n\n    const reviews = await llmQuery([\n      { query: 'Classify the failure mechanism in this excerpt.', context: traceAbcExcerpt },\n      { query: 'Classify the failure mechanism in this excerpt.', context: traceDefExcerpt },\n    ]);\n\nOBSERVABILITY rules:\n- Each discovery turn must emit at least one concise `console.log(...)` showing what evidence was learned.\n- Finish gathering evidence before submitting the analysis.\n- Reuse runtime variables across turns; don't recompute.\n\nOUTPUT contract — your final answer must include:\n- A clear prose conclusion answering the user's question.\n- Trace ids and span ids cited as evidence for each claim.\n- Failure modes named in the user's domain language, with frequency and concrete examples.\n- A concise findings array containing only claims supported by inspected evidence.\n\nDo NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.";
 declare const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-actor-v6-2026-07-14";
 //#endregion
 //#region src/trace-analyst/store-otlp.d.ts
@@ -570,43 +711,49 @@ declare abstract class BufferedOtlpTraceStore implements TraceAnalysisStore {
   private readonly perAttributeSpanBudget;
   private readonly perCallByteCeiling;
   private readonly perMatchTextBudget;
-  private indexPromise?;
-  /** Cached UTF-8 buffer. Every read needs slice access, so each source is
-   *  materialised once. */
-  private bufferPromise?;
+  private indexValue?;
+  private indexTask?;
+  private bufferValue?;
+  private bufferTask?;
   constructor(opts: BufferedOtlpTraceStoreOptions);
-  getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
+  hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean>;
+  hasSpans(opts: {
+    trace_id: string;
+    span_ids: readonly string[];
+  }, context?: TraceAnalysisStoreContext): Promise<string[]>;
+  getOverview(filters?: TraceAnalystFilters, context?: TraceAnalysisStoreContext): Promise<DatasetOverview>;
   queryTraces(opts: {
     filters?: TraceAnalystFilters;
     limit: number;
     offset?: number;
-  }): Promise<QueryTracesPage>;
-  countTraces(filters?: TraceAnalystFilters): Promise<number>;
+  }, context?: TraceAnalysisStoreContext): Promise<QueryTracesPage>;
+  countTraces(filters?: TraceAnalystFilters, context?: TraceAnalysisStoreContext): Promise<number>;
   viewTrace(opts: {
     trace_id: string;
     per_attribute_byte_cap?: number;
-  }): Promise<ViewTraceResult>;
+  }, context?: TraceAnalysisStoreContext): Promise<ViewTraceResult>;
   viewSpans(opts: {
     trace_id: string;
     span_ids: readonly string[];
     per_attribute_byte_cap?: number;
-  }): Promise<ViewSpansResult>;
+  }, context?: TraceAnalysisStoreContext): Promise<ViewSpansResult>;
   searchTrace(opts: {
     trace_id: string;
     regex_pattern: string;
     max_matches?: number;
-  }): Promise<SearchTraceResult>;
+  }, context?: TraceAnalysisStoreContext): Promise<SearchTraceResult>;
   searchSpan(opts: {
     trace_id: string;
     span_id: string;
     regex_pattern: string;
     max_matches?: number;
-  }): Promise<SearchSpanResult>;
+  }, context?: TraceAnalysisStoreContext): Promise<SearchSpanResult>;
   /** Force the index to materialise. Useful to amortise startup cost
    *  before the first agent call. */
-  ensureIndexed(): Promise<void>;
+  ensureIndexed(context?: TraceAnalysisStoreContext): Promise<void>;
   private buffer;
-  protected abstract readBuffer(): Promise<Buffer>;
+  protected abstract readBuffer(signal?: AbortSignal): Promise<Buffer>;
+  protected abstract sourcePath(): string;
   private index;
   private buildIndex;
   private matchedTraces;
@@ -621,47 +768,75 @@ declare class OtlpFileTraceStore extends BufferedOtlpTraceStore {
   constructor(opts: OtlpFileTraceStoreOptions);
   /** Stat-then-read so an oversized file fails loud before allocating the
    *  source buffer. Missing files remain distinct from malformed traces. */
-  protected readBuffer(): Promise<Buffer>;
+  protected readBuffer(signal?: AbortSignal): Promise<Buffer>;
+  protected sourcePath(): string;
 }
+/** Build the bounded trace store directly from OpenInference JSONL text. */
+declare function otlpTextToTraceAnalysisStore(text: string, opts?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
+//#endregion
+//#region src/trace-analyst/store-tool-spans.d.ts
 /** Missing tool spans cannot distinguish a tool-free run from broken capture. */
 declare class ToolTraceMissingError extends CaptureIntegrityError {
   constructor();
 }
 /**
- * Snapshot canonical tool spans into the bounded read interface used by trace analysts.
- * One `runId` becomes one trace; arguments, results, source attributes, errors, and timing
- * remain queryable through the same OTLP projection as file-backed traces.
+ * Snapshot canonical tool spans into the read interface used by trace analysts.
+ * One run becomes one trace while arguments, results, errors, and timing remain searchable.
  */
-declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, opts?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
-declare class TraceFileMissingError extends NotFoundError {
-  constructor(path: string);
-}
-declare class TraceNotFoundError extends NotFoundError {
-  readonly trace_id: string;
-  constructor(trace_id: string);
-}
-declare class SpanNotFoundError extends NotFoundError {
-  readonly trace_id: string;
-  readonly span_id: string;
-  constructor(trace_id: string, span_id: string);
-}
+declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, options?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
+//#endregion
+//#region src/eval-tools.d.ts
+/** One agent-callable tool. `parameters` is a JSON Schema (draft-07+) object. */
+interface EvalToolDef {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  handler: (args: unknown, ctx?: {
+    signal?: AbortSignal;
+  }) => Promise<unknown>;
+}
+interface MakeEvalToolsConfig {
+  /** Judges available to `run_judges`. Omit to exclude the tool. */
+  judges?: Array<JudgeConfig<unknown>>;
+  /** Host-side correctness checker for `verify_completion` (the third
+   *  `verifyCompletion` argument — a function, so it cannot cross the wire).
+   *  Omit to exclude the tool. */
+  completion?: {
+    checkCorrectness: CorrectnessChecker;
+  };
+  /** `analyzeRuns` options minus `runs` (runs arrive as tool args, inline or
+   *  via `path`). Omit to exclude the tool. */
+  analyze?: Omit<AnalyzeRunsOptions, 'runs'>;
+}
+/** OpenAI function-tool wire shape for an `EvalToolDef`. */
+declare function toOpenAiTool(def: EvalToolDef): {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+};
+/**
+ * Build the eval toolset for the supplied config. Only sections present in
+ * `cfg` produce tools, so the agent's tool list mirrors what the host
+ * actually wired. Handlers fail loud on malformed args — no silent defaults.
+ */
+declare function makeEvalTools(cfg: MakeEvalToolsConfig): EvalToolDef[];
 //#endregion
 //#region src/trace-analyst/tools.d.ts
-interface BuildTraceAnalystToolsOpts {
+declare const TRACE_ANALYST_TOOL_NAMESPACE: 'traces';
+interface BuildTraceAnalysisToolsOptions extends BoundedTraceAnalysisStoreOptions {
   store: TraceAnalysisStore;
-  /** Override the default sample-trace-id slot count (20). Mostly for tests. */
-  sampleTraceLimit?: number;
 }
-/**
- * Build the trace-analyst function set. Pass the result into
- * `agent(...).functions.local`.
- */
-declare function buildTraceAnalystTools(opts: BuildTraceAnalystToolsOpts): AxFunction[];
-/**
- * Convenience: same shape as `buildTraceAnalystTools` but returns the
- * grouped form expected when registering trace tools alongside other
- * agent function modules. */
-declare function traceAnalystFunctionGroup(opts: BuildTraceAnalystToolsOpts): {
+interface TraceAnalysisToolDescriptor extends EvalToolDef {
+  namespace: typeof TRACE_ANALYST_TOOL_NAMESPACE;
+}
+/** Bind all seven trace reads without exposing an agent framework type. */
+declare function buildTraceAnalysisToolDescriptors(options: BuildTraceAnalysisToolsOptions): TraceAnalysisToolDescriptor[];
+/** Adapt the canonical descriptors into Ax functions used by the built-in analyst. */
+declare function buildTraceAnalystTools(options: BuildTraceAnalysisToolsOptions): AxFunction[];
+declare function traceAnalystFunctionGroup(options: BuildTraceAnalysisToolsOptions): {
   namespace: string;
   title: string;
   selectionCriteria: string;
@@ -763,5 +938,5 @@ declare function iterateRawCalls(sink: RawProviderSink, filter?: {
   spanId?: string;
 }): AsyncGenerator<ReplayCacheEntry>;
 //#endregion
-export { planTraceInsightQuestions as $, firstStringAttr as A, OtlpSpan as At, TraceInsightPanelRole as B, otlpRowsToRunRecords as C, applyToolSpanOtlpAttributes as Ct, ProjectedOtlpSpan as D, OTEL_AGENT_EVAL_SCOPE as Dt, otlpToTraceRunRecords as E, traceSpanKindToOpenInferenceKind as Et, FlattenOtlpOptions as F, TraceInsightSuite as G, TraceInsightQualityGate as H, flattenOtlpExportToNdjson as I, buildTraceInsightPrompt as J, TraceInsightTask as K, OtlpFlatLine as L, projectOtlpFlatLine as M, readOtlpStatus as N, asString as O, OtlpExport as Ot, stringField as P, inferDomainKeywords as Q, TraceInsightContext as R, TraceAggregate as S, ToolSpanOtlpInput as St, otlpToRunRecords as T, isOtlpModelCall as Tt, TraceInsightQuestion as U, TraceInsightPromptInput as V, TraceInsightReadiness as W, describeTraceInsightScope as X, defaultTraceInsightPanel as Y, domainEvidencePattern as Z, toolSpansToTraceAnalysisStore as _, OtelExportConfig as _t, ReplayFetchOptions as a, TraceStoreToOtlpOptions as at, OtlpToRunRecordsOptions as b, OtlpSpanRole as bt, buildTraceAnalystTools as c, DEFAULT_REDACTION_RULES as ct, OtlpFileTraceStoreOptions as d, RedactionRule as dt, scoreTraceInsightReadiness as et, SpanNotFoundError as f, redactString as ft, TraceNotFoundError as g, ExportableSpan as gt, TraceFileMissingError as h, otelRunCompleteHook as ht, ReplayCacheStats as i, TraceStoreSource as it, inferOtlpKind as j, exportRunAsOtlp as jt, extractOtlpAttributes as k, OtlpResourceSpans as kt, traceAnalystFunctionGroup as l, REDACTION_VERSION as lt, ToolTraceMissingError as m, createOtelTracingStore as mt, ReplayCacheEntry as n, TraceAnalystHookOptions as nt, createReplayFetch as o, TracesToOtlpResult as ot, ToolSpansToTraceAnalysisStoreOptions as p, redactValue as pt, buildTraceInsightContext as q, ReplayCacheMissError as r, traceAnalystOnRunComplete as rt, iterateRawCalls as s, convertTraceStoresToOtlp as st, ReplayCache as t, tokenizeDomainWords as tt, OtlpFileTraceStore as u, RedactionReport as ut, TRACE_ANALYST_ACTOR_DESCRIPTION as v, OtelExporter as vt, otlpRowsToTraceRunRecords as w, classifyOtlpSpanRole as wt, OtlpTraceRunRecord as x, OtlpSpanRoleInput as xt, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as y, createOtelExporter as yt, TraceInsightFinding as z };
-//# sourceMappingURL=replay-BRfMIs81.d.ts.map
+export { buildTraceInsightContext as $, otlpRowsToTraceRunRecords as A, RedactionReport as At, stringField as B, OtlpSpanRole as Bt, otlpTextToTraceAnalysisStore as C, createBoundedTraceAnalysisStore as Ct, OtlpTraceRunRecord as D, convertTraceStoresToOtlp as Dt, OtlpToRunRecordsOptions as E, TracesToOtlpResult as Et, extractOtlpAttributes as F, otelRunCompleteHook as Ft, TraceInsightFinding as G, isOtlpModelCall as Gt, flattenOtlpExportToNdjson as H, ToolSpanOtlpInput as Ht, firstStringAttr as I, ExportableSpan as It, TraceInsightQualityGate as J, OtlpExport as Jt, TraceInsightPanelRole as K, traceSpanKindToOpenInferenceKind as Kt, inferOtlpKind as L, OtelExportConfig as Lt, otlpToTraceRunRecords as M, redactString as Mt, ProjectedOtlpSpan as N, redactValue as Nt, TraceAggregate as O, DEFAULT_REDACTION_RULES as Ot, asString as P, createOtelTracingStore as Pt, TraceInsightTask as Q, projectOtlpFlatLine as R, OtelExporter as Rt, ToolSpansToTraceAnalysisStoreOptions as S, analyzeTraces as St, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as T, TraceStoreToOtlpOptions as Tt, OtlpFlatLine as U, applyToolSpanOtlpAttributes as Ut, FlattenOtlpOptions as V, OtlpSpanRoleInput as Vt, TraceInsightContext as W, classifyOtlpSpanRole as Wt, TraceInsightReadiness as X, OtlpSpan as Xt, TraceInsightQuestion as Y, OtlpResourceSpans as Yt, TraceInsightSuite as Z, exportRunAsOtlp as Zt, toOpenAiTool as _, TraceNotFoundError as _t, ReplayFetchOptions as a, planTraceInsightQuestions as at, OtlpFileTraceStore as b, AnalyzeTracesResult as bt, BuildTraceAnalysisToolsOptions as c, TraceAnalystHookOptions as ct, buildTraceAnalysisToolDescriptors as d, TraceAnalysisLimitError as dt, buildTraceInsightPrompt as et, buildTraceAnalystTools as f, TraceAnalysisStoreContractError as ft, makeEvalTools as g, TraceFileTooLargeError as gt, MakeEvalToolsConfig as h, TraceFileMissingError as ht, ReplayCacheStats as i, inferDomainKeywords as it, otlpToRunRecords as j, RedactionRule as jt, otlpRowsToRunRecords as k, REDACTION_VERSION as kt, TRACE_ANALYST_TOOL_NAMESPACE as l, traceAnalystOnRunComplete as lt, EvalToolDef as m, TraceFileMalformedError as mt, ReplayCacheEntry as n, describeTraceInsightScope as nt, createReplayFetch as o, scoreTraceInsightReadiness as ot, traceAnalystFunctionGroup as p, TraceAnalysisValidationError as pt, TraceInsightPromptInput as q, OTEL_AGENT_EVAL_SCOPE as qt, ReplayCacheMissError as r, domainEvidencePattern as rt, iterateRawCalls as s, tokenizeDomainWords as st, ReplayCache as t, defaultTraceInsightPanel as tt, TraceAnalysisToolDescriptor as u, SpanNotFoundError as ut, ToolTraceMissingError as v, AnalyzeTracesInput as vt, TRACE_ANALYST_ACTOR_DESCRIPTION as w, TraceStoreSource as wt, OtlpFileTraceStoreOptions as x, AnalyzeTracesTurnSnapshot as xt, toolSpansToTraceAnalysisStore as y, AnalyzeTracesOptions as yt, readOtlpStatus as z, createOtelExporter as zt };
+//# sourceMappingURL=replay-K8FaC0CB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replay-K8FaC0CB.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/store-boundary.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/errors.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/store-tool-spans.ts","../src/eval-tools.ts","../src/trace-analyst/tools.ts","../src/replay.ts"],"mappings":"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"}

package/dist/reporting.d.ts

@@ -1,6 +1,6 @@
-import { N as benjaminiHochberg, Q as pairedBootstrap, gt as wilcoxonSignedRank, v as PairedBootstrapOptions, y as PairedBootstrapResult } from "./statistics-CKOqre5S.js";
-import { _ as paretoChart, a as ParetoPoint, c as ResearchReportCandidate, d as ResearchReportOptions, f as ResearchReportRecommendation, g as gainHistogram, h as SummaryTableRow, i as ParetoFigureSpec, l as ResearchReportDecision, m as SummaryTableOptions, n as GainDistributionFigureSpec, o as RESEARCH_REPORT_HARD_PAIR_FLOOR, p as SummaryTable, r as GainDistributionOptions, s as ResearchReport, t as GainDistributionBin, u as ResearchReportMethodology, v as researchReport, y as summaryTable } from "./summary-report-CPMINBqs.js";
-import { _ as ReleaseConfidenceStatus, a as JudgeReplayGateArgs, b as assertReleaseConfidence, c as judgeReplayGate, d as ReleaseConfidenceAxis, f as ReleaseConfidenceAxisName, g as ReleaseConfidenceScorecard, h as ReleaseConfidenceMetrics, i as BootstrapResult, m as ReleaseConfidenceIssue, n as renderReleaseReport, o as Verdict, p as ReleaseConfidenceInput, r as BootstrapOptions, s as bootstrapCi, t as RenderReleaseReportOptions, v as ReleaseConfidenceThresholds, x as evaluateReleaseConfidence, y as ReleaseTraceEvidence } from "./release-report-DpBxGGI1.js";
+import { N as benjaminiHochberg, Q as pairedBootstrap, gt as wilcoxonSignedRank, v as PairedBootstrapOptions, y as PairedBootstrapResult } from "./statistics-_7P642CN.js";
+import { _ as paretoChart, a as ParetoPoint, c as ResearchReportCandidate, d as ResearchReportOptions, f as ResearchReportRecommendation, g as gainHistogram, h as SummaryTableRow, i as ParetoFigureSpec, l as ResearchReportDecision, m as SummaryTableOptions, n as GainDistributionFigureSpec, o as RESEARCH_REPORT_HARD_PAIR_FLOOR, p as SummaryTable, r as GainDistributionOptions, s as ResearchReport, t as GainDistributionBin, u as ResearchReportMethodology, v as researchReport, y as summaryTable } from "./summary-report-DHipz9Kx.js";
+import { _ as ReleaseConfidenceStatus, a as JudgeReplayGateArgs, b as assertReleaseConfidence, c as judgeReplayGate, d as ReleaseConfidenceAxis, f as ReleaseConfidenceAxisName, g as ReleaseConfidenceScorecard, h as ReleaseConfidenceMetrics, i as BootstrapResult, m as ReleaseConfidenceIssue, n as renderReleaseReport, o as Verdict, p as ReleaseConfidenceInput, r as BootstrapOptions, s as bootstrapCi, t as RenderReleaseReportOptions, v as ReleaseConfidenceThresholds, x as evaluateReleaseConfidence, y as ReleaseTraceEvidence } from "./release-report-CofgVNZt.js";
 import { a as PairedEvalueStep, c as pairedEvalueSequence, i as PairedEvalueSequence, n as InterimReleaseConfidenceInput, o as SequentialDecision, r as PairedEvalueOptions, s as evaluateInterimReleaseConfidence, t as InterimReleaseConfidence } from "./sequential-CYwq6Ff_.js";
-import { a as rubricPredictiveValidity, i as RubricRanking, n as RubricPredictiveValidityInput, r as RubricPredictiveValidityReport, t as RubricOutcomePair } from "./rubric-predictive-validity-C1dCLcvb.js";
+import { a as rubricPredictiveValidity, i as RubricRanking, n as RubricPredictiveValidityInput, r as RubricPredictiveValidityReport, t as RubricOutcomePair } from "./rubric-predictive-validity-C4sztLR3.js";
 export { type BootstrapOptions, type BootstrapResult, type GainDistributionBin, type GainDistributionFigureSpec, type GainDistributionOptions, type InterimReleaseConfidence, type InterimReleaseConfidenceInput, type JudgeReplayGateArgs, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type ParetoFigureSpec, type ParetoPoint, RESEARCH_REPORT_HARD_PAIR_FLOOR, type ReleaseConfidenceAxis, type ReleaseConfidenceAxisName, type ReleaseConfidenceInput, type ReleaseConfidenceIssue, type ReleaseConfidenceMetrics, type ReleaseConfidenceScorecard, type ReleaseConfidenceStatus, type ReleaseConfidenceThresholds, type ReleaseTraceEvidence, type RenderReleaseReportOptions, type ResearchReport, type ResearchReportCandidate, type ResearchReportDecision, type ResearchReportMethodology, type ResearchReportOptions, type ResearchReportRecommendation, type RubricOutcomePair, type RubricPredictiveValidityInput, type RubricPredictiveValidityReport, type RubricRanking, type SequentialDecision, type SummaryTable, type SummaryTableOptions, type SummaryTableRow, type Verdict, assertReleaseConfidence, benjaminiHochberg, bootstrapCi, evaluateInterimReleaseConfidence, evaluateReleaseConfidence, gainHistogram, judgeReplayGate, pairedBootstrap, pairedEvalueSequence, paretoChart, renderReleaseReport, researchReport, rubricPredictiveValidity, summaryTable, wilcoxonSignedRank };

package/dist/reporting.js

@@ -1,6 +1,6 @@
-import { E as pairedBootstrap, W as wilcoxonSignedRank, s as benjaminiHochberg } from "./statistics-CnGCLLqc.js";
-import { a as evaluateReleaseConfidence, i as assertReleaseConfidence, n as bootstrapCi, r as judgeReplayGate, t as renderReleaseReport } from "./release-report-DooPguBc.js";
-import { a as summaryTable, i as researchReport, n as gainHistogram, r as paretoChart, t as RESEARCH_REPORT_HARD_PAIR_FLOOR } from "./summary-report-BEk8OFLs.js";
+import { E as pairedBootstrap, W as wilcoxonSignedRank, s as benjaminiHochberg } from "./statistics-ByxzSiOM.js";
+import { a as evaluateReleaseConfidence, i as assertReleaseConfidence, n as bootstrapCi, r as judgeReplayGate, t as renderReleaseReport } from "./release-report-B5XPBvAU.js";
+import { a as summaryTable, i as researchReport, n as gainHistogram, r as paretoChart, t as RESEARCH_REPORT_HARD_PAIR_FLOOR } from "./summary-report-9A5y7EsK.js";
 import { n as pairedEvalueSequence, t as evaluateInterimReleaseConfidence } from "./sequential-Br0mAPHA.js";
-import { t as rubricPredictiveValidity } from "./rubric-predictive-validity-BJf-8ejY.js";
+import { t as rubricPredictiveValidity } from "./rubric-predictive-validity-BRR632r1.js";
 export { RESEARCH_REPORT_HARD_PAIR_FLOOR, assertReleaseConfidence, benjaminiHochberg, bootstrapCi, evaluateInterimReleaseConfidence, evaluateReleaseConfidence, gainHistogram, judgeReplayGate, pairedBootstrap, pairedEvalueSequence, paretoChart, renderReleaseReport, researchReport, rubricPredictiveValidity, summaryTable, wilcoxonSignedRank };

package/dist/{researcher-Doo95b50.d.ts → researcher-Da0Wj-bt.d.ts}

@@ -1,11 +1,10 @@
-import { i as AgentProfileCellInput, r as AgentProfileCell } from "./agent-profile-cell-CCm3l2v2.js";
-import { a as RunRecord, c as RunTaskFailure, n as RunCostProvenance, r as RunJudgeMetadata, s as RunSplitTag, t as JudgeScoresRecord, u as RunTokenUsage } from "./run-record-DcObtIGh.js";
-import { l as RawProviderSink } from "./raw-provider-sink-BU29Sh8h.js";
+import { i as AgentProfileCellInput, r as AgentProfileCell } from "./agent-profile-cell-Cw0PVwDr.js";
+import { a as RunRecord, c as RunTaskFailure, n as RunCostProvenance, r as RunJudgeMetadata, s as RunSplitTag, t as JudgeScoresRecord, u as RunTokenUsage } from "./run-record-BPCa2rQ8.js";
+import { Z as LlmRouteRequirements, _t as RawProviderSink, q as LlmClientOptions } from "./types-CTvKfr5F.js";
 import { s as TraceStore } from "./store-CT9YIIve.js";
 import { i as TraceEmitter, t as RunCompleteHook } from "./emitter-DGQGoLyj.js";
-import { a as RunIntegrityReport, n as RunIntegrityExpectations } from "./integrity-rmVhXWA7.js";
-import { o as LlmClientOptions, u as LlmRouteRequirements } from "./llm-client-BiK4HW0u.js";
-import { d as ResearchReportOptions, s as ResearchReport, x as GateDecision } from "./summary-report-CPMINBqs.js";
+import { a as RunIntegrityReport, n as RunIntegrityExpectations } from "./integrity-CKxosZ5Z.js";
+import { d as ResearchReportOptions, s as ResearchReport, x as GateDecision } from "./summary-report-DHipz9Kx.js";
 //#region src/eval-campaign.d.ts
 interface CampaignVariant<V> {
   id: string;
@@ -312,4 +311,4 @@ declare class NoopResearcher implements Researcher {
 }
 //#endregion
 export { EvalCampaignResult as _, FailureMode as a, SteeringChange as c, CampaignRunContext as d, CampaignRunOutcome as f, EvalCampaignOptions as g, CampaignVariant as h, ExperimentResult as i, CampaignFactoryParams as l, CampaignScenario as m, CallbackResearcherOptions as n, NoopResearcher as o, CampaignRunner as p, ExperimentPlan as r, Researcher as s, CallbackResearcher as t, CampaignIntegrityPolicy as u, FailedRun as v, runEvalCampaign as y };
-//# sourceMappingURL=researcher-Doo95b50.d.ts.map
+//# sourceMappingURL=researcher-Da0Wj-bt.d.ts.map

package/dist/researcher-Da0Wj-bt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"researcher-Da0Wj-bt.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"}

package/dist/{reward-hacking-D-QqXvg-.d.ts → reward-hacking-CQ3hTCO3.d.ts}

@@ -1,5 +1,5 @@
 import { s as VerificationReport } from "./multi-layer-verifier-BHY1gWAc.js";
-import { a as RunRecord } from "./run-record-DcObtIGh.js";
+import { a as RunRecord } from "./run-record-BPCa2rQ8.js";
 //#region src/rl/verifiable-reward.d.ts
 type VerifiableRewardSource = 'compile' | 'test' | 'schema' | 'sandbox' | 'judge' | 'composite';
 interface VerifiableReward {
@@ -221,4 +221,4 @@ interface DetectRewardHackingInput {
 declare function detectRewardHacking(input: DetectRewardHackingInput): RewardHackingReport;
 //#endregion
 export { detectRewardHacking as a, VerifiableRewardSource as c, filterDeterministicallyRewarded as d, RewardHackingSignal as i, extractVerifiableReward as l, RewardHackingFinding as n, VerifiableReward as o, RewardHackingReport as r, VerifiableRewardExtractionOptions as s, DetectRewardHackingInput as t, extractVerifiableRewardsFromRecords as u };
-//# sourceMappingURL=reward-hacking-D-QqXvg-.d.ts.map
+//# sourceMappingURL=reward-hacking-CQ3hTCO3.d.ts.map

package/dist/{reward-hacking-D-QqXvg-.d.ts.map → reward-hacking-CQ3hTCO3.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"reward-hacking-D-QqXvg-.d.ts","names":[],"sources":["../src/rl/verifiable-reward.ts","../src/rl/reward-hacking.ts"],"mappings":";;;KAiCY;UAQK;;EAEf;;EAEA,QAAQ;;;;;;;;EAQR;;;;;;EAMA;;EAEA;;;;;;;EAOA,YAAY;;;;;;;;;;;EAWZ;;;;;;;;;;;;;;;;;;EAkBA;;UAGe;;;;;;;;EAQf;;;;EAIA,aAAa,sBAAsB;;;;;;;EAOnC;;;;;EAKA;;;;;;;;;;;;EAYA;;;;;;;;;;;;;;;iBA6Cc,wBACd,QAAQ,oBACR,OAAM,oCACL;;;;;;;;;;;;;;;;;;;;;;;iBAqGa,oCACd,MAAM,aACN,OAAM,oCACL;EAAQ;EAAe,QAAQ;;;;;;;;;;;iBA4GlB,gCACd,MAAM,aACN,OAAM,oCACL;EAAQ,KAAK;EAAW,QAAQ;;;;KChWvB;UAMK;EACf,QAAQ;;EAER;EACA;;EAEA,QAAQ;;UAGO;EACf,UAAU;;EAEV,kBAAkB;;;;;;EAMlB;;EAEA;;EAEA;;UAGe;;;;;EAKf,MAAM;;;;;EAKN,WAAW,KAAK;;;;;;EAMhB,WAAW,KAAK;;;;;;EAMhB,qBAAqB,KAAK;;;;;EAK1B;;;;;EAKA;IAAe;IAAkB;;;;;EAIjC,0BAA0B;;iBAgBZ,oBAAoB,OAAO,2BAA2B"}
+{"version":3,"file":"reward-hacking-CQ3hTCO3.d.ts","names":[],"sources":["../src/rl/verifiable-reward.ts","../src/rl/reward-hacking.ts"],"mappings":";;;KAiCY;UAQK;;EAEf;;EAEA,QAAQ;;;;;;;;EAQR;;;;;;EAMA;;EAEA;;;;;;;EAOA,YAAY;;;;;;;;;;;EAWZ;;;;;;;;;;;;;;;;;;EAkBA;;UAGe;;;;;;;;EAQf;;;;EAIA,aAAa,sBAAsB;;;;;;;EAOnC;;;;;EAKA;;;;;;;;;;;;EAYA;;;;;;;;;;;;;;;iBA6Cc,wBACd,QAAQ,oBACR,OAAM,oCACL;;;;;;;;;;;;;;;;;;;;;;;iBAqGa,oCACd,MAAM,aACN,OAAM,oCACL;EAAQ;EAAe,QAAQ;;;;;;;;;;;iBA4GlB,gCACd,MAAM,aACN,OAAM,oCACL;EAAQ,KAAK;EAAW,QAAQ;;;;KChWvB;UAMK;EACf,QAAQ;;EAER;EACA;;EAEA,QAAQ;;UAGO;EACf,UAAU;;EAEV,kBAAkB;;;;;;EAMlB;;EAEA;;EAEA;;UAGe;;;;;EAKf,MAAM;;;;;EAKN,WAAW,KAAK;;;;;;EAMhB,WAAW,KAAK;;;;;;EAMhB,qBAAqB,KAAK;;;;;EAK1B;;;;;EAKA;IAAe;IAAkB;;;;;EAIjC,0BAA0B;;iBAgBZ,oBAAoB,OAAO,2BAA2B"}

package/dist/{reward-hacking-a-kYs0-i.js → reward-hacking-GyN0kMd8.js}

@@ -1,6 +1,6 @@
-import { L as pearsonR } from "./statistics-CnGCLLqc.js";
 import { n as observedScore, s as trainingScore, t as isRealnessGated } from "./reward-nw2xZGZG.js";
-import { s as validateRunRecord } from "./run-record-BIwU2wdV.js";
+import { L as pearsonR } from "./statistics-ByxzSiOM.js";
+import { s as validateRunRecord } from "./run-record-vRgqWmJw.js";
 //#region src/campaign/run-record.ts
 /**
 * Project one campaign cell into the canonical run format.
@@ -593,4 +593,4 @@ function defaultSecondary(verifiableOpts) {
 //#endregion
 export { campaignCellExecutionEvidence as a, campaignCellToRunRecord as c, filterDeterministicallyRewarded as i, projectCampaignCellQuality as l, extractVerifiableReward as n, campaignCellJudgeDimensions as o, extractVerifiableRewardsFromRecords as r, campaignCellTaskScore as s, detectRewardHacking as t };
 
-//# sourceMappingURL=reward-hacking-a-kYs0-i.js.map
+//# sourceMappingURL=reward-hacking-GyN0kMd8.js.map