@tangle-network/agent-eval 0.128.1 → 0.129.0

package/dist/index.d.ts

@@ -2,7 +2,6 @@ import { AgentProfile, HarnessType } from '@tangle-network/agent-interface';
 export { AgentProfile, HarnessType } from '@tangle-network/agent-interface';
 import { AxAIArgs, AxAIService, AxFunction, AxAgentActorTurnCallbackArgs } from '@ax-llm/ax';
 import { z } from 'zod';
-import { TCloud } from '@tangle-network/tcloud';
 
 /**
  * TraceSchema v1 — the canonical data model for agent-eval.
@@ -1166,8 +1165,6 @@ interface CostReceipt extends CostCallBase, CostUsage {
     actualCostUsd?: number;
     error?: string;
 }
-/** @deprecated Read-only compatibility shape. New paid work uses `runPaidCall`. */
-type CostLedgerEntry = Omit<CostReceipt, 'status' | 'callId' | 'phase' | 'actor' | 'maximumCostUsd' | 'usageUnknown' | 'pricing' | 'error'>;
 interface CostReceiptInput extends CostUsage {
     model: string;
     /** Caller-supplied rates for a local estimate when the provider does not report billed cost. */
@@ -1506,9 +1503,8 @@ declare function providerFromBaseUrl(baseUrl: string): string;
  *     { baseUrl: 'https://router.tangle.tools/v1', apiKey: process.env.KEY },
  *   )
  *
- * This is THE llm-calling seam for agent-eval primitives that need structured
- * output (semantic concept judge, reviewer directives, critic scores). Primitives
- * that need free-form text use `callLlm` and parse output themselves.
+ * `createChatClient` wraps this implementation for provider-neutral package
+ * entry points. Direct callers can use `callLlm` or `callLlmJson`.
  */
 
 interface LlmMessage {
@@ -1644,8 +1640,8 @@ interface LlmClientOptions {
      * total attempts × `timeoutMs`.
      */
     deadlineMs?: number;
-    /** Total provider attempts. Legacy option name; default 3 (1 initial + 2 retries). */
-    maxRetries?: number;
+    /** Total provider attempts. Default 3. */
+    maximumAttempts?: number;
     /** Token rates used when the provider omits cost or package pricing does not cover the model. */
     customTokenPricing?: CustomTokenPricing;
     /**
@@ -1693,10 +1689,9 @@ interface LlmClientOptions {
  * name/message/code, then recurses into `error.cause` — undici nests the
  * real socket fault one or more levels under `.cause`.
  *
- * This is THE retry classifier for the package: `callLlm` and
- * `withJudgeRetry` both route through it, so a connection-class error is
- * treated identically whether it surfaces in the HTTP client or a
- * TCloud-backed judge.
+ * This is the retry classifier for the package: `callLlm` and
+ * `withJudgeRetry` both route through it, so connection failures are treated
+ * consistently across transports.
  */
 declare function isTransientLlmError(err: unknown): boolean;
 /** Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 16s. Attempt is 0-indexed. */
@@ -1797,42 +1792,27 @@ declare class LlmClient {
 }
 
 /**
- * ChatClient — the single LLM abstraction analysts call.
- *
- * agent-eval already ships an `LlmClient` (OpenAI-compatible, retry,
- * graceful JSON-schema degrade) and judges that talk to `TCloud`. Two
- * mixed patterns force every analyst author to pick a transport, which
- * couples analyst code to runtime concerns (cli-bridge vs router vs
- * sandbox-sdk) it shouldn't know about.
- *
- * `ChatClient` is one interface every analyst takes via `AnalystContext.chat`.
- * The operator decides at the registry boundary which transport binds
- * to it. Analyst code stays transport-agnostic; swapping production
- * (sandbox-sdk) for local dev (cli-bridge) or tests (mock) is a one-
- * line factory call.
+ * Provider-neutral chat contract for every model call made by agent-eval.
  *
- * Designed to coexist: existing `LlmClient` callers and existing
- * `TCloud`-based judges keep working untouched. New analyst code uses
- * `ChatClient`. When old call sites migrate, they pick up budgeting,
- * cancellation, and unified telemetry for free.
+ * Callers choose the transport at the package boundary with `createChatClient`.
+ * Evaluation code receives canonical requests and results without importing a
+ * provider SDK.
  */
 
 /**
- * Unified chat interface. Mirrors LlmCallRequest/Result so the OpenAI-
- * compatible mental model stays. Two methods: a one-shot `chat()` and
- * an `streamChat()` for future agentic loops (not yet exposed).
+ * Unified chat interface using the package's canonical LLM request and result.
  */
 interface ChatClient {
-    /** Display name of the bound transport — included in telemetry. */
+    /** Display name of the bound transport, included in telemetry. */
     readonly transport: ChatTransport;
-    /** Default model when caller omits — operators bind this per environment. */
+    /** Default model when the caller omits one. */
     readonly defaultModel?: string;
     /** Total provider attempts this transport can make for one chat call. */
     readonly maximumAttempts?: number;
     /** Implementations must enforce `req.maxTokens` when it is present. */
     chat(req: ChatRequest, opts?: ChatCallOpts): Promise<ChatResponse>;
 }
-type ChatTransport = 'router' | 'sandbox-sdk' | 'cli-bridge' | 'direct-provider' | 'mock';
+type ChatTransport = 'router' | 'sandbox-sdk' | 'cli-bridge' | 'direct-provider' | 'custom' | 'mock';
 interface ChatRequest extends Omit<LlmCallRequest, 'model'> {
     /** Optional — falls back to ChatClient.defaultModel. */
     model?: string;
@@ -1848,7 +1828,7 @@ interface ChatCallOpts {
     /** Stable provider idempotency key for retries/redrives of one paid call. */
     idempotencyKey?: string;
 }
-type CreateChatClientOpts = RouterTransportOpts | CliBridgeTransportOpts | DirectProviderTransportOpts | SandboxSdkTransportOpts | MockTransportOpts;
+type CreateChatClientOpts = RouterTransportOpts | CliBridgeTransportOpts | DirectProviderTransportOpts | SandboxSdkTransportOpts | CustomTransportOpts | MockTransportOpts;
 interface BaseTransportOpts {
     defaultModel?: string;
     /** Total provider attempts. Required for opaque transports used in capped runs. */
@@ -1870,15 +1850,18 @@ interface DirectProviderTransportOpts extends BaseTransportOpts {
     apiKey: string;
 }
 /**
- * Sandbox-SDK transport. Provided as a thin pass-through: the caller
- * supplies a callable that mimics LlmClient.chat() against an already-
- * configured Sandbox handle. We don't import the SDK here to keep
- * agent-eval dep-free of @tangle-network/sandbox.
+ * Sandbox-SDK transport. The caller supplies a canonical chat function for an
+ * already-configured Sandbox handle, so agent-eval does not import the SDK.
  */
 interface SandboxSdkTransportOpts extends BaseTransportOpts {
     transport: 'sandbox-sdk';
     chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
 }
+/** Caller-adapted SDK or transport returning the canonical ChatResponse shape. */
+interface CustomTransportOpts extends BaseTransportOpts {
+    transport: 'custom';
+    chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
+}
 /**
  * Mock transport for tests. The handler receives the request and returns
  * whatever the test wants. No retries, no JSON-schema degrade.
@@ -2370,7 +2353,14 @@ type RunTaskFailure = {
     failureClass: Exclude<FailureClass, 'success'>;
     failureMode?: string;
 };
-/** Return task quality, preferring held-out evidence when both scores exist. */
+/**
+ * Return task quality, preferring held-out evidence when both scores exist.
+ *
+ * RAW: no realness protection is applied. Built on `observedScore` rather
+ * than repeating the split derivation, so only `rollout/reward.ts` reads the
+ * raw fields. Anything that becomes training data must use `trainingScore` or
+ * `trainingReward` instead.
+ */
 declare function runTaskScore(record: RunRecord): number | undefined;
 declare class RunRecordValidationError extends ValidationError {
     readonly path: string;
@@ -2677,8 +2667,6 @@ interface BenchmarkRunnerConfig {
     promptVersion?: string;
     /** Shared ledger for agent and judge calls made by the benchmark. */
     costLedger?: CostLedgerHandle;
-    /** Exact maximum provider attempts configured on the supplied TCloud client. */
-    tcloudMaximumAttempts?: number;
 }
 interface JudgeInput {
     scenario: Scenario$1;
@@ -2689,11 +2677,8 @@ interface JudgeInput {
     costPhase?: string;
     costTags?: Record<string, string>;
     signal?: AbortSignal;
-    /** Exact maximum provider attempts configured on the supplied TCloud client. */
-    tcloudMaximumAttempts?: number;
 }
-type JudgeFn = (tc: TCloud, input: JudgeInput) => Promise<JudgeScore$1[]>;
-
+type JudgeFn = (chat: ChatClient, input: JudgeInput) => Promise<JudgeScore$1[]>;
 interface TestResult {
     name: string;
     passed: boolean;
@@ -2935,13 +2920,8 @@ interface AnalystRunSummary {
     reason?: string;
     findings_count: number;
     latency_ms: number;
-    cost_usd: number;
-    /**
-     * Additive receipt for model usage. Registry-produced summaries populate it
-     * even when the analyst emits no findings. `cost_usd` remains the legacy
-     * numeric field; inspect `usage.cost` before treating zero as observed.
-     */
-    usage?: AnalystUsageReceipt;
+    /** Additive model usage and cost provenance for this analyst. */
+    usage: AnalystUsageReceipt;
     /** When `status='failed'`: the error class + message, never the full stack. */
     error?: {
         class: string;
@@ -3003,12 +2983,9 @@ type AnalystRunEvent = {
 /**
  * Typed Ax output for analyst findings.
  *
- * Replaces the legacy `findings:string[]` pattern (where every bullet
- * became a flat-severity `AnalystFinding`) with a structured object
- * array. Ax binds the field as `findings:json[]` so the provider emits
- * native structured output; at the kind-factory boundary we Zod-validate
- * each emitted finding so malformed rows fail loud instead of being
- * silently lifted with default severity.
+ * Ax binds the field as `findings:json[]` so the provider emits native
+ * structured output. At the kind-factory boundary every row is validated
+ * before it becomes an `AnalystFinding`.
  *
  * Why not `f.object().array()` directly in the signature? The Ax
  * signature string `question:string -> findings:json[]` already lets
@@ -3022,31 +2999,7 @@ declare const RawAnalystEvidenceSchema: z.ZodObject<{
     excerpt: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type RawAnalystEvidence = z.infer<typeof RawAnalystEvidenceSchema>;
-/** Original public schema retained for stored rows and callback contracts. */
 declare const RawAnalystFindingSchema: z.ZodObject<{
-    evidence_uri: z.ZodString;
-    evidence_excerpt: z.ZodOptional<z.ZodString>;
-    severity: z.ZodEnum<{
-        info: "info";
-        critical: "critical";
-        medium: "medium";
-        low: "low";
-        high: "high";
-    }>;
-    claim: z.ZodString;
-    subject: z.ZodOptional<z.ZodString>;
-    confidence: z.ZodNumber;
-    rationale: z.ZodOptional<z.ZodString>;
-    recommended_action: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
-/**
- * Canonical plural-evidence contract. The preprocessor accepts the original
- * `evidence_uri` / `evidence_excerpt` pair and normalizes it into one evidence
- * item so persisted rows and older model fixtures remain readable. New output
- * always receives the plural shape.
- */
-declare const CanonicalRawAnalystFindingSchema: z.ZodPreprocess<z.ZodObject<{
     evidence: z.ZodArray<z.ZodObject<{
         uri: z.ZodString;
         excerpt: z.ZodOptional<z.ZodString>;
@@ -3063,8 +3016,8 @@ declare const CanonicalRawAnalystFindingSchema: z.ZodPreprocess<z.ZodObject<{
     confidence: z.ZodNumber;
     rationale: z.ZodOptional<z.ZodString>;
     recommended_action: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>>;
-type CanonicalRawAnalystFinding = z.infer<typeof CanonicalRawAnalystFindingSchema>;
+}, z.core.$strict>;
+type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
 
 /**
  * Analyst-kind factory — the typed way to define trace analysts.
@@ -3073,7 +3026,7 @@ type CanonicalRawAnalystFinding = z.infer<typeof CanonicalRawAnalystFindingSchem
  * and bounded Ax subqueries target one failure-mode lens (failure-mode
  * classification, knowledge gap discovery, knowledge poisoning,
  * self-improvement, ...). Kinds emit findings in the typed
- * `CanonicalRawAnalystFinding` shape via a JSON-array Ax output; the factory
+ * `RawAnalystFinding` shape via a JSON-array Ax output; the factory
  * validates each row with Zod and lifts it into `AnalystFinding[]`.
  *
  * Composition rules:
@@ -3136,7 +3089,7 @@ interface TraceAnalystKindSpec {
  */
 interface TraceAnalystGolden {
     question: string;
-    expected: ReadonlyArray<Omit<CanonicalRawAnalystFinding, 'confidence'>>;
+    expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
 }
 interface CreateTraceAnalystKindOpts {
     /** AxAIService bound at registration time. */
@@ -3831,9 +3784,9 @@ declare function ghCliClient(opts?: GhCliClientOptions): AutoPrClient;
  * Domain-agnostic. Each agent provides its own scenarios, judges, and system prompt.
  */
 declare class BenchmarkRunner {
-    private tc;
+    private chat;
     private config;
-    constructor(tc: TCloud, config: BenchmarkRunnerConfig);
+    constructor(chat: ChatClient, config: BenchmarkRunnerConfig);
     run(scenarios?: Scenario$1[]): Promise<BenchmarkReport$1>;
 }
 
@@ -4210,8 +4163,6 @@ interface AgentDriverConfig {
     productContext?: string;
     /** Shared account for driver-model calls. */
     costLedger?: CostLedgerHandle;
-    /** Exact provider attempt count, required when costLedger has a cap. */
-    tcloudMaximumAttempts?: number;
 }
 /**
  * AgentDriver — meta-agent that plays a persona against the real product.
@@ -4221,13 +4172,12 @@ interface AgentDriverConfig {
  * the next realistic user message.
  */
 declare class AgentDriver {
-    private tc;
+    private chat;
     private client;
     private driverModel;
     private productContext;
     private costLedger;
-    private tcloudMaximumAttempts?;
-    constructor(tc: TCloud, config: AgentDriverConfig);
+    constructor(chat: ChatClient, config: AgentDriverConfig);
     /**
      * Run a persona through the product.
      *
@@ -4295,8 +4245,6 @@ interface DecideNextUserTurnOpts {
     costLedger?: CostLedgerHandle;
     /** Attribution tags merged into the paid-call receipt. */
     costTags?: Record<string, string>;
-    /** Exact provider attempt count, required when costLedger has a cap. */
-    tcloudMaximumAttempts?: number;
 }
 /**
  * Decide the simulated user's next turn — the reactive, adversarial
@@ -4305,7 +4253,7 @@ interface DecideNextUserTurnOpts {
  * workspace machinery. Returns the next user message, or the literal "DONE"
  * when the simulated professional would sign off.
  */
-declare function decideNextUserTurn(tc: TCloud, opts: DecideNextUserTurnOpts): Promise<string>;
+declare function decideNextUserTurn(chat: ChatClient, opts: DecideNextUserTurnOpts): Promise<string>;
 
 interface ExecutorConfig {
     /** System prompt for the agent under test */
@@ -4318,8 +4266,6 @@ interface ExecutorConfig {
     costLedger?: CostLedgerHandle;
     costPhase?: string;
     costTags?: Record<string, string>;
-    /** Exact maximum provider attempts configured on the supplied TCloud client. */
-    tcloudMaximumAttempts?: number;
     signal?: AbortSignal;
     /** Regex patterns for detecting tool/API calls in responses */
     toolCallPatterns?: RegExp[];
@@ -4338,11 +4284,11 @@ interface ExecutorConfig {
     sleep?: (ms: number) => Promise<void>;
 }
 /**
- * Execute a scenario against an LLM via tcloud.
+ * Execute a scenario against an injected chat client.
  *
  * Runs multi-turn conversation, extracts artifacts, runs judges.
  */
-declare function executeScenario(tc: TCloud, scenario: Scenario$1, config: ExecutorConfig): Promise<ScenarioResult>;
+declare function executeScenario(chat: ChatClient, scenario: Scenario$1, config: ExecutorConfig): Promise<ScenarioResult>;
 
 /**
  * Backend-integrity guard: distinguish "agent failed" from "eval ran against
@@ -4602,76 +4548,15 @@ type JudgeParseErrorOptions = {
     llmCall?: LlmCallMetadata;
 };
 /**
- * A judge's LLM response could not be parsed into scored dimensions.
- * Thrown instead of fabricating a `{ dimension: 'parse_error', score: 0 }`
- * row — a synthetic zero is indistinguishable from a real low score
- * downstream. Carries the raw response for forensics. Callers (executor,
- * ensemble wrappers) catch this per-judge and record a failed judge.
+ * A judge's model response could not be parsed into scored dimensions.
+ * Carries the raw response and paid-call metadata without fabricating a score.
  */
 declare class JudgeParseError extends JudgeError {
-    /** Name of the judge whose response failed to parse. */
     readonly judgeName: string;
-    /** The raw (truncated) model response that failed to parse. */
     readonly raw: string;
-    /** Paid-call metadata remains available even when the verdict is unusable. */
     readonly llmCall?: LlmCallMetadata;
     constructor(judgeName: string, raw: string, options?: JudgeParseErrorOptions);
 }
-/**
- * Create a domain expert judge with a configurable domain.
- *
- * The judge evaluates professional accuracy and depth.
- *
- * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
- * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
- * multi-model panels via `ensembleJudge` (src/judge-panel.ts) — which are
- * pluggable, fail-loud, and drive the campaign/improvement-loop engines.
- */
-declare function createDomainExpertJudge(domain: string): JudgeFn;
-/**
- * Code execution judge — evaluates whether code blocks are valid and runnable.
- *
- * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
- * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
- * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
- */
-declare const codeExecutionJudge: JudgeFn;
-/**
- * Coherence judge — evaluates multi-turn consistency and progression.
- *
- * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
- * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
- * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
- */
-declare const coherenceJudge: JudgeFn;
-/**
- * Adversarial judge — red-teams agent responses.
- *
- * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
- * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
- * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
- */
-declare const adversarialJudge: JudgeFn;
-/**
- * Create a custom judge with a fully custom prompt.
- *
- * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
- * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
- * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
- */
-declare function createCustomJudge(name: string, systemPrompt: string, opts?: {
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-}): JudgeFn;
-/**
- * Default judge set (domain must be provided for domain expert)
- *
- * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
- * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
- * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
- */
-declare function defaultJudges(domain: string): JudgeFn[];
 
 type KnowledgeRequirementCategory = 'user_specific' | 'company_specific' | 'domain_specific' | 'codebase_specific' | 'market_specific' | 'regulatory' | 'tool_api' | 'credential_or_secret' | 'runtime_environment' | 'preference' | 'historical_context';
 type KnowledgeAcquisitionMode = 'ask_user' | 'search_web' | 'query_connector' | 'inspect_repo' | 'run_command' | 'infer_low_confidence' | 'not_available';
@@ -4872,6 +4757,13 @@ interface GateEvidence {
     /** Median per-task USD cost across the baseline runs, for
      *  symmetric reporting. */
     medianBaselineCost: number | null;
+    /**
+     * Runs (candidate + baseline) dropped before pairing because the
+     * authenticity gate flagged them as gamed. Surfaced rather than silent: a
+     * promotion decision computed over a shrunken pool has to say by how much,
+     * and a nonzero count here is itself the finding.
+     */
+    realnessGatedRuns: number;
 }
 interface GateDecision$1 {
     /** Final promote/no-promote verdict. */
@@ -5028,6 +4920,13 @@ interface ReleaseConfidenceMetrics {
     domainCounts: Record<string, number>;
     failureClassCounts: Partial<Record<FailureClass, number>>;
     responsibleSurfaceCounts: Record<string, number>;
+    /**
+     * Runs excluded from `passRate` because the authenticity gate flagged them as
+     * gamed. Surfaced, never silent: a release whose pass rate is computed over a
+     * shrunken denominator has to say by how much, or the exclusion is just a
+     * different way of hiding the same runs.
+     */
+    realnessGatedRuns: number;
 }
 interface ReleaseConfidenceScorecard {
     target: string;
@@ -5302,9 +5201,8 @@ interface ContinuousCalibrationResult extends CalibrationResult {
     };
 }
 /**
- * Drop-in superset of `calibrateJudge` that adds continuous-value
- * agreement metrics. The old fields (n, pearson, kappa, mae, worstItems)
- * are preserved unchanged so existing callers continue to work.
+ * Extends `calibrateJudge` with continuous-value agreement metrics while
+ * retaining its base calibration summary.
  */
 declare function calibrateJudgeContinuous(golden: GoldenItem[], candidate: CandidateScore[], opts?: ContinuousAgreementOptions): ContinuousCalibrationResult;
 
@@ -6145,6 +6043,28 @@ declare function printDriverSummary(results: DriverResult[]): void;
  * `outcome.reward` is THE single scalar (null = no verdict exists — a
  * labeled gap, never 0). `outcome.realness_gated` is the anti-Goodhart
  * flag: a gated line must never export as a positive training example.
+ *
+ * That last sentence is enforced here, by `validateRolloutLine`, not merely
+ * documented. Validating `reward` and `realness_gated` independently — each a
+ * well-typed field, their COMBINATION unchecked — is what let a line claiming
+ * `{reward: 0.95, realness_gated: true}` validate clean and walk into every
+ * training export. The relationship between the two IS the invariant, so it is
+ * checked where every other structural claim about a line is checked.
+ *
+ * The invariant is about the OUTCOME, not about one field of it. Zeroing
+ * `reward` while `outcome.metrics` still carried the per-layer scores that
+ * reward was computed from exported the gamed signal anyway, in the dict the
+ * verifiers format reads as its per-rubric scores. So `gateGamedOutcome`
+ * transforms the whole outcome once, at `assertMinted` — the funnel every
+ * minted line passes — and the reward-bearing components are relocated to
+ * `provenance.gated_evidence`, which no exporter projects.
+ *
+ * WHICH checks each door applies is not decided in this file. `./gate-checks`
+ * owns the canonical list and the total per-entry-point policy; the three doors
+ * below (`validateRolloutLine`, `assertRewardGate`, `assertMinted`) each call
+ * `gateErrors` with their declared policy, so a check added to that list applies
+ * here without anyone editing this file, and a check deliberately skipped has to
+ * name itself there.
  */
 declare const ROLLOUT_SCHEMA = "tangle.rollout.v1";
 /** `agent` = a solo evaluation run (no multi-agent topology). */
@@ -6173,6 +6093,14 @@ interface ChatMessage {
     /** Required on role:"tool" — the ChatToolCall this result answers. */
     tool_call_id?: string;
     name?: string;
+    /**
+     * Harbor ATIF `is_copied_context` (RFC 0001 rule 7): this turn was COPIED IN
+     * from another trajectory's context, not produced by the agent on this line.
+     * The RFC makes excluding it from SFT a MUST, and `toSftRows` does — training
+     * on it teaches the model to author text it never authored, and credits this
+     * run for another one's work. Absent = false (authored here).
+     */
+    is_copied_context?: boolean;
 }
 interface ToolDef {
     type: 'function';
@@ -6196,6 +6124,21 @@ interface RolloutStep {
     output?: string;
     status?: 'ok' | 'error';
     durationMs?: number;
+    /**
+     * LLM inferences this span represents. 0 = deterministic dispatch with no
+     * model call — distinct from absent, which means the producer did not track it.
+     */
+    llm_call_count?: number;
+    /** Exact prompt tokenization. Removes the ambiguity of re-tokenizing text at train time. */
+    prompt_token_ids?: number[];
+    /** Exact completion tokenization; aligns index-wise with `logprobs`. */
+    completion_token_ids?: number[];
+    /**
+     * Per-completion-token log probabilities under the sampling policy. Required
+     * for off-policy correction (importance weighting) when the rollout was
+     * generated by a policy other than the one being trained.
+     */
+    logprobs?: number[];
 }
 interface RolloutTask {
     /** Benchmark/suite id (e.g. "swe-bench-verified") or the experiment id. */
@@ -6240,11 +6183,39 @@ interface RolloutOutcome {
     is_truncated: boolean;
     error: string | null;
     /**
-     * Anti-Goodhart flag from `RunRecord.outcome.realness.gated`: the run
-     * faked its success signal. Reward is forced to 0 at mint time and the
-     * line never qualifies for SFT.
+     * Anti-Goodhart flag from `RunRecord.outcome.realness.gated`: the run faked
+     * its success signal. `true` requires `reward` to be 0 or null — the
+     * validator rejects the line otherwise — and the line never qualifies for
+     * SFT. Required on the wire: a line that does not state the flag does not
+     * validate, so no producer can dodge the gate by omitting it.
+     *
+     * `true` ALSO requires `metrics` to be empty and `verdict` to be null: the
+     * numbers the reward was computed from are relocated to
+     * `provenance.gated_evidence` by `gateGamedOutcome`. See that function for
+     * why zeroing the scalar alone was not enough.
      */
     realness_gated: boolean;
+    /**
+     * Whether an authenticity SCREEN ever RAN on this reward — a different claim
+     * from `realness_gated`, which is the screen's VERDICT.
+     *
+     * `realness_gated: false` reads as "we looked and nothing fired". A producer
+     * with no screen at all was emitting exactly that, so a never-screened reward
+     * was indistinguishable on the wire from a screened-clean one, and the whole
+     * anti-Goodhart apparatus silently treated the first as the second. The two
+     * claims are now separable:
+     *
+     *   - `true`   — a screen ran; `realness_gated` is its verdict.
+     *   - `false`  — the producer declares it HAS no screen (`unscreenedRewardFields`).
+     *                `assertMinted` REFUSES such a line when its reward is above
+     *                zero: an unscreened positive reward is precisely the signal
+     *                the gate exists to qualify, and nothing has qualified it.
+     *   - absent   — not stated. Pre-unification ledgers land here, as does a
+     *                `RunRecord` carrying no `outcome.realness` at all. Absent is
+     *                read as "unknown", never as `false` (which would refuse most
+     *                of the existing corpus) and never as `true`.
+     */
+    realness_screened?: boolean;
 }
 interface RolloutCostBlock {
     usd: number | null;
@@ -6254,6 +6225,11 @@ interface RolloutCostBlock {
     cache_read: number | null;
     cache_write: number | null;
     wall_s: number | null;
+    /**
+     * Total LLM inferences across the invocation (ATIF `llm_call_count`,
+     * aggregated). Optional and additive: absent = not tracked, never 0.
+     */
+    llm_call_count?: number | null;
 }
 interface RolloutArtifacts {
     patch_path: string | null;
@@ -6261,11 +6237,43 @@ interface RolloutArtifacts {
     /** Source-of-truth transcript pointer (session id / jsonl path) for audit. */
     transcript_ref: string | null;
 }
+/**
+ * The reward-bearing half of a GATED line's outcome, moved off `outcome` and
+ * parked here verbatim. Diagnostics, never training input — see
+ * `gateGamedOutcome`.
+ */
+interface GatedEvidence {
+    /** `outcome.metrics` exactly as the producer measured it. */
+    metrics?: Record<string, unknown>;
+    /** `outcome.verdict` verbatim — the judge record that claimed the success. */
+    verdict?: unknown;
+    /**
+     * The per-step fields `tangle.rollout.v1` does not declare, parked here when
+     * the gate projected `steps[]` down to the schema's own key set.
+     *
+     * A per-step reward is training signal exactly like the scalar, and `steps`
+     * rides through `toRewardRows` verbatim — so a gated line was shipping its
+     * step-level credit assignment at full value beside a `reward` of 0.
+     */
+    steps?: unknown;
+}
 interface RolloutProvenance {
     captured_at: string;
     capture: RolloutCapture;
-    /** Present on gap lines: why `messages` could not be recovered. */
+    /**
+     * Why this line is incomplete. Required when `messages` is empty (the
+     * transcript could not be recovered); also set by interchange importers to
+     * name a MISSING LABEL — an imported trajectory carries no verdict, so
+     * `outcome.reward` is null and this says why.
+     */
     gap?: string;
+    /**
+     * Present only on a realness-gated line: the outcome fields the gate
+     * relocated, kept so an auditor can still see WHY the run was gated and what
+     * it claimed. Deliberately OUTSIDE `outcome`, because every training exporter
+     * reads `outcome` and none reads `provenance`.
+     */
+    gated_evidence?: GatedEvidence;
 }
 interface RolloutLine {
     schema: typeof ROLLOUT_SCHEMA;
@@ -6297,6 +6305,82 @@ interface RolloutLine {
 declare function validateRolloutLine(value: unknown): string[];
 declare function assertRolloutLine(value: unknown, context?: string): asserts value is RolloutLine;
 declare function isRolloutLine(value: unknown): value is RolloutLine;
+/**
+ * Phantom property. `declare const` means it exists only in the type system:
+ * nothing is written at runtime, so a branded line still serializes to exactly
+ * the same JSON as a plain one.
+ */
+declare const MINTED_ROLLOUT: unique symbol;
+/**
+ * A minted outcome states the gate verdict — it is not allowed to stay silent —
+ * and, when that verdict is `true`, carries nothing else the reward was derived
+ * from (`gateGamedOutcome` has run).
+ */
+interface MintedRolloutOutcome extends RolloutOutcome {
+    realness_gated: boolean;
+}
+/**
+ * A `RolloutLine` whose reward has been checked against the anti-Goodhart
+ * invariant. The type every training-data exporter takes.
+ *
+ * Why a brand and not just the interface: `RolloutLine` is structural, so any
+ * hand-built object literal of the right shape IS one — which is how a line
+ * declaring `{reward: 0.95, realness_gated: true}` reached the exporters
+ * despite them "only accepting a minted line". The phantom symbol makes the
+ * type nominal: it cannot be produced by writing an object literal, only by
+ * `mintRolloutRows` (which applies the gate), `readRolloutLedger` (which
+ * validates every line off disk), or an explicit, greppable `assertMinted`.
+ *
+ * Belt and braces on purpose. The brand closes first-party call sites at
+ * COMPILE time; `validateRolloutLine` closes data arriving at RUNTIME (ledger
+ * files, foreign imports, JSON from another process) where types are absent.
+ * Neither alone is enough.
+ *
+ * Assignable to `RolloutLine` in one direction only: readers, analysis, and
+ * the ledger writer keep taking the plain type.
+ */
+type MintedRolloutLine = Omit<RolloutLine, 'outcome'> & {
+    readonly [MINTED_ROLLOUT]: true;
+    outcome: MintedRolloutOutcome;
+};
+/**
+ * Promote a line to the type the training exporters accept, applying the
+ * anti-Goodhart gate to the WHOLE outcome on the way through. THE escape hatch
+ * — grep `assertMinted` to enumerate every place a line enters the training
+ * path without coming from mint or a ledger.
+ *
+ * The gate runs HERE, once, rather than at each producer, because this is the
+ * single funnel every minted line passes: `mintRolloutRows` calls it,
+ * `readRolloutLedger` calls it per line off disk, `scrubLines` calls it on the
+ * way out of a release, and a hand-built line has no other door. One
+ * transformation at the funnel means an already-published ledger holding a
+ * gated line with populated `metrics` is RE-GATED when it is read, instead of
+ * being rejected (which would make every such artifact unreadable) or trusted
+ * (which is the leak). Three steps, in this order:
+ *
+ *   1. VALIDATE the schema.
+ *   2. REFUSE every check `GATE_POLICIES.assertMinted` marks `enforce` — today
+ *      the reward relationship (which stays a REJECTION: a caller claiming
+ *      `{reward: 0.95, realness_gated: true}` is a producer defect and must fail
+ *      loudly, since laundering it into `reward: 0` here would hide the
+ *      producer) and a positive reward the producer declared it never screened.
+ *   3. TRANSFORM the one check that policy marks `repair` — relocate the
+ *      reward's components off `outcome` (`gateGamedOutcome`), so no exporter
+ *      can leak them whichever field it reads.
+ *
+ * Step 2 enumerates nothing by hand: a check added to `GATE_CHECKS` is enforced
+ * here the moment its disposition in that policy says so.
+ *
+ * Also normalizes the optional wire flag to an explicit boolean.
+ * `realness_gated` is absent on pre-unification ledgers and absent means "not
+ * flagged" per the schema, so filling it in states a claim the line was already
+ * making, and makes the flag readable on every published row instead of most of
+ * them. `realness_screened` is NOT filled in: absent means "unknown", and
+ * inventing either value there would be the same overclaim this round removed.
+ */
+declare function assertMinted(value: unknown, context?: string): MintedRolloutLine;
+/** `assertMinted` over a batch, naming the offending index in the error. */
+declare function assertMintedLines(values: readonly unknown[], context?: string): MintedRolloutLine[];
 
 /**
  * Pure exporters over `tangle.rollout.v1` lines → the training-data shapes
@@ -6309,8 +6393,40 @@ declare function isRolloutLine(value: unknown): value is RolloutLine;
  * All exporters are pure functions of the lines — filtering (never train on
  * holdout, reward thresholds, the realness gate) happens HERE, on inline
  * labels, no joins.
+ *
+ * Every exporter takes `MintedRolloutLine[]`, not `RolloutLine[]`: the reward
+ * on a minted line has been checked against the anti-Goodhart invariant, and
+ * the brand is what stops a hand-built object literal claiming a positive
+ * reward on a gamed run from being handed to an exporter that copies it
+ * verbatim into training data.
  */
 
+/**
+ * The gate's two claims, which travel TOGETHER on every emitted row.
+ *
+ * `realness_gated` alone is ambiguous, and the ambiguity is exploitable:
+ * `false` reads as "we screened it and nothing fired", so a producer that has no
+ * screen at all emitted rows indistinguishable from screened-clean ones, and
+ * every consumer of the published dataset read them as clean. The second field
+ * is what separates the two claims, and it only removes the ambiguity if it
+ * reaches the WIRE — for a round it existed on `RolloutOutcome` and on no
+ * exported row shape at all, which left the published rows exactly as ambiguous
+ * as before.
+ *
+ * So there is one helper and every row shape spreads it. A row that states one
+ * claim without the other is not constructible by copying the pattern, and
+ * `exporters.test.ts` walks every emitted shape to prove none does.
+ */
+interface RealnessLabels {
+    /** The screen's VERDICT: the run faked its success signal. */
+    realness_gated: boolean;
+    /**
+     * Whether a screen RAN at all. `true` = it ran, so `realness_gated` is its
+     * verdict. `false` = the producer declares it has none. `null` = not stated
+     * (pre-unification producers), which is "unknown" and never "clean".
+     */
+    realness_screened: boolean | null;
+}
 interface TrainingExportOptions {
     /** Include held-out evaluation data in training output. Default false. */
     allowHeldOutTrainingData?: boolean;
@@ -6326,15 +6442,24 @@ interface SftRow {
         candidate_id: string | null;
         instance_id: string;
         reward: number;
-    };
+    } & RealnessLabels;
 }
 /**
  * Supervised fine-tune rows: the completed conversation of each qualifying
  * line. Fail-closed filters: trainable split only (never holdout/canary),
- * positive reward, realness-gated lines never qualify, gap lines carry
- * no trainable content.
- */
-declare function toSftRows(lines: RolloutLine[], options?: SftExportOptions): SftRow[];
+ * reward strictly above `minimumQualityExclusive` (default 0), realness-gated
+ * lines never qualify, gap lines carry no trainable content, and
+ * copied-context turns are dropped from the transcript (Harbor ATIF RFC 0001
+ * rule 7 — see `ChatMessage.is_copied_context`).
+ *
+ * `realness_gated` is therefore always `false` on an emitted row. It is carried
+ * anyway: an SFT row is a pure imitation target, so the row states its realness
+ * claims instead of making the reader know the format's policy, and carrying
+ * both flags on all four shapes is what lets the release accounting measure
+ * every config with one rule rather than skipping the one whose row shape
+ * happened to omit the field.
+ */
+declare function toSftRows(lines: MintedRolloutLine[], options?: SftExportOptions): SftRow[];
 interface RewardRow {
     /** First user turn — the task prompt. */
     prompt: string;
@@ -6346,14 +6471,307 @@ interface RewardRow {
         candidate_id: string | null;
         instance_id: string;
         split: RolloutSplit;
-    };
+    } & RealnessLabels;
 }
 /**
  * Reward-labeled rows for completed, positive-quality training runs.
  */
-declare function toRewardRows(lines: RolloutLine[], options?: TrainingExportOptions): RewardRow[];
+declare function toRewardRows(lines: MintedRolloutLine[], options?: TrainingExportOptions): RewardRow[];
 declare function toJsonl(rows: ReadonlyArray<unknown>): string;
 
+/**
+ * Harbor ATIF-v1.7 interchange — `tangle.rollout.v1` ⇄ Agent Trajectory
+ * Interchange Format.
+ *
+ * ATIF is the portability format (spec:
+ * https://www.harborframework.com/docs/agents/trajectory-format, normative
+ * RFC: harbor-framework/harbor `rfcs/0001-trajectory-format.md`). It sits
+ * BELOW the waist of the rollout hourglass in both directions — export reads
+ * `RolloutLine[]`, import writes `RolloutLine[]` — and it is never a source
+ * of training labels:
+ *
+ *   ATIF models NO reward, NO judge verdict, NO task/split coordinates.
+ *
+ * Consequences, both deliberate:
+ *   - EXPORT drops `outcome.reward`, `outcome.reward_source` and
+ *     `outcome.verdict` entirely. They are not smuggled into `extra`: a
+ *     third-party reading our ATIF file must not be able to mistake an
+ *     agent-eval judge score for something ATIF sanctioned.
+ *   - IMPORT therefore mints UNLABELED lines: `reward: null` (the existing
+ *     "null reward is a labeled gap, never 0" semantics), `verdict: null`,
+ *     and a `provenance.gap` naming the missing label. An imported
+ *     trajectory is not a training example until a judge scores it.
+ *
+ * Everything else we own that ATIF has no field for travels in a namespaced
+ * escrow at `extra.tangle.*`, so our own round-trip is exact while a foreign
+ * reader can ignore it. Fields that neither ATIF nor the escrow can carry
+ * come back explicitly null / fail-closed, never invented.
+ *
+ * THE ESCROW IS NAMESPACED, NOT AUTHENTICATED. Anyone can write
+ * `extra.tangle.*` into a file. So the escrow may restore what a value IS, but
+ * never what a line is ALLOWED to do: `task.split` is forced to `holdout` on
+ * every import regardless of what the document claims, and promoting an
+ * imported trajectory to a trainable split is an explicit, greppable act
+ * (`relabelImportedSplit`) rather than a property of the file. The document
+ * keeps its claim — the claim just is not authority.
+ *
+ * Multi-agent shape differs on purpose. ATIF EMBEDS children in
+ * `subagent_trajectories`; we keep a flat ledger with a normalized
+ * `parent_rollout_id` edge. Export assembles the tree, import flattens it.
+ * `session_id` is RUN-scoped in ATIF, so it carries `run_id` — the coordinate
+ * that is shared by every invocation of one run — not `rollout_id`, which
+ * identifies a single invocation and would split one run across session ids.
+ *
+ * ROUND-TRIPPING IS IDEMPOTENT: `import(export(import(export(x))))` is
+ * byte-identical to `import(export(x))`. Import composes `provenance.gap` as a
+ * de-duplicated ordered set rather than appending, and it emits every
+ * `ChatMessage` with keys in the canonical schema order (role, content,
+ * reasoning_content, tool_calls, tool_call_id, name, is_copied_context), so a
+ * ledger hashed on serialized bytes sees no diff across further passes. The
+ * FIRST import may re-order a producer's keys — that is the canonicalization.
+ *
+ * NOT building a Letta converter. Letta's trajectory-v1 is a strict subset of
+ * what we need from ATIF here — no per-step or aggregate cost, no
+ * multi-agent/subagent structure, no token-id or logprob channel — so a Letta
+ * sink would carry less than this one and add a second format to keep
+ * correct. Decision recorded in docs/rollout.md; do not re-litigate without a
+ * concrete consumer that reads Letta and cannot read ATIF.
+ */
+
+declare const ATIF_SCHEMA_VERSION = "ATIF-v1.7";
+/** Gap note on every imported line — ATIF carries no verdict, so nothing is scored. */
+declare const HARBOR_IMPORT_GAP = "imported from Harbor ATIF; no verdict";
+type HarborStepSource = 'system' | 'user' | 'agent';
+interface HarborImageSource {
+    media_type: string;
+    path: string;
+}
+interface HarborContentPart {
+    type: 'text' | 'image';
+    text?: string;
+    source?: HarborImageSource;
+}
+interface HarborToolCall {
+    tool_call_id: string;
+    function_name: string;
+    /** ATIF requires a decoded JSON object here, unlike our raw argument string. */
+    arguments: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+}
+interface HarborSubagentTrajectoryRef {
+    trajectory_id?: string;
+    trajectory_path?: string;
+    /** Informational only since v1.7 — never a resolution key. */
+    session_id?: string;
+    extra?: Record<string, unknown>;
+}
+interface HarborObservationResult {
+    source_call_id?: string;
+    content?: string | HarborContentPart[];
+    subagent_trajectory_ref?: HarborSubagentTrajectoryRef[];
+    extra?: Record<string, unknown>;
+}
+interface HarborObservation {
+    results: HarborObservationResult[];
+}
+interface HarborMetrics {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    cached_tokens?: number;
+    cost_usd?: number;
+    prompt_token_ids?: number[];
+    completion_token_ids?: number[];
+    logprobs?: number[];
+    extra?: Record<string, unknown>;
+}
+interface HarborStep {
+    /** Ordinal, sequential from 1. */
+    step_id: number;
+    timestamp?: string;
+    source: HarborStepSource;
+    model_name?: string;
+    reasoning_effort?: string | number;
+    message: string | HarborContentPart[];
+    reasoning_content?: string;
+    tool_calls?: HarborToolCall[];
+    observation?: HarborObservation;
+    metrics?: HarborMetrics;
+    llm_call_count?: number;
+    is_copied_context?: boolean;
+    extra?: Record<string, unknown>;
+}
+interface HarborAgent {
+    name: string;
+    version: string;
+    model_name?: string;
+    /** OpenAI function-calling schema — byte-identical to our `ToolDef`. */
+    tool_definitions?: ToolDef[];
+    extra?: Record<string, unknown>;
+}
+interface HarborFinalMetrics {
+    total_prompt_tokens?: number;
+    total_completion_tokens?: number;
+    total_cached_tokens?: number;
+    total_cost_usd?: number;
+    total_steps?: number;
+    extra?: Record<string, unknown>;
+}
+interface HarborTrajectory {
+    schema_version: string;
+    session_id?: string;
+    /** Required on embedded subagents; we always set it so lines stay joinable. */
+    trajectory_id?: string;
+    agent: HarborAgent;
+    steps: HarborStep[];
+    notes?: string;
+    final_metrics?: HarborFinalMetrics;
+    continued_trajectory_ref?: string;
+    subagent_trajectories?: HarborTrajectory[];
+    extra?: Record<string, unknown>;
+}
+/**
+ * Assemble one episode's flat lines into a single ATIF trajectory tree,
+ * linked by `parent_rollout_id`.
+ *
+ * Reward, verdict and split are NOT emitted (ATIF models none of them); the
+ * split and the rest of the task coordinates survive only in `extra.tangle`.
+ *
+ * We deliberately do NOT synthesize an `observation.subagent_trajectory_ref`
+ * pointing at each child: our ledger records WHICH invocation spawned a
+ * worker, not which STEP did, and attaching the ref to a guessed step would
+ * fabricate a causal claim. Children are embedded in `subagent_trajectories`
+ * (each with the `trajectory_id` the spec requires) and the edge is stated in
+ * the child's escrowed `parent_rollout_id`.
+ *
+ * Throws when the lines are not one tree — use `toHarborTrajectories` for a forest.
+ */
+declare function toHarborTrajectory(lines: RolloutLine[]): HarborTrajectory;
+/** Every independent tree in the input, one ATIF document each. */
+declare function toHarborTrajectories(lines: RolloutLine[]): HarborTrajectory[];
+interface FromHarborOptions {
+    /** Injected clock for deterministic output when the source carries no capture time. */
+    now?: () => Date;
+}
+/**
+ * Flatten an ATIF trajectory tree back into `tangle.rollout.v1` lines, parent
+ * first, each child carrying `parent_rollout_id`.
+ *
+ * Every line comes back UNLABELED: `reward`, `reward_source` and `verdict` are
+ * null and `provenance.gap` says why. ATIF models no verdict, so scoring an
+ * imported trajectory is a judge's job, not this function's. Every line lands
+ * on `holdout` whatever the document claims — see `relabelImportedSplit`.
+ */
+declare function fromHarborTrajectory(trajectory: HarborTrajectory, options?: FromHarborOptions): RolloutLine[];
+/**
+ * THE explicit door out of `holdout` for imported lines.
+ *
+ * Import forces `holdout` because a document's own claim about its split is not
+ * evidence — anyone can write `extra.tangle.task.split`. Promoting a file to a
+ * trainable split is an operator's decision about provenance they verified, so
+ * it is a separate, greppable call: `grep relabelImportedSplit` enumerates
+ * every place foreign data was declared trainable, which is exactly the audit
+ * the trusted-escrow version made impossible.
+ *
+ * Returns plain `RolloutLine`s. They still have to pass `assertMinted` (and its
+ * anti-Goodhart check) to reach an exporter — re-labeling a split is not
+ * minting a reward.
+ */
+declare function relabelImportedSplit(lines: readonly RolloutLine[], split: RolloutSplit): RolloutLine[];
+
+/**
+ * The two named score derivations every consumer must choose between.
+ *
+ * The anti-Goodhart gate (`outcome.realness.gated`) only holds if it is
+ * impossible to read a run's score WITHOUT deciding whether the gate applies.
+ * A bare `outcome.holdoutScore ?? outcome.searchScore` makes that decision
+ * invisible — and silently answers "no gate", which is the wrong default on
+ * every path that produces training data. So the expression lives here, once,
+ * behind two names that force the caller to state the intent:
+ *
+ *   - `trainingScore` / `trainingReward` — GATED. Anything that becomes
+ *     training data, or a reward a trainer consumes, uses these.
+ *   - `observedScore` — RAW. Analysis, reporting, and reward-hack DETECTION
+ *     need the ungated number; that is how a gamed run is visible at all.
+ *
+ * A leaf module on purpose: it imports only the `RunRecord` type, so gate and
+ * reporting code can depend on it without pulling in the trace store that
+ * `mint.ts` needs.
+ */
+
+/**
+ * Which split's score wins when a record carries both. `'holdout'` is the
+ * canonical "real signal" default; `'search'` exists because some callers
+ * deliberately score on the search split when both are present.
+ */
+type ScorePreference = 'holdout' | 'search';
+/** Only the outcome is read, so every accessor here accepts anything carrying one. */
+type Scored = Pick<RunRecord, 'outcome'>;
+/** True when the authenticity gate flagged the run as gamed (`realness.gated`). */
+declare function isRealnessGated(record: Scored): boolean;
+/**
+ * The RAW score recorded on ONE split, with no cross-split fallback and no
+ * anti-Goodhart gate.
+ *
+ * The narrowest of the three raw readers, and the one every split-scoped
+ * consumer wants: a per-split report, a promotion gate, or a paired comparison
+ * asks "what did this run score on the split I am summarising", and answering
+ * it with the other split's number silently mixes populations. `undefined` =
+ * that split was never scored.
+ *
+ * Same warning as `observedScore`: this INCLUDES runs flagged as gamed. Never
+ * feed it into training data.
+ */
+declare function observedSplitScore(record: Scored, split: ScorePreference): number | undefined;
+/**
+ * The RAW split score the run carries, with NO anti-Goodhart gate applied.
+ *
+ * INCLUDES RUNS FLAGGED AS GAMED (`outcome.realness.gated === true`); NEVER
+ * feed this into training data — a fine-tune that sees it learns from gamed
+ * successes. It is exported anyway because analysis, reporting, and
+ * reward-hacking detection legitimately need the ungated number: forcing a
+ * gamed run to 0 collapses the proxy signal toward ground truth and makes a
+ * detector report "clean" on exactly the population that is being gamed.
+ *
+ * Returns `undefined` when the record carries neither score — an unscored run
+ * is a labeled gap, not a measured zero, and each caller picks its own
+ * sentinel (`?? 0`, `?? null`, skip, throw). Non-finite values are returned
+ * as-is; callers that care keep their own `Number.isFinite` guard.
+ */
+declare function observedScore(record: Scored, prefer?: ScorePreference): number | undefined;
+/** Which split actually carried the score, or that none did. */
+type ScoreOrigin = 'holdout' | 'search' | 'unscored';
+/**
+ * Where `observedScore` / `trainingScore` read their number from — the
+ * provenance label a rollout line's `reward_source` is built from, and the
+ * only supported way to ask "was this run scored at all" without respelling
+ * the field access.
+ */
+declare function scoreOrigin(record: Scored, prefer?: ScorePreference): ScoreOrigin;
+/**
+ * The GATED score — the only derivation allowed to reach training data.
+ *
+ * A realness-gated run scores 0 no matter what it claims, so a fine-tune
+ * cannot learn from a gamed success. An unscored run stays `undefined` (a
+ * labeled gap), keeping "we never measured this" distinct from "we measured
+ * zero"; callers that need a number apply their own sentinel.
+ */
+declare function trainingScore(record: Scored, prefer?: ScorePreference): number | undefined;
+/**
+ * `{reward, gated}` as written onto a minted `RolloutLine` — `trainingScore`
+ * plus the flag itself, so the gate travels into the exported row and a
+ * downstream filter can drop or down-weight the line.
+ *
+ * An unscored record yields `reward: null`, matching the schema's "no verdict
+ * exists — a labeled gap, never 0" rule. It previously collapsed to 0, which
+ * made a run nobody graded indistinguishable from one graded as a total
+ * failure, and taught any trainer reading the row that the trajectory was bad.
+ * A gated run still yields 0, because that IS a verdict: the gate decided.
+ */
+declare function trainingReward(record: Scored): {
+    reward: number | null;
+    gated: boolean;
+};
+
 /**
  * Rollout minting — `tangle.rollout.v1` lines joined from the records the
  * substrate ALREADY keeps. There is no separate rollout store: a rollout
@@ -6366,10 +6784,20 @@ declare function toJsonl(rows: ReadonlyArray<unknown>): string;
  *   - preference-pair export  → `feedbackTrajectoryToOptimizerRow` (feedback-trajectory.ts)
  *   - PRM / reward-model      → `reward-model-export.ts`
  *
- * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true
- * is never exported with a positive reward — the gate travels into the
- * training data (`reward` forced to 0, `realness_gated: true`), so a
- * fine-tune cannot learn from gamed successes.
+ * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true is
+ * never exported with a positive reward OR with any of the numbers that reward
+ * was computed from. The gate travels into the training data (`reward` forced
+ * to 0, `realness_gated: true`) and the whole outcome is transformed by
+ * `gateGamedOutcome` inside `assertMinted` below, which relocates `metrics` and
+ * `verdict` to `provenance.gated_evidence`. Mint returns
+ * `MintedRolloutLine[]`: the brand the training exporters require, which only
+ * this function, `readRolloutLedger`, and an explicit `assertMinted` can mint.
+ *
+ * A record carrying NEITHER split score is REJECTED (`ValidationError`), never
+ * minted at 0 — "nobody graded this" is not the same claim as "graded a total
+ * failure", and a trainer reading 0 learns the second. Lines that already
+ * carry `reward: null` (interchange imports, existing ledgers) remain valid on
+ * the wire; only the RunRecord→line door refuses.
  *
  * Records without spans become labeled GAP LINES (messages: [],
  * provenance.gap) — present in the output AND surfaced in
@@ -6390,14 +6818,11 @@ interface MintRolloutOptions {
     now?: () => Date;
 }
 interface MintRolloutResult {
-    rows: RolloutLine[];
+    rows: MintedRolloutLine[];
     /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */
     missingTraces: string[];
 }
-declare function rolloutReward(record: RunRecord): {
-    reward: number;
-    gated: boolean;
-};
+
 /**
  * Join RunRecords with their traces into canonical rollout lines. Records
  * without spans are emitted as labeled gap lines and reported in
@@ -7370,7 +7795,7 @@ interface OtlpFlatLine {
     }>;
 }
 interface FlattenOtlpOptions {
-    /** `'openinference'` (default) mirrors legacy per-span attributes into the
+    /** `'openinference'` (default) maps source per-span attributes into the
      *  canonical OpenInference vocabulary the analyst readers consume. `'none'`
      *  passes attributes through untouched. */
     attributeVocabulary?: 'openinference' | 'none';
@@ -8217,10 +8642,6 @@ interface LlmCorrectnessCheckerOpts {
     costPhase?: string;
     costTags?: Record<string, string>;
     signal?: AbortSignal;
-    /** Exact maximum provider attempts configured on the supplied TCloud client. */
-    tcloudMaximumAttempts?: number;
-    /** Usage/cost retained by a failed provider response; enables a safe retry. */
-    receiptFromError?: (error: Error, attempt: number) => CostReceiptInput | undefined;
     /** Max chars of artifact content sent to the checker. */
     maxContentChars?: number;
     /**
@@ -8253,7 +8674,7 @@ declare function parseCorrectnessResponse(raw: string): {
  * only: a plan, a gesture, or a description of what should be done does not
  * fulfil a requirement — the artifact must BE the deliverable.
  */
-declare function createLlmCorrectnessChecker(tc: TCloud, opts?: LlmCorrectnessCheckerOpts): CorrectnessChecker;
+declare function createLlmCorrectnessChecker(chat: ChatClient, opts?: LlmCorrectnessCheckerOpts): CorrectnessChecker;
 /**
  * Deterministic `CorrectnessChecker` — the no-LLM counterpart to
  * `createLlmCorrectnessChecker`. A produced item fulfils a requirement when its
@@ -8477,7 +8898,7 @@ interface JudgeConfig<TArtifact, TScenario extends Scenario = Scenario> {
 /** The canonical judge verdict shape — one declaration, shared by campaign
  *  judges and the multishot judge runner (which re-exports this type).
  *
- *  Scale is PRODUCER-DEFINED: campaign convention is [0,1]; the legacy
+ *  Scale is PRODUCER-DEFINED: campaign convention is [0,1]; the
  *  multishot runner emits 0-10. Cross-scale comparison must go through
  *  `detectScale` (src/campaign/gates/statistical-heldout.ts, used by
  *  promotion-policy) — never renormalize a producer's values in place, as
@@ -8657,8 +9078,6 @@ interface CampaignAggregates {
     byScenario: Record<string, ScenarioAggregate>;
     /** Canonical campaign accounting, including worker and judge calls. */
     cost: CostLedgerSummary;
-    /** Compatibility alias of `cost.totalCostUsd`. */
-    totalCostUsd: number;
     /** Cells whose dispatch completed, including cells whose later judge failed. */
     cellsExecuted: number;
     cellsSkipped: number;
@@ -8669,7 +9088,7 @@ interface CampaignAggregates {
     cellsDispatchFailed?: number;
     /** Present on results that record failure stages. */
     cellsJudgeFailed?: number;
-    /** Legacy failures whose stage was not recorded. */
+    /** Failures whose stage could not be classified. */
     cellsUnclassifiedFailed?: number;
 }
 interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scenario> {
@@ -11345,9 +11764,26 @@ interface CostSummary {
  * for the analysis projection.
  */
 
-/** The score the query/compare layer ranks on: holdout when present (the
- *  gated number), else search. Execution-only records are valid RunRecords,
- *  but cannot participate in score-ranked queries. */
+/**
+ * The score the query/compare layer ranks on: holdout when present, else
+ * search, with the anti-Goodhart gate applied — a run flagged as gamed reads 0
+ * however high it claims to have scored.
+ *
+ * The gate is load-bearing here and this function did not previously apply it,
+ * despite saying it did. `getBest` is few-shot exemplar selection: whatever it
+ * returns is pasted into the next agent's prompt as an example to imitate.
+ * Ranking on the raw number handed the highest-scoring gamed trajectory to
+ * every subsequent run — propagation through the context window rather than
+ * through a gradient, but propagation all the same.
+ *
+ * Analysis that needs to SEE the inflated number (reward-hack detection,
+ * per-run reporting) reads `observedScore` from `rollout/reward.ts` directly.
+ *
+ * Returns `undefined` for an execution-only record (neither score present):
+ * such rows are valid RunRecords, but cannot participate in score-ranked
+ * queries. A gated run still reads 0 — the gate's verdict is a number, never
+ * a gap.
+ */
 declare function runScore(record: RunRecord): number | undefined;
 interface RunRecordFilter {
     experimentId?: string;
@@ -11382,6 +11818,17 @@ interface CandidateComparison {
     bWins: number;
     ties: number;
     aWins: number;
+    /**
+     * Runs of either candidate excluded from the comparison because the
+     * authenticity gate flagged them (`outcome.realness.gated`).
+     *
+     * Excluded rather than scored 0: `runScore` is gated, so leaving them in
+     * would have entered a gamed run as a silent zero, which reads as "this
+     * candidate failed the scenario" when what happened is "this candidate's
+     * result is not evidence". A non-zero count here is itself the finding — a
+     * comparison drawn over a shrunken scenario set has to say so.
+     */
+    realnessGatedRuns: number;
 }
 /**
  * Backing persistence for `EvalTraceStore`. The in-memory store is the default;
@@ -11420,6 +11867,12 @@ declare class EvalTraceStore {
      * Highest-scoring run for a scenario (optionally restricted to a candidate).
      * Returns null when no run matches. Ties resolve to the earliest-appended run
      * so the result is stable.
+     *
+     * Runs flagged as gamed are DROPPED, not zeroed. The caller's use for this is
+     * few-shot seeding — the returned trajectory becomes an example to copy — so
+     * the same rule as SFT applies: a faked success must not be in the candidate
+     * set at all. When every run for the scenario is gated the honest answer is
+     * `null` (no exemplar), never the least-bad fake.
      */
     getBest(scenarioId: string, opts?: {
         candidateId?: string;
@@ -11430,6 +11883,9 @@ declare class EvalTraceStore {
      * ran a scenario more than once, its best `runScore` for that scenario is
      * used. Throws when there is no paired scenario — an unpaired "comparison" is
      * not one.
+     *
+     * Realness-gated runs are excluded and counted in `realnessGatedRuns`, never
+     * folded in as a zero.
      */
     compareRuns(candidateA: string, candidateB: string): Promise<CandidateComparison>;
 }
@@ -14937,7 +15393,7 @@ interface CampaignStorage {
     write(path: string, content: string | Uint8Array): void;
     /** Append only when the current UTF-8 byte length matches `expectedBytes`.
      * Returns the new length, or undefined when another writer won. */
-    append?(path: string, content: string, expectedBytes: number): number | undefined;
+    append(path: string, content: string, expectedBytes: number): number | undefined;
 }
 
 /**
@@ -17187,4 +17643,4 @@ type CachedJudge<TArtifact, TScenario extends Scenario = Scenario> = JudgeConfig
  */
 declare function cachedJudge<TArtifact, TScenario extends Scenario = Scenario>(judge: JudgeConfig<TArtifact, TScenario>, store: VerdictCacheStore, options: CachedJudgeOptions): CachedJudge<TArtifact, TScenario>;
 
-export { AGENT_PROFILE_KINDS, ATTESTATION_ALGORITHM, type ActionExecutionPolicy, type ActionPolicyDecision, type ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, type AgentEvalErrorCode, type AgentInterfaceProfileLike, type AgentProfileCell, type AgentProfileCellInput, type AgentProfileCellSchemaVersion, AgentProfileCellValidationError, type AgentProfileDimensionValue, type AgentProfileHarness, type AgentProfileJson, type AgentProfileJsonObject, type AgentProfileKind, type AgentProfileRuntimeReceipt, type AgentProfileSource, type AgentProfileSourceInput, type AlignmentOp, type Analyst, type AnalystContext, type AnalystCost, type AnalystFinding, type AnalystHooks, type AnalystInputKind, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystSeverity, type AnalystUsageReceipt, type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, type Artifact$1 as Artifact, type ArtifactCheck, type Artifact as ArtifactCheckArtifact, type ArtifactEventLike, type ArtifactResult, type ArtifactValidator, type AsiSeverity, type AssertCapabilityHeadroomOptions, type AssertCrossFamilyOptions, type AssertSingleBackendOptions, type AttestationProvenance, type AttestationVerification, type AttestedReport, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, BENCHMARK_SPLIT_SEED, type BackendDescriptor, BackendIntegrityError, type BackendIntegrityReport, type BaselineOptions, type BaselineReport, BehaviorAssertion, type BehavioralMetrics, type BehavioralTokenSequence, type BenchmarkAdapter, type BenchmarkDatasetItem, type BenchmarkEvaluation, type BenchmarkFamily, type BenchmarkReport$1 as BenchmarkReport, type BenchmarkResponder, BenchmarkRunner, type BenchmarkRunnerConfig, type BenchmarkScenario, type BenchmarkSource, type BenchmarkTaskKind, type BisectOptions, type BisectResult, type BisectStep, type BlendWeights, type BootstrapOptions, type BootstrapResult, BudgetBreachError, BudgetGuard, type BudgetLedgerEntry, type BudgetPolicy, type BudgetSpec, CODING_HARNESSES, type CachedJudge, type CachedJudgeOptions, type CalibrationResult, CallExpectation, CallbackResearcher, type CallbackResearcherOptions, type CampaignFactoryParams, type CampaignIntegrityPolicy, type CampaignRunContext, type CampaignRunOutcome, type CampaignRunner, type CampaignScenario, type CampaignVariant, type CanaryAlert, type CanaryEvaluation, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateComparison, type CandidateScenario, type CandidateScore, type CanonicalRawAnalystFinding, type CapabilityHeadroomOptions, type CapabilityHeadroomResult, type CaptureFetchContext, type CaptureFetchOptions, CaptureIntegrityError, type CausalAttributionReport, type CellVerdict, type ChannelRollup, type ChatCallOpts, type ChatClient, type ChatMessage, type ChatRequest, type ChatResponse, type ChatToolCall, type ChatTransport, type CheckResult, type CliBridgeTransportOpts, type CliffsMagnitude, type ClusterBootstrapInterval, type ClusterSignFlipAlternative, type ClusterSignFlipResult, type ClusteredBinaryCluster, type ClusteredMatchedPair, type ClusteredPairedBinaryOptions, type ClusteredPairedBinaryResult, type ClusteredPairedBinaryStatistics, type CollectedArtifacts, type CommandRunner, type ComparePairedArmsOptions, type CompletionCriterion, type CompletionRequirement, type CompletionVerdict, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, ConfigError, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type ContractCheckResult, type ContractJudgeOptions, type ContractMetric, type ContractReport, type ContractRule, type ContractRuleKind, type ContractSpan, type ContractVerdict, type ContractViolation, type ControlActionFailureMode, type ControlActionOutcome, type ControlBudget, type ControlContext, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlRunToRunRecordOptions, type ControlRuntimeConfig, type ControlRuntimeError, type ControlSeverity, type ControlStep, type ControlStopPolicies, ConvergenceTracker, type CorpusAgreementOptions, type CorpusAgreementPerDimension, type CorpusAgreementReport, type CorpusScoreRecord, type CorrectnessChecker, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, type CostChannel, type CostEntry, CostLedger, type CostLedgerEntry, type CostLedgerFilter, type CostLedgerHandle, type CostLedgerOptions, type CostLedgerPersistence, CostLedgerPersistenceError, type CostLedgerSummary, type CostReceipt, CostReceiptCaptureError, type CostReceiptInput, type CostReport, CostReservationExceededError, type CostResult, type CostSummary, CostTracker, type CostUsage, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateAnalystAiConfig, type CreateChatClientOpts, type CreateDefaultReviewerOptions, type CreateExperimentInput, type CreateSandboxPoolOpts, type CreateTraceAnalystKindOpts, CrossFamilyError, type CrossTraceDiff, type CrossTraceDiffOptions, type CustomTokenPricing, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, type DataAcquisitionPlan, Dataset, type DatasetDifficulty, type DatasetManifest, type DatasetOverview, type DatasetProvenance, type DatasetScenario, type DatasetSplit, type DecideNextUserTurnOpts, type DefaultAnalystRegistryOptions, type DefaultVerdict, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DescriptionLengthCandidate, type DescriptionLengthConfig, type DescriptionLengthDecision, type DescriptionLengthEvidence, DescriptionLengthGate, type DescriptionLengthRejectionCode, type DetectorEvent, type DetectorSeverity, type DetectorSignal, type DiffPolicy, type DiffScorecardOptions, type DirEntry, type DirectProviderTransportOpts, type Direction, type DiscoverPersonasOptions, type DiscoveredPersona, DockerSandboxDriver, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, ERROR_COUNT_PATTERNS, type EnsembleAggregate, type EnsembleJudgeOptions, type ErrorCluster, type ErrorCountPattern, type ErrorStreakOptions, type EvalCampaignOptions, type EvalCampaignResult, type EvalResult, type EvalToolDef, EvalTraceStore, type EventFilter, type EventKind, type EvidenceRef, type EvolutionRound, type ExecutorConfig, type Expectation, type Experiment, type ExperimentPlan, type ExperimentProvenance, type ExperimentRep, type ExperimentResult, type ExperimentStats, type ExperimentStore, ExperimentTracker, type ExperimentTrackerOptions, type ExperimentVerdict, type ExportableSpan, type ExportedRewardModel, type ExtractOptions, type ExtractResult, type ExtractUsageFromSseOptions, type ExtractedUsage, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, type FactorContribution, type FactorialCell, type FailedRun, type FailureClass, type FailureClassification, type FailureContext, type FailureMode, type FailureRule, type FeedbackArtifactType, type FeedbackAttempt, type FeedbackLabel, type FeedbackLabelKind, type FeedbackLabelSource, type FeedbackOptimizerRow, type FeedbackOutcome, type FeedbackPattern, type FeedbackReplayAdapter, type FeedbackReplayResult, type FeedbackSeverity, type FeedbackSplitPolicy, type FeedbackTask, type FeedbackTrajectory, type FeedbackTrajectoryFilter, type FeedbackTrajectoryStore, type FieldDestination, type FileChange, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, type FileSystemRawProviderSinkOptions, FileSystemTraceStore, type FileSystemTraceStoreOptions, type Finding, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, type FlattenOtlpOptions, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type GainDistributionBin, type GainDistributionFigureSpec, type GainDistributionOptions, type GateDecision$1 as GateDecision, type GateEvidence, type GenericSpan, type GhCliClientOptions, type GoldenItem, type GoldenSeverity, type GoldenSpec, HARNESS_NATIVE_MODEL, type HarnessAdapter, type HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessVariant, type HarnessVariantReport, type HeadroomClass, type HeadroomInput, HeldOutGate, type HeldOutGateConfig, type HeldOutGateRejectionCode, type HeldOutPartition, type HiddenCriteriaGrader, type HiddenGradeResult, type HiddenLeak, HoldoutAuditor, HoldoutLockedError, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, IMPROVEMENT_KIND_SPEC, INPUT_VALUE, INTENT_MATCH_JUDGE_VERSION, type ImageData, type ImprovementThresholds, type ImprovementVerdictResult, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, type InMemoryRawProviderSinkOptions, InMemoryTraceStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, type InterimReleaseConfidence, type InterimReleaseConfidenceInput, type JudgeConfig$1 as JudgeConfig, JudgeError, type JudgeFamily, type JudgeFleetOptions, type JudgeFn, type JudgeInput, JudgeParseError, type JudgeReplayGateArgs, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, type JudgeRubric, JudgeRunner, type JudgeScore$1 as JudgeScore, type JudgeScoreInput, type JudgeScoresRecord, type JudgeSpan, type JudgeVerdict, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type KnowledgeAcquisitionMode, type KnowledgeBundle, type KnowledgeFallbackPolicy, type KnowledgeFreshness, type KnowledgeImportance, type KnowledgeReadinessReport, type KnowledgeRecommendedAction, type KnowledgeRequirement, type KnowledgeRequirementCategory, type KnowledgeResponsibleSurface, type KnowledgeSensitivity, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, type Layer, type LayerResult, type LayerStatus, type LeaderboardOptions, type LeaderboardRow, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallError, type LlmCallMetadata, type LlmCallRequest, type LlmCallResult, LlmClient, type LlmClientOptions, type LlmCorrectnessCheckerOpts, type LlmJsonCall, type LlmJudgeDimension, type LlmJudgeOptions, type LlmMessage, LlmResponseError, type LlmReviewerConfig, LlmRouteAssertionError, type LlmRouteRequirements, type LlmSpan, type LlmSpanOtlpInput, type LlmUsage, LockedJsonlAppender, MODEL_PRICING, type MakeEvalToolsConfig, type MatchResult, type MatchedPair, type MatchedRunRecordPair, type MatcherResult, type MaximumCharge, type McNemarResult, type Measured, type MeasurementPolicy, type MergeOptions, type Message, type MetricSamples, type MetricVerdict, MetricsCollector, type MintRolloutOptions, type MintRolloutResult, type MockTransportOpts, type ModelCostRollup, type ModelPreflight, type ModelSeats, ModelsUnreachableError, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, type MultiToolchainLayerConfig, type Mutator, Mutex, type NoLeakOptions, type NoProgressOptions, NoopRawProviderSink, NoopResearcher, NotFoundError, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, type Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, type OtelExportConfig, type OtelExporter, type OtelPipelineHandle, type OtelPipelineOptions, type OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, type OtlpResourceSpans, type OtlpSpan, type OtlpSpanRole, type OtlpSpanRoleInput, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type PaidCallResult, type PairArmsOptions, type PairArmsResult, type PairRunRecordsResult, type PairedArmRow, type PairedArmsComparison, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedCorrectness, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedMetricDelta, type PairedSignTestResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParetoFigureSpec, type ParetoPoint, type ParetoResult, type PartitionHeldOutOptions, type PendingCostCall, type PendingCostCallView, type PersistedFinding, type PersonaConfig, type PersonaRigor, type Playbook, type PlaybookEntry, type PoolSlot, type PositionalBiasResult, type PrReviewAuditCase, type PrReviewBenchmarkSummary, type PrReviewComment, type PrReviewMatchedFinding, type PrReviewOutcome, type PrReviewReferenceFinding, type PrReviewScore, type PrReviewScoreWeights, type PrReviewSeverity, type PrReviewSource, type PreferenceMemoryEntry, type PreflightModelsOptions, type PreflightOutcome, type ProducedProposal, type ProducedState, type ProductBenchmarkArm, type ProductBenchmarkArtifactPaths, type ProductBenchmarkBudgets, type ProductBenchmarkExportOptions, type ProductBenchmarkExportResult, type ProductBenchmarkManifest, type ProductBenchmarkProfileRef, type ProductBenchmarkRecord, type ProductBenchmarkRepoRef, type ProductBenchmarkRunInput, type ProductBenchmarkScenario, type ProductBenchmarkSingleRunExportOptions, type ProductBenchmarkSplit, type ProductBenchmarkSubstrateVersions, type ProductBenchmarkValidationReport, ProductClient, type ProductClientConfig, type ProfileAxisSpec, type ProjectRuntimeTrajectoryEvidenceOptions, type ProjectedOtlpSpan, type PromptHandle, PromptRegistry, type ProportionInterval, type ProposalEventLike, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, type ProposeFn, type ProposeInput, type ProposeOutput, type ProposeReviewConfig, type ProposeReviewControlAction, type ProposeReviewControlConfig, type ProposeReviewControlResult, type ProposeReviewControlState, type ProposeReviewReport, type ProposeReviewShot, type ProposedSideEffect, type ProvenanceReader, type ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, RESEARCH_REPORT_HARD_PAIR_FLOOR, ROLLOUT_SCHEMA, RUN_COST_ATTR_KEYS, type RawAnalystEvidence, type RawAnalystFinding, type RawProviderDirection, type RawProviderEvent, type RawProviderSink, type RawProviderSinkFilter, type RecordRunsOptions, type RedTeamCase, type RedTeamCategory, type RedTeamFinding, type RedTeamPayload, type RedTeamReport, type RedactionReport, type RedactionRule, type ReferenceEquivalenceJudgeInput, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceJudgeResult, type ReferenceEquivalenceScenario, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, type RegistryRunOpts, type ReleaseConfidenceAxis, type ReleaseConfidenceAxisName, type ReleaseConfidenceInput, type ReleaseConfidenceIssue, type ReleaseConfidenceMetrics, type ReleaseConfidenceScorecard, type ReleaseConfidenceStatus, type ReleaseConfidenceThresholds, type ReleaseTraceEvidence, type RenderReleaseReportOptions, type RepeatedActionOptions, ReplayCache, type ReplayCacheEntry, ReplayCacheMissError, type ReplayCacheStats, ReplayError, type ReplayFetchOptions, type RepoRef, type RequirementCheck, type ResearchReport, type ResearchReportCandidate, type ResearchReportDecision, type ResearchReportMethodology, type ResearchReportOptions, type ResearchReportRecommendation, type Researcher, type RetrievalSpan, type Review, type ReviewFn, type ReviewInput, type ReviewMemoryEntry, type ReviewMemoryStore, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RewardRow, type RiskDifferenceResult, type RobustnessResult, type RolloutCapture, type RolloutLine, type RolloutRole, type RolloutScrubber, type RolloutSplit, type RolloutStep, type RouteMap, type RoutedField, type RouterTransportOpts, type RubricDimension, type Run, type RunCommandInput, type RunCommandResult, type RunCompleteHook, type RunCompleteHookContext, type RunCostProvenance, RunCritic, type RunCriticOptions, type RunEvidenceMetadata, type RunFilter, RunIntegrityError, type RunIntegrityExpectations, type RunIntegrityIssue, type RunIntegrityIssueCode, type RunIntegrityReport, type RunJudgeMetadata, type RunLayer, type RunOutcome, type RunPaidCallInput, type RunRecord, type RunRecordBackend, type RunRecordFilter, RunRecordValidationError, type RunScore, type RunScoreWeights, type RunSplitTag, type RunStatus, type RunTaskFailure, type RunTerminalOutcome, type RunTokenUsage, type RunTrace, type RuntimeEventLike, type RuntimeResolution, type RuntimeTrajectoryEvidenceProjection, type RuntimeTrajectoryEvidenceSummary, type RuntimeTrajectoryHookEvent, type RuntimeTrajectoryRecord, type RuntimeTrajectoryRunRecord, SEMANTIC_CONCEPT_JUDGE_VERSION, SKILL_USAGE_ANALYST, SPAN_KIND_ATTR_KEYS, SUPERVISOR_RUN_SCHEMA, type SandboxDriver, SandboxHarness, type SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxResult, type SandboxSdkTransportOpts, type SandboxSpan, type SatisfiedBy, type ScanOptions, type Scenario$1 as Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, type ScoreKnowledgeReadinessOptions, type Scorecard, type ScorecardCell, type ScorecardCellDiff, type ScorecardDiff, type ScorecardEntry, type ScorecardLogLine, type ScoredTarget, type SearchSpanResult, type SearchTraceResult, type SeatName, type SeatPresetName, SeatUnsetError, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SelfPreferenceResult, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SequentialDecision, type SerializedRegex, type SeriesConvergenceOptions, type SeriesConvergenceResult, type Severity, type SftExportOptions, type SftRow, type SignTestAlternative, type SignedManifest, type SignedManifestAlgo, type SingleBackendDivergence, SingleBackendError, type SingleBackendField, type SingleBackendReport, SkillUsageAnalyst, type SliceOptions, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type SourceLimits, type Span, type SpanBase, type SpanFilter, type SpanHandle, type SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanPredicate, type SpanStatus, type SseUsageMode, type SteeringBundle, type SteeringChange, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type StopDecision, type StreamingDetector, type SuboptimalCode, type SuboptimalSignal, SubprocessSandboxDriver, type SubprocessSandboxDriverOptions, type SummaryTable, type SummaryTableOptions, type SummaryTableRow, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunRollup, type SupervisorRunSources, type SupervisorRunTree, type SynthesisReason, type SynthesisTarget, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type TaskGold, type TaskHeadroom, type TestGradedRunOptions, type TestGradedRunResult, type TestGradedScenario, type TestOutputParser, type TestResult, type TextMatcher, type ThresholdContract, TokenCounter, type TokenSpec, type ToolCallEventLike, type ToolDef, type ToolMatcher, type ToolSpan, type ToolSpanOtlpInput, type ToolStats, type ToolUseMetrics, type ToolUseOptions, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystGolden, type TraceAnalystHookOptions, type TraceAnalystKindSpec, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, type TraceContract, TraceContractBuilder, TraceEmitter, type TraceEmitterOptions, type TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, type TraceStore, type TraceStoreSource, type TraceStoreToOtlpOptions, type TracedAnalystOptions, type TracedJudgeOptions, type TracesToOtlpResult, type Trajectory, type TrajectoryStep, type TreatmentClass, type TreatmentGate, type TreatmentGateInput, type TreatmentGateOptions, type TrialTrace, type Turn, type TurnMetrics, type TurnResult, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, type UiFinding, type UiFindingScreenshot, type UiFindingSeverity, type UiLens, type Unavailable, type UserQuestion, type ValidationContext, ValidationError, type ValidationIssue, type ValidationResult, type VerbosityBiasResult, type Verdict, type VerdictCacheStats, type VerdictCacheStore, type Verification, VerificationError, type VerificationReport, type VerifyContext, type VerifyFn, type VerifyOptions, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WeightedCompositeInput, type WeightedCompositeResult, type WorkerDriverContext, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, acquisitionPlansForKnowledgeGaps, adversarialJudge, agentProfileCellHashMaterial, agentProfileCellKey, agentProfileHash, agentProfileId, agentProfileModelId, agentVisibleFields, aggregateJudgeVerdicts, aggregateLlm, aggregatePrReviewScore, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeSupervisorRun, analyzeSupervisorRunSources, analyzeTraces, appendScorecard, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertCapabilityHeadroom, assertCrossFamily, assertLlmRoute, assertModelsServed, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealAgentReceipts, assertRealBackend, assertReleaseConfidence, assertRolloutLine, assertRunAgentProfileCell, assertRunCaptured, assertSingleBackend, assignFeedbackSplit, assignHeldOutTag, attachCostToReport, attest, attributeCounterfactuals, backoffMs, deterministicSplit as benchmarkDeterministicSplit, index$1 as benchmarks, benjaminiHochberg, bisect, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, buildAgentInterfaceProfileCell, buildAgentProfileCell, buildDefaultAnalystRegistry, buildDriverSystemPrompt, buildProductBenchmarkManifest, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, buildWorkerDriverSystemPrompt, byteLengthRange, cachedJudge, calibrateJudge, calibrateJudgeContinuous, callLlm, callLlmJson, canaryLeakView, canonicalJson, canonicalize, capabilityHeadroom, captureFetchToRawSink, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, clamp01, classifyFailure, classifyOtlpSpanRole, classifyTreatment, claudeCodeSupervisorRunReader, cliffsDelta, clusteredPairedBinary, codeExecutionJudge, cohensD, coherenceJudge, collectionPreserved, commentsForSource, commitBisect, comparePairedArms, compareReferenceReplay, compareToBaseline, compilerJudge, completionVerdict, composeParsers, composeValidators, computeExperimentStats, computeFindingId, computeToolUseMetrics, computeTraceMetrics, confidenceInterval, containsAll, contentHash, contextInputTokens, continuousAgreement, contractJudge, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, controlRunToRunRecord, convertTraceStoresToOtlp, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, costReport, createAnalystAi, createAntiSlopJudge, createChatClient, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createFeedbackTrajectory, createIntentMatchJudge, createLlmCorrectnessChecker, createLlmReviewer, createOtelExporter, createOtelTracingStore, createReferenceEquivalenceJudge, createReplayFetch, createSandboxPool, createSemanticConceptJudge, createTokenRecallChecker, createTraceAnalystKind, crossTraceDiff, crowdingDistance, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultBlendWeights, defaultIsMaterial, defaultJudges, defaultProviderRedactor, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, distillPlaybook, domainEvidencePattern, dominates, eProcess, ensembleJudge, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, executeScenario, expandProfileAxes, expectAgent, exportProductBenchmark, exportProductBenchmarkRuns, exportRewardModel, exportRunAsOtlp, extractAssetUrls, extractErrorCount, extractOtlpAttributes, extractProducedState, extractUsage, extractUsageFromResponse, extractUsageFromSse, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findProductBenchmarkArtifacts, findSkipCountsAsPass, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, gainHistogram, gateTreatmentApplied, gateTreatmentFromMetrics, gateTreatmentFromSpans, gateTreatmentFromToolSpans, ghCliClient, gitProvenanceReader, precision as goldenPrecision, gradeOnHidden, gradeSemanticStatus, groupBy, groupRunsByAgentProfileCell, harnessAxisOf, hasCapturedToolArgs, hashContent, hashJson, hashScenarios, hashToUnit, hiddenGrade, holm, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryReviewStore, inMemoryRunRecordBackend, inMemoryVerdictCache, inferDomainKeywords, inferOtlpKind, interRaterReliability, interpretCliffs, iqr, isHiddenDestination, isJudgeSpan, isLlmSpan, isModelPriced, isOtelConfigured, isOtlpModelCall, isRetrievalSpan, isRolloutLine, isRunRecord, isSandboxSpan, isToolSpan, isTrainableSplit, isTransientLlmError, isUnavailable, iterateRawCalls, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, jsonlRunRecordBackend, judgeFamily, judgeReplayGate, judgeSpans, keyPreserved, knowledgeReadinessTracePayload, leaderboard, linterJudge, llmJudge, llmSpanFromProvider, llmSpans, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, makeFinding, mannWhitneyU, mapConcurrent, matchGoldens, matchSpan, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, mergeLayerResults, mergeSteeringBundle, mintRolloutRows, modelDescriptionBits, modelHasSnapshot, modelPriceKey, mulberry32, multiToolchainLayer, noProgressDetector, normalizeScores, notBlocked, objectiveEval, observeAll, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedSignTest, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseCorrectnessResponse, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, parseRunRecordSafe, parseRuntimeTrajectoryHookEvent, partialCredit, partitionHeldOut, passAtK, passOrthogonality, pearsonR, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, preflightModels, printDriverSummary, probeLlm, productBenchmarkIntegrityFailures, productBenchmarkMutableSurfaces, productBenchmarkRepoIdentity, productBenchmarkSplits, index as profile, projectOtlpFlatLine, projectRuntimeTrajectoryEvidence, promptBisect, proposeSynthesisTargets, providerFromBaseUrl, pytestTestParser, ranks, readClaudeCodeSupervisorRun, readOtlpStatus, readProductBenchmarkManifest, readProductBenchmarkRecords, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderPriorFindings, renderReleaseReport, renderSteeringText, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, renderUpstreamFindings, repeatedActionDetector, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requireAgentProfileCell, requiredPairedSampleSize, requiredSampleSize, researchReport, resolveModelPricing, resolveSeat, rolloutReward, rollupSupervisorRuns, roundTripRunRecord, routeFields, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runEvalCampaign, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProposeReview, runProposeReviewAsControlLoop, runRecordToProductBenchmarkRecord, runReferenceEquivalenceJudge, runReferenceReplay, runScore, runSelfPlay, runSemanticConceptJudge, runTaskScore, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreContinuity, scoreFromEvals, scoreKnowledgeReadiness, scorePrReviewComments, scorePrReviewSource, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, seatPresets, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, showMeasured, signManifest, spearmanR, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stringField, stripFencedJson, subjectiveEval, summarizeAgentReceiptIntegrity, summarizeBackendIntegrity, summarizeHarnessResults, summarizePrReviewBenchmark, summarizePreferenceMemory, summaryTable, supervisorRunRolloutLines, testJudge, textInSnapshot, throwIfRunIncomplete, toAgentProfileJson, toJsonl, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, toRewardRows, toSftRows, tokenizeDomainWords, toolNamesForRun, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceContract, traceJudge, traceJudgeEnsemble, traceSpanKindToOpenInferenceKind, tracedAnalyzeTraces, typoMutator, urlContains, userQuestionsForKnowledgeGaps, validateAgentProfileCell, validateProductBenchmarkManifest, validateProductBenchmarkRecord, validateProductBenchmarkRun, validateRolloutLine, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedComposite, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, withOtelPipeline, wranglerDeployRunner, writeSupervisorRunReport };
+export { AGENT_PROFILE_KINDS, ATIF_SCHEMA_VERSION, ATTESTATION_ALGORITHM, type ActionExecutionPolicy, type ActionPolicyDecision, type ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, type AgentEvalErrorCode, type AgentInterfaceProfileLike, type AgentProfileCell, type AgentProfileCellInput, type AgentProfileCellSchemaVersion, AgentProfileCellValidationError, type AgentProfileDimensionValue, type AgentProfileHarness, type AgentProfileJson, type AgentProfileJsonObject, type AgentProfileKind, type AgentProfileRuntimeReceipt, type AgentProfileSource, type AgentProfileSourceInput, type AlignmentOp, type Analyst, type AnalystContext, type AnalystCost, type AnalystFinding, type AnalystHooks, type AnalystInputKind, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystSeverity, type AnalystUsageReceipt, type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, type Artifact$1 as Artifact, type ArtifactCheck, type Artifact as ArtifactCheckArtifact, type ArtifactEventLike, type ArtifactResult, type ArtifactValidator, type AsiSeverity, type AssertCapabilityHeadroomOptions, type AssertCrossFamilyOptions, type AssertSingleBackendOptions, type AttestationProvenance, type AttestationVerification, type AttestedReport, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, BENCHMARK_SPLIT_SEED, type BackendDescriptor, BackendIntegrityError, type BackendIntegrityReport, type BaselineOptions, type BaselineReport, BehaviorAssertion, type BehavioralMetrics, type BehavioralTokenSequence, type BenchmarkAdapter, type BenchmarkDatasetItem, type BenchmarkEvaluation, type BenchmarkFamily, type BenchmarkReport$1 as BenchmarkReport, type BenchmarkResponder, BenchmarkRunner, type BenchmarkRunnerConfig, type BenchmarkScenario, type BenchmarkSource, type BenchmarkTaskKind, type BisectOptions, type BisectResult, type BisectStep, type BlendWeights, type BootstrapOptions, type BootstrapResult, BudgetBreachError, BudgetGuard, type BudgetLedgerEntry, type BudgetPolicy, type BudgetSpec, CODING_HARNESSES, type CachedJudge, type CachedJudgeOptions, type CalibrationResult, CallExpectation, CallbackResearcher, type CallbackResearcherOptions, type CampaignFactoryParams, type CampaignIntegrityPolicy, type CampaignRunContext, type CampaignRunOutcome, type CampaignRunner, type CampaignScenario, type CampaignVariant, type CanaryAlert, type CanaryEvaluation, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateComparison, type CandidateScenario, type CandidateScore, type CapabilityHeadroomOptions, type CapabilityHeadroomResult, type CaptureFetchContext, type CaptureFetchOptions, CaptureIntegrityError, type CausalAttributionReport, type CellVerdict, type ChannelRollup, type ChatCallOpts, type ChatClient, type ChatMessage, type ChatRequest, type ChatResponse, type ChatToolCall, type ChatTransport, type CheckResult, type CliBridgeTransportOpts, type CliffsMagnitude, type ClusterBootstrapInterval, type ClusterSignFlipAlternative, type ClusterSignFlipResult, type ClusteredBinaryCluster, type ClusteredMatchedPair, type ClusteredPairedBinaryOptions, type ClusteredPairedBinaryResult, type ClusteredPairedBinaryStatistics, type CollectedArtifacts, type CommandRunner, type ComparePairedArmsOptions, type CompletionCriterion, type CompletionRequirement, type CompletionVerdict, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, ConfigError, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type ContractCheckResult, type ContractJudgeOptions, type ContractMetric, type ContractReport, type ContractRule, type ContractRuleKind, type ContractSpan, type ContractVerdict, type ContractViolation, type ControlActionFailureMode, type ControlActionOutcome, type ControlBudget, type ControlContext, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlRunToRunRecordOptions, type ControlRuntimeConfig, type ControlRuntimeError, type ControlSeverity, type ControlStep, type ControlStopPolicies, ConvergenceTracker, type CorpusAgreementOptions, type CorpusAgreementPerDimension, type CorpusAgreementReport, type CorpusScoreRecord, type CorrectnessChecker, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, type CostChannel, type CostEntry, CostLedger, type CostLedgerFilter, type CostLedgerHandle, type CostLedgerOptions, type CostLedgerPersistence, CostLedgerPersistenceError, type CostLedgerSummary, type CostReceipt, CostReceiptCaptureError, type CostReceiptInput, type CostReport, CostReservationExceededError, type CostResult, type CostSummary, CostTracker, type CostUsage, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateAnalystAiConfig, type CreateChatClientOpts, type CreateDefaultReviewerOptions, type CreateExperimentInput, type CreateSandboxPoolOpts, type CreateTraceAnalystKindOpts, CrossFamilyError, type CrossTraceDiff, type CrossTraceDiffOptions, type CustomTokenPricing, type CustomTransportOpts, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, type DataAcquisitionPlan, Dataset, type DatasetDifficulty, type DatasetManifest, type DatasetOverview, type DatasetProvenance, type DatasetScenario, type DatasetSplit, type DecideNextUserTurnOpts, type DefaultAnalystRegistryOptions, type DefaultVerdict, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DescriptionLengthCandidate, type DescriptionLengthConfig, type DescriptionLengthDecision, type DescriptionLengthEvidence, DescriptionLengthGate, type DescriptionLengthRejectionCode, type DetectorEvent, type DetectorSeverity, type DetectorSignal, type DiffPolicy, type DiffScorecardOptions, type DirEntry, type DirectProviderTransportOpts, type Direction, type DiscoverPersonasOptions, type DiscoveredPersona, DockerSandboxDriver, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, ERROR_COUNT_PATTERNS, type EnsembleAggregate, type EnsembleJudgeOptions, type ErrorCluster, type ErrorCountPattern, type ErrorStreakOptions, type EvalCampaignOptions, type EvalCampaignResult, type EvalResult, type EvalToolDef, EvalTraceStore, type EventFilter, type EventKind, type EvidenceRef, type EvolutionRound, type ExecutorConfig, type Expectation, type Experiment, type ExperimentPlan, type ExperimentProvenance, type ExperimentRep, type ExperimentResult, type ExperimentStats, type ExperimentStore, ExperimentTracker, type ExperimentTrackerOptions, type ExperimentVerdict, type ExportableSpan, type ExportedRewardModel, type ExtractOptions, type ExtractResult, type ExtractUsageFromSseOptions, type ExtractedUsage, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, type FactorContribution, type FactorialCell, type FailedRun, type FailureClass, type FailureClassification, type FailureContext, type FailureMode, type FailureRule, type FeedbackArtifactType, type FeedbackAttempt, type FeedbackLabel, type FeedbackLabelKind, type FeedbackLabelSource, type FeedbackOptimizerRow, type FeedbackOutcome, type FeedbackPattern, type FeedbackReplayAdapter, type FeedbackReplayResult, type FeedbackSeverity, type FeedbackSplitPolicy, type FeedbackTask, type FeedbackTrajectory, type FeedbackTrajectoryFilter, type FeedbackTrajectoryStore, type FieldDestination, type FileChange, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, type FileSystemRawProviderSinkOptions, FileSystemTraceStore, type FileSystemTraceStoreOptions, type Finding, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, type FlattenOtlpOptions, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type FromHarborOptions, type GainDistributionBin, type GainDistributionFigureSpec, type GainDistributionOptions, type GateDecision$1 as GateDecision, type GateEvidence, type GenericSpan, type GhCliClientOptions, type GoldenItem, type GoldenSeverity, type GoldenSpec, HARBOR_IMPORT_GAP, HARNESS_NATIVE_MODEL, type HarborAgent, type HarborContentPart, type HarborFinalMetrics, type HarborImageSource, type HarborMetrics, type HarborObservation, type HarborObservationResult, type HarborStep, type HarborStepSource, type HarborSubagentTrajectoryRef, type HarborToolCall, type HarborTrajectory, type HarnessAdapter, type HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessVariant, type HarnessVariantReport, type HeadroomClass, type HeadroomInput, HeldOutGate, type HeldOutGateConfig, type HeldOutGateRejectionCode, type HeldOutPartition, type HiddenCriteriaGrader, type HiddenGradeResult, type HiddenLeak, HoldoutAuditor, HoldoutLockedError, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, IMPROVEMENT_KIND_SPEC, INPUT_VALUE, INTENT_MATCH_JUDGE_VERSION, type ImageData, type ImprovementThresholds, type ImprovementVerdictResult, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, type InMemoryRawProviderSinkOptions, InMemoryTraceStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, type InterimReleaseConfidence, type InterimReleaseConfidenceInput, type JudgeConfig$1 as JudgeConfig, JudgeError, type JudgeFamily, type JudgeFleetOptions, type JudgeFn, type JudgeInput, JudgeParseError, type JudgeReplayGateArgs, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, type JudgeRubric, JudgeRunner, type JudgeScore$1 as JudgeScore, type JudgeScoreInput, type JudgeScoresRecord, type JudgeSpan, type JudgeVerdict, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type KnowledgeAcquisitionMode, type KnowledgeBundle, type KnowledgeFallbackPolicy, type KnowledgeFreshness, type KnowledgeImportance, type KnowledgeReadinessReport, type KnowledgeRecommendedAction, type KnowledgeRequirement, type KnowledgeRequirementCategory, type KnowledgeResponsibleSurface, type KnowledgeSensitivity, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, type Layer, type LayerResult, type LayerStatus, type LeaderboardOptions, type LeaderboardRow, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallError, type LlmCallMetadata, type LlmCallRequest, type LlmCallResult, LlmClient, type LlmClientOptions, type LlmCorrectnessCheckerOpts, type LlmJsonCall, type LlmJudgeDimension, type LlmJudgeOptions, type LlmMessage, LlmResponseError, type LlmReviewerConfig, LlmRouteAssertionError, type LlmRouteRequirements, type LlmSpan, type LlmSpanOtlpInput, type LlmUsage, LockedJsonlAppender, MODEL_PRICING, type MakeEvalToolsConfig, type MatchResult, type MatchedPair, type MatchedRunRecordPair, type MatcherResult, type MaximumCharge, type McNemarResult, type Measured, type MeasurementPolicy, type MergeOptions, type Message, type MetricSamples, type MetricVerdict, MetricsCollector, type MintRolloutOptions, type MintRolloutResult, type MintedRolloutLine, type MintedRolloutOutcome, type MockTransportOpts, type ModelCostRollup, type ModelPreflight, type ModelSeats, ModelsUnreachableError, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, type MultiToolchainLayerConfig, type Mutator, Mutex, type NoLeakOptions, type NoProgressOptions, NoopRawProviderSink, NoopResearcher, NotFoundError, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, type Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, type OtelExportConfig, type OtelExporter, type OtelPipelineHandle, type OtelPipelineOptions, type OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, type OtlpResourceSpans, type OtlpSpan, type OtlpSpanRole, type OtlpSpanRoleInput, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type PaidCallResult, type PairArmsOptions, type PairArmsResult, type PairRunRecordsResult, type PairedArmRow, type PairedArmsComparison, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedCorrectness, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedMetricDelta, type PairedSignTestResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParetoFigureSpec, type ParetoPoint, type ParetoResult, type PartitionHeldOutOptions, type PendingCostCall, type PendingCostCallView, type PersistedFinding, type PersonaConfig, type PersonaRigor, type Playbook, type PlaybookEntry, type PoolSlot, type PositionalBiasResult, type PrReviewAuditCase, type PrReviewBenchmarkSummary, type PrReviewComment, type PrReviewMatchedFinding, type PrReviewOutcome, type PrReviewReferenceFinding, type PrReviewScore, type PrReviewScoreWeights, type PrReviewSeverity, type PrReviewSource, type PreferenceMemoryEntry, type PreflightModelsOptions, type PreflightOutcome, type ProducedProposal, type ProducedState, type ProductBenchmarkArm, type ProductBenchmarkArtifactPaths, type ProductBenchmarkBudgets, type ProductBenchmarkExportOptions, type ProductBenchmarkExportResult, type ProductBenchmarkManifest, type ProductBenchmarkProfileRef, type ProductBenchmarkRecord, type ProductBenchmarkRepoRef, type ProductBenchmarkRunInput, type ProductBenchmarkScenario, type ProductBenchmarkSingleRunExportOptions, type ProductBenchmarkSplit, type ProductBenchmarkSubstrateVersions, type ProductBenchmarkValidationReport, ProductClient, type ProductClientConfig, type ProfileAxisSpec, type ProjectRuntimeTrajectoryEvidenceOptions, type ProjectedOtlpSpan, type PromptHandle, PromptRegistry, type ProportionInterval, type ProposalEventLike, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, type ProposeFn, type ProposeInput, type ProposeOutput, type ProposeReviewConfig, type ProposeReviewControlAction, type ProposeReviewControlConfig, type ProposeReviewControlResult, type ProposeReviewControlState, type ProposeReviewReport, type ProposeReviewShot, type ProposedSideEffect, type ProvenanceReader, type ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, RESEARCH_REPORT_HARD_PAIR_FLOOR, ROLLOUT_SCHEMA, RUN_COST_ATTR_KEYS, type RawAnalystEvidence, type RawAnalystFinding, type RawProviderDirection, type RawProviderEvent, type RawProviderSink, type RawProviderSinkFilter, type RecordRunsOptions, type RedTeamCase, type RedTeamCategory, type RedTeamFinding, type RedTeamPayload, type RedTeamReport, type RedactionReport, type RedactionRule, type ReferenceEquivalenceJudgeInput, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceJudgeResult, type ReferenceEquivalenceScenario, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, type RegistryRunOpts, type ReleaseConfidenceAxis, type ReleaseConfidenceAxisName, type ReleaseConfidenceInput, type ReleaseConfidenceIssue, type ReleaseConfidenceMetrics, type ReleaseConfidenceScorecard, type ReleaseConfidenceStatus, type ReleaseConfidenceThresholds, type ReleaseTraceEvidence, type RenderReleaseReportOptions, type RepeatedActionOptions, ReplayCache, type ReplayCacheEntry, ReplayCacheMissError, type ReplayCacheStats, ReplayError, type ReplayFetchOptions, type RepoRef, type RequirementCheck, type ResearchReport, type ResearchReportCandidate, type ResearchReportDecision, type ResearchReportMethodology, type ResearchReportOptions, type ResearchReportRecommendation, type Researcher, type RetrievalSpan, type Review, type ReviewFn, type ReviewInput, type ReviewMemoryEntry, type ReviewMemoryStore, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RewardRow, type RiskDifferenceResult, type RobustnessResult, type RolloutCapture, type RolloutLine, type RolloutRole, type RolloutScrubber, type RolloutSplit, type RolloutStep, type RouteMap, type RoutedField, type RouterTransportOpts, type RubricDimension, type Run, type RunCommandInput, type RunCommandResult, type RunCompleteHook, type RunCompleteHookContext, type RunCostProvenance, RunCritic, type RunCriticOptions, type RunEvidenceMetadata, type RunFilter, RunIntegrityError, type RunIntegrityExpectations, type RunIntegrityIssue, type RunIntegrityIssueCode, type RunIntegrityReport, type RunJudgeMetadata, type RunLayer, type RunOutcome, type RunPaidCallInput, type RunRecord, type RunRecordBackend, type RunRecordFilter, RunRecordValidationError, type RunScore, type RunScoreWeights, type RunSplitTag, type RunStatus, type RunTaskFailure, type RunTerminalOutcome, type RunTokenUsage, type RunTrace, type RuntimeEventLike, type RuntimeResolution, type RuntimeTrajectoryEvidenceProjection, type RuntimeTrajectoryEvidenceSummary, type RuntimeTrajectoryHookEvent, type RuntimeTrajectoryRecord, type RuntimeTrajectoryRunRecord, SEMANTIC_CONCEPT_JUDGE_VERSION, SKILL_USAGE_ANALYST, SPAN_KIND_ATTR_KEYS, SUPERVISOR_RUN_SCHEMA, type SandboxDriver, SandboxHarness, type SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxResult, type SandboxSdkTransportOpts, type SandboxSpan, type SatisfiedBy, type ScanOptions, type Scenario$1 as Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, type ScoreKnowledgeReadinessOptions, type ScoreOrigin, type ScorePreference, type Scorecard, type ScorecardCell, type ScorecardCellDiff, type ScorecardDiff, type ScorecardEntry, type ScorecardLogLine, type ScoredTarget, type SearchSpanResult, type SearchTraceResult, type SeatName, type SeatPresetName, SeatUnsetError, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SelfPreferenceResult, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SequentialDecision, type SerializedRegex, type SeriesConvergenceOptions, type SeriesConvergenceResult, type Severity, type SftExportOptions, type SftRow, type SignTestAlternative, type SignedManifest, type SignedManifestAlgo, type SingleBackendDivergence, SingleBackendError, type SingleBackendField, type SingleBackendReport, SkillUsageAnalyst, type SliceOptions, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type SourceLimits, type Span, type SpanBase, type SpanFilter, type SpanHandle, type SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanPredicate, type SpanStatus, type SseUsageMode, type SteeringBundle, type SteeringChange, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type StopDecision, type StreamingDetector, type SuboptimalCode, type SuboptimalSignal, SubprocessSandboxDriver, type SubprocessSandboxDriverOptions, type SummaryTable, type SummaryTableOptions, type SummaryTableRow, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunRollup, type SupervisorRunSources, type SupervisorRunTree, type SynthesisReason, type SynthesisTarget, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type TaskGold, type TaskHeadroom, type TestGradedRunOptions, type TestGradedRunResult, type TestGradedScenario, type TestOutputParser, type TestResult, type TextMatcher, type ThresholdContract, TokenCounter, type TokenSpec, type ToolCallEventLike, type ToolDef, type ToolMatcher, type ToolSpan, type ToolSpanOtlpInput, type ToolStats, type ToolUseMetrics, type ToolUseOptions, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystGolden, type TraceAnalystHookOptions, type TraceAnalystKindSpec, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, type TraceContract, TraceContractBuilder, TraceEmitter, type TraceEmitterOptions, type TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, type TraceStore, type TraceStoreSource, type TraceStoreToOtlpOptions, type TracedAnalystOptions, type TracedJudgeOptions, type TracesToOtlpResult, type Trajectory, type TrajectoryStep, type TreatmentClass, type TreatmentGate, type TreatmentGateInput, type TreatmentGateOptions, type TrialTrace, type Turn, type TurnMetrics, type TurnResult, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, type UiFinding, type UiFindingScreenshot, type UiFindingSeverity, type UiLens, type Unavailable, type UserQuestion, type ValidationContext, ValidationError, type ValidationIssue, type ValidationResult, type VerbosityBiasResult, type Verdict, type VerdictCacheStats, type VerdictCacheStore, type Verification, VerificationError, type VerificationReport, type VerifyContext, type VerifyFn, type VerifyOptions, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WeightedCompositeInput, type WeightedCompositeResult, type WorkerDriverContext, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, acquisitionPlansForKnowledgeGaps, agentProfileCellHashMaterial, agentProfileCellKey, agentProfileHash, agentProfileId, agentProfileModelId, agentVisibleFields, aggregateJudgeVerdicts, aggregateLlm, aggregatePrReviewScore, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeSupervisorRun, analyzeSupervisorRunSources, analyzeTraces, appendScorecard, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertCapabilityHeadroom, assertCrossFamily, assertLlmRoute, assertMinted, assertMintedLines, assertModelsServed, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealAgentReceipts, assertRealBackend, assertReleaseConfidence, assertRolloutLine, assertRunAgentProfileCell, assertRunCaptured, assertSingleBackend, assignFeedbackSplit, assignHeldOutTag, attachCostToReport, attest, attributeCounterfactuals, backoffMs, deterministicSplit as benchmarkDeterministicSplit, index$1 as benchmarks, benjaminiHochberg, bisect, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, buildAgentInterfaceProfileCell, buildAgentProfileCell, buildDefaultAnalystRegistry, buildDriverSystemPrompt, buildProductBenchmarkManifest, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, buildWorkerDriverSystemPrompt, byteLengthRange, cachedJudge, calibrateJudge, calibrateJudgeContinuous, callLlm, callLlmJson, canaryLeakView, canonicalJson, canonicalize, capabilityHeadroom, captureFetchToRawSink, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, clamp01, classifyFailure, classifyOtlpSpanRole, classifyTreatment, claudeCodeSupervisorRunReader, cliffsDelta, clusteredPairedBinary, cohensD, collectionPreserved, commentsForSource, commitBisect, comparePairedArms, compareReferenceReplay, compareToBaseline, compilerJudge, completionVerdict, composeParsers, composeValidators, computeExperimentStats, computeFindingId, computeToolUseMetrics, computeTraceMetrics, confidenceInterval, containsAll, contentHash, contextInputTokens, continuousAgreement, contractJudge, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, controlRunToRunRecord, convertTraceStoresToOtlp, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, costReport, createAnalystAi, createAntiSlopJudge, createChatClient, createDefaultReviewer, createFeedbackTrajectory, createIntentMatchJudge, createLlmCorrectnessChecker, createLlmReviewer, createOtelExporter, createOtelTracingStore, createReferenceEquivalenceJudge, createReplayFetch, createSandboxPool, createSemanticConceptJudge, createTokenRecallChecker, createTraceAnalystKind, crossTraceDiff, crowdingDistance, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultBlendWeights, defaultIsMaterial, defaultProviderRedactor, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, distillPlaybook, domainEvidencePattern, dominates, eProcess, ensembleJudge, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, executeScenario, expandProfileAxes, expectAgent, exportProductBenchmark, exportProductBenchmarkRuns, exportRewardModel, exportRunAsOtlp, extractAssetUrls, extractErrorCount, extractOtlpAttributes, extractProducedState, extractUsage, extractUsageFromResponse, extractUsageFromSse, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findProductBenchmarkArtifacts, findSkipCountsAsPass, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, fromHarborTrajectory, gainHistogram, gateTreatmentApplied, gateTreatmentFromMetrics, gateTreatmentFromSpans, gateTreatmentFromToolSpans, ghCliClient, gitProvenanceReader, precision as goldenPrecision, gradeOnHidden, gradeSemanticStatus, groupBy, groupRunsByAgentProfileCell, harnessAxisOf, hasCapturedToolArgs, hashContent, hashJson, hashScenarios, hashToUnit, hiddenGrade, holm, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryReviewStore, inMemoryRunRecordBackend, inMemoryVerdictCache, inferDomainKeywords, inferOtlpKind, interRaterReliability, interpretCliffs, iqr, isHiddenDestination, isJudgeSpan, isLlmSpan, isModelPriced, isOtelConfigured, isOtlpModelCall, isRealnessGated, isRetrievalSpan, isRolloutLine, isRunRecord, isSandboxSpan, isToolSpan, isTrainableSplit, isTransientLlmError, isUnavailable, iterateRawCalls, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, jsonlRunRecordBackend, judgeFamily, judgeReplayGate, judgeSpans, keyPreserved, knowledgeReadinessTracePayload, leaderboard, linterJudge, llmJudge, llmSpanFromProvider, llmSpans, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, makeFinding, mannWhitneyU, mapConcurrent, matchGoldens, matchSpan, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, mergeLayerResults, mergeSteeringBundle, mintRolloutRows, modelDescriptionBits, modelHasSnapshot, modelPriceKey, mulberry32, multiToolchainLayer, noProgressDetector, normalizeScores, notBlocked, objectiveEval, observeAll, observedScore, observedSplitScore, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedSignTest, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseCorrectnessResponse, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, parseRunRecordSafe, parseRuntimeTrajectoryHookEvent, partialCredit, partitionHeldOut, passAtK, passOrthogonality, pearsonR, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, preflightModels, printDriverSummary, probeLlm, productBenchmarkIntegrityFailures, productBenchmarkMutableSurfaces, productBenchmarkRepoIdentity, productBenchmarkSplits, index as profile, projectOtlpFlatLine, projectRuntimeTrajectoryEvidence, promptBisect, proposeSynthesisTargets, providerFromBaseUrl, pytestTestParser, ranks, readClaudeCodeSupervisorRun, readOtlpStatus, readProductBenchmarkManifest, readProductBenchmarkRecords, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, relabelImportedSplit, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderPriorFindings, renderReleaseReport, renderSteeringText, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, renderUpstreamFindings, repeatedActionDetector, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requireAgentProfileCell, requiredPairedSampleSize, requiredSampleSize, researchReport, resolveModelPricing, resolveSeat, rollupSupervisorRuns, roundTripRunRecord, routeFields, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runEvalCampaign, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProposeReview, runProposeReviewAsControlLoop, runRecordToProductBenchmarkRecord, runReferenceEquivalenceJudge, runReferenceReplay, runScore, runSelfPlay, runSemanticConceptJudge, runTaskScore, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreContinuity, scoreFromEvals, scoreKnowledgeReadiness, scoreOrigin, scorePrReviewComments, scorePrReviewSource, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, seatPresets, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, showMeasured, signManifest, spearmanR, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stringField, stripFencedJson, subjectiveEval, summarizeAgentReceiptIntegrity, summarizeBackendIntegrity, summarizeHarnessResults, summarizePrReviewBenchmark, summarizePreferenceMemory, summaryTable, supervisorRunRolloutLines, testJudge, textInSnapshot, throwIfRunIncomplete, toAgentProfileJson, toHarborTrajectories, toHarborTrajectory, toJsonl, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, toRewardRows, toSftRows, tokenizeDomainWords, toolNamesForRun, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceContract, traceJudge, traceJudgeEnsemble, traceSpanKindToOpenInferenceKind, tracedAnalyzeTraces, trainingReward, trainingScore, typoMutator, urlContains, userQuestionsForKnowledgeGaps, validateAgentProfileCell, validateProductBenchmarkManifest, validateProductBenchmarkRecord, validateProductBenchmarkRun, validateRolloutLine, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedComposite, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, withOtelPipeline, wranglerDeployRunner, writeSupervisorRunReport };