@leostera/evalkit 0.10.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,74 +110,379 @@ 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;
-  /** The model that answered this turn, when the agent knows it. */
-  model?: string;
-} | {
-  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;
-  /** The model that answered, recorded with the usage. */
-  model?: string;
+  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';
 };
-/** 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.
+ * What a run's container can reach: nothing, only the project's fixtures,
+ * or whatever the container runtime allows by default.
  */
-export declare function turnResultEvents(result: TurnResult, turn: number, now: () => Date): AutEvent[];
+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>;
+};
+/**
+ * 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 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
 /**
@@ -370,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;
@@ -411,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 = {
@@ -441,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?: {
@@ -495,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 {
@@ -557,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;
@@ -597,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>;
@@ -645,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>;
@@ -694,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;
@@ -711,15 +1076,26 @@ export declare const JudgeRunInfoSchema: Schema.Struct<{
   }>>;
   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;
+    }>>;
   }>>;
   prompt: Schema.optional<typeof Schema.String>;
   reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
   attempts: Schema.optional<typeof Schema.Number>;
-  events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+  /** 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>;
@@ -752,15 +1128,26 @@ export declare const ScoreResultSchema: Schema.Struct<{
     }>>;
     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;
+      }>>;
     }>>;
     prompt: Schema.optional<typeof Schema.String>;
     reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
     attempts: Schema.optional<typeof Schema.Number>;
-    events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+    /** 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<{
@@ -803,15 +1190,26 @@ export declare const CheckpointResultSchema: Schema.Struct<{
     }>>;
     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;
+      }>>;
     }>>;
     prompt: Schema.optional<typeof Schema.String>;
     reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
     attempts: Schema.optional<typeof Schema.Number>;
-    events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+    /** 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<{
@@ -820,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;
   }>>;
 }>;
@@ -868,15 +1266,26 @@ export declare const RunScoringSchema: Schema.Struct<{
       }>>;
       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;
+        }>>;
       }>>;
       prompt: Schema.optional<typeof Schema.String>;
       reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
       attempts: Schema.optional<typeof Schema.Number>;
-      events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+      /** 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<{
@@ -931,15 +1340,26 @@ export declare const RunScoringSchema: Schema.Struct<{
       }>>;
       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;
+        }>>;
       }>>;
       prompt: Schema.optional<typeof Schema.String>;
       reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
       attempts: Schema.optional<typeof Schema.Number>;
-      events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+      /** 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<{
@@ -948,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;
     }>>;
   }>>>>;
@@ -967,7 +1387,7 @@ 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<{
@@ -1002,15 +1422,26 @@ export declare const RunSummarySchema: Schema.Struct<{
         }>>;
         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;
+          }>>;
         }>>;
         prompt: Schema.optional<typeof Schema.String>;
         reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
         attempts: Schema.optional<typeof Schema.Number>;
-        events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+        /** 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<{
@@ -1065,15 +1496,26 @@ export declare const RunSummarySchema: Schema.Struct<{
         }>>;
         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;
+          }>>;
         }>>;
         prompt: Schema.optional<typeof Schema.String>;
         reply: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
         attempts: Schema.optional<typeof Schema.Number>;
-        events: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+        /** 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<{
@@ -1082,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;
       }>>;
     }>>>>;
@@ -1105,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[] | {
@@ -1146,47 +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;
-  /** The model that answered this turn, when the agent knows it. */
-  model?: string;
-} | {
-  kind: 'completed';
-  output?: JsonValue;
-  timestamp: string;
-} | {
-  kind: 'error';
-  error: RecordedError;
-  timestamp: string;
-};
 export type RunnerEvent = {
   kind: 'run-started';
   timestamp: string;
@@ -1235,7 +1637,10 @@ export type RunnerEvent = {
   scorer: string;
   error: RecordedError;
   timestamp: string;
-} | {
+} | ({
+  kind: 'limit-reached';
+  timestamp: string;
+} & LimitReached) | {
   kind: 'run-completed';
   timestamp: string;
 } | {
@@ -1243,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;
@@ -1265,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. */
@@ -1277,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
@@ -1327,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;
@@ -1372,7 +1804,7 @@ export declare function agent(expectation: JsonObject): AgentStep;
  */
 export type JudgeRunInfo = {
   agent?: AutIdentity;
-  /** The model the judge reported using (`turn-completed` `model`). */
+  /** The model the judge reported using, as `provider/id`. */
   model?: string;
   /** Tokens the judge used: never counted in the agent's `tokens`. */
   usage?: Usage;
@@ -1382,8 +1814,8 @@ export type JudgeRunInfo = {
   reply?: JsonValue;
   /** 2 when its first reply was not in the format asked for and it was asked again. */
   attempts?: number;
-  /** Judge-agent observations; never attributed to the AUT trajectory. */
-  events?: JsonValue[];
+  /** 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 = {
@@ -1439,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;
   /**
@@ -1566,7 +2005,6 @@ export declare function judge(name: string, options: Omit<JudgeRule, 'kind' | 'n
   answer?: JudgeAnswer;
 }): JudgeRule;
 export type EvalPolicy = {
-  timeoutMs?: number;
   /** Stop later transcript steps after a failed checkpoint assertion. Default false. */
   failfast?: boolean;
 };
@@ -1586,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;
@@ -1646,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;
@@ -1690,7 +2135,7 @@ export type RunProcess = {
   hostname: string;
 };
 export type RunMetadata = {
-  schemaVersion: 6;
+  schemaVersion: 7;
   runId: string;
   runUri: ResourceUri<'run'>;
   evalId: string;
@@ -1711,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;
@@ -1736,8 +2193,9 @@ export type CheckpointResult = {
   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;
   };
 };
@@ -1745,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', 'judge tokens'];
+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 & {});
@@ -1785,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>;
@@ -1810,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;
 };
-/** A local, one-prompt-per-turn AUT backed by Pi's non-interactive print mode. */
-export declare function piAgent(options?: PiAutOptions): AutAdapter;
+/**
+ * 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;
+};
+/**
+ * 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, CriteriaOptions, CriterionInput, CriterionResult, DefinitionSite, EvalMatrix, EvalMatrixCell, EvalkitConfig, JudgeAnswer, JudgeChoice, JudgeCriterion, KeepSandboxes, MatrixSelection, ReachedCriterion, ShareConfig, ShareHeaders, UnreachedCriterion, 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