@leostera/evalkit 0.9.0 → 0.11.0

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import * as Schema from "effect/Schema";
+import { AssistantBlock, AssistantBlock as AssistantBlock$1, EntryRecord, EntryRecord as EntryRecord$1, MessageRecord, MessageRecord as MessageRecord$1, ModelContext, ModelContext as ModelContext$1, ModelRef, ModelRef as ModelRef$1, Origin, StopReason, ToolCallBlock, ToolCallBlock as ToolCallBlock$1, Transcript, Transcript as Transcript$1, TranscriptHeader, TreeRecord, TreeRecord as TreeRecord$1, Usage, UserBlock, UserBlock as UserBlock$1, UserContent, UserContent as UserContent$1 } from "@leostera/atxf";
 //#region ../core/src/identity.d.ts
 export declare const ResourceKindSchema: Schema.Literal<["run", "artifact"]>;
 export type ResourceKind = typeof ResourceKindSchema.Type;
@@ -109,70 +110,462 @@ export declare function relativeDatasetPath(value: string, label: string): strin
 export declare function defineDataset<TLoaded extends DatasetContent>(definition: StaticDatasetDefinition | ComputedDatasetDefinition<TLoaded>): Dataset;
 export declare function isDataset(value: unknown): value is Dataset;
 //#endregion
-//#region ../core/src/aut-events.d.ts
+//#region ../core/src/usage.d.ts
 /**
- * Events as adapters emit them. Payloads accept any JSON-convertible value and
- * timestamps are optional; EvalKit converts them once into `AutEvent`s.
+ * Token usage as an adapter reports it: ATXF's buckets, each optional.
+ * The buckets are disjoint: `input` excludes cached tokens, which are
+ * `cacheRead` (read from a prompt cache) and `cacheWrite` (written to one);
+ * `output` includes `reasoning`. Convert your provider's conventions: one
+ * that counts cached tokens inside its prompt tokens reports
+ * `input: promptTokens - cachedTokens, cacheRead: cachedTokens`.
  */
-export type AutEventInput = {
-  kind: 'started';
-  timestamp?: string;
-} | {
-  kind: 'message';
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: unknown;
-  timestamp?: string;
-} | {
-  kind: 'tool-call';
-  id: string;
-  name: string;
-  arguments?: unknown;
-  timestamp?: string;
-} | {
-  kind: 'tool-result';
-  id: string;
-  name?: string;
-  result?: unknown;
-  timestamp?: string;
-} | {
-  kind: 'turn-started';
-  turn: number;
-  timestamp?: string;
-} | {
-  kind: 'turn-completed';
-  turn: number;
-  timestamp?: string;
-  latencyMs?: number;
-  usage?: Usage;
-} | {
-  kind: 'completed';
-  output?: unknown;
-  timestamp?: string;
-} | {
-  kind: 'error';
-  error: RecordedError;
-  timestamp?: string;
+type UsageInput = {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  reasoning?: number;
+  /** The provider's total; used only when no bucket is reported. */
+  total?: number;
+};
+//#endregion
+//#region ../core/src/agent-transcript.d.ts
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/** An ATXF tree record to append: `id`, `time` and `parentId` are filled in when absent. */
+export type RecordInput = DistributiveOmit<TreeRecord$1, 'id' | 'time' | 'parentId' | 'hash'> & {
+  id?: string;
+  time?: string;
+  parentId?: string | null;
+};
+/** An assistant message: what the model said and the tools it called. */
+export type AssistantInput = {
+  /** Text, or ATXF blocks: `text`, `reasoning`, `tool_call` and `image`. */
+  content: string | AssistantBlock$1[];
+  /** `provider/id` (`openai/gpt-5`), or an ATXF model reference. */
+  model?: string | ModelRef$1;
+  /** This response's usage, in ATXF's buckets. */
+  usage?: UsageInput;
+  stop?: StopReason;
+  error?: {
+    message: string;
+    code?: string;
+  };
+};
+/**
+ * Where an adapter records what its agent did, as an ATXF transcript
+ * (https://atxf.leostera.dev). Each method appends one record and returns
+ * its ID. EvalKit writes each scripted user message itself, unless the
+ * adapter writes it (or imports a transcript holding it) first.
+ */
+export type TranscriptWriter = {
+  /** A message the agent received. */
+  user(content: string | UserBlock$1[], options?: {
+    origin?: Origin;
+  }): string;
+  assistant(message: AssistantInput): string;
+  /**
+   * A tool call's result. A string is the result's text; any other
+   * JSON-convertible value is kept as is in `details.result` and shown as
+   * JSON.
+   */
+  toolResult(callId: string, result: unknown, options?: {
+    name?: string;
+    isError?: boolean;
+  }): string;
+  /** Any other ATXF tree record, such as `reasoning` settings, a compaction or a sub-agent link. */
+  append(record: RecordInput): string;
+  /**
+   * Appends an ATXF transcript's records that were not imported before (by
+   * ID), keeping their IDs and native records: for agents whose sessions
+   * ATXF converts (`pi.toAtxf(await readFile(sessionFile, 'utf8'))`, from `@leostera/atxf/pi`). Import the whole session
+   * after each turn; a user message matching the one EvalKit is about to
+   * write stands for it.
+   */
+  import(transcript: Transcript$1): void;
+  /**
+   * Marks a turn's start or end, as the agent saw it: `turn('start')`
+   * returns a turn ID to pass to `turn('end', { turnId, outcome })`.
+   */
+  turn(phase: 'start' | 'end', options?: {
+    turnId?: string;
+    outcome?: 'succeeded' | 'failed' | 'interrupted';
+    error?: {
+      message: string;
+      code?: string;
+    };
+  }): string;
+  /**
+   * Keeps a sub-agent's ATXF transcript with the run, in
+   * `transcripts/<id>.atxf.jsonl`, linked from this one by an `agent_link`
+   * record with its `transcriptId` (append one, or import a session that
+   * has it). Its steps and tokens count toward the run's limits. Pass the
+   * whole transcript again as it grows; it replaces the one kept.
+   */
+  subagent(transcript: Transcript$1): void;
 };
 export type TurnToolCall = {
   name: string;
   arguments?: unknown;
-  /** When given, a `tool-result` event is recorded after the call. */
+  /** When given, the call's result is recorded after it. */
   result?: unknown;
   id?: string;
 };
-/** What `send()` may return instead of (or as well as) emitting events. A string is the reply. */
+/** What `send()` may return instead of writing to the transcript. A string is the reply. */
 export type TurnResult = string | {
+  /** Text, or a JSON value (recorded as its JSON text). */
   reply?: unknown;
   toolCalls?: readonly TurnToolCall[];
-  usage?: Usage;
+  usage?: UsageInput;
+  /** The model that answered. */
+  model?: string | ModelRef$1;
+};
+//#endregion
+//#region ../core/src/isolation.d.ts
+/**
+ * Where a run's processes run, and the shell adapters and scorers use to
+ * run them (RFD0009). Types and constructors only: the runner implements
+ * them.
+ */
+/** Commands run on the host, in the run's workspace. The default. */
+export type NoIsolation = {
+  kind: 'none';
+};
+/**
+ * What a run's container can reach: nothing, only the project's fixtures,
+ * or whatever the container runtime allows by default.
+ */
+export type ContainerNetwork = 'none' | 'fixtures' | 'full';
+/** A host path mounted read-only into every run's container. */
+export type ContainerMount = {
+  host: string;
+  path: string;
+};
+/** One container per run, from `image`, with the candidate workspace at `/workspace`. */
+export type ContainerIsolation = {
+  kind: 'container';
+  /** An image reference (`node:22`), or a Dockerfile path relative to the project (`./evals/Dockerfile`). */
+  image: string;
+  network: ContainerNetwork;
+  /** The `docker`-compatible command to run: `docker` (the default) or `podman`. */
+  runtime: string;
+  /** Names of host environment variables passed into the container; nothing else is. */
+  env: readonly string[];
+  mounts: readonly ContainerMount[];
+};
+/** macOS only: each run's processes run under a generated `sandbox-exec` profile. */
+export type SandboxExecIsolation = {
+  kind: 'sandbox-exec';
+  /** Host paths the run may read and write besides its workspace, such as a cache (`~/.npm`). */
+  allow: readonly string[];
+  /** Host paths the run may only read, such as a toolchain or an agent CLI's install. */
+  read: readonly string[];
+  /** More host paths the run may not touch, such as a fixture's state; `allow` and `read` still win inside them. */
+  deny: readonly string[];
+  /**
+   * Names of host environment variables the run gets, besides `PATH`,
+   * `HOME`, `TMPDIR`, `USER`, `LANG` and `TERM`; undefined passes the whole
+   * environment. A command's own `env` is added on top.
+   */
+  env?: readonly string[];
+};
+export type SandboxExecOptions = {
+  allow?: readonly string[];
+  read?: readonly string[];
+  deny?: readonly string[];
+  env?: readonly string[];
+};
+export type Isolation = NoIsolation | ContainerIsolation | SandboxExecIsolation;
+export type ContainerOptions = {
+  image: string;
+  /** Default `'none'`. */
+  network?: ContainerNetwork;
+  runtime?: string;
+  env?: readonly string[];
+  /** `{ host, path }`, or `'host:path'`. */
+  mounts?: readonly (ContainerMount | string)[];
+};
+/** No isolation: commands run on the host in the run's workspace. */
+export declare function none(): NoIsolation;
+/**
+ * Container isolation through the `docker` CLI, or a compatible one such as
+ * podman's: a container per run, the candidate workspace mounted at
+ * `/workspace`, the evaluator workspace never mounted, and its own process
+ * table, so a `pkill` reaches only that run.
+ */
+export declare function container(options: ContainerOptions): ContainerIsolation;
+/**
+ * macOS `sandbox-exec` isolation, for projects that cannot use containers:
+ * the run cannot read or write the project, the home directory or other
+ * runs' workspaces, except its own workspace and `allow`, and can signal
+ * only processes it started.
+ */
+export declare function sandboxExec(options?: SandboxExecOptions): SandboxExecIsolation;
+/**
+ * A service runs reach, such as a fake store or API, started on the host
+ * before the first run that needs it and stopped after the invocation's
+ * last.
+ */
+export type Fixture = {
+  /** The command that starts it, run with `sh -c` in the project root. */
+  start: string;
+  /** A URL polled until it answers, or a command that must exit 0. */
+  ready?: string;
+  /** A command run before the fixture is stopped. */
+  stop?: string;
+  /** The port it listens on; taken from `ready` when that is a URL with one. */
+  port?: number;
+};
+/** A fixture as one run reaches it. */
+export type FixtureAddress = {
+  /** Where the run reaches it: `http://localhost:8787`, or `http://fixtures.<name>:8787` from a container. */
+  url: string;
+};
+/** A process's exit: a signal shows as 128 plus its number, a timeout as 124. */
+export type ShellExit = {
+  exitCode: number;
+  /** The signal that stopped it, if one did. */
+  signal?: string;
+  /** True when `timeoutMs` passed and the process was stopped. */
+  timedOut?: true;
+};
+export type ShellResult = ShellExit & {
+  stdout: string;
+  stderr: string;
+};
+export type ShellOptions = {
+  /** Relative to the workspace. */
+  cwd?: string;
+  /** Added to the environment the process gets. */
+  env?: Readonly<Record<string, string>>;
+  /** Stops the process when aborted. Default: the run's signal. */
+  signal?: AbortSignal;
+  /** Stops the process after this many milliseconds. */
+  timeoutMs?: number;
+  /** Written to the process's standard input, which is then closed. */
+  input?: string;
+};
+/** A process started with `spawn`. Its output is always read, so it never blocks on a full pipe. */
+export type ShellProcess = {
+  /** Its process ID where it runs (inside the container, for container isolation). */
+  readonly pid: number | undefined;
+  /** Its standard output so far: the last megabyte. */
+  stdout(): string;
+  stderr(): string;
+  /** Calls `listener` with each chunk of output as it arrives; returns a function that stops. */
+  onOutput(listener: (chunk: string, stream: 'stdout' | 'stderr') => void): () => void;
+  /** Resolves when it exits. */
+  wait(): Promise<ShellExit>;
+  /** Signals it and the processes it started. Default `SIGTERM`. */
+  kill(signal?: string): Promise<void>;
 };
-/** Converts an adapter event into a recorded `AutEvent`. */
-export declare function normalizeAutEvent(input: AutEventInput, now: () => Date): AutEvent;
 /**
- * The events a returned turn result stands for: each tool call (and its
- * result), then the reply, then the usage as a `turn-completed` event.
+ * The run's shell: commands, long-lived processes and files, wherever the
+ * run's isolation puts them. One per run, shared by the adapter and the
+ * run's scorers; processes it started are stopped when the run ends. A
+ * string command runs with `sh -c`; an array runs as it is.
  */
-export declare function turnResultEvents(result: TurnResult, turn: number, now: () => Date): AutEvent[];
+export type Shell = {
+  readonly isolation: Isolation['kind'];
+  /** The workspace as commands see it: its host path, or `/workspace` in a container. */
+  readonly root: string;
+  /**
+   * The run's private directory, outside the workspace, as commands see it
+   * (`/evalkit-home` in a container): for an agent CLI's config and session
+   * files. It is never snapshotted, and is removed with the run.
+   */
+  readonly home: string;
+  exec(command: string | readonly string[], options?: ShellOptions): Promise<ShellResult>;
+  spawn(command: string | readonly string[], options?: Omit<ShellOptions, 'timeoutMs'>): ShellProcess;
+  /** Relative to the workspace, or absolute inside `root` or `home`. */
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string | Uint8Array): Promise<void>;
+  /** A directory's entries, relative to the workspace; directories end with `/`. */
+  list(path?: string): Promise<string[]>;
+};
+//#endregion
+//#region ../core/src/limits.d.ts
+/** What a run may use before EvalKit stops it. */
+type Limits = {
+  /** Assistant messages, one per model call, sub-agents included. */
+  steps?: number;
+  /** The `tokens` metric: uncached input, cache writes and output. Cache reads do not count. */
+  tokens?: number;
+  /** Milliseconds from the session's start to the end of its last turn; scoring is not counted. */
+  time?: number;
+};
+type LimitKind = keyof Limits;
+declare const LIMIT_KINDS: readonly LimitKind[];
+/** Limits as written in config and scenarios: `time` may be a duration such as `'20m'`. */
+type LimitsInput = {
+  steps?: number;
+  tokens?: number;
+  /** Milliseconds, or `'90s'`, `'20m'`, `'1h'`. */
+  time?: number | string;
+};
+/** Which limit a run hit, its value, and how much was used. */
+type LimitReached = {
+  limit: LimitKind;
+  value: number;
+  used: number;
+};
+/** `'20m'` → 1_200_000. A number is milliseconds. */
+declare function parseDuration(value: number | string, owner: string): number;
+/** Checks and normalizes limits; `owner` names where they were written. */
+declare function parseLimits(input: LimitsInput | undefined, owner: string): Limits;
+/** Later layers win, kind by kind: config, then scenario, then matrix cell, then the command line. */
+declare function resolveLimits(...layers: readonly Limits[]): Limits;
+/** A matrix's `limits` axes are parameters named `limits.<kind>`. */
+declare const LIMIT_PARAMETER_PREFIX = "limits.";
+/** The limits a matrix cell's `limits.<kind>` parameters set. */
+declare function limitsFromParameters(parameters: Readonly<Record<string, unknown>> | undefined): Limits;
+/** `steps=80` or `time=1h`, from `--limit`. */
+declare function parseLimitFlag(flag: string): Limits;
+/** `40 steps`, `2,000,000 tokens`, `20m`. */
+declare function formatLimit(kind: LimitKind, value: number): string;
+//#endregion
+//#region ../core/src/transcript.d.ts
+/** The ATXF version EvalKit writes. */
+declare const ATXF_VERSION = "0.1";
+declare function isTreeRecord(record: EntryRecord$1): record is TreeRecord$1;
+type AssistantMessage = MessageRecord$1 & {
+  role: 'assistant';
+};
+type ToolMessage = MessageRecord$1 & {
+  role: 'tool';
+};
+/**
+ * The records from the transcript's root to its active leaf, in order: what
+ * the session is now, without abandoned branches (ATXF §4).
+ */
+declare function activePath(transcript: Transcript$1): TreeRecord$1[];
+/** Messages on the active path, optionally of one role. */
+declare function transcriptMessages(transcript: Transcript$1, role?: MessageRecord$1['role']): MessageRecord$1[];
+/** A tool call and, when the transcript has it, its result. */
+type PairedToolCall = {
+  /** The assistant message holding the call. */
+  message: AssistantMessage;
+  call: ToolCallBlock$1;
+  result?: ToolMessage;
+};
+/** A tool call as scorers see it: its name, arguments and what it returned. */
+type ToolCall = {
+  id: string;
+  name: string;
+  /** Its arguments; `{}` when the agent recorded raw `input` instead. */
+  arguments: Record<string, unknown>;
+  /** Raw input for tools that take text rather than JSON arguments. */
+  input?: string;
+  /** What the tool returned (JSON the adapter recorded, else the result's text); undefined before a result. */
+  result?: unknown;
+  /** The tool reported an error. */
+  isError: boolean;
+  /** The assistant message holding the call. */
+  messageId: string;
+  /** The tool result message, when there is one. */
+  resultId?: string;
+};
+/** Every tool call on the active path, in order, with its result. */
+declare function transcriptToolCalls(transcript: Transcript$1, name?: string): ToolCall[];
+/** Tool calls among `records`, each paired with the first result for it. */
+declare function callsIn(records: readonly TreeRecord$1[]): PairedToolCall[];
+/** The text of a message's content: text blocks joined, other blocks left out. */
+declare function contentText(content: UserContent$1 | AssistantBlock$1[]): string;
+/** The text of the last assistant message on the active path, or `''`. */
+declare function transcriptReply(transcript: Transcript$1): string;
+/**
+ * A tool result's value: the JSON an adapter returned (kept in
+ * `details.result`), else the result's text.
+ */
+declare function toolResultValue(result: ToolMessage): unknown;
+/** `provider/id`, or `id` when the provider is unknown. */
+declare function modelName(model: ModelRef$1 | undefined): string | undefined;
+/** `openai/gpt-5` → `{ provider: 'openai', id: 'gpt-5' }`; without a provider, `unknown`. */
+declare function parseModel(model: string | ModelRef$1): ModelRef$1;
+/** The transcript, empty: what scorers see before the agent recorded anything. */
+declare function emptyTranscript(header: Transcript$1['header']): Transcript$1;
+//#endregion
+//#region ../core/src/judge.d.ts
+/**
+ * How a judge must answer, and how EvalKit turns the answer into a score.
+ *
+ * - `verdict` (the default): a value from 0 to 1 and a reason, as JSON.
+ * - `choices`: one of a fixed set of answers, such as A/B/C, each worth a value.
+ * - `criteria`: a value from 0 to 1 per criterion; the score is their weighted mean.
+ */
+type JudgeAnswer = {
+  kind: 'verdict';
+} | {
+  kind: 'choices';
+  choices: JudgeChoice[];
+} | {
+  kind: 'criteria';
+  criteria: JudgeCriterion[];
+};
+/** One answer a `choices` judge can give. Keys are matched case-insensitively. */
+type JudgeChoice = {
+  key: string;
+  label: string;
+  value: number;
+};
+/** One thing a `criteria` judge scores. */
+type JudgeCriterion = {
+  name: string;
+  weight: number;
+  description?: string;
+};
+/**
+ * A judge that answers with one of these choices, in this order:
+ * `choices({ A: ['Accurate and helpful', 1], B: ['Partly right', 0.5], C: ['Wrong', 0] })`.
+ */
+export declare function choices(options: Record<string, readonly [label: string, value: number]>): JudgeAnswer;
+/**
+ * Criteria by name: a number is the weight; `{ weight, description }` also
+ * says what the criterion checks. Weights default to 1.
+ */
+type CriteriaOptions = Record<string, number | {
+  weight?: number;
+  description?: string;
+}>;
+/**
+ * A judge that scores each criterion from 0 to 1; the score is the weighted
+ * mean. A number is the weight; `{ weight, description }` also says what the
+ * criterion means. Weights default to 1.
+ */
+export declare function criteria(options: CriteriaOptions): JudgeAnswer;
+/**
+ * One criterion's result, as a scorer returns it and as results record it:
+ * a value with what it saw, or `reached: false` when the check never got to
+ * run, because something before it failed (say, the app would not start).
+ * A criterion not reached counts as 0; the score's `explanation` says why,
+ * once, instead of every criterion repeating it.
+ */
+type CriterionResult = ReachedCriterion | UnreachedCriterion;
+type ReachedCriterion = {
+  name: string;
+  /** From 0 to 1. */
+  value: number;
+  /** Default 1, or the declared weight. */
+  weight?: number;
+  /** Why this value. */
+  explanation?: string;
+  /** What the check observed, as plain data. */
+  evidence?: JsonValue;
+};
+type UnreachedCriterion = {
+  name: string;
+  reached: false;
+  weight?: number;
+  explanation?: string;
+};
+/** A criterion as a scorer returns it: its evidence may be any plain value. */
+type CriterionInput = (Omit<ReachedCriterion, 'evidence'> & {
+  evidence?: unknown;
+}) | UnreachedCriterion;
+/**
+ * The pass mark in words: `only 1`, `≥ 0.5`, or for choices the ones that
+ * pass, such as `A or B`.
+ */
+export declare function passMark(passAt: number | undefined, answer?: JudgeAnswer): string;
 //#endregion
 //#region ../core/src/catalog.d.ts
 /**
@@ -184,6 +577,8 @@ export declare function turnResultEvents(result: TurnResult, turn: number, now:
 export type CatalogOptions = {
   /** Project root; definition sites are reported relative to it, never absolute. */
   root?: string;
+  /** The project's default judge agent (`judge` in evalkit.config.ts). */
+  judge?: AutAdapter;
 };
 export type EvalCatalogAgent = {
   name?: string;
@@ -235,10 +630,20 @@ export type EvalCatalogDataset = {
 export type EvalCatalogScorer = {
   name: string;
   kind: ScoringRule['kind'];
+  /** What it checks, in the author's words. */
+  description?: string;
   passAt?: number;
   supportsPartial?: boolean;
   /** Judges only. */
   rubric?: string;
+  /** Judges only: the agent that judges (its own, or the project's default). */
+  agent?: EvalCatalogAgent;
+  /** Judges only: the names of the inputs it sees. */
+  inputs?: string[];
+  /** Judges only: how it answers. */
+  answer?: JudgeAnswer;
+  /** Judges only: the prompt it receives, with `{input}` placeholders. */
+  prompt?: string;
   definedAt?: string;
 };
 export type EvalCatalogStep =
@@ -271,9 +676,10 @@ export type EvalCatalogEntry = {
   /** Runs started each time the scenario runs (`repeat`). */
   repeat: number;
   policy: {
-    timeoutMs?: number;
     failfast?: boolean;
   };
+  /** The scenario's own limits; the project's, a cell's and `--limit` may add to them. */
+  limits?: Limits;
   transcript: EvalCatalogStep[];
   scorers: EvalCatalogScorer[];
   metadata?: JsonValue;
@@ -312,13 +718,22 @@ type EvalMatrixDefinition = {
   cases?: readonly JsonObject[];
   /** Partial patterns over declared dimensions; matching cells are never run. */
   exclude?: readonly JsonObject[];
+  /**
+   * Limits to compare, as axes: `{ steps: [40, 80] }`. Each becomes the axis
+   * `limits.steps`, so cells show it and `-a limits.steps=80` selects it.
+   */
+  limits?: Readonly<{
+    steps?: readonly number[];
+    tokens?: readonly number[];
+    time?: readonly (number | string)[];
+  }>;
 };
 type EvalMatrix = EvalMatrixDefinition & {
   kind: 'matrix';
   count(selection?: MatrixSelection): number;
   cells(selection?: MatrixSelection): IterableIterator<EvalMatrixCell>;
 };
-export declare function defineEvalMatrix<const T extends EvalMatrixDefinition>(definition: T): EvalMatrix & T;
+export declare function defineEvalMatrix<const T extends EvalMatrixDefinition>(input: T): EvalMatrix & T;
 //#endregion
 //#region ../core/src/config.d.ts
 type EvalkitConfig = {
@@ -342,6 +757,24 @@ type EvalkitConfig = {
     repeat?: number;
     maxCells?: number;
   };
+  /**
+   * What each run may use before EvalKit stops it: `{ steps: 40, tokens:
+   * 2_000_000, time: '20m' }`. A scenario's `limits`, a matrix cell's and
+   * `--limit` override these, kind by kind.
+   */
+  limits?: LimitsInput;
+  /**
+   * Where each run's processes run: `none()` (the default, on the host),
+   * `container({ image, network })` or `sandboxExec({ allow })`. Adapters
+   * and scorers run commands through `context.shell`, which puts them there.
+   */
+  isolation?: Isolation;
+  /**
+   * Services runs reach, by name: started on the host before the first run
+   * that needs them and stopped after the invocation's last. Each run finds
+   * them in `context.fixtures`.
+   */
+  fixtures?: Readonly<Record<string, Fixture>>;
   reportDir?: string;
   /** The candidate files saved with each run's results. */
   artifacts?: {
@@ -355,11 +788,21 @@ type EvalkitConfig = {
     /** Limits for files adapters `attach()`. */
     attachments?: AttachmentLimits;
   };
-  /** Where each run's real workspace lives during a run. Default `_evalkit-sandbox`. */
+  /**
+   * Where each run's real workspace lives. Default: outside the project, in
+   * `<tmp>/evalkit/<project>-<hash>`, so agents cannot read the project or
+   * other runs by looking around. Inside the project, `run` warns.
+   */
   sandboxDir?: string;
   /** Which run workspaces to keep in `sandboxDir` afterwards. Default `'failed'`: only runs that did not pass. */
   keepSandboxes?: KeepSandboxes;
   share?: ShareConfig;
+  /**
+   * The agent for every judge that names none: `judge(name, { rubric })`.
+   * Made with `defineAgent()`; it gets each run's parameters, so a matrix
+   * axis can choose its model.
+   */
+  judge?: AutAdapter;
 };
 type KeepSandboxes = 'failed' | 'all' | 'none';
 type AttachmentLimits = {
@@ -386,32 +829,6 @@ type ShareConfig = {
 /** Pure, typed project configuration. Loading/discovery belongs to the CLI. */
 export declare function defineConfig<const T extends EvalkitConfig>(configuration: T): T;
 //#endregion
-//#region ../core/src/usage.d.ts
-/**
- * Token usage an agent reports for one turn. EvalKit never measures or infers
- * it; adapters copy it from their provider.
- */
-type Usage = {
-  /**
-   * Every input token the model read this turn: the prompt, history and tool
-   * results, **including** tokens read from or written to a prompt cache.
-   * (Some providers report cached tokens separately; add them in.)
-   */
-  inputTokens?: number;
-  /** Every token the model produced, including reasoning tokens. */
-  outputTokens?: number;
-  /** Of `inputTokens`, how many were read from a prompt cache. Informational. */
-  cachedInputTokens?: number;
-  /** The provider's own total; used only when input and output are not reported. */
-  totalTokens?: number;
-};
-/**
- * The tokens a turn counts toward the `tokens` metric: `inputTokens +
- * outputTokens` (cached input included), or `totalTokens` when neither is
- * reported. Undefined when the turn reported no usage.
- */
-export declare function turnTokens(usage: Usage | undefined): number | undefined;
-//#endregion
 //#region ../core/src/json.d.ts
 /** A value that cannot be stored in a report, with the path of the offending part. */
 export declare class NotJsonError extends Error {
@@ -448,9 +865,9 @@ export declare function definitionSite(value: unknown): DefinitionSite | undefin
 //#endregion
 //#region ../core/src/schema.d.ts
 /** Runtime schemas for serialized EvalKit report and API boundaries. */
-export declare const RunStatusSchema: Schema.Literal<["running", "passed", "failed", "errored", "cancelled"]>;
+export declare const RunStatusSchema: Schema.Literal<["running", "passed", "failed", "errored", "cancelled", "limited"]>;
 /** The report schema version this EvalKit writes and reads. */
-export declare const REPORT_SCHEMA_VERSION = 6;
+export declare const REPORT_SCHEMA_VERSION = 7;
 export declare const RecordedErrorSchema: Schema.Struct<{
   name: typeof Schema.String;
   message: typeof Schema.String;
@@ -488,8 +905,25 @@ export declare const RunDatasetSchema: Schema.Struct<{
   source: Schema.Literal<["static", "computed"]>;
   digest: typeof Schema.String;
 }>;
+export declare const LimitsSchema: Schema.Struct<{
+  steps: Schema.optional<typeof Schema.Number>;
+  tokens: Schema.optional<typeof Schema.Number>;
+  time: Schema.optional<typeof Schema.Number>;
+}>;
+export declare const LimitReachedSchema: Schema.Struct<{
+  limit: Schema.Literal<["steps", "tokens", "time"]>;
+  value: typeof Schema.Number;
+  used: typeof Schema.Number;
+}>;
+export declare const RunIsolationSchema: Schema.Union<[Schema.Struct<{
+  kind: Schema.Literal<["container"]>;
+  image: typeof Schema.String;
+  network: Schema.Literal<["none", "fixtures", "full"]>;
+}>, Schema.Struct<{
+  kind: Schema.Literal<["sandbox-exec"]>;
+}>]>;
 export declare const RunMetadataSchema: Schema.Struct<{
-  schemaVersion: Schema.Literal<[6]>;
+  schemaVersion: Schema.Literal<[7]>;
   runUri: Schema.filter<typeof Schema.String>;
   evalId: typeof Schema.String;
   suiteId: Schema.optional<typeof Schema.String>;
@@ -536,10 +970,22 @@ export declare const RunMetadataSchema: Schema.Struct<{
     source: Schema.Literal<["static", "computed"]>;
     digest: typeof Schema.String;
   }>>>>;
+  limits: Schema.optional<Schema.Struct<{
+    steps: Schema.optional<typeof Schema.Number>;
+    tokens: Schema.optional<typeof Schema.Number>;
+    time: Schema.optional<typeof Schema.Number>;
+  }>>;
+  isolation: Schema.optional<Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["container"]>;
+    image: typeof Schema.String;
+    network: Schema.Literal<["none", "fixtures", "full"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["sandbox-exec"]>;
+  }>]>>;
 }>;
 /** On-disk manifests include a lifecycle status. */
 export declare const RunManifestSchema: Schema.Struct<{
-  schemaVersion: Schema.Literal<[6]>;
+  schemaVersion: Schema.Literal<[7]>;
   runUri: Schema.filter<typeof Schema.String>;
   evalId: typeof Schema.String;
   suiteId: Schema.optional<typeof Schema.String>;
@@ -585,14 +1031,42 @@ export declare const RunManifestSchema: Schema.Struct<{
     source: Schema.Literal<["static", "computed"]>;
     digest: typeof Schema.String;
   }>>>>;
-  status: Schema.optional<Schema.Literal<["running", "passed", "failed", "errored", "cancelled"]>>;
+  limits: Schema.optional<Schema.Struct<{
+    steps: Schema.optional<typeof Schema.Number>;
+    tokens: Schema.optional<typeof Schema.Number>;
+    time: Schema.optional<typeof Schema.Number>;
+  }>>;
+  isolation: Schema.optional<Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["container"]>;
+    image: typeof Schema.String;
+    network: Schema.Literal<["none", "fixtures", "full"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["sandbox-exec"]>;
+  }>]>>;
+  status: Schema.optional<Schema.Literal<["running", "passed", "failed", "errored", "cancelled", "limited"]>>;
 }>;
+/** ATXF usage: disjoint buckets, `input` without cached tokens. */
 export declare const UsageSchema: Schema.Struct<{
-  inputTokens: Schema.optional<typeof Schema.Number>;
-  outputTokens: Schema.optional<typeof Schema.Number>;
-  cachedInputTokens: Schema.optional<typeof Schema.Number>;
-  totalTokens: Schema.optional<typeof Schema.Number>;
+  input: typeof Schema.Number;
+  output: typeof Schema.Number;
+  cacheRead: Schema.optional<typeof Schema.Number>;
+  cacheWrite: Schema.optional<typeof Schema.Number>;
+  reasoning: Schema.optional<typeof Schema.Number>;
+  total: Schema.optional<typeof Schema.Number>;
+  cost: Schema.optional<Schema.Struct<{
+    currency: Schema.optional<typeof Schema.String>;
+    input: Schema.optional<typeof Schema.Number>;
+    output: Schema.optional<typeof Schema.Number>;
+    cacheRead: Schema.optional<typeof Schema.Number>;
+    cacheWrite: Schema.optional<typeof Schema.Number>;
+    total: typeof Schema.Number;
+  }>>;
 }>;
+/**
+ * An ATXF transcript in JSON (`{ header, records }`). Its records are checked
+ * by the ATXF validator where they are written, not here.
+ */
+export declare const TranscriptSchema: Schema.declare<Transcript, Transcript, readonly [], never>;
 export declare const JudgeRunInfoSchema: Schema.Struct<{
   agent: Schema.optional<Schema.Struct<{
     id: typeof Schema.String;
@@ -600,15 +1074,45 @@ export declare const JudgeRunInfoSchema: Schema.Struct<{
     name: Schema.optional<typeof Schema.String>;
     version: Schema.optional<typeof Schema.String>;
   }>>;
+  model: Schema.optional<typeof Schema.String>;
   usage: Schema.optional<Schema.Struct<{
-    inputTokens: Schema.optional<typeof Schema.Number>;
-    outputTokens: Schema.optional<typeof Schema.Number>;
-    cachedInputTokens: Schema.optional<typeof Schema.Number>;
-    totalTokens: Schema.optional<typeof Schema.Number>;
+    input: typeof Schema.Number;
+    output: typeof Schema.Number;
+    cacheRead: Schema.optional<typeof Schema.Number>;
+    cacheWrite: Schema.optional<typeof Schema.Number>;
+    reasoning: Schema.optional<typeof Schema.Number>;
+    total: Schema.optional<typeof Schema.Number>;
+    cost: Schema.optional<Schema.Struct<{
+      currency: Schema.optional<typeof Schema.String>;
+      input: Schema.optional<typeof Schema.Number>;
+      output: Schema.optional<typeof Schema.Number>;
+      cacheRead: Schema.optional<typeof Schema.Number>;
+      cacheWrite: Schema.optional<typeof Schema.Number>;
+      total: typeof Schema.Number;
+    }>>;
   }>>;
-  events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+  prompt: Schema.optional<typeof Schema.String>;
+  reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+  attempts: Schema.optional<typeof Schema.Number>;
+  /** The judge's own session, an ATXF transcript (checked when written). */
+  transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
 }>;
 export declare const ScoreResultSchema: Schema.Struct<{
+  passAt: Schema.optional<typeof Schema.Number>;
+  choice: Schema.optional<typeof Schema.String>;
+  criteria: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.Struct<{
+    name: typeof Schema.String;
+    value: typeof Schema.Number;
+    weight: Schema.optional<typeof Schema.Number>;
+    explanation: Schema.optional<typeof Schema.String>;
+    evidence: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+  }>, Schema.Struct<{
+    name: typeof Schema.String;
+    reached: Schema.Literal<[false]>;
+    weight: Schema.optional<typeof Schema.Number>;
+    explanation: Schema.optional<typeof Schema.String>;
+  }>]>>>>;
+  attachments: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
   name: typeof Schema.String;
   kind: Schema.Literal<["predicate", "judge"]>;
   value: Schema.optional<typeof Schema.Number>;
@@ -622,13 +1126,28 @@ export declare const ScoreResultSchema: Schema.Struct<{
       name: Schema.optional<typeof Schema.String>;
       version: Schema.optional<typeof Schema.String>;
     }>>;
+    model: Schema.optional<typeof Schema.String>;
     usage: Schema.optional<Schema.Struct<{
-      inputTokens: Schema.optional<typeof Schema.Number>;
-      outputTokens: Schema.optional<typeof Schema.Number>;
-      cachedInputTokens: Schema.optional<typeof Schema.Number>;
-      totalTokens: Schema.optional<typeof Schema.Number>;
+      input: typeof Schema.Number;
+      output: typeof Schema.Number;
+      cacheRead: Schema.optional<typeof Schema.Number>;
+      cacheWrite: Schema.optional<typeof Schema.Number>;
+      reasoning: Schema.optional<typeof Schema.Number>;
+      total: Schema.optional<typeof Schema.Number>;
+      cost: Schema.optional<Schema.Struct<{
+        currency: Schema.optional<typeof Schema.String>;
+        input: Schema.optional<typeof Schema.Number>;
+        output: Schema.optional<typeof Schema.Number>;
+        cacheRead: Schema.optional<typeof Schema.Number>;
+        cacheWrite: Schema.optional<typeof Schema.Number>;
+        total: typeof Schema.Number;
+      }>>;
     }>>;
-    events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+    prompt: Schema.optional<typeof Schema.String>;
+    reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    attempts: Schema.optional<typeof Schema.Number>;
+    /** The judge's own session, an ATXF transcript (checked when written). */
+    transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
   }>>;
   durationMs: typeof Schema.Number;
   error: Schema.optional<Schema.Struct<{
@@ -639,6 +1158,21 @@ export declare const ScoreResultSchema: Schema.Struct<{
   skipped: Schema.optional<Schema.Literal<[true]>>;
 }>;
 export declare const CheckpointResultSchema: Schema.Struct<{
+  passAt: Schema.optional<typeof Schema.Number>;
+  choice: Schema.optional<typeof Schema.String>;
+  criteria: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.Struct<{
+    name: typeof Schema.String;
+    value: typeof Schema.Number;
+    weight: Schema.optional<typeof Schema.Number>;
+    explanation: Schema.optional<typeof Schema.String>;
+    evidence: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+  }>, Schema.Struct<{
+    name: typeof Schema.String;
+    reached: Schema.Literal<[false]>;
+    weight: Schema.optional<typeof Schema.Number>;
+    explanation: Schema.optional<typeof Schema.String>;
+  }>]>>>>;
+  attachments: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
   step: typeof Schema.Number;
   kind: Schema.Literal<["predicate", "judge", "expect-tool-call"]>;
   name: typeof Schema.String;
@@ -654,13 +1188,28 @@ export declare const CheckpointResultSchema: Schema.Struct<{
       name: Schema.optional<typeof Schema.String>;
       version: Schema.optional<typeof Schema.String>;
     }>>;
+    model: Schema.optional<typeof Schema.String>;
     usage: Schema.optional<Schema.Struct<{
-      inputTokens: Schema.optional<typeof Schema.Number>;
-      outputTokens: Schema.optional<typeof Schema.Number>;
-      cachedInputTokens: Schema.optional<typeof Schema.Number>;
-      totalTokens: Schema.optional<typeof Schema.Number>;
+      input: typeof Schema.Number;
+      output: typeof Schema.Number;
+      cacheRead: Schema.optional<typeof Schema.Number>;
+      cacheWrite: Schema.optional<typeof Schema.Number>;
+      reasoning: Schema.optional<typeof Schema.Number>;
+      total: Schema.optional<typeof Schema.Number>;
+      cost: Schema.optional<Schema.Struct<{
+        currency: Schema.optional<typeof Schema.String>;
+        input: Schema.optional<typeof Schema.Number>;
+        output: Schema.optional<typeof Schema.Number>;
+        cacheRead: Schema.optional<typeof Schema.Number>;
+        cacheWrite: Schema.optional<typeof Schema.Number>;
+        total: typeof Schema.Number;
+      }>>;
     }>>;
-    events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+    prompt: Schema.optional<typeof Schema.String>;
+    reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    attempts: Schema.optional<typeof Schema.Number>;
+    /** The judge's own session, an ATXF transcript (checked when written). */
+    transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
   }>>;
   durationMs: Schema.optional<typeof Schema.Number>;
   error: Schema.optional<Schema.Struct<{
@@ -669,7 +1218,7 @@ export declare const CheckpointResultSchema: Schema.Struct<{
     stack: Schema.optional<typeof Schema.String>;
   }>>;
   matchedToolCall: Schema.optional<Schema.Struct<{
-    eventIndex: typeof Schema.Number;
+    messageId: typeof Schema.String;
     id: typeof Schema.String;
   }>>;
 }>;
@@ -687,6 +1236,21 @@ export declare const MetricResultSchema: Schema.Struct<{
 }>;
 export declare const RunScoringSchema: Schema.Struct<{
   results: Schema.mutable<Schema.Array$<Schema.Struct<{
+    passAt: Schema.optional<typeof Schema.Number>;
+    choice: Schema.optional<typeof Schema.String>;
+    criteria: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.Struct<{
+      name: typeof Schema.String;
+      value: typeof Schema.Number;
+      weight: Schema.optional<typeof Schema.Number>;
+      explanation: Schema.optional<typeof Schema.String>;
+      evidence: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>, Schema.Struct<{
+      name: typeof Schema.String;
+      reached: Schema.Literal<[false]>;
+      weight: Schema.optional<typeof Schema.Number>;
+      explanation: Schema.optional<typeof Schema.String>;
+    }>]>>>>;
+    attachments: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
     name: typeof Schema.String;
     kind: Schema.Literal<["predicate", "judge"]>;
     value: Schema.optional<typeof Schema.Number>;
@@ -700,13 +1264,28 @@ export declare const RunScoringSchema: Schema.Struct<{
         name: Schema.optional<typeof Schema.String>;
         version: Schema.optional<typeof Schema.String>;
       }>>;
+      model: Schema.optional<typeof Schema.String>;
       usage: Schema.optional<Schema.Struct<{
-        inputTokens: Schema.optional<typeof Schema.Number>;
-        outputTokens: Schema.optional<typeof Schema.Number>;
-        cachedInputTokens: Schema.optional<typeof Schema.Number>;
-        totalTokens: Schema.optional<typeof Schema.Number>;
+        input: typeof Schema.Number;
+        output: typeof Schema.Number;
+        cacheRead: Schema.optional<typeof Schema.Number>;
+        cacheWrite: Schema.optional<typeof Schema.Number>;
+        reasoning: Schema.optional<typeof Schema.Number>;
+        total: Schema.optional<typeof Schema.Number>;
+        cost: Schema.optional<Schema.Struct<{
+          currency: Schema.optional<typeof Schema.String>;
+          input: Schema.optional<typeof Schema.Number>;
+          output: Schema.optional<typeof Schema.Number>;
+          cacheRead: Schema.optional<typeof Schema.Number>;
+          cacheWrite: Schema.optional<typeof Schema.Number>;
+          total: typeof Schema.Number;
+        }>>;
       }>>;
-      events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+      prompt: Schema.optional<typeof Schema.String>;
+      reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+      attempts: Schema.optional<typeof Schema.Number>;
+      /** The judge's own session, an ATXF transcript (checked when written). */
+      transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
     }>>;
     durationMs: typeof Schema.Number;
     error: Schema.optional<Schema.Struct<{
@@ -729,6 +1308,21 @@ export declare const RunScoringSchema: Schema.Struct<{
     }>>;
   }>>>>;
   checkpoints: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
+    passAt: Schema.optional<typeof Schema.Number>;
+    choice: Schema.optional<typeof Schema.String>;
+    criteria: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.Struct<{
+      name: typeof Schema.String;
+      value: typeof Schema.Number;
+      weight: Schema.optional<typeof Schema.Number>;
+      explanation: Schema.optional<typeof Schema.String>;
+      evidence: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>, Schema.Struct<{
+      name: typeof Schema.String;
+      reached: Schema.Literal<[false]>;
+      weight: Schema.optional<typeof Schema.Number>;
+      explanation: Schema.optional<typeof Schema.String>;
+    }>]>>>>;
+    attachments: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
     step: typeof Schema.Number;
     kind: Schema.Literal<["predicate", "judge", "expect-tool-call"]>;
     name: typeof Schema.String;
@@ -744,13 +1338,28 @@ export declare const RunScoringSchema: Schema.Struct<{
         name: Schema.optional<typeof Schema.String>;
         version: Schema.optional<typeof Schema.String>;
       }>>;
+      model: Schema.optional<typeof Schema.String>;
       usage: Schema.optional<Schema.Struct<{
-        inputTokens: Schema.optional<typeof Schema.Number>;
-        outputTokens: Schema.optional<typeof Schema.Number>;
-        cachedInputTokens: Schema.optional<typeof Schema.Number>;
-        totalTokens: Schema.optional<typeof Schema.Number>;
+        input: typeof Schema.Number;
+        output: typeof Schema.Number;
+        cacheRead: Schema.optional<typeof Schema.Number>;
+        cacheWrite: Schema.optional<typeof Schema.Number>;
+        reasoning: Schema.optional<typeof Schema.Number>;
+        total: Schema.optional<typeof Schema.Number>;
+        cost: Schema.optional<Schema.Struct<{
+          currency: Schema.optional<typeof Schema.String>;
+          input: Schema.optional<typeof Schema.Number>;
+          output: Schema.optional<typeof Schema.Number>;
+          cacheRead: Schema.optional<typeof Schema.Number>;
+          cacheWrite: Schema.optional<typeof Schema.Number>;
+          total: typeof Schema.Number;
+        }>>;
       }>>;
-      events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+      prompt: Schema.optional<typeof Schema.String>;
+      reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+      attempts: Schema.optional<typeof Schema.Number>;
+      /** The judge's own session, an ATXF transcript (checked when written). */
+      transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
     }>>;
     durationMs: Schema.optional<typeof Schema.Number>;
     error: Schema.optional<Schema.Struct<{
@@ -759,7 +1368,7 @@ export declare const RunScoringSchema: Schema.Struct<{
       stack: Schema.optional<typeof Schema.String>;
     }>>;
     matchedToolCall: Schema.optional<Schema.Struct<{
-      eventIndex: typeof Schema.Number;
+      messageId: typeof Schema.String;
       id: typeof Schema.String;
     }>>;
   }>>>>;
@@ -778,11 +1387,26 @@ export declare const AttachmentEntrySchema: Schema.Struct<{
   truncatedFrom: Schema.optional<typeof Schema.Number>;
 }>;
 export declare const RunSummarySchema: Schema.Struct<{
-  status: Schema.Literal<["running", "passed", "failed", "errored", "cancelled"]>;
+  status: Schema.Literal<["running", "passed", "failed", "errored", "cancelled", "limited"]>;
   endedAt: typeof Schema.String;
   durationMs: Schema.optional<typeof Schema.Number>;
   scoring: Schema.optional<Schema.Struct<{
     results: Schema.mutable<Schema.Array$<Schema.Struct<{
+      passAt: Schema.optional<typeof Schema.Number>;
+      choice: Schema.optional<typeof Schema.String>;
+      criteria: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.Struct<{
+        name: typeof Schema.String;
+        value: typeof Schema.Number;
+        weight: Schema.optional<typeof Schema.Number>;
+        explanation: Schema.optional<typeof Schema.String>;
+        evidence: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+      }>, Schema.Struct<{
+        name: typeof Schema.String;
+        reached: Schema.Literal<[false]>;
+        weight: Schema.optional<typeof Schema.Number>;
+        explanation: Schema.optional<typeof Schema.String>;
+      }>]>>>>;
+      attachments: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
       name: typeof Schema.String;
       kind: Schema.Literal<["predicate", "judge"]>;
       value: Schema.optional<typeof Schema.Number>;
@@ -796,13 +1420,28 @@ export declare const RunSummarySchema: Schema.Struct<{
           name: Schema.optional<typeof Schema.String>;
           version: Schema.optional<typeof Schema.String>;
         }>>;
+        model: Schema.optional<typeof Schema.String>;
         usage: Schema.optional<Schema.Struct<{
-          inputTokens: Schema.optional<typeof Schema.Number>;
-          outputTokens: Schema.optional<typeof Schema.Number>;
-          cachedInputTokens: Schema.optional<typeof Schema.Number>;
-          totalTokens: Schema.optional<typeof Schema.Number>;
+          input: typeof Schema.Number;
+          output: typeof Schema.Number;
+          cacheRead: Schema.optional<typeof Schema.Number>;
+          cacheWrite: Schema.optional<typeof Schema.Number>;
+          reasoning: Schema.optional<typeof Schema.Number>;
+          total: Schema.optional<typeof Schema.Number>;
+          cost: Schema.optional<Schema.Struct<{
+            currency: Schema.optional<typeof Schema.String>;
+            input: Schema.optional<typeof Schema.Number>;
+            output: Schema.optional<typeof Schema.Number>;
+            cacheRead: Schema.optional<typeof Schema.Number>;
+            cacheWrite: Schema.optional<typeof Schema.Number>;
+            total: typeof Schema.Number;
+          }>>;
         }>>;
-        events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+        prompt: Schema.optional<typeof Schema.String>;
+        reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        attempts: Schema.optional<typeof Schema.Number>;
+        /** The judge's own session, an ATXF transcript (checked when written). */
+        transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
       }>>;
       durationMs: typeof Schema.Number;
       error: Schema.optional<Schema.Struct<{
@@ -825,6 +1464,21 @@ export declare const RunSummarySchema: Schema.Struct<{
       }>>;
     }>>>>;
     checkpoints: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
+      passAt: Schema.optional<typeof Schema.Number>;
+      choice: Schema.optional<typeof Schema.String>;
+      criteria: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.Struct<{
+        name: typeof Schema.String;
+        value: typeof Schema.Number;
+        weight: Schema.optional<typeof Schema.Number>;
+        explanation: Schema.optional<typeof Schema.String>;
+        evidence: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+      }>, Schema.Struct<{
+        name: typeof Schema.String;
+        reached: Schema.Literal<[false]>;
+        weight: Schema.optional<typeof Schema.Number>;
+        explanation: Schema.optional<typeof Schema.String>;
+      }>]>>>>;
+      attachments: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
       step: typeof Schema.Number;
       kind: Schema.Literal<["predicate", "judge", "expect-tool-call"]>;
       name: typeof Schema.String;
@@ -840,13 +1494,28 @@ export declare const RunSummarySchema: Schema.Struct<{
           name: Schema.optional<typeof Schema.String>;
           version: Schema.optional<typeof Schema.String>;
         }>>;
+        model: Schema.optional<typeof Schema.String>;
         usage: Schema.optional<Schema.Struct<{
-          inputTokens: Schema.optional<typeof Schema.Number>;
-          outputTokens: Schema.optional<typeof Schema.Number>;
-          cachedInputTokens: Schema.optional<typeof Schema.Number>;
-          totalTokens: Schema.optional<typeof Schema.Number>;
+          input: typeof Schema.Number;
+          output: typeof Schema.Number;
+          cacheRead: Schema.optional<typeof Schema.Number>;
+          cacheWrite: Schema.optional<typeof Schema.Number>;
+          reasoning: Schema.optional<typeof Schema.Number>;
+          total: Schema.optional<typeof Schema.Number>;
+          cost: Schema.optional<Schema.Struct<{
+            currency: Schema.optional<typeof Schema.String>;
+            input: Schema.optional<typeof Schema.Number>;
+            output: Schema.optional<typeof Schema.Number>;
+            cacheRead: Schema.optional<typeof Schema.Number>;
+            cacheWrite: Schema.optional<typeof Schema.Number>;
+            total: typeof Schema.Number;
+          }>>;
         }>>;
-        events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+        prompt: Schema.optional<typeof Schema.String>;
+        reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        attempts: Schema.optional<typeof Schema.Number>;
+        /** The judge's own session, an ATXF transcript (checked when written). */
+        transcript: Schema.optional<Schema.declare<Transcript, Transcript, readonly [], never>>;
       }>>;
       durationMs: Schema.optional<typeof Schema.Number>;
       error: Schema.optional<Schema.Struct<{
@@ -855,7 +1524,7 @@ export declare const RunSummarySchema: Schema.Struct<{
         stack: Schema.optional<typeof Schema.String>;
       }>>;
       matchedToolCall: Schema.optional<Schema.Struct<{
-        eventIndex: typeof Schema.Number;
+        messageId: typeof Schema.String;
         id: typeof Schema.String;
       }>>;
     }>>>>;
@@ -878,17 +1547,18 @@ export declare const RunSummarySchema: Schema.Struct<{
     message: typeof Schema.String;
     stack: Schema.optional<typeof Schema.String>;
   }>>;
+  limit: Schema.optional<Schema.Struct<{
+    limit: Schema.Literal<["steps", "tokens", "time"]>;
+    value: typeof Schema.Number;
+    used: typeof Schema.Number;
+  }>>;
 }>;
-export declare const TrajectoryEventSchema: Schema.Schema<TrajectoryEvent>;
+export declare const RunEventSchema: Schema.Schema<RunEvent>;
 export declare const ApiErrorSchema: Schema.Struct<{
   error: typeof Schema.String;
   message: typeof Schema.String;
 }>;
 //#endregion
-//#region ../core/src/trajectory.d.ts
-/** Decode one private report's JSONL trajectory; reject malformed/non-event lines with their line number. */
-export declare function parseTrajectoryJsonl(contents: string): TrajectoryEvent[];
-//#endregion
 //#region ../core/src/index.d.ts
 export type JsonPrimitive = boolean | number | string | null;
 export type JsonValue = JsonPrimitive | JsonValue[] | {
@@ -919,45 +1589,6 @@ export type RecordedError = {
   message: string;
   stack?: string;
 };
-export type AutEvent = {
-  kind: 'started';
-  timestamp: string;
-} | {
-  kind: 'message';
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: JsonValue;
-  timestamp: string;
-} | {
-  kind: 'tool-call';
-  id: string;
-  name: string;
-  arguments: JsonValue;
-  timestamp: string;
-} | {
-  kind: 'tool-result';
-  id: string;
-  name?: string;
-  result: JsonValue;
-  timestamp: string;
-} | {
-  kind: 'turn-started';
-  turn: number;
-  timestamp: string;
-} | {
-  kind: 'turn-completed';
-  turn: number;
-  timestamp: string;
-  latencyMs?: number;
-  usage?: Usage;
-} | {
-  kind: 'completed';
-  output?: JsonValue;
-  timestamp: string;
-} | {
-  kind: 'error';
-  error: RecordedError;
-  timestamp: string;
-};
 export type RunnerEvent = {
   kind: 'run-started';
   timestamp: string;
@@ -1006,7 +1637,10 @@ export type RunnerEvent = {
   scorer: string;
   error: RecordedError;
   timestamp: string;
-} | {
+} | ({
+  kind: 'limit-reached';
+  timestamp: string;
+} & LimitReached) | {
   kind: 'run-completed';
   timestamp: string;
 } | {
@@ -1014,11 +1648,25 @@ export type RunnerEvent = {
   error: RecordedError;
   timestamp: string;
 };
-export type TrajectoryEvent = (AutEvent & {
-  source: 'aut';
-}) | (RunnerEvent & {
-  source: 'runner';
-});
+/**
+ * One of EvalKit's own events in `run-events.jsonl`. `at` is the ID of the
+ * transcript record it happened after (null before the first), which places
+ * it in the agent's transcript.
+ */
+/**
+ * What the dashboard shows of one run's session: the agent's transcript
+ * (null before its first line is written) and EvalKit's events, placed in
+ * it by `at`.
+ */
+export type RunTranscriptView = {
+  transcript: Transcript | null;
+  /** Sub-agent transcripts the run kept, by transcript ID. */
+  subagents: Record<string, Transcript>;
+  runEvents: RunEvent[];
+};
+export type RunEvent = RunnerEvent & {
+  at: string | null;
+};
 export type WorkspaceView = {
   /** Absolute path to this run-scoped workspace. Do not persist it in reports. */
   root: string;
@@ -1036,6 +1684,20 @@ export type AutContext = {
   runtime?: AgentRuntimeName;
   /** Values of the scenario's candidate datasets, by dataset ID. */
   data: JsonObject;
+  /**
+   * Aborts when the run hits a limit or is cancelled. Pass it to model calls
+   * and tool processes so they stop with the run.
+   */
+  signal: AbortSignal;
+  /** The limits in force for this run; see `limits` in the config. */
+  limits: Limits;
+  /**
+   * The run's shell: run the agent and its tools through it, so they run
+   * where the project's `isolation` puts them. Scorers get the same one.
+   */
+  shell: Shell;
+  /** The project's fixtures, as this run reaches them, by name. */
+  fixtures: Readonly<Record<string, FixtureAddress>>;
   /** Contains only resources visible to the AUT/model. */
   workspace: CandidateWorkspace;
   /** Private evaluator capability for trusted AUT adapters; never expose this to the model. */
@@ -1048,8 +1710,11 @@ export type AutAdapter<TMessage = string> = {
   start(options: {
     context: AutContext;
     runtime?: AgentRuntime;
-    /** Optional: stream events as they happen. Returning a turn result from `send` is enough for most agents. */
-    onEvent: (event: AutEventInput) => void | Promise<void>;
+    /**
+     * Where to record what the agent does, as ATXF. Optional: returning a
+     * turn result from `send` is enough for most agents.
+     */
+    transcript: TranscriptWriter;
     /**
      * Saves a file with the run's results, such as the agent's raw log,
      * whether or not its sandbox is kept. `name` is a relative path of
@@ -1098,19 +1763,15 @@ export type AgentStep = {
   kind: 'agent';
   expectation: JsonObject;
 };
+/** One user step and what the agent did in answer to it. */
 export type TurnView = {
   userStepIndex: number;
-  events: readonly (AutEvent & {
-    source: 'aut';
-  })[];
-  assistantMessages: readonly (Extract<AutEvent, {
-    kind: 'message';
-  }> & {
-    role: 'assistant';
-    source: 'aut';
-  })[];
+  /** The transcript records of this turn, on the active path, in order. */
+  records: readonly TreeRecord[];
+  assistantMessages: readonly AssistantMessage[];
   toolCalls: readonly {
-    eventIndex: number;
+    /** The assistant message holding the call. */
+    messageId: string;
     id: string;
     name: string;
     arguments: JsonValue;
@@ -1136,11 +1797,25 @@ export declare function expectToolCall(expected: ExpectToolCallStep['expected'])
  */
 export declare function user(message: UserStep['message']): UserStep;
 export declare function agent(expectation: JsonObject): AgentStep;
+/**
+ * What a judge saw and said. The built-in `judge()` records all of it; a
+ * predicate that calls a model itself can report `model`, `prompt` and
+ * `reply` so the dashboard shows them the same way.
+ */
 export type JudgeRunInfo = {
   agent?: AutIdentity;
+  /** The model the judge reported using, as `provider/id`. */
+  model?: string;
+  /** Tokens the judge used: never counted in the agent's `tokens`. */
   usage?: Usage;
-  /** Judge-agent observations; never attributed to the AUT trajectory. */
-  events?: JsonValue[];
+  /** The exact prompt the judge received. */
+  prompt?: string;
+  /** Its reply, as text or JSON. */
+  reply?: JsonValue;
+  /** 2 when its first reply was not in the format asked for and it was asked again. */
+  attempts?: number;
+  /** The judge's own session, as ATXF; never part of the agent's transcript. */
+  transcript?: Transcript;
 };
 /** A scorer's "does not apply" result; see `skip()`. */
 export type SkippedScore = {
@@ -1148,7 +1823,8 @@ export type SkippedScore = {
   reason: string;
 };
 export type ScoreValue<Evidence = unknown> = number | SkippedScore | {
-  value: number;
+  /** From 0 to 1. Without it, the weighted mean of `criteria`. */
+  value?: number;
   passed?: boolean;
   explanation?: string;
   /**
@@ -1156,7 +1832,12 @@ export type ScoreValue<Evidence = unknown> = number | SkippedScore | {
    * evidence reaches later scorers through `checkpoint(rule)`.
    */
   evidence?: Evidence;
-  /** Judge-agent evidence, never inferred from AUT usage. */
+  /**
+   * Per-criterion results, each shown on its own; see `CriterionResult`.
+   * Return `{ name, reached: false }` for a check that never ran.
+   */
+  criteria?: CriterionInput[];
+  /** What a model-backed scorer saw and said; never counted as AUT usage. */
   judge?: JudgeRunInfo;
 };
 /**
@@ -1169,8 +1850,15 @@ export type ScoreResult = {
   kind: 'predicate' | 'judge';
   value?: number;
   passed?: boolean;
+  /** The pass mark the value was held to (1 unless the rule set `passAt`). */
+  passAt?: number;
   explanation?: string;
   evidence?: JsonValue;
+  /** A `choices` judge's answer, such as `B`. */
+  choice?: string;
+  criteria?: CriterionResult[];
+  /** Files its scorer saved with `attach()`, by name. */
+  attachments?: string[];
   judge?: JudgeRunInfo;
   durationMs: number;
   error?: RecordedError;
@@ -1183,14 +1871,21 @@ export type ArtifactView = {
 };
 export type ScoringContext = {
   context: AutContext;
-  trajectory: {
-    events: readonly TrajectoryEvent[];
-  };
+  /**
+   * What the agent did, as an ATXF transcript: all of it for final scorers,
+   * up to this step for checkpoints. `messages(ctx)`, `toolCalls(ctx)` and
+   * `lastReply(ctx)` read it.
+   */
+  transcript: Transcript;
+  /** Sub-agent transcripts the agent kept, by transcript ID. */
+  subagents: Readonly<Record<string, Transcript>>;
+  /** EvalKit's events so far: steps, checkpoints and scorers. */
+  runEvents: readonly RunEvent[];
   artifacts: ArtifactView;
   /** Most recent completed turn; absent if no user message has been sent. */
   turn?: TurnView;
-  /** Content of the last assistant message of `turn`. */
-  output?: JsonValue;
+  /** The text of the last assistant message of `turn`. */
+  output?: string;
   /** Values of all the scenario's datasets (candidate and evaluator), by dataset ID. */
   data: JsonObject;
   /**
@@ -1225,21 +1920,60 @@ export type CheckpointOutcome<Evidence> = Omit<CheckpointResult, 'evidence'> & {
 export type PredicateScorer<Evidence = unknown> = {
   kind: 'predicate';
   name: string;
+  /** What it checks, in a sentence, shown wherever the scorer is. */
+  description?: string;
   supportsPartial?: boolean;
   /** A numeric result passes when it is at least this value. Default: only 1 passes. */
   passAt?: number;
+  /**
+   * The checks it reports, declared up front so they show before a run.
+   * A declared criterion it leaves out is recorded as not reached; one it
+   * did not declare is an error.
+   */
+  criteria?: JudgeCriterion[];
   run(context: ScoringContext): boolean | ScoreValue<Evidence> | Promise<boolean | ScoreValue<Evidence>>;
 };
+/** What a judge sees: one named input, read from the run. */
+export type JudgeInput = (scoring: ScoringContext) => JsonValue | undefined | Promise<JsonValue | undefined>;
+/**
+ * A rubric-graded scorer. EvalKit builds the prompt from the rubric, the
+ * inputs and the answer format, runs the judge agent, checks its answer
+ * (asking once more if it is not in the format asked for), and records
+ * what it saw and said.
+ */
 export type JudgeRule = {
   kind: 'judge';
   name: string;
   rubric: string;
+  /** What it checks, in a sentence, shown wherever the judge is. */
+  description?: string;
+  /**
+   * The agent that judges, made with `defineAgent()`. Default: `judge` in
+   * evalkit.config.ts. It gets the run's parameters, so a matrix axis can
+   * choose its model.
+   */
+  agent?: AutAdapter;
+  /**
+   * What the judge sees, by name. Default: `conversation` (this turn at a
+   * checkpoint, the whole run in final scoring) and `reply` (the last reply).
+   */
+  inputs?: Readonly<Record<string, JudgeInput>>;
+  /** How it answers. Default `verdict`: a value from 0 to 1 and a reason. */
+  answer: JudgeAnswer;
+  /** A value passes when it is at least this. Default: only 1 passes. */
+  passAt?: number;
   /** Run even when the scenario stopped early or execution failed. */
   supportsPartial?: boolean;
 };
 export type ScoringRule = PredicateScorer | JudgeRule;
 /** A scorer in code. Its `evidence` type carries through to `checkpoint(rule)`. */
-export declare function predicate<Evidence = unknown>(name: string, run: PredicateScorer<Evidence>['run'], options?: Pick<PredicateScorer, 'supportsPartial' | 'passAt'>): PredicateScorer<Evidence>;
+export declare function predicate<Evidence = unknown>(name: string, run: PredicateScorer<Evidence>['run'], options?: Pick<PredicateScorer, 'supportsPartial' | 'passAt' | 'description'> & {
+  /** The checks it reports by name: `{ 'cannot push': 'the share token gets 403' }` or `{ name: { weight, description } }`. */
+  criteria?: Record<string, string | number | {
+    weight?: number;
+    description?: string;
+  }>;
+}): PredicateScorer<Evidence>;
 /**
  * A number measured for every run, such as tokens, retries or web searches.
  * Metrics never decide pass or fail; they are averaged per run and shown on
@@ -1267,9 +2001,10 @@ export type MetricResult = {
   builtIn?: true;
   error?: RecordedError;
 };
-export declare function judge(name: string, options: Pick<JudgeRule, 'rubric' | 'supportsPartial'>): JudgeRule;
+export declare function judge(name: string, options: Omit<JudgeRule, 'kind' | 'name' | 'answer'> & {
+  answer?: JudgeAnswer;
+}): JudgeRule;
 export type EvalPolicy = {
-  timeoutMs?: number;
   /** Stop later transcript steps after a failed checkpoint assertion. Default false. */
   failfast?: boolean;
 };
@@ -1277,8 +2012,6 @@ export type EvalDefinition<TAgent extends AutAdapter = AutAdapter> = {
   id: string;
   name?: string;
   agent: TAgent;
-  /** Separate judge agent; its model and tools are never inherited from the AUT. */
-  judge?: AutAdapter;
   /** Data and files the scenario uses; each run gets its own copy. */
   datasets?: readonly Dataset[];
   transcript: TranscriptStep[];
@@ -1291,6 +2024,11 @@ export type EvalDefinition<TAgent extends AutAdapter = AutAdapter> = {
    * under identical conditions, to see how often it passes. Default 1.
    */
   repeat?: number;
+  /**
+   * What each run may use before EvalKit stops it: `{ steps: 40, time: '20m' }`.
+   * Over the project's `limits`; a matrix cell's and `--limit` come after.
+   */
+  limits?: LimitsInput;
   /** Any JSON-convertible object; converted when the eval is defined. */
   metadata?: Record<string, unknown>;
   workspace?: EvalWorkspace;
@@ -1308,6 +2046,10 @@ export type EvalWorkspace = {
   ignore?: readonly string[];
 };
 export declare function defineEval<const T extends EvalDefinition>(definition: T): T;
+/** A judge never grades with the agent it is judging. */
+export declare function assertJudgesIndependent(definition: Pick<EvalDefinition, 'agent' | 'transcript' | 'scoring'> & {
+  id: string;
+}, defaultJudge?: AutAdapter): void;
 export type EvalSuite<TEvals extends readonly EvalDefinition[] = readonly EvalDefinition[]> = {
   id: string;
   name?: string;
@@ -1347,9 +2089,11 @@ export type EvalSuiteMetadata = {
 export declare function registerEvals<const TRegistrations extends readonly EvalRegistration[]>(registrations: TRegistrations): EvalRegistry;
 /**
  * How a run ended: `passed` or `failed` by its scores, `errored` when it could
- * not finish (the agent, a dataset or EvalKit failed), `cancelled` by Ctrl+C.
+ * not finish (the agent, a dataset or EvalKit failed), `cancelled` by Ctrl+C,
+ * `limited` when it hit one of its limits (graded by scorers that support
+ * partial work, and never a pass).
  */
-export type RunStatus = 'running' | 'passed' | 'failed' | 'errored' | 'cancelled';
+export type RunStatus = 'running' | 'passed' | 'failed' | 'errored' | 'cancelled' | 'limited';
 /** Runs launched together as repeats of one configuration (`repeat`). */
 export type Batch = {
   id: string;
@@ -1391,7 +2135,7 @@ export type RunProcess = {
   hostname: string;
 };
 export type RunMetadata = {
-  schemaVersion: 6;
+  schemaVersion: 7;
   runId: string;
   runUri: ResourceUri<'run'>;
   evalId: string;
@@ -1412,6 +2156,18 @@ export type RunMetadata = {
   workspaceIgnore?: string[];
   /** The datasets this run used, with content digests. */
   datasets?: RunDataset[];
+  /** The limits in force. */
+  limits?: Limits;
+  /** Where its processes ran; absent for runs on the host. */
+  isolation?: RunIsolation;
+};
+/** A run's isolation as its manifest records it: no host paths, no environment. */
+export type RunIsolation = {
+  kind: 'container';
+  image: string;
+  network: ContainerNetwork;
+} | {
+  kind: 'sandbox-exec';
 };
 export type RunDataset = {
   id: string;
@@ -1427,13 +2183,19 @@ export type CheckpointResult = {
   status: 'passed' | 'failed' | 'error' | 'skipped';
   value?: number;
   passed?: boolean;
+  passAt?: number;
   explanation?: string;
   evidence?: JsonValue;
+  choice?: string;
+  criteria?: CriterionResult[];
+  /** Files its scorer saved with `attach()`, by name. */
+  attachments?: string[];
   judge?: JudgeRunInfo;
   durationMs?: number;
   error?: RecordedError;
+  /** The tool call it matched: the assistant message holding it, and the call's ID. */
   matchedToolCall?: {
-    eventIndex: number;
+    messageId: string;
     id: string;
   };
 };
@@ -1441,13 +2203,17 @@ export type CheckpointResult = {
  * Metrics EvalKit records for every run; scenario metrics may not reuse
  * these names.
  *
- * - `agent time` (ms): from the run's first event to its last one before
- *   final scoring.
- * - `tokens`: the sum of `turnTokens(usage)` over the turns that reported
- *   usage, cached input included. Absent when no turn reported any.
- * - `tool calls`: the agent's `tool-call` events.
+ * - `agent time` (ms): from the session's start to the end of its last turn.
+ * - `tokens`: uncached input, cache writes and output, summed over the
+ *   transcript (`uncachedTokens`). Absent when nothing reported usage.
+ * - `cached tokens`: input tokens read from a prompt cache.
+ * - `output tokens`: output, reasoning included.
+ * - `cache hit rate`: the share of input tokens read from a cache, 0 to 1.
+ * - `steps`: assistant messages, one per model call.
+ * - `tool calls`: tool calls in the transcript.
+ * - `judge tokens`: `tokens` over the judges' transcripts, never the agent's.
  */
-export declare const BUILT_IN_METRICS: readonly ['agent time', 'tokens', 'tool calls'];
+export declare const BUILT_IN_METRICS: readonly ['agent time', 'tokens', 'cached tokens', 'output tokens', 'cache hit rate', 'steps', 'tool calls', 'judge tokens'];
 export type BuiltInMetricName = (typeof BUILT_IN_METRICS)[number];
 /** A built-in metric's name (suggested by editors), or a scenario's own. */
 export type MetricName = BuiltInMetricName | (string & {});
@@ -1481,10 +2247,17 @@ export type RunSummary = {
   artifacts?: ArtifactEntry[];
   attachments?: AttachmentEntry[];
   error?: RecordedError;
+  /** The limit a `limited` run hit. */
+  limit?: LimitReached;
 };
 export type RunWriter = {
   readonly location: string;
-  appendEvent(event: TrajectoryEvent): Promise<void>;
+  /** Appends one of EvalKit's events to `run-events.jsonl`. */
+  appendEvent(event: RunEvent): Promise<void>;
+  /** Appends an ATXF record (the header first) to `transcript.atxf.jsonl`. */
+  appendTranscript(line: Transcript['header'] | Transcript['records'][number]): Promise<void>;
+  /** Writes a sub-agent's whole transcript (JSONL), replacing the one kept. */
+  writeSubagent(id: string, text: string): Promise<void>;
   writeScores(scoring: RunScoring): Promise<void>;
   /** Writes a file below this run's artifact root. */
   writeArtifact(path: string, data: Uint8Array): Promise<void>;
@@ -1506,17 +2279,165 @@ export type RunResult = {
   durationMs?: number;
   scoring?: RunScoring;
   error?: RecordedError;
+  /** The limit a `limited` run hit. */
+  limit?: LimitReached;
 };
 export declare function recordError(error: unknown): RecordedError;
+/** Messages on the active path of what the agent did, optionally of one role. */
+export declare function messages(scoring: Pick<ScoringContext, 'transcript'>, role?: MessageRecord['role']): Message[];
+/** A message as scorers see it: who said it and its text, with the ATXF record for the rest. */
+export type Message = {
+  id: string;
+  role: MessageRecord['role'];
+  /** Its text blocks, joined; tool calls and images are left out. */
+  text: string;
+  time: string;
+  record: MessageRecord;
+};
+/** The agent's tool calls, in order, each with its result when recorded; optionally of one tool. */
+export declare function toolCalls(scoring: Pick<ScoringContext, 'transcript'>, name?: string): ToolCall[];
+/** The text of the agent's last reply, or `''`. */
+export declare function lastReply(scoring: Pick<ScoringContext, 'transcript'>): string;
+/** Everything the agent's transcript reported using; undefined when nothing reported usage. */
+export declare function usage(scoring: Pick<ScoringContext, 'transcript'>): Usage | undefined;
+/**
+ * What the model saw at the end of the agent's transcript, rebuilt by ATXF
+ * (compactions and context edits applied): its instructions, tools and
+ * messages.
+ */
+export declare function modelContext(scoring: Pick<ScoringContext, 'transcript'>): ModelContext$1;
 //#endregion
-//#region ../agents/src/index.d.ts
-type PiAutOptions = {
+//#region ../agents/src/harness.d.ts
+/** Options every coding-agent harness takes. */
+type HarnessOptions = {
+  /** The CLI to run; defaults to the harness's own name (`pi`, `codex`, …). */
   command?: string;
-  /** Additional non-secret Pi arguments, such as an explicit model selection. */
-  args?: string[];
+  /**
+   * The model, in the CLI's own syntax (`--model`), or a function of the
+   * run's parameters for a matrix: `({ model }) => String(model)`.
+   */
+  model?: string | ((parameters: JsonObject) => string | undefined);
+  /** More arguments for every turn, after EvalKit's own. */
+  args?: readonly string[];
+  /** Environment variables for the CLI, such as an API key or proxy settings. */
+  env?: Readonly<Record<string, string>>;
+  /**
+   * Which config the CLI reads. `'private'` (the default) points it at a
+   * new, empty config directory in the run's private home, so the person's
+   * extensions, skills, instructions and logins never reach the agent and
+   * every run starts the same; give it what it needs with `configFiles`
+   * and `env`. `'user'` uses the person's own config, which isolation
+   * usually hides: allow it with `sandboxExec({ read })`.
+   */
+  config?: 'private' | 'user';
+  /**
+   * Files to write into the private config directory before the first
+   * turn, by path relative to it (`'auth.json'`), such as a provider's
+   * settings. The agent can read them, so prefer credentials it cannot
+   * use elsewhere, or a proxy that adds them.
+   */
+  configFiles?: Readonly<Record<string, string | Uint8Array>>;
+};
+/** One turn's command line. */
+type HarnessTurn = {
+  /** The CLI, as configured. */
+  command: string;
+  /** The model for this run, if one was chosen. */
+  model: string | undefined;
+  /** The private config directory, or undefined with `config: 'user'`. */
+  configDir: string | undefined;
+  /** The run's directory for this harness's own files, as commands see it. */
+  stateDir: string;
+  /** The session to continue, or undefined on the first turn when the CLI picks it. */
+  session: string | undefined;
+  first: boolean;
+};
+/** What a harness needs to say about its CLI. */
+type HarnessSpec = {
+  id: string;
+  name: string;
+  command: string;
+  /** Environment variables that point the CLI at a private config directory. */
+  configEnv(configDir: string): Record<string, string>;
+  /** A session ID to start with, for CLIs that take one. */
+  newSession?(): string;
+  /** The command for one turn, starting with `turn.command`; the message goes on stdin. */
+  argv(turn: HarnessTurn): string[];
+  /** The session ID the CLI printed, for CLIs that pick their own. */
+  sessionFromOutput?(stdout: string): string | undefined;
+  /**
+   * A shell command that copies the session's native record to `target`;
+   * it runs where the CLI ran, with the same environment.
+   */
+  saveSession(options: HarnessTurn & {
+    session: string;
+    target: string;
+  }): string[];
+  /** The native record as an ATXF transcript. */
+  toAtxf(text: string): Transcript$1;
+};
+/**
+ * An adapter that runs a coding-agent CLI through `context.shell`, one
+ * non-interactive invocation per user message, continuing one session.
+ * After each turn it imports the CLI's own session record through ATXF,
+ * so the run's transcript has every message, tool call and token count.
+ */
+export declare function harnessAgent(spec: HarnessSpec, options: HarnessOptions): AutAdapter;
+//#endregion
+//#region ../agents/src/pi.d.ts
+type PiOptions = HarnessOptions & {
+  /** False runs Pi without tools (`--no-tools`), such as for a judge. */
+  tools?: boolean;
+  /** Skill files or directories to load (`--skill`), as paths commands see. */
+  skills?: readonly string[];
+  /** Text appended to Pi's system prompt (`--append-system-prompt`). */
+  appendSystemPrompt?: string;
+};
+/**
+ * Pi (https://pi.dev) as the agent under test: `pi --print` with its own
+ * tools, system prompt and context handling, one session per run. Its
+ * session file becomes the run's transcript.
+ */
+export declare function piAgent(options?: PiOptions): AutAdapter;
+//#endregion
+//#region ../agents/src/codex.d.ts
+type CodexOptions = HarnessOptions;
+/**
+ * Codex as the agent under test: `codex exec` with approvals and its own
+ * sandbox off (EvalKit's isolation is the sandbox; Codex's cannot nest in
+ * `sandboxExec()`), one session per run. Its rollout file becomes the
+ * run's transcript.
+ */
+export declare function codexAgent(options?: CodexOptions): AutAdapter;
+//#endregion
+//#region ../agents/src/opencode.d.ts
+type OpencodeOptions = HarnessOptions & {
+  /** The opencode agent to run (`--agent`), such as `build`. */
+  agent?: string;
+};
+/**
+ * opencode as the agent under test: `opencode run --standalone`, with a
+ * private server per command and permissions auto-approved, one session
+ * per run. Its session export becomes the run's transcript.
+ *
+ * With `config: 'private'`, opencode's config, data and state directories
+ * (`XDG_CONFIG_HOME`, `XDG_DATA_HOME`, `XDG_STATE_HOME`) are in the config
+ * directory: put `config/opencode/opencode.json` and
+ * `data/opencode/auth.json` in `configFiles`.
+ */
+export declare function opencodeAgent(options?: OpencodeOptions): AutAdapter;
+//#endregion
+//#region ../agents/src/claude-code.d.ts
+type ClaudeCodeOptions = HarnessOptions & {
+  /** Text appended to Claude Code's system prompt (`--append-system-prompt`). */
+  appendSystemPrompt?: string;
 };
-/** A local, one-prompt-per-turn AUT backed by Pi's non-interactive print mode. */
-export declare function piAgent(options?: PiAutOptions): AutAdapter;
+/**
+ * Claude Code as the agent under test: `claude -p` with every tool allowed
+ * (EvalKit's isolation is the sandbox), one session per run. Its session
+ * file becomes the run's transcript.
+ */
+export declare function claudeCodeAgent(options?: ClaudeCodeOptions): AutAdapter;
 //#endregion
-export type { AttachmentLimits, DefinitionSite, EvalMatrix, EvalMatrixCell, EvalkitConfig, KeepSandboxes, MatrixSelection, ShareConfig, ShareHeaders, Usage };
+export type { ATXF_VERSION, AssistantBlock, AssistantMessage, AttachmentLimits, ClaudeCodeOptions, CodexOptions, CriteriaOptions, CriterionInput, CriterionResult, DefinitionSite, EntryRecord, EvalMatrix, EvalMatrixCell, EvalkitConfig, HarnessOptions, HarnessSpec, HarnessTurn, JudgeAnswer, JudgeChoice, JudgeCriterion, KeepSandboxes, LIMIT_KINDS, LIMIT_PARAMETER_PREFIX, LimitKind, LimitReached, Limits, LimitsInput, MatrixSelection, MessageRecord, ModelContext, ModelRef, OpencodeOptions, PairedToolCall, PiOptions, ReachedCriterion, ShareConfig, ShareHeaders, ToolCall, ToolCallBlock, ToolMessage, Transcript, TranscriptHeader, TreeRecord, UnreachedCriterion, Usage, UsageInput, UserBlock, UserContent, activePath, callsIn, contentText, emptyTranscript, formatLimit, isTreeRecord, limitsFromParameters, modelName, parseDuration, parseLimitFlag, parseLimits, parseModel, resolveLimits, toolResultValue, transcriptMessages, transcriptReply, transcriptToolCalls };
 //# sourceMappingURL=index.d.mts.map