@ls-stack/agent-eval 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,2043 @@
+import { z } from "zod/v4";
+
+//#region ../shared/src/schemas/display.d.ts
+declare const scalarCellSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+/** Primitive table cell value supported by the eval UI. */
+type ScalarCell = z.infer<typeof scalarCellSchema>;
+declare const jsonCellSchema: z.ZodType<string | number | boolean | null | Record<string, unknown> | unknown[]>;
+/** JSON-safe value supported by `format: 'json'` columns. */
+type JsonCell = z.infer<typeof jsonCellSchema>;
+declare const repoFileRefSchema: z.ZodObject<{
+  source: z.ZodLiteral<"repo">;
+  path: z.ZodString;
+  mimeType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Reference to a file that lives in the authored workspace. */
+type RepoFileRef = z.infer<typeof repoFileRefSchema>;
+declare const runArtifactRefSchema: z.ZodObject<{
+  source: z.ZodLiteral<"run">;
+  artifactId: z.ZodString;
+  mimeType: z.ZodString;
+  fileName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Reference to a generated artifact stored under a specific run. */
+type RunArtifactRef = z.infer<typeof runArtifactRefSchema>;
+declare const fileRefSchema: z.ZodUnion<readonly [z.ZodObject<{
+  source: z.ZodLiteral<"repo">;
+  path: z.ZodString;
+  mimeType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  source: z.ZodLiteral<"run">;
+  artifactId: z.ZodString;
+  mimeType: z.ZodString;
+  fileName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+/** File reference supported by media and file columns. */
+type FileRef = z.infer<typeof fileRefSchema>;
+/** Numeric presentation options for values rendered with `format: 'number'`. */
+type NumberDisplayOptions = {
+  /** Number notation used when rendering the value. */notation?: 'standard' | 'compact'; /** Compact style used when `notation: 'compact'` is enabled. */
+  compactDisplay?: 'short' | 'long'; /** String prepended to the rendered number, such as `$`. */
+  prefix?: string; /** String appended to the rendered number, such as ` ms`. */
+  suffix?: string; /** Fixed number of decimal places to render. */
+  decimalPlaces?: number;
+};
+/** Schema for numeric presentation options used by number-formatted values. */
+declare const numberDisplayOptionsSchema: z.ZodType<NumberDisplayOptions>;
+/** Schema for the supported column rendering kinds in list views. */
+declare const columnKindSchema: z.ZodEnum<{
+  string: "string";
+  number: "number";
+  boolean: "boolean";
+}>;
+/** Display kind used by a column definition in the UI. */
+type ColumnKind = z.infer<typeof columnKindSchema>;
+/** Schema for the built-in column formatting presets. */
+declare const columnFormatSchema: z.ZodEnum<{
+  number: "number";
+  boolean: "boolean";
+  file: "file";
+  markdown: "markdown";
+  json: "json";
+  image: "image";
+  audio: "audio";
+  video: "video";
+  duration: "duration";
+  percent: "percent";
+  passFail: "passFail";
+  stars: "stars";
+}>;
+/** Formatting preset applied to a column value in the UI. */
+type ColumnFormat = z.infer<typeof columnFormatSchema>;
+/** Schema describing a rendered column in the eval results table. */
+declare const columnDefSchema: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  kind: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+  }>;
+  format: z.ZodOptional<z.ZodEnum<{
+    number: "number";
+    boolean: "boolean";
+    file: "file";
+    markdown: "markdown";
+    json: "json";
+    image: "image";
+    audio: "audio";
+    video: "video";
+    duration: "duration";
+    percent: "percent";
+    passFail: "passFail";
+    stars: "stars";
+  }>>;
+  numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+  isScore: z.ZodOptional<z.ZodBoolean>;
+  isManualScore: z.ZodOptional<z.ZodBoolean>;
+  passThreshold: z.ZodOptional<z.ZodNumber>;
+  maxStars: z.ZodOptional<z.ZodNumber>;
+  hideInTable: z.ZodOptional<z.ZodBoolean>;
+  sortable: z.ZodOptional<z.ZodBoolean>;
+  align: z.ZodOptional<z.ZodEnum<{
+    left: "left";
+    center: "center";
+    right: "right";
+  }>>;
+}, z.core.$strip>;
+/** Column definition exposed to the UI for eval and case tables. */
+type ColumnDef = z.infer<typeof columnDefSchema>;
+/** Schema for any supported value that can populate a table cell. */
+declare const cellValueSchema: z.ZodUnion<readonly [z.ZodType<string | number | boolean | Record<string, unknown> | unknown[] | null, unknown, z.core.$ZodTypeInternals<string | number | boolean | Record<string, unknown> | unknown[] | null, unknown>>, z.ZodUnion<readonly [z.ZodObject<{
+  source: z.ZodLiteral<"repo">;
+  path: z.ZodString;
+  mimeType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  source: z.ZodLiteral<"run">;
+  artifactId: z.ZodString;
+  mimeType: z.ZodString;
+  fileName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>]>;
+/** Value stored in a rendered eval result table cell. */
+type CellValue = z.infer<typeof cellValueSchema>;
+//#endregion
+//#region ../shared/src/schemas/trace.d.ts
+/** Schema for the semantic categories used to classify trace spans. */
+declare const traceSpanKindSchema: z.ZodEnum<{
+  eval: "eval";
+  agent: "agent";
+  llm: "llm";
+  tool: "tool";
+  retrieval: "retrieval";
+  scorer: "scorer";
+  checkpoint: "checkpoint";
+  custom: "custom";
+}>;
+/** Semantic category used to classify a trace span in the UI. */
+type TraceSpanKind = z.infer<typeof traceSpanKindSchema>;
+/** Schema for the supported presentation formats of trace attributes. */
+declare const traceAttributeDisplayFormatSchema: z.ZodEnum<{
+  string: "string";
+  number: "number";
+  duration: "duration";
+  json: "json";
+}>;
+/**
+ * Formatting hint for trace attribute values rendered by the UI.
+ *
+ * This affects presentation only and does not change the stored value.
+ */
+type TraceAttributeDisplayFormat = z.infer<typeof traceAttributeDisplayFormatSchema>;
+/** Schema for the UI locations where a trace attribute can appear. */
+declare const traceAttributeDisplayPlacementSchema: z.ZodEnum<{
+  tree: "tree";
+  detail: "detail";
+  section: "section";
+}>;
+/** UI locations where a trace attribute may be rendered. */
+type TraceAttributeDisplayPlacement = z.infer<typeof traceAttributeDisplayPlacementSchema>;
+/** Schema for resolved trace display rules sent to the UI. */
+declare const traceAttributeDisplaySchema: z.ZodObject<{
+  key: z.ZodOptional<z.ZodString>;
+  path: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  format: z.ZodOptional<z.ZodEnum<{
+    string: "string";
+    number: "number";
+    duration: "duration";
+    json: "json";
+  }>>;
+  numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+  placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    tree: "tree";
+    detail: "detail";
+    section: "section";
+  }>>>;
+  scope: z.ZodOptional<z.ZodEnum<{
+    self: "self";
+    subtree: "subtree";
+  }>>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    all: "all";
+    last: "last";
+    sum: "sum";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Resolved trace display rule consumed by the UI.
+ *
+ * `path` points at the attribute to render on each span. `scope` and `mode`
+ * control whether the value comes from the current span only or from the full
+ * subtree, and how multiple matches are combined.
+ */
+type TraceAttributeDisplay = z.infer<typeof traceAttributeDisplaySchema>;
+/** Schema for trace display config after transforms have been resolved. */
+declare const traceDisplayConfigSchema: z.ZodObject<{
+  attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+      string: "string";
+      number: "number";
+      duration: "duration";
+      json: "json";
+    }>>;
+    numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+    placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      tree: "tree";
+      detail: "detail";
+      section: "section";
+    }>>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+      self: "self";
+      subtree: "subtree";
+    }>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+      all: "all";
+      last: "last";
+      sum: "sum";
+    }>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** UI-ready trace display configuration attached to case details. */
+type TraceDisplayConfig = z.infer<typeof traceDisplayConfigSchema>;
+/** Context passed to a `traceDisplay` transform while resolving a span value. */
+type TraceAttributeTransformContext = {
+  value: unknown;
+  span: EvalTraceSpan;
+};
+/**
+ * Runner-side transform used to derive a display value from a raw trace
+ * attribute.
+ */
+type TraceAttributeTransform = (ctx: TraceAttributeTransformContext) => unknown;
+/** Schema for authored trace display rules accepted from user config. */
+declare const traceAttributeDisplayInputSchema: z.ZodObject<{
+  key: z.ZodOptional<z.ZodString>;
+  path: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  format: z.ZodOptional<z.ZodEnum<{
+    string: "string";
+    number: "number";
+    duration: "duration";
+    json: "json";
+  }>>;
+  numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+  placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    tree: "tree";
+    detail: "detail";
+    section: "section";
+  }>>>;
+  scope: z.ZodOptional<z.ZodEnum<{
+    self: "self";
+    subtree: "subtree";
+  }>>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    all: "all";
+    last: "last";
+    sum: "sum";
+  }>>;
+  transform: z.ZodOptional<z.ZodCustom<TraceAttributeTransform, TraceAttributeTransform>>;
+}, z.core.$strip>;
+/**
+ * Authored trace display rule accepted in eval definitions and config files.
+ *
+ * `key` allows the same source `path` to be displayed multiple ways, such as
+ * raw and compact views of a single token count. `numberFormat` customizes
+ * `format: 'number'` values. `transform` runs in the
+ * runner before the UI receives the resolved trace payload.
+ */
+type TraceAttributeDisplayInput = z.infer<typeof traceAttributeDisplayInputSchema>;
+/** Schema for authored trace display config in eval or workspace config. */
+declare const traceDisplayInputConfigSchema: z.ZodObject<{
+  attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+      string: "string";
+      number: "number";
+      duration: "duration";
+      json: "json";
+    }>>;
+    numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+    placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      tree: "tree";
+      detail: "detail";
+      section: "section";
+    }>>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+      self: "self";
+      subtree: "subtree";
+    }>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+      all: "all";
+      last: "last";
+      sum: "sum";
+    }>>;
+    transform: z.ZodOptional<z.ZodCustom<TraceAttributeTransform, TraceAttributeTransform>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Trace display configuration authored by users in config or eval files. */
+type TraceDisplayInputConfig = z.infer<typeof traceDisplayInputConfigSchema>;
+/** Schema for a persisted trace span captured during case execution. */
+declare const traceSpanSchema: z.ZodObject<{
+  id: z.ZodString;
+  parentId: z.ZodNullable<z.ZodString>;
+  caseId: z.ZodString;
+  kind: z.ZodEnum<{
+    eval: "eval";
+    agent: "agent";
+    llm: "llm";
+    tool: "tool";
+    retrieval: "retrieval";
+    scorer: "scorer";
+    checkpoint: "checkpoint";
+    custom: "custom";
+  }>;
+  name: z.ZodString;
+  startedAt: z.ZodString;
+  endedAt: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    error: "error";
+    running: "running";
+    ok: "ok";
+    cancelled: "cancelled";
+  }>;
+  attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  error: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Persisted trace span shape stored for each eval case run. */
+type EvalTraceSpan = z.infer<typeof traceSpanSchema>;
+//#endregion
+//#region ../shared/src/schemas/eval.d.ts
+/** Freshness signal derived from the latest relevant run plus git state. */
+declare const evalFreshnessStatusSchema: z.ZodEnum<{
+  fresh: "fresh";
+  stale: "stale";
+  outdated: "outdated";
+}>;
+/** Freshness signal derived from the latest relevant run plus git state. */
+type EvalFreshnessStatus = z.infer<typeof evalFreshnessStatusSchema>;
+/** Reducer used to collapse a column's per-case values into a single stat. */
+declare const evalStatAggregateSchema: z.ZodEnum<{
+  avg: "avg";
+  min: "min";
+  max: "max";
+  sum: "sum";
+  last: "last";
+}>;
+/** Reducer used to collapse a column's per-case values into a single stat. */
+type EvalStatAggregate = z.infer<typeof evalStatAggregateSchema>;
+/**
+ * One entry in the EvalCard stats row. Built-in kinds use latest run totals;
+ * `column` aggregates a score or numeric output column across the latest run.
+ */
+declare const evalStatItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"cases">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"passRate">;
+  accent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"duration">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"column">;
+  key: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  aggregate: z.ZodEnum<{
+    avg: "avg";
+    min: "min";
+    max: "max";
+    sum: "sum";
+    last: "last";
+  }>;
+  format: z.ZodOptional<z.ZodEnum<{
+    number: "number";
+    boolean: "boolean";
+    file: "file";
+    duration: "duration";
+    markdown: "markdown";
+    json: "json";
+    image: "image";
+    audio: "audio";
+    video: "video";
+    percent: "percent";
+    passFail: "passFail";
+    stars: "stars";
+  }>>;
+  accent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "kind">;
+/** Single stat rendered in the EvalCard stats row. */
+type EvalStatItem = z.infer<typeof evalStatItemSchema>;
+/** Ordered list of stats rendered in the EvalCard stats row. */
+declare const evalStatsConfigSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"cases">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"passRate">;
+  accent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"duration">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"column">;
+  key: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  aggregate: z.ZodEnum<{
+    avg: "avg";
+    min: "min";
+    max: "max";
+    sum: "sum";
+    last: "last";
+  }>;
+  format: z.ZodOptional<z.ZodEnum<{
+    number: "number";
+    boolean: "boolean";
+    file: "file";
+    duration: "duration";
+    markdown: "markdown";
+    json: "json";
+    image: "image";
+    audio: "audio";
+    video: "video";
+    percent: "percent";
+    passFail: "passFail";
+    stars: "stars";
+  }>>;
+  accent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "kind">>;
+/** Ordered list of stats rendered in the EvalCard stats row. */
+type EvalStatsConfig = z.infer<typeof evalStatsConfigSchema>;
+/** Schema summarizing a discovered eval for list and overview screens. */
+declare const evalSummarySchema: z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+  filePath: z.ZodString;
+  stale: z.ZodBoolean;
+  outdated: z.ZodBoolean;
+  freshnessStatus: z.ZodEnum<{
+    fresh: "fresh";
+    stale: "stale";
+    outdated: "outdated";
+  }>;
+  latestRunAt: z.ZodNullable<z.ZodString>;
+  latestRunCommitSha: z.ZodNullable<z.ZodString>;
+  currentCommitSha: z.ZodNullable<z.ZodString>;
+  columnDefs: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+      string: "string";
+      number: "number";
+      boolean: "boolean";
+    }>;
+    format: z.ZodOptional<z.ZodEnum<{
+      number: "number";
+      boolean: "boolean";
+      file: "file";
+      duration: "duration";
+      markdown: "markdown";
+      json: "json";
+      image: "image";
+      audio: "audio";
+      video: "video";
+      percent: "percent";
+      passFail: "passFail";
+      stars: "stars";
+    }>>;
+    numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+    isScore: z.ZodOptional<z.ZodBoolean>;
+    isManualScore: z.ZodOptional<z.ZodBoolean>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    maxStars: z.ZodOptional<z.ZodNumber>;
+    hideInTable: z.ZodOptional<z.ZodBoolean>;
+    sortable: z.ZodOptional<z.ZodBoolean>;
+    align: z.ZodOptional<z.ZodEnum<{
+      left: "left";
+      center: "center";
+      right: "right";
+    }>>;
+  }, z.core.$strip>>;
+  caseCount: z.ZodNullable<z.ZodNumber>;
+  lastRunStatus: z.ZodNullable<z.ZodEnum<{
+    error: "error";
+    pass: "pass";
+    fail: "fail";
+    running: "running";
+    cancelled: "cancelled";
+    unscored: "unscored";
+  }>>;
+  stats: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"cases">;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"passRate">;
+    accent: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"duration">;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"column">;
+    key: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    aggregate: z.ZodEnum<{
+      avg: "avg";
+      min: "min";
+      max: "max";
+      sum: "sum";
+      last: "last";
+    }>;
+    format: z.ZodOptional<z.ZodEnum<{
+      number: "number";
+      boolean: "boolean";
+      file: "file";
+      duration: "duration";
+      markdown: "markdown";
+      json: "json";
+      image: "image";
+      audio: "audio";
+      video: "video";
+      percent: "percent";
+      passFail: "passFail";
+      stars: "stars";
+    }>>;
+    accent: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>], "kind">>>;
+  charts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    heading: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+      area: "area";
+      line: "line";
+      bar: "bar";
+    }>;
+    metrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      source: z.ZodLiteral<"builtin">;
+      metric: z.ZodEnum<{
+        passRate: "passRate";
+        durationMs: "durationMs";
+      }>;
+      label: z.ZodOptional<z.ZodString>;
+      color: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        accent: "accent";
+        error: "error";
+        accentDim: "accentDim";
+        warning: "warning";
+        textMuted: "textMuted";
+      }>>;
+      axis: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+      }>>;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"column">;
+      key: z.ZodString;
+      aggregate: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        sum: "sum";
+        latest: "latest";
+        passThresholdRate: "passThresholdRate";
+      }>;
+      label: z.ZodOptional<z.ZodString>;
+      color: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        accent: "accent";
+        error: "error";
+        accentDim: "accentDim";
+        warning: "warning";
+        textMuted: "textMuted";
+      }>>;
+      axis: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+      }>>;
+    }, z.core.$strip>], "source">>;
+    yDomain: z.ZodOptional<z.ZodObject<{
+      left: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      right: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tooltipExtras: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      source: z.ZodLiteral<"builtin">;
+      metric: z.ZodEnum<{
+        passRate: "passRate";
+        durationMs: "durationMs";
+      }>;
+      label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"column">;
+      key: z.ZodString;
+      aggregate: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        sum: "sum";
+        latest: "latest";
+        passThresholdRate: "passThresholdRate";
+      }>;
+      label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "source">>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Metadata shown for one discovered eval in the explorer UI. */
+type EvalSummary = z.infer<typeof evalSummarySchema>;
+/** Schema for one case row in an eval run result table. */
+declare const caseRowSchema: z.ZodObject<{
+  caseId: z.ZodString;
+  evalId: z.ZodString;
+  status: z.ZodEnum<{
+    error: "error";
+    pass: "pass";
+    fail: "fail";
+    running: "running";
+    cancelled: "cancelled";
+    pending: "pending";
+  }>;
+  latencyMs: z.ZodNullable<z.ZodNumber>;
+  costUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  columns: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodType<string | number | boolean | Record<string, unknown> | unknown[] | null, unknown, z.core.$ZodTypeInternals<string | number | boolean | Record<string, unknown> | unknown[] | null, unknown>>, z.ZodUnion<readonly [z.ZodObject<{
+    source: z.ZodLiteral<"repo">;
+    path: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"run">;
+    artifactId: z.ZodString;
+    mimeType: z.ZodString;
+    fileName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>]>>;
+  trial: z.ZodNumber;
+}, z.core.$strip>;
+/** Flattened per-case row rendered in run tables and streamed updates. */
+type CaseRow = z.infer<typeof caseRowSchema>;
+/** Structured assertion failure metadata captured for one case run. */
+declare const assertionFailureSchema: z.ZodObject<{
+  message: z.ZodString;
+  stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Assertion failure metadata captured for one case run. */
+type AssertionFailure = z.infer<typeof assertionFailureSchema>;
+/** Trace payload captured while computing one score for a case. */
+declare const scoreTraceSchema: z.ZodObject<{
+  trace: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    caseId: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      eval: "eval";
+      agent: "agent";
+      llm: "llm";
+      tool: "tool";
+      retrieval: "retrieval";
+      scorer: "scorer";
+      checkpoint: "checkpoint";
+    }>;
+    name: z.ZodString;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      error: "error";
+      running: "running";
+      cancelled: "cancelled";
+      ok: "ok";
+    }>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      message: z.ZodString;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  traceDisplay: z.ZodObject<{
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+      path: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      format: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        duration: "duration";
+        json: "json";
+      }>>;
+      numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+      placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tree: "tree";
+        detail: "detail";
+        section: "section";
+      }>>>;
+      scope: z.ZodOptional<z.ZodEnum<{
+        self: "self";
+        subtree: "subtree";
+      }>>;
+      mode: z.ZodOptional<z.ZodEnum<{
+        sum: "sum";
+        last: "last";
+        all: "all";
+      }>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/** Trace payload captured while computing one score for a case. */
+type ScoreTrace = z.infer<typeof scoreTraceSchema>;
+/** Schema for the detailed payload shown when opening a specific case. */
+declare const caseDetailSchema: z.ZodObject<{
+  caseId: z.ZodString;
+  evalId: z.ZodString;
+  status: z.ZodEnum<{
+    error: "error";
+    pass: "pass";
+    fail: "fail";
+    running: "running";
+    cancelled: "cancelled";
+    pending: "pending";
+  }>;
+  input: z.ZodUnknown;
+  trace: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    caseId: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      eval: "eval";
+      agent: "agent";
+      llm: "llm";
+      tool: "tool";
+      retrieval: "retrieval";
+      scorer: "scorer";
+      checkpoint: "checkpoint";
+    }>;
+    name: z.ZodString;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      error: "error";
+      running: "running";
+      cancelled: "cancelled";
+      ok: "ok";
+    }>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      message: z.ZodString;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  traceDisplay: z.ZodObject<{
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+      path: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      format: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        duration: "duration";
+        json: "json";
+      }>>;
+      numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+      placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tree: "tree";
+        detail: "detail";
+        section: "section";
+      }>>>;
+      scope: z.ZodOptional<z.ZodEnum<{
+        self: "self";
+        subtree: "subtree";
+      }>>;
+      mode: z.ZodOptional<z.ZodEnum<{
+        sum: "sum";
+        last: "last";
+        all: "all";
+      }>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>;
+  scoringTraces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    trace: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      parentId: z.ZodNullable<z.ZodString>;
+      caseId: z.ZodString;
+      kind: z.ZodEnum<{
+        custom: "custom";
+        eval: "eval";
+        agent: "agent";
+        llm: "llm";
+        tool: "tool";
+        retrieval: "retrieval";
+        scorer: "scorer";
+        checkpoint: "checkpoint";
+      }>;
+      name: z.ZodString;
+      startedAt: z.ZodString;
+      endedAt: z.ZodNullable<z.ZodString>;
+      status: z.ZodEnum<{
+        error: "error";
+        running: "running";
+        cancelled: "cancelled";
+        ok: "ok";
+      }>;
+      attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      error: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    traceDisplay: z.ZodObject<{
+      attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+          string: "string";
+          number: "number";
+          duration: "duration";
+          json: "json";
+        }>>;
+        numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+        placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+          tree: "tree";
+          detail: "detail";
+          section: "section";
+        }>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+          self: "self";
+          subtree: "subtree";
+        }>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+          sum: "sum";
+          last: "last";
+          all: "all";
+        }>>;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  columns: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodType<string | number | boolean | Record<string, unknown> | unknown[] | null, unknown, z.core.$ZodTypeInternals<string | number | boolean | Record<string, unknown> | unknown[] | null, unknown>>, z.ZodUnion<readonly [z.ZodObject<{
+    source: z.ZodLiteral<"repo">;
+    path: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"run">;
+    artifactId: z.ZodString;
+    mimeType: z.ZodString;
+    fileName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>]>>;
+  assertionFailures: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodPipe<z.ZodString, z.ZodTransform<{
+    message: string;
+    stack?: string | undefined;
+  }, string>>]>>;
+  error: z.ZodNullable<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  trial: z.ZodNumber;
+}, z.core.$strip>;
+/** Full case payload including inputs, trace, outputs, and failures. */
+type CaseDetail = z.infer<typeof caseDetailSchema>;
+//#endregion
+//#region ../shared/src/schemas/chart.d.ts
+/** Chart type rendered for a single eval history chart. */
+declare const evalChartTypeSchema: z.ZodEnum<{
+  area: "area";
+  line: "line";
+  bar: "bar";
+}>;
+/** Chart type rendered for a single eval history chart. */
+type EvalChartType = z.infer<typeof evalChartTypeSchema>;
+/**
+ * Run-level metric sourced from the aggregated `RunSummary` for a run, rather
+ * than from a per-case column.
+ */
+declare const evalChartBuiltinMetricSchema: z.ZodEnum<{
+  passRate: "passRate";
+  durationMs: "durationMs";
+}>;
+/**
+ * Run-level metric sourced from the aggregated `RunSummary` for a run, rather
+ * than from a per-case column.
+ */
+type EvalChartBuiltinMetric = z.infer<typeof evalChartBuiltinMetricSchema>;
+/** Reducer applied to a numeric column across all cases of a single run. */
+declare const evalChartAggregateSchema: z.ZodEnum<{
+  avg: "avg";
+  sum: "sum";
+  min: "min";
+  max: "max";
+  latest: "latest";
+  passThresholdRate: "passThresholdRate";
+}>;
+/** Reducer applied to a numeric column across all cases of a single run. */
+type EvalChartAggregate = z.infer<typeof evalChartAggregateSchema>;
+/**
+ * Semantic color token resolved to a theme color by the web UI. The SDK does
+ * not emit raw hex so authored evals stay decoupled from the web theme.
+ */
+declare const evalChartColorSchema: z.ZodEnum<{
+  accent: "accent";
+  accentDim: "accentDim";
+  success: "success";
+  error: "error";
+  warning: "warning";
+  textMuted: "textMuted";
+}>;
+/** Semantic color token resolved to a theme color by the web UI. */
+type EvalChartColor = z.infer<typeof evalChartColorSchema>;
+/** Y-axis placement for a plotted series on a dual-axis chart. */
+declare const evalChartAxisSchema: z.ZodEnum<{
+  left: "left";
+  right: "right";
+}>;
+/** Y-axis placement for a plotted series on a dual-axis chart. */
+type EvalChartAxis = z.infer<typeof evalChartAxisSchema>;
+/**
+ * One plotted series on an eval history chart. `builtin` metrics come from the
+ * per-run `RunSummary`; `column` metrics aggregate a per-case score or
+ * `setEvalOutput` column across the run using `aggregate`.
+ */
+declare const evalChartMetricSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  source: z.ZodLiteral<"builtin">;
+  metric: z.ZodEnum<{
+    passRate: "passRate";
+    durationMs: "durationMs";
+  }>;
+  label: z.ZodOptional<z.ZodString>;
+  color: z.ZodOptional<z.ZodEnum<{
+    accent: "accent";
+    accentDim: "accentDim";
+    success: "success";
+    error: "error";
+    warning: "warning";
+    textMuted: "textMuted";
+  }>>;
+  axis: z.ZodOptional<z.ZodEnum<{
+    left: "left";
+    right: "right";
+  }>>;
+}, z.core.$strip>, z.ZodObject<{
+  source: z.ZodLiteral<"column">;
+  key: z.ZodString;
+  aggregate: z.ZodEnum<{
+    avg: "avg";
+    sum: "sum";
+    min: "min";
+    max: "max";
+    latest: "latest";
+    passThresholdRate: "passThresholdRate";
+  }>;
+  label: z.ZodOptional<z.ZodString>;
+  color: z.ZodOptional<z.ZodEnum<{
+    accent: "accent";
+    accentDim: "accentDim";
+    success: "success";
+    error: "error";
+    warning: "warning";
+    textMuted: "textMuted";
+  }>>;
+  axis: z.ZodOptional<z.ZodEnum<{
+    left: "left";
+    right: "right";
+  }>>;
+}, z.core.$strip>], "source">;
+/** One plotted series on an eval history chart. */
+type EvalChartMetric = z.infer<typeof evalChartMetricSchema>;
+/** Extra field rendered only in the tooltip, not plotted as a series. */
+declare const evalChartTooltipExtraSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  source: z.ZodLiteral<"builtin">;
+  metric: z.ZodEnum<{
+    passRate: "passRate";
+    durationMs: "durationMs";
+  }>;
+  label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  source: z.ZodLiteral<"column">;
+  key: z.ZodString;
+  aggregate: z.ZodEnum<{
+    avg: "avg";
+    sum: "sum";
+    min: "min";
+    max: "max";
+    latest: "latest";
+    passThresholdRate: "passThresholdRate";
+  }>;
+  label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "source">;
+/** Extra field rendered only in the tooltip, not plotted as a series. */
+type EvalChartTooltipExtra = z.infer<typeof evalChartTooltipExtraSchema>;
+/**
+ * Authored configuration for one eval history chart rendered in `EvalCard`.
+ * Authors declare a list of these via `EvalDefinition.charts` — the UI renders
+ * each entry as its own chart frame, stacked in authoring order.
+ */
+declare const evalChartConfigSchema: z.ZodObject<{
+  heading: z.ZodOptional<z.ZodString>;
+  type: z.ZodEnum<{
+    area: "area";
+    line: "line";
+    bar: "bar";
+  }>;
+  metrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"builtin">;
+    metric: z.ZodEnum<{
+      passRate: "passRate";
+      durationMs: "durationMs";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodEnum<{
+      accent: "accent";
+      accentDim: "accentDim";
+      success: "success";
+      error: "error";
+      warning: "warning";
+      textMuted: "textMuted";
+    }>>;
+    axis: z.ZodOptional<z.ZodEnum<{
+      left: "left";
+      right: "right";
+    }>>;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"column">;
+    key: z.ZodString;
+    aggregate: z.ZodEnum<{
+      avg: "avg";
+      sum: "sum";
+      min: "min";
+      max: "max";
+      latest: "latest";
+      passThresholdRate: "passThresholdRate";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodEnum<{
+      accent: "accent";
+      accentDim: "accentDim";
+      success: "success";
+      error: "error";
+      warning: "warning";
+      textMuted: "textMuted";
+    }>>;
+    axis: z.ZodOptional<z.ZodEnum<{
+      left: "left";
+      right: "right";
+    }>>;
+  }, z.core.$strip>], "source">>;
+  yDomain: z.ZodOptional<z.ZodObject<{
+    left: z.ZodOptional<z.ZodObject<{
+      min: z.ZodOptional<z.ZodNumber>;
+      max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    right: z.ZodOptional<z.ZodObject<{
+      min: z.ZodOptional<z.ZodNumber>;
+      max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  tooltipExtras: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"builtin">;
+    metric: z.ZodEnum<{
+      passRate: "passRate";
+      durationMs: "durationMs";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"column">;
+    key: z.ZodString;
+    aggregate: z.ZodEnum<{
+      avg: "avg";
+      sum: "sum";
+      min: "min";
+      max: "max";
+      latest: "latest";
+      passThresholdRate: "passThresholdRate";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "source">>>;
+}, z.core.$strip>;
+/** Authored configuration for one eval history chart. */
+type EvalChartConfig = z.infer<typeof evalChartConfigSchema>;
+/**
+ * Ordered list of history charts rendered for an eval. Opt-in: when omitted or
+ * empty, the UI renders no history chart at all.
+ */
+declare const evalChartsConfigSchema: z.ZodArray<z.ZodObject<{
+  heading: z.ZodOptional<z.ZodString>;
+  type: z.ZodEnum<{
+    area: "area";
+    line: "line";
+    bar: "bar";
+  }>;
+  metrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"builtin">;
+    metric: z.ZodEnum<{
+      passRate: "passRate";
+      durationMs: "durationMs";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodEnum<{
+      accent: "accent";
+      accentDim: "accentDim";
+      success: "success";
+      error: "error";
+      warning: "warning";
+      textMuted: "textMuted";
+    }>>;
+    axis: z.ZodOptional<z.ZodEnum<{
+      left: "left";
+      right: "right";
+    }>>;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"column">;
+    key: z.ZodString;
+    aggregate: z.ZodEnum<{
+      avg: "avg";
+      sum: "sum";
+      min: "min";
+      max: "max";
+      latest: "latest";
+      passThresholdRate: "passThresholdRate";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodEnum<{
+      accent: "accent";
+      accentDim: "accentDim";
+      success: "success";
+      error: "error";
+      warning: "warning";
+      textMuted: "textMuted";
+    }>>;
+    axis: z.ZodOptional<z.ZodEnum<{
+      left: "left";
+      right: "right";
+    }>>;
+  }, z.core.$strip>], "source">>;
+  yDomain: z.ZodOptional<z.ZodObject<{
+    left: z.ZodOptional<z.ZodObject<{
+      min: z.ZodOptional<z.ZodNumber>;
+      max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    right: z.ZodOptional<z.ZodObject<{
+      min: z.ZodOptional<z.ZodNumber>;
+      max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  tooltipExtras: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"builtin">;
+    metric: z.ZodEnum<{
+      passRate: "passRate";
+      durationMs: "durationMs";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"column">;
+    key: z.ZodString;
+    aggregate: z.ZodEnum<{
+      avg: "avg";
+      sum: "sum";
+      min: "min";
+      max: "max";
+      latest: "latest";
+      passThresholdRate: "passThresholdRate";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "source">>>;
+}, z.core.$strip>>;
+/** Ordered list of history charts rendered for an eval. */
+type EvalChartsConfig = z.infer<typeof evalChartsConfigSchema>;
+//#endregion
+//#region ../shared/src/schemas/run.d.ts
+/** Schema for persisted metadata about a single run invocation. */
+declare const runManifestSchema: z.ZodObject<{
+  id: z.ZodString;
+  shortId: z.ZodString;
+  status: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    cancelled: "cancelled";
+    error: "error";
+  }>;
+  startedAt: z.ZodString;
+  endedAt: z.ZodNullable<z.ZodString>;
+  commitSha: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+  evalSourceFingerprints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+  target: z.ZodObject<{
+    mode: z.ZodEnum<{
+      all: "all";
+      evalIds: "evalIds";
+      caseIds: "caseIds";
+    }>;
+    evalIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    caseIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>;
+  trials: z.ZodNumber;
+  trialSelection: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    lowestScore: "lowestScore";
+    median: "median";
+  }>>>;
+  cacheMode: z.ZodOptional<z.ZodEnum<{
+    use: "use";
+    bypass: "bypass";
+    refresh: "refresh";
+  }>>;
+}, z.core.$strip>;
+/** Persisted lifecycle metadata for a single eval run. */
+type RunManifest = z.infer<typeof runManifestSchema>;
+/** Schema for aggregate metrics computed over a completed or active run. */
+declare const runSummarySchema: z.ZodObject<{
+  runId: z.ZodString;
+  status: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    cancelled: "cancelled";
+    error: "error";
+  }>;
+  totalCases: z.ZodNumber;
+  passedCases: z.ZodNumber;
+  failedCases: z.ZodNumber;
+  errorCases: z.ZodNumber;
+  cancelledCases: z.ZodNumber;
+  totalDurationMs: z.ZodNullable<z.ZodNumber>;
+  errorMessage: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** Roll-up statistics for one run. */
+type RunSummary = z.infer<typeof runSummarySchema>;
+//#endregion
+//#region ../shared/src/status.d.ts
+/**
+ * Canonical derived result status used for aggregated displays and propagation
+ * across case, eval, file, folder, and run result views.
+ */
+type DerivedStatus = 'pending' | 'running' | 'pass' | 'fail' | 'error' | 'cancelled';
+/**
+ * Aggregate summary derived from a scoped set of case rows.
+ *
+ * This is intentionally separate from `RunSummary`: it represents a summary
+ * over any slice of case rows, such as a single eval within a run.
+ */
+type ScopedCaseSummary = {
+  status: DerivedStatus;
+  totalCases: number;
+  passedCases: number;
+  failedCases: number;
+  errorCases: number;
+  cancelledCases: number;
+  pendingCases: number;
+  runningCases: number;
+  totalDurationMs: number | null;
+};
+type RunLifecycleStatus = RunManifest['status'] | null | undefined;
+/**
+ * Derive an aggregate status from child statuses, optionally allowing a raw run
+ * lifecycle status to override active terminal states such as `running`,
+ * `cancelled`, and `error`.
+ */
+declare function deriveStatusFromChildStatuses(params: {
+  statuses: Iterable<DerivedStatus | null | undefined>;
+  lifecycleStatus?: RunLifecycleStatus;
+}): DerivedStatus;
+/**
+ * Derive an aggregate status from a scoped set of case rows.
+ *
+ * Pass `lifecycleStatus` only when the parent scope's raw run lifecycle should
+ * override the derived child result, such as for a whole-run display.
+ */
+declare function deriveStatusFromCaseRows(params: {
+  caseRows: Iterable<Pick<CaseRow, 'status'>>;
+  lifecycleStatus?: RunLifecycleStatus;
+}): DerivedStatus;
+/**
+ * Derive counts, aggregate metrics, and display status from a scoped set of
+ * case rows.
+ */
+declare function deriveScopedSummaryFromCases(params: {
+  caseRows: Iterable<CaseRow>;
+  lifecycleStatus?: RunLifecycleStatus;
+}): ScopedCaseSummary;
+//#endregion
+//#region ../shared/src/evalStatus.d.ts
+/** Display status used for eval, file, and folder UI surfaces. */
+type EvalDisplayStatus = DerivedStatus | 'stale' | 'outdated' | 'unscored';
+/**
+ * Derive the user-facing eval status from the raw latest run result plus
+ * freshness state.
+ */
+declare function getEvalDisplayStatus(params: {
+  freshnessStatus: EvalFreshnessStatus;
+  stale: boolean;
+  outdated: boolean;
+  lastRunStatus: 'pass' | 'fail' | 'error' | 'running' | 'cancelled' | 'unscored' | null;
+  isRunning?: boolean;
+}): EvalDisplayStatus;
+//#endregion
+//#region ../shared/src/evalTitle.d.ts
+type EvalTitleLike = {
+  id: string;
+  title?: string;
+};
+/**
+ * Resolve the display title for an eval.
+ *
+ * Returns the authored `title` when present; otherwise derives a human-readable
+ * label from the stable eval `id` so display surfaces can avoid repeating both
+ * fields in common cases.
+ */
+declare function getEvalTitle(evalLike: EvalTitleLike): string;
+//#endregion
+//#region ../shared/src/schemas/sse.d.ts
+declare const sseEventTypeSchema: z.ZodEnum<{
+  "discovery.updated": "discovery.updated";
+  "run.started": "run.started";
+  "run.summary": "run.summary";
+  "case.started": "case.started";
+  "case.updated": "case.updated";
+  "case.finished": "case.finished";
+  "trace.span": "trace.span";
+  "run.finished": "run.finished";
+  "run.cancelled": "run.cancelled";
+  "run.error": "run.error";
+}>;
+/** Server-sent event name emitted by the runner or backend. */
+type SseEventType = z.infer<typeof sseEventTypeSchema>;
+/** Schema for the SSE envelope used to stream run updates to clients. */
+declare const sseEnvelopeSchema: z.ZodObject<{
+  type: z.ZodString;
+  runId: z.ZodOptional<z.ZodString>;
+  timestamp: z.ZodString;
+  payload: z.ZodUnknown;
+}, z.core.$strip>;
+/** Wire format for a streamed event emitted during eval execution. */
+type SseEnvelope = z.infer<typeof sseEnvelopeSchema>;
+//#endregion
+//#region ../shared/src/schemas/api.d.ts
+/** Schema for the API request that starts a new eval run. */
+declare const createRunRequestSchema: z.ZodObject<{
+  target: z.ZodObject<{
+    mode: z.ZodEnum<{
+      all: "all";
+      evalIds: "evalIds";
+      caseIds: "caseIds";
+    }>;
+    evalIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    caseIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>;
+  trials: z.ZodNumber;
+  cache: z.ZodOptional<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+      use: "use";
+      bypass: "bypass";
+      refresh: "refresh";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Request payload accepted by the run creation endpoint. */
+type CreateRunRequest = z.infer<typeof createRunRequestSchema>;
+/** Schema for updating a UI-authored manual score on one persisted case. */
+declare const updateManualScoreRequestSchema: z.ZodObject<{
+  value: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+/** Request payload accepted by the manual score update endpoint. */
+type UpdateManualScoreRequest = z.infer<typeof updateManualScoreRequestSchema>;
+//#endregion
+//#region ../shared/src/schemas/config.d.ts
+/** Strategy used to collapse repeated trials into one stored case result. */
+declare const trialSelectionModeSchema: z.ZodEnum<{
+  lowestScore: "lowestScore";
+  median: "median";
+}>;
+/** Strategy used to collapse repeated trials into one stored case result. */
+type TrialSelectionMode = z.infer<typeof trialSelectionModeSchema>;
+/** Top-level config authored in `agent-evals.config.ts`. */
+type AgentEvalsConfig = {
+  /** Root directory used to resolve all relative paths. Defaults to `process.cwd()`. */workspaceRoot?: string; /** Glob patterns (relative to `workspaceRoot`) used to discover eval files. */
+  include: string[]; /** Number of trials per case when none is specified. Defaults to `1`. */
+  defaultTrials?: number;
+  /**
+   * Strategy used to pick the single persisted result when `trials > 1`.
+   *
+   * `lowestScore` is the default. `median` uses the lower median when the
+   * number of trials is even.
+   */
+  trialSelection?: TrialSelectionMode;
+  /**
+   * Maximum number of case executions that may run in parallel across one run,
+   * including trial fan-out. Defaults to `2`.
+   */
+  concurrency?: number;
+  /**
+   * Age threshold, in days, before a latest run from a different commit is
+   * considered outdated. Defaults to `14`.
+   */
+  staleAfterDays?: number;
+  /**
+   * Global trace attribute display config for the UI.
+   *
+   * These rules are merged with per-eval `traceDisplay` rules, with the eval
+   * definition taking precedence for matching `key` or `path` entries.
+   */
+  traceDisplay?: TraceDisplayInputConfig;
+  /**
+   * Optional controls for the operation cache. When omitted, the cache is
+   * enabled and stored under `<workspaceRoot>/.agent-evals/cache`.
+   */
+  cache?: {
+    /** Disable the cache entirely; spans with `cache` options execute as if uncached. */enabled?: boolean; /** Override the directory used to persist cache entries. */
+    dir?: string;
+  };
+};
+/** Zod schema for validating `agent-evals.config.ts` input. */
+declare const agentEvalsConfigSchema: z.ZodObject<{
+  workspaceRoot: z.ZodOptional<z.ZodString>;
+  include: z.ZodArray<z.ZodString>;
+  defaultTrials: z.ZodOptional<z.ZodNumber>;
+  trialSelection: z.ZodOptional<z.ZodEnum<{
+    lowestScore: "lowestScore";
+    median: "median";
+  }>>;
+  concurrency: z.ZodOptional<z.ZodNumber>;
+  staleAfterDays: z.ZodOptional<z.ZodNumber>;
+  traceDisplay: z.ZodOptional<z.ZodObject<{
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+      path: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      format: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        duration: "duration";
+        json: "json";
+      }>>;
+      numberFormat: z.ZodOptional<z.ZodType<NumberDisplayOptions, unknown, z.core.$ZodTypeInternals<NumberDisplayOptions, unknown>>>;
+      placements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tree: "tree";
+        detail: "detail";
+        section: "section";
+      }>>>;
+      scope: z.ZodOptional<z.ZodEnum<{
+        self: "self";
+        subtree: "subtree";
+      }>>;
+      mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        last: "last";
+        sum: "sum";
+      }>>;
+      transform: z.ZodOptional<z.ZodCustom<TraceAttributeTransform, TraceAttributeTransform>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+  cache: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    dir: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+//#endregion
+//#region ../shared/src/schemas/cache.d.ts
+/**
+ * Mode that controls how the cache is consulted for a given run.
+ *
+ * - `use`: read cache on hit, write on miss. Default.
+ * - `bypass`: never read, never write.
+ * - `refresh`: never read, always write (forces re-execution and overwrites).
+ */
+declare const cacheModeSchema: z.ZodEnum<{
+  use: "use";
+  bypass: "bypass";
+  refresh: "refresh";
+}>;
+/** Mode controlling how cached spans behave during a run. */
+type CacheMode = z.infer<typeof cacheModeSchema>;
+/** Options accepted by an `evalTracer.span` call to opt the span into caching. */
+declare const spanCacheOptionsSchema: z.ZodObject<{
+  key: z.ZodUnknown;
+  namespace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options accepted by an `evalTracer.span` call to opt the span into caching. */
+type SpanCacheOptions = z.infer<typeof spanCacheOptionsSchema>;
+/** Summary of a single persisted cache entry, used by list/delete endpoints. */
+declare const cacheListItemSchema: z.ZodObject<{
+  key: z.ZodString;
+  namespace: z.ZodString;
+  spanName: z.ZodString;
+  spanKind: z.ZodEnum<{
+    eval: "eval";
+    agent: "agent";
+    llm: "llm";
+    tool: "tool";
+    retrieval: "retrieval";
+    scorer: "scorer";
+    checkpoint: "checkpoint";
+    custom: "custom";
+  }>;
+  storedAt: z.ZodString;
+  codeFingerprint: z.ZodString;
+  sizeBytes: z.ZodNumber;
+}, z.core.$strip>;
+/** Summary row for a single cache entry. */
+type CacheListItem = z.infer<typeof cacheListItemSchema>;
+/** Serialized nested span captured while recording a cached operation. */
+type SerializedCacheSpan = {
+  kind: TraceSpanKind;
+  name: string;
+  attributes?: Record<string, unknown>;
+  status: 'running' | 'ok' | 'error' | 'cancelled';
+  error?: {
+    name?: string;
+    message: string;
+    stack?: string;
+  };
+  children: SerializedCacheSpan[];
+};
+/** Zod schema for `SerializedCacheSpan`, defined lazily for recursion. */
+declare const serializedCacheSpanSchema: z.ZodType<SerializedCacheSpan>;
+/**
+ * One captured operation performed while a cached span's body executed.
+ *
+ * Operations are replayed in order against a fresh scope on cache hit to
+ * reproduce the observable effects of the original run.
+ */
+declare const cacheRecordingOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"setOutput">;
+  key: z.ZodString;
+  value: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"incrementOutput">;
+  key: z.ZodString;
+  delta: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"checkpoint">;
+  name: z.ZodString;
+  data: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"subSpan">;
+  span: z.ZodType<SerializedCacheSpan, unknown, z.core.$ZodTypeInternals<SerializedCacheSpan, unknown>>;
+}, z.core.$strip>], "kind">;
+/** Single effect captured by a cache recording. */
+type CacheRecordingOp = z.infer<typeof cacheRecordingOpSchema>;
+/** Captured observable effects + return value of a cached span body. */
+declare const cacheRecordingSchema: z.ZodObject<{
+  returnValue: z.ZodUnknown;
+  finalAttributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  ops: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"setOutput">;
+    key: z.ZodString;
+    value: z.ZodUnknown;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"incrementOutput">;
+    key: z.ZodString;
+    delta: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"checkpoint">;
+    name: z.ZodString;
+    data: z.ZodUnknown;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"subSpan">;
+    span: z.ZodType<SerializedCacheSpan, unknown, z.core.$ZodTypeInternals<SerializedCacheSpan, unknown>>;
+  }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+/** Captured observable effects + return value of a cached span body. */
+type CacheRecording = z.infer<typeof cacheRecordingSchema>;
+/** Persisted cache file containing metadata and a recording. */
+declare const cacheEntrySchema: z.ZodObject<{
+  version: z.ZodLiteral<1>;
+  key: z.ZodString;
+  namespace: z.ZodString;
+  spanName: z.ZodString;
+  spanKind: z.ZodEnum<{
+    eval: "eval";
+    agent: "agent";
+    llm: "llm";
+    tool: "tool";
+    retrieval: "retrieval";
+    scorer: "scorer";
+    checkpoint: "checkpoint";
+    custom: "custom";
+  }>;
+  storedAt: z.ZodString;
+  codeFingerprint: z.ZodString;
+  recording: z.ZodObject<{
+    returnValue: z.ZodUnknown;
+    finalAttributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    ops: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"setOutput">;
+      key: z.ZodString;
+      value: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"incrementOutput">;
+      key: z.ZodString;
+      delta: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"checkpoint">;
+      name: z.ZodString;
+      data: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"subSpan">;
+      span: z.ZodType<SerializedCacheSpan, unknown, z.core.$ZodTypeInternals<SerializedCacheSpan, unknown>>;
+    }, z.core.$strip>], "kind">>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/** Persisted cache file contents. */
+type CacheEntry = z.infer<typeof cacheEntrySchema>;
+//#endregion
+//#region ../sdk/src/types.d.ts
+/** Single authored eval case with its stable identifier and input payload. */
+type EvalCase<TInput> = {
+  id: string;
+  input: TInput;
+  tags?: string[];
+};
+/** UI overrides for a derived or scored column emitted by an eval. */
+type EvalColumnOverride = {
+  /** Display label shown for the column in tables and detail views. */label?: string;
+  /**
+   * Presentation preset for the value.
+   *
+   * Use this to control how the UI renders the cell and infer table behavior,
+   * for example `number`, `boolean`, `duration`, `markdown`, `json`, or
+   * file/media previews.
+   */
+  format?: ColumnFormat;
+  /**
+   * Extra options for `format: 'number'`.
+   *
+   * Use this to add a prefix or suffix, force a fixed number of decimal
+   * places, or switch to compact notation such as `1.2K`.
+   */
+  numberFormat?: NumberDisplayOptions;
+  /**
+   * Hides the column from the runs table while keeping it available in detail
+   * views and raw output data.
+   */
+  hideInTable?: boolean; /** Whether the UI should allow sorting rows by this column. */
+  sortable?: boolean; /** Horizontal alignment used when rendering the column cells. */
+  align?: 'left' | 'center' | 'right';
+  /**
+   * Maximum number of stars used when `format: 'stars'`.
+   *
+   * Values are still stored as normalized `0..1` numbers; the UI maps the
+   * selected star count evenly across that range.
+   */
+  maxStars?: number;
+};
+/** Column override map keyed by output or score field name. */
+type EvalColumns = Record<string, EvalColumnOverride>;
+/** Query helpers built from the flattened trace recorded for one eval case. */
+type EvalTraceTree = {
+  spans: EvalTraceSpan[];
+  rootSpans: EvalTraceSpan[];
+  findSpan: (name: string) => EvalTraceSpan | undefined;
+  findSpansByKind: (kind: EvalTraceSpan['kind']) => EvalTraceSpan[];
+  flattenDfs: () => EvalTraceSpan[];
+  checkpoints: Map<string, unknown>;
+};
+/** Context passed to an eval's `execute` function for a single case run. */
+type EvalExecuteContext<TInput> = {
+  input: TInput;
+  signal: AbortSignal;
+};
+/** Context passed to `deriveFromTracing` after execution has completed. */
+type EvalDeriveContext<TInput> = {
+  trace: EvalTraceTree;
+  input: TInput;
+  case: EvalCase<TInput>;
+};
+/** Context passed to score functions after outputs have been collected. */
+type EvalScoreContext<TInput> = {
+  input: TInput;
+  outputs: Record<string, unknown>;
+  case: EvalCase<TInput>;
+};
+/** Score callback that computes a numeric result for one case. */
+type EvalScoreFn<TInput> = (ctx: EvalScoreContext<TInput>) => number | Promise<number>;
+/**
+ * Score definition accepted by `defineEval`, with optional UI metadata.
+ *
+ * When `passThreshold` is provided, this score gates the case pass/fail:
+ * a case fails if its computed value is strictly below the threshold. A
+ * score without a `passThreshold` is informational only and never causes
+ * a case to fail on its own.
+ */
+type EvalScoreDef<TInput> = EvalScoreFn<TInput> | ({
+  compute: EvalScoreFn<TInput>;
+  passThreshold?: number;
+} & EvalColumnOverride);
+/**
+ * Manual score definition accepted by `defineEval`.
+ *
+ * Manual scores are emitted as score columns with pending values during CLI
+ * execution. The web UI is responsible for setting their normalized `0..1`
+ * values after a run completes.
+ */
+type EvalManualScoreDef = EvalColumnOverride & {
+  /**
+   * Optional pass/fail gate applied after a value is filled. Pending manual
+   * values keep the eval in an `unscored` state instead of failing the case.
+   */
+  passThreshold?: number;
+};
+/** Complete authored eval definition consumed by `defineEval`. */
+type EvalDefinition<TInput = unknown> = {
+  id: string;
+  title?: string;
+  /**
+   * Authored cases for this eval.
+   *
+   * When omitted or resolved to an empty array, the runner still executes the
+   * eval once using a synthetic case with empty object input.
+   */
+  cases?: EvalCase<TInput>[] | (() => Promise<EvalCase<TInput>[]>);
+  columns?: EvalColumns;
+  /**
+   * Per-eval trace attribute display rules for the UI.
+   *
+   * These are merged with the global `AgentEvalsConfig.traceDisplay` rules.
+   * Matching entries override the global rule by `key`, or by `path` when no
+   * `key` is provided.
+   */
+  traceDisplay?: TraceDisplayInputConfig;
+  execute: (ctx: EvalExecuteContext<TInput>) => Promise<void> | void;
+  deriveFromTracing?: (ctx: EvalDeriveContext<TInput>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+  scores?: Record<string, EvalScoreDef<TInput>>;
+  /**
+   * Score columns whose values are entered in the web UI after a run.
+   *
+   * Keys become persisted score columns, initialized as pending (`null`) for
+   * every case. Once filled, values are normalized numbers in the `0..1`
+   * range and participate in summaries, stats, charts, and pass thresholds
+   * like computed scores.
+   */
+  manualScores?: Record<string, EvalManualScoreDef>;
+  /**
+   * Optional stats row configuration for the EvalCard in the web UI.
+   *
+   * Opt-in: when omitted (or empty) the EvalCard renders no stats row at all.
+   * When provided, the stats render in order, left to right.
+   *
+   * Built-in kinds (`cases`, `passRate`, `duration`, `cost`) read from the
+   * latest run summary. `kind: 'column'` aggregates a score or numeric output
+   * column across the latest run's cases — `key` must match one of the eval's
+   * score or column keys, and only finite numeric values participate in the
+   * reduction. When no case has a numeric value for the key the stat renders
+   * an em dash. `label` and `format` default to the matching `ColumnDef`.
+   */
+  stats?: EvalStatsConfig;
+  /**
+   * Optional history chart configuration for the EvalCard in the web UI.
+   *
+   * Opt-in: when omitted (or empty) the EvalCard renders no history chart at
+   * all. Each entry in the list renders as its own chart frame, stacked in
+   * authoring order.
+   *
+   * Each chart declares its `type` (`area | line | bar`) and one or more
+   * `metrics`. Built-in metrics (`passRate`, `durationMs`) aggregate
+   * the run summary. Column metrics aggregate a score or numeric `setEvalOutput`
+   * column across the run using an `aggregate` reducer (`avg`, `sum`, `min`,
+   * `max`, `latest`, `passThresholdRate`). `passThresholdRate` requires a
+   * score column with `passThreshold`.
+   */
+  charts?: EvalChartsConfig;
+};
+//#endregion
+//#region ../sdk/src/defineEval.d.ts
+/**
+ * Registered eval metadata tracked by the SDK during module loading.
+ *
+ * Consumers usually access these entries through `getEvalRegistry()`.
+ */
+type EvalRegistryEntry = {
+  id: string;
+  title?: string;
+  use: <R>(fn: <TInput>(def: EvalDefinition<TInput>) => R) => R;
+};
+/** Return the in-memory registry of evals defined in the current process. */
+declare function getEvalRegistry(): Map<string, EvalRegistryEntry>;
+/**
+ * Register an eval definition with the SDK so the runner can discover it
+ * after importing the eval module.
+ */
+declare function defineEval<TInput>(definition: EvalDefinition<TInput>): void;
+//#endregion
+//#region ../sdk/src/repoFile.d.ts
+/**
+ * Create a file reference that can be emitted via `setEvalOutput(...)` and rendered
+ * by a column configured with `format: 'image' | 'audio' | 'video' | 'file'`.
+ *
+ * @param path Relative or absolute path to the repository file.
+ * @param mimeType Optional MIME type hint for UI rendering.
+ * @returns A repo-backed file reference suitable for file/media columns.
+ */
+declare function repoFile(path: string, mimeType?: string): RepoFileRef;
+//#endregion
+//#region ../sdk/src/runtime.d.ts
+/**
+ * Adapter used by the SDK to read and write cache entries for cached spans.
+ *
+ * Implementations are typically injected by the runner before the eval case
+ * starts executing.
+ */
+type CacheAdapter = {
+  /** Return the stored entry for `keyHash` under `namespace`, or `null`. */lookup(namespace: string, keyHash: string): Promise<CacheEntry | null>; /** Persist a cache entry. Must be safe under concurrent calls. */
+  write(entry: CacheEntry): Promise<void>;
+};
+/** Runner-supplied cache context attached to an eval case scope. */
+type CacheScopeContext = {
+  adapter: CacheAdapter;
+  mode: CacheMode;
+  evalId: string; /** Hash of the eval source file; used to invalidate on code changes. */
+  codeFingerprint: string;
+};
+/** Active recording frame captured while a cached span body executes. */
+type CacheRecordingFrame = {
+  /** Length of `scope.spans` immediately before the cached body started. */baseSpanIndex: number; /** Id of the cached span that owns this recording. */
+  cachedSpanId: string; /** Ordered observable effects recorded during the cached body. */
+  ops: CacheRecordingOp[];
+};
+/** Mutable per-case runtime state stored in async local storage. */
+type EvalCaseScope = {
+  caseId: string;
+  outputs: Record<string, unknown>; /** Structured assertion failures recorded for the current case. */
+  assertionFailures: AssertionFailure[];
+  spans: EvalTraceSpan[];
+  checkpoints: Map<string, unknown>;
+  spanStack: string[];
+  activeSpanStack: EvalTraceSpan[];
+  /**
+   * Stack of active cache recorders. Ops are written to the top-most frame
+   * when it exists and `replayingDepth === 0`.
+   */
+  recordingStack: CacheRecordingFrame[];
+  /**
+   * Incremented while replaying a cached span, so nested SDK calls do not
+   * accidentally double-record ops into outer recorders.
+   */
+  replayingDepth: number; /** Runner-provided cache adapter + mode; absent when caching is disabled. */
+  cacheContext: CacheScopeContext | undefined;
+};
+/** Error thrown when an eval assertion fails during case execution. */
+declare class EvalAssertionError extends Error {
+  constructor(message: string);
+}
+/** Return the current eval scope for the active async context, if any. */
+declare function getCurrentScope(): EvalCaseScope | undefined;
+/**
+ * Return whether the current async execution is inside an active eval case.
+ *
+ * This is useful for shared workflow code that wants to branch on eval-only
+ * behavior without importing or inspecting the full eval scope.
+ */
+declare function isInEvalScope(): boolean;
+/**
+ * Attach cache context (adapter, mode, eval id, fingerprint) to a scope.
+ *
+ * Runner-internal helper called immediately before the user's `execute`
+ * function runs inside `runInEvalScope`.
+ */
+declare function setScopeCacheContext(scope: EvalCaseScope, context: CacheScopeContext): void;
+/** Optional inputs accepted when starting a new eval case scope. */
+type RunInEvalScopeOptions = {
+  /** Cache adapter + mode attached to the scope before `fn` runs. */cacheContext?: CacheScopeContext;
+};
+/**
+ * Execute a callback inside a fresh eval case scope and capture its outputs,
+ * trace data, and terminal error state.
+ */
+declare function runInEvalScope<T>(caseId: string, fn: () => Promise<T> | T, options?: RunInEvalScopeOptions): Promise<{
+  result: T | undefined;
+  scope: EvalCaseScope;
+  error: Error | undefined;
+}>;
+/**
+ * Record or replace an output value for the current case scope.
+ *
+ * Supported values include scalars, JSON-safe objects/arrays, explicit file
+ * refs, and native `Blob`/`File` instances for media or file columns.
+ */
+declare function setEvalOutput(key: string, value: unknown): void;
+/**
+ * Add a numeric delta to an output value in the current case scope.
+ *
+ * If the existing value is non-numeric, the operation is recorded as an
+ * assertion failure instead of mutating the output.
+ */
+declare function incrementEvalOutput(key: string, delta: number): void;
+/**
+ * Assert a condition for the current eval case and throw on failure.
+ *
+ * Calls made outside `runInEvalScope(...)` are ignored so shared workflow code
+ * can safely reuse `evalAssert(...)` when it also runs outside an eval.
+ */
+declare function evalAssert(condition: boolean, message: string): void;
+//#endregion
+//#region ../sdk/src/tracer.d.ts
+/**
+ * Mutable handle for the current span.
+ *
+ * Prefer the ambient `evalSpan` export for most code so helpers deeper in the call
+ * stack can annotate the active span without receiving an injected argument.
+ */
+type TraceActiveSpan = {
+  /** Rename the active span after it has been created. */setName(value: string): void; /** Set a single attribute on the active span. Later writes replace the same key. */
+  setAttribute(key: string, value: unknown): void; /** Merge multiple attributes into the active span. */
+  setAttributes(value: Record<string, unknown>): void;
+};
+/**
+ * Ambient handle for the active span in the current async context.
+ *
+ * Calls are no-ops when executed outside of `evalTracer.span(...)`.
+ */
+declare const evalSpan: TraceActiveSpan;
+type TraceSpanInfoBase = {
+  kind: EvalTraceSpan['kind'];
+  name: string;
+  attributes?: Record<string, unknown>;
+};
+/** Info accepted by `evalTracer.span(info, fn)` when creating an uncached span. */
+type TraceSpanInfoUncached = TraceSpanInfoBase & {
+  cache?: undefined;
+};
+/**
+ * Info accepted by `evalTracer.span(info, fn)` when opting in to caching.
+ *
+ * Cached spans return `Promise<unknown>` because the replayed value comes from
+ * a JSON round-trip on cache hit. Narrow the value yourself when you need a
+ * typed return.
+ */
+type TraceSpanInfoCached = TraceSpanInfoBase & {
+  cache: SpanCacheOptions;
+};
+/** Info accepted by `evalTracer.span(info, fn)`. */
+type TraceSpanInfo = TraceSpanInfoUncached | TraceSpanInfoCached;
+declare function traceSpan<T>(info: TraceSpanInfoUncached, fn: () => Promise<T> | T): Promise<T>;
+declare function traceSpan<T>(info: TraceSpanInfoUncached, fn: (span: TraceActiveSpan) => Promise<T> | T): Promise<T>;
+declare function traceSpan(info: TraceSpanInfoCached, fn: () => unknown): Promise<unknown>;
+declare function traceSpan(info: TraceSpanInfoCached, fn: (span: TraceActiveSpan) => unknown): Promise<unknown>;
+/**
+ * Trace builder used to create hierarchical spans and checkpoints during eval
+ * execution.
+ */
+declare const evalTracer: {
+  /** Run a callback inside a new trace span and record its lifecycle. */span: typeof traceSpan; /** Record a named point-in-time value alongside the trace. */
+  checkpoint(name: string, data: unknown): void;
+};
+/** Build a queryable trace tree helper from a flat span list and checkpoints. */
+declare function buildTraceTree(spans: EvalTraceSpan[], checkpoints: Map<string, unknown>): EvalTraceTree;
+/** Hash the components of a cache key into a deterministic hex digest. */
+declare function hashCacheKey(input: {
+  namespace: string;
+  codeFingerprint: string;
+  key: unknown;
+}): string;
+//#endregion
+//#region ../runner/src/cacheStore.d.ts
+/** Filter accepted by `FsCacheStore.clear` to narrow the set of entries removed. */
+type CacheClearFilter = {
+  namespace?: string;
+  key?: string;
+};
+//#endregion
+//#region ../runner/src/runner.d.ts
+/** Imperative runner interface used by the server and CLI. */
+type EvalRunner = {
+  /** Load workspace config, discover evals, and start file watching when enabled. */init(): Promise<void>; /** Return the currently discovered eval summaries for the active workspace. */
+  getEvals(): EvalSummary[]; /** Look up one discovered eval by id. */
+  getEval(id: string): EvalSummary | undefined; /** Re-scan configured eval files and emit a discovery update to listeners. */
+  refreshDiscovery(): Promise<void>;
+  startRun(request: CreateRunRequest): Promise<{
+    manifest: RunManifest;
+    summary: RunSummary;
+    cases: CaseRow[];
+  }>; /** Return run manifests tracked in memory, including persisted runs loaded during init. */
+  getRuns(): RunManifest[]; /** Return one run with its summary and case rows when available in memory. */
+  getRun(id: string): {
+    manifest: RunManifest;
+    summary: RunSummary;
+    cases: CaseRow[];
+  } | undefined; /** Request cancellation for an in-flight run. */
+  cancelRun(id: string): void; /** Return full details for a single case in a run, when available. */
+  getCaseDetail(runId: string, caseId: string): CaseDetail | undefined; /** Subscribe to streamed events for a specific run. */
+  subscribe(runId: string, listener: (event: SseEnvelope) => void): () => void; /** Subscribe to discovery updates triggered by file changes or manual refresh. */
+  subscribeDiscovery(listener: (event: SseEnvelope) => void): () => void; /** Resolve the workspace root backing this runner instance. */
+  getWorkspaceRoot(): string; /** Resolve a persisted artifact path when artifact storage is supported. */
+  getArtifactPath(artifactId: string): string | undefined; /** Return summaries for every persisted cache entry in the workspace. */
+  listCache(): Promise<CacheListItem[]>;
+  /**
+   * Remove cache entries matching `filter`, or all entries when no filter is
+   * supplied.
+   */
+  clearCache(filter?: CacheClearFilter): Promise<void>; /** Recompute persisted case and run statuses for terminal runs touching one eval. */
+  recomputeStatusesForEval(evalId: string): Promise<{
+    updatedRuns: number;
+  }>; /** Delete terminal persisted runs that touch one eval from in-memory history and disk. */
+  cleanRunsForEval(evalId: string): Promise<{
+    deletedRuns: number;
+  }>; /** Persist a UI-authored manual score for one case and recompute affected summaries. */
+  updateManualScore(params: {
+    runId: string;
+    caseId: string;
+    scoreKey: string;
+    value: number | null;
+  }): Promise<{
+    updated: true;
+    run: {
+      manifest: RunManifest;
+      summary: RunSummary;
+      cases: CaseRow[];
+    };
+    caseDetail: CaseDetail;
+  } | {
+    updated: false;
+    reason: string;
+  }>;
+  /**
+   * Delete one persisted run from in-memory history and disk.
+   *
+   * Ignored for in-flight runs — cancel first, then delete.
+   * Returns `deleted: false` when the run is missing or still running.
+   */
+  deleteRun(runId: string): Promise<{
+    deleted: boolean;
+  }>;
+};
+type CreateRunnerOptions = {
+  watchForChanges?: boolean;
+};
+/** Create an in-memory eval runner bound to the current workspace config. */
+declare function createRunner({
+  watchForChanges
+}?: CreateRunnerOptions): EvalRunner;
+//#endregion
+//#region src/cli.d.ts
+/**
+ * Run the Agent Evals CLI against the current workspace.
+ *
+ * @param argv Raw command-line arguments excluding the executable name.
+ */
+declare function runCli(argv: string[]): Promise<void>;
+//#endregion
+export { type AgentEvalsConfig, type AssertionFailure, type CacheAdapter, type CacheEntry, type CacheListItem, type CacheMode, type CacheRecording, type CacheRecordingFrame, type CacheRecordingOp, type CacheScopeContext, type CaseDetail, type CaseRow, type CellValue, type ColumnDef, type ColumnFormat, type ColumnKind, type CreateRunRequest, type DerivedStatus, EvalAssertionError, type EvalCase, type EvalCaseScope, type EvalChartAggregate, type EvalChartAxis, type EvalChartBuiltinMetric, type EvalChartColor, type EvalChartConfig, type EvalChartMetric, type EvalChartTooltipExtra, type EvalChartType, type EvalChartsConfig, type EvalColumnOverride, type EvalColumns, type EvalDefinition, type EvalDeriveContext, type EvalDisplayStatus, type EvalExecuteContext, type EvalFreshnessStatus, type EvalManualScoreDef, type EvalRunner, type EvalScoreContext, type EvalScoreDef, type EvalScoreFn, type EvalStatAggregate, type EvalStatItem, type EvalStatsConfig, type EvalSummary, type EvalTraceSpan, type EvalTraceTree, type FileRef, type JsonCell, type NumberDisplayOptions, type RepoFileRef, type RunArtifactRef, type RunInEvalScopeOptions, type RunManifest, type RunSummary, type ScalarCell, type ScopedCaseSummary, type ScoreTrace, type SerializedCacheSpan, type SpanCacheOptions, type SseEnvelope, type SseEventType, type TraceActiveSpan, type TraceAttributeDisplay, type TraceAttributeDisplayFormat, type TraceAttributeDisplayInput, type TraceAttributeDisplayPlacement, type TraceAttributeTransform, type TraceAttributeTransformContext, type TraceDisplayConfig, type TraceDisplayInputConfig, type TraceSpanInfo, type TraceSpanKind, type TrialSelectionMode, type UpdateManualScoreRequest, agentEvalsConfigSchema, assertionFailureSchema, buildTraceTree, cacheEntrySchema, cacheListItemSchema, cacheModeSchema, cacheRecordingOpSchema, cacheRecordingSchema, caseDetailSchema, caseRowSchema, cellValueSchema, columnDefSchema, columnFormatSchema, columnKindSchema, createRunRequestSchema, createRunner, defineEval, deriveScopedSummaryFromCases, deriveStatusFromCaseRows, deriveStatusFromChildStatuses, evalAssert, evalChartAggregateSchema, evalChartAxisSchema, evalChartBuiltinMetricSchema, evalChartColorSchema, evalChartConfigSchema, evalChartMetricSchema, evalChartTooltipExtraSchema, evalChartTypeSchema, evalChartsConfigSchema, evalFreshnessStatusSchema, evalSpan, evalStatAggregateSchema, evalStatItemSchema, evalStatsConfigSchema, evalSummarySchema, evalTracer, fileRefSchema, getCurrentScope, getEvalDisplayStatus, getEvalRegistry, getEvalTitle, hashCacheKey, incrementEvalOutput, isInEvalScope, jsonCellSchema, numberDisplayOptionsSchema, repoFile, repoFileRefSchema, runArtifactRefSchema, runCli, runInEvalScope, runManifestSchema, runSummarySchema, scoreTraceSchema, serializedCacheSpanSchema, setEvalOutput, setScopeCacheContext, spanCacheOptionsSchema, sseEnvelopeSchema, traceAttributeDisplayFormatSchema, traceAttributeDisplayInputSchema, traceAttributeDisplayPlacementSchema, traceAttributeDisplaySchema, traceDisplayConfigSchema, traceDisplayInputConfigSchema, traceSpanKindSchema, traceSpanSchema, trialSelectionModeSchema, updateManualScoreRequestSchema };