static-fire 0.0.0-stage → 0.44.0

package/src/core/view.ts

@@ -0,0 +1,498 @@
+// The view: the comparable trials for a set of filters, pooled across batches, with their summary.
+// `static-fire show`, GET /api/view and the dashboard all read it through buildView().
+//
+// Comparability is computed from content (spec #1, "Model"): a trial is in the view when it ran on the task
+// hash in view and its latest finished grading under the grading hash in view is that grading. Trials from
+// every batch pool by config key. SQL (through the store) only selects rows; score.ts computes the means,
+// confidence intervals, indexes and dead criteria (DEC-2). Run conditions never decide comparability (DEC-3).
+import type { GradingRecord, GradingSetupRecord, Store, TrialRecord } from "./db";
+import { namedSetup, versionNames } from "./grading-versions";
+import type { NamedGradingSetup, VersionName } from "./grading-versions";
+import { gradingHash as currentGradingHash, taskHash as currentTaskHash } from "./identity";
+import type { CriterionContent, GradingContent } from "./identity";
+import { summarize } from "./score";
+import { CONFIG_FACETS, valueSet } from "./view-query";
+import type { ConfigFacet } from "./view-query";
+import { loadJudges, loadSuites, loadTask } from "./authored";
+import { projectRoot } from "./project";
+import type { AgentConfig, ConfigSummary, Criterion, Experiment, Grades, JudgeConfig, Measure, Suite, Task, TaskSnapshot, Trial, Verdict } from "./types";
+
+// ---- Inputs ------------------------------------------------------------------------------------
+
+/** What the caller asks for. Every field is optional; an empty object is the default view. */
+export interface ViewFilters {
+  /** Suite ids. Their tasks are in scope and the Workflow Index is the mean over these suites. Default: every suite. */
+  suites?: string[];
+  /** Task ids. When set, only these tasks are in scope and no suite is (so no Suite or Workflow Index). Wins over `suites`. */
+  tasks?: string[];
+  /** Judge id from judges.yaml. Default: the first one (the default judge). */
+  judge?: string;
+  /**
+   * A grading hash, in full or a unique prefix. It replaces the current grading hash, and the task hash, of
+   * the tasks that grading setup belongs to (db.ts gradingSetupTaskIds); this is how an earlier task version is
+   * reached. One of those tasks must be in scope. Its judge is the judge of the whole view: `judge`, when also
+   * given, must name that judge.
+   */
+  grading?: string;
+  /**
+   * Config facets: only trials whose config has any of these harnesses, models, efforts or Profiles; a trial
+   * must match every facet that has a value. `none` matches a config without an effort or a Profile. An empty
+   * list is no filter. They narrow which configs are in the view (summary, dead criteria and left-out counts
+   * included) and never change the task hash or grading hash in view.
+   */
+  harness?: string[];
+  model?: string[];
+  effort?: string[];
+  profile?: string[];
+  /** Trials that started on or after this time. A date ("2026-11-06") means 00:00 UTC that day. */
+  since?: string;
+  /** Trials that started on or before this time. A date means to the end of that day (UTC). */
+  until?: string;
+}
+
+/** The authored definitions the view reads. Default: the YAML files of the project. Tests pass their own. */
+export interface Catalog {
+  suites: Suite[];
+  judges: JudgeConfig[];
+  loadTask(id: string): Task;
+}
+
+export const projectCatalog = (root = projectRoot()): Catalog => ({ suites: loadSuites(root), judges: loadJudges(root), loadTask: (id) => loadTask(id, root) });
+
+// ---- Output ------------------------------------------------------------------------------------
+
+/** One task in scope. Hashes are always full (64 hex characters); short forms are for display only. */
+export interface ViewTask {
+  /** The task hash in view: the current one, or the grading setup's when `grading` picked an earlier one. */
+  taskHash: string;
+  /** The grading hash in view: the current one for the judge, or the one `grading` picked. */
+  gradingHash: string;
+  /** The grading version name of that grading hash (versionNames), or null when the store has no row for it yet. */
+  gradingName: string | null;
+  /**
+   * The task file's `version` stored with that task hash (a readable label only), else the file's current one.
+   * Null when the task has none: it is then shown by its short task hash alone.
+   */
+  label: number | null;
+  /** True when both hashes are the ones today's files give for the judge in view. */
+  current: boolean;
+  /** The task's criteria as that grading setup used them (see taskDefinition). */
+  def: TaskSnapshot;
+}
+
+/**
+ * One trial in the view, in today's `Trial` shape so the dashboard components keep working, plus its record
+ * fields. `configId` is the config key (what trials pool by); the config file name is `configFile`.
+ * `status` is "done" (valid: counts in the means), "invalid" (its grading in view is invalid, or it copied the
+ * held-out original) or "failed" (the harness could not run). `experimentId` is the batch id.
+ */
+export interface ViewTrial extends Trial {
+  batchId: string;
+  configKey: string;
+  configFile: string;
+  taskHash: string;
+  /** The grading that counts for this trial in the view, or null for a failed or held-out-copy trial. */
+  gradingId: number | null;
+  gradedAt: string | null;
+}
+
+/** The trials of one config on one task that the view pools. */
+export interface Pooled {
+  /** Valid trials in the mean. */
+  n: number;
+  /** Earliest and latest start time of those trials (null when n is 0). */
+  from: string | null;
+  to: string | null;
+  /** The batches they came from. */
+  batches: string[];
+  /** How many distinct user setups and Profile versions (Profile hashes) those trials ran under. Information only (DEC-3). */
+  setups: number;
+  profiles: number;
+}
+
+/** A config's row: score.ts's ConfigSummary (configId = config key), plus pooling and partial information. */
+export interface ViewConfigSummary extends ConfigSummary {
+  configKey: string;
+  /** The config file names its trials in view were run under (a renamed file keeps its history). */
+  configFiles: string[];
+  /** Task id → the trials pooled for that task. */
+  pooled: Record<string, Pooled>;
+  /**
+   * Suite id → null when the config has a valid score on every task of the suite (it has a Suite Index), else
+   * how many it has: the row reads "partial (have of of tasks)" and `suites[id].mean` is null.
+   */
+  partial: Record<string, { have: number; of: number } | null>;
+  /**
+   * How many distinct user setups and Profile versions all the config's pooled trials in the view ran under.
+   * Above 1 the row says so ("2 setups, 2 Profile versions"). Information only: never part of comparability (DEC-3).
+   */
+  conditions: { setups: number; profiles: number };
+}
+
+/** A count of left-out trials and of the distinct configs (config keys) they belong to. */
+export interface LeftOutCount { trials: number; configs: number }
+
+/** A grading version of an earlier task version, with how many of that version's trials it holds (see OtherTaskVersion). */
+export type CountedGradingSetup = NamedGradingSetup & { trials: number };
+
+/** One earlier (or other) task version that some trials ran on. */
+export interface OtherTaskVersion {
+  taskId: string;
+  /** Full task hash. */
+  taskHash: string;
+  /** The task file's `version` stored with that hash, or null if the store has no record of it. */
+  label: number | null;
+  /**
+   * Trials in scope and the date range that ran on this task hash, every ended one (failed ones and a human
+   * config's earlier trials too). A grading version's `trials` counts fewer: only the ones the view would show.
+   */
+  trials: number;
+  /**
+   * Every grading version stored for this task hash, oldest first, with its name and `trials`: how many of this
+   * version's trials (counted as the view counts them) have a latest grading under it that is valid.
+   * Set one as `grading` to view this version.
+   */
+  gradingSetups: CountedGradingSetup[];
+  /**
+   * The grading version a link to this task version opens (see linkTarget), or null when none is stored.
+   */
+  link: string | null;
+}
+
+/**
+ * Trials in scope and in the date range that the view leaves out, by reason. Trials outside the scope or the
+ * date range are not counted anywhere. A human config's earlier trials (only its latest counts) and trials
+ * that have not ended are not counted either.
+ */
+export interface LeftOut {
+  /** Ran on the task hash in view, but graded only under another grading hash (other criteria or another judge). Regrading brings them in. */
+  otherGrading: LeftOutCount;
+  /** Ran on another task hash: they did a different job. Reached only by choosing one of its grading setups. */
+  otherTask: LeftOutCount & { versions: OtherTaskVersion[] };
+  /** Ran on the task hash in view and ended, but have no finished grading under any grading hash. */
+  ungraded: LeftOutCount;
+  /**
+   * The ids of the trials counted under `otherGrading` and `ungraded`, sorted: what a regrade of this view
+   * grades (POST /api/regrade), so it matches the view's date range, facets and human-config rule exactly.
+   */
+  gradable: string[];
+}
+
+export interface View {
+  /** The filters as resolved: ids, the judge, and the date bounds actually applied (ISO times). */
+  filters: {
+    suiteIds: string[]; taskIds: string[]; judge: JudgeConfig; grading: string | null; since: string | null; until: string | null;
+    /** The values of each config facet applied, sorted (absent when not set). */
+    harness?: string[]; model?: string[]; effort?: string[]; profile?: string[];
+  };
+  /** Task id → the task in scope. */
+  tasks: Record<string, ViewTask>;
+  /** The trials in the view, by task, config key, then id. */
+  trials: ViewTrial[];
+  /** One row per config key with a trial in the view, and the dead criteria among those configs. */
+  summary: { configs: ViewConfigSummary[]; deadCriteria: Record<string, string[]> };
+  leftOut: LeftOut;
+}
+
+// ---- The view ----------------------------------------------------------------------------------
+
+/** Selects and summarises the comparable trials for `filters`. Throws on an unknown id or an unusable filter. */
+export function buildView(store: Store, filters: ViewFilters = {}, catalog: Catalog = projectCatalog()): View {
+  const { suites, taskIds } = scope(filters, catalog);
+  const since = bound(filters.since, "since"), until = bound(filters.until, "until");
+  const picked = filters.grading ? pickGrading(store, filters.grading) : null;
+  // A view shows one judge: a picked grading setup's judge, for every task in scope.
+  const judge = picked ? setupJudge(picked, filters.judge, catalog.judges) : pickJudge(filters.judge, catalog.judges);
+  const pickedTasks = new Set(picked ? store.gradingSetupTaskIds(picked.hash) : []);
+  if (picked && !taskIds.some((t) => pickedTasks.has(t))) {
+    throw new Error(`grading version ${picked.hash} is for task ${[...pickedTasks].join(", ")}, which is not in scope (${taskIds.join(", ")})`);
+  }
+
+  const tasks: Record<string, ViewTask> = {};
+  const inView: ViewTrial[] = [];
+  const records = new Map<string, TrialRecord>();   // trial id → its row, for the config fields
+  const left = { otherGrading: new Counter(), otherTask: new Counter(), ungraded: new Counter() };
+  const otherVersions = new Map<string, { version: OtherTaskVersion; rows: TrialRecord[] }>();   // with its trials, to count per grading version
+  const gradable: string[] = [];
+
+  for (const taskId of taskIds) {
+    const task = catalog.loadTask(taskId);
+    const nowTask = currentTaskHash(task), nowGrading = currentGradingHash(task, judge);
+    const names = versionNames(store, taskId);
+    const tHash = pickedTasks.has(taskId) ? picked!.taskHash : nowTask;
+    const gHash = pickedTasks.has(taskId) ? picked!.hash : nowGrading;
+    const stored = store.getTaskVersion(tHash);
+    const label = stored ? stored.label : task.version ?? null;   // a stored task version keeps its label, even none
+    tasks[taskId] = {
+      taskHash: tHash, gradingHash: gHash, gradingName: names.get(gHash)?.name ?? null,   // null: today's grading version is not stored yet
+      label,
+      current: tHash === nowTask && gHash === nowGrading,
+      def: gHash === nowGrading ? snapshotOf(task) : taskDefinition(task, picked!, label),
+    };
+
+    const rows = store.listTrials({ taskId }).filter((r) => ENDED.has(r.status) && inRange(r.startedAt, since, until) && matchesConfig(r, filters));
+    const same: TrialRecord[] = [];
+    for (const r of rows) {
+      if (r.taskHash === tHash) { same.push(r); continue; }
+      left.otherTask.add(r.configKey);
+      const key = `${taskId}\0${r.taskHash}`;   // two tasks can share an assignment (task hash): each keeps its own entry
+      const v = otherVersions.get(key) ?? otherVersions.set(key, { version: otherVersion(store, taskId, r.taskHash, names), rows: [] }).get(key)!;
+      v.version.trials++;
+      v.rows.push(r);
+    }
+    for (const r of latestHumanOnly(same)) {
+      records.set(r.id, r);
+      if (r.status !== "done") { inView.push(viewTrial(r, null, [])); continue; }   // failed, or copied the held-out original
+      const g = store.currentGrading(r.id, gHash);
+      if (g) { inView.push(viewTrial(r, g, store.listVerdicts(g.id))); continue; }
+      const other = store.listGradings(r.id).some((x) => x.status !== "grading");
+      (other ? left.otherGrading : left.ungraded).add(r.configKey);
+      gradable.push(r.id);
+    }
+  }
+
+  for (const { version: v, rows } of otherVersions.values()) {
+    const shown = latestHumanOnly(rows).filter((r) => r.status === "done");
+    for (const g of v.gradingSetups) g.trials = shown.filter((r) => store.currentGrading(r.id, g.hash)?.status === "done").length;
+    v.link = linkTarget(v.gradingSetups, judge);
+  }
+
+  inView.sort((a, b) => cmp(a.taskId, b.taskId) || cmp(a.configKey, b.configKey) || cmp(a.id, b.id));
+  return {
+    filters: {
+      suiteIds: suites.map((s) => s.id), taskIds, judge, grading: picked?.hash ?? null, since, until,
+      ...Object.fromEntries(CONFIG_FACETS.map((k) => [k, valueSet(filters[k] ?? [])] as const).filter(([, v]) => v.length)),
+    },
+    tasks,
+    trials: inView,
+    summary: summarizeTrials(inView, records, tasks, suites),
+    leftOut: {
+      otherGrading: left.otherGrading.count(),
+      otherTask: { ...left.otherTask.count(), versions: [...otherVersions.values()].map((x) => x.version) },
+      ungraded: left.ungraded.count(),
+      gradable: gradable.sort(),
+    },
+  };
+}
+
+// ---- Selection ---------------------------------------------------------------------------------
+
+const ENDED = new Set(["done", "failed", "invalid"]);
+const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0);
+
+function scope(f: ViewFilters, catalog: Catalog): { suites: Suite[]; taskIds: string[] } {
+  if (f.tasks?.length) return { suites: [], taskIds: [...new Set(f.tasks)] };
+  const byId = new Map(catalog.suites.map((s) => [s.id, s]));
+  const suites = f.suites?.length
+    ? [...new Set(f.suites)].map((id) => byId.get(id) ?? fail(`no suite ${id} (suites: ${[...byId.keys()].join(", ") || "none"})`))
+    : catalog.suites;
+  return { suites, taskIds: [...new Set(suites.flatMap((s) => s.tasks))] };
+}
+
+function pickJudge(id: string | undefined, judges: JudgeConfig[]): JudgeConfig {
+  if (!judges.length) fail("judges.yaml lists no judge");
+  if (id === undefined) return judges[0]!;
+  return judges.find((j) => j.id === id) ?? fail(`no judge ${id} (judges: ${judges.map((j) => j.id).join(", ")})`);
+}
+
+/** True when a judge config is the judge a grading setup recorded (harness, model, effort). */
+export const isSetupJudge = (j: Pick<JudgeConfig, "harness" | "model" | "effort">, s: Pick<GradingSetupRecord, "judgeHarness" | "judgeModel" | "judgeEffort">) =>
+  j.harness === s.judgeHarness && j.model === s.judgeModel && (j.effort ?? null) === s.judgeEffort;
+
+/**
+ * The judge of a view on a picked grading setup: the setup's judge, from judges.yaml when it is there, else built
+ * from the setup's own fields. A judge id given with it must name that judge.
+ */
+function setupJudge(s: GradingSetupRecord, id: string | undefined, judges: JudgeConfig[]): JudgeConfig {
+  if (id !== undefined) {
+    const named = pickJudge(id, judges);
+    if (!isSetupJudge(named, s)) {
+      fail(`grading version ${s.hash.slice(0, 12)} was graded by judge ${s.judgeLabel}; it cannot be shown with judge ${id}. Leave out the judge, or pick a grading version of that judge.`);
+    }
+    return named;
+  }
+  return judges.find((j) => isSetupJudge(j, s)) ?? {
+    id: [s.judgeHarness, s.judgeModel, s.judgeEffort].filter(Boolean).join("/"), label: s.judgeLabel,
+    harness: s.judgeHarness as JudgeConfig["harness"], model: s.judgeModel, ...(s.judgeEffort ? { effort: s.judgeEffort } : {}),
+  };
+}
+
+function pickGrading(store: Store, prefix: string): GradingSetupRecord {
+  const p = prefix.toLowerCase();
+  const found = store.listGradingSetups().filter((g) => g.hash.startsWith(p));
+  if (found.length === 1) return found[0]!;
+  return fail(found.length ? `grading ${prefix} matches ${found.length} grading versions; give more characters` : `no grading version ${prefix}`);
+}
+
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+
+/** A filter's date bound as an ISO time: since → start of the day, until → last millisecond of the day. */
+function bound(value: string | undefined, which: "since" | "until"): string | null {
+  if (value === undefined || value === "") return null;
+  const iso = DATE_ONLY.test(value) ? `${value}T${which === "since" ? "00:00:00.000" : "23:59:59.999"}Z` : value;
+  const t = new Date(iso);
+  if (Number.isNaN(t.getTime())) fail(`--${which} ${value} is not a date (use 2026-11-06 or an ISO time)`);
+  return t.toISOString();
+}
+
+function inRange(startedAt: string | null, since: string | null, until: string | null): boolean {
+  if (!since && !until) return true;
+  if (!startedAt) return false;
+  const t = new Date(startedAt).getTime();
+  return (!since || t >= new Date(since).getTime()) && (!until || t <= new Date(until).getTime());
+}
+
+export { CONFIG_FACETS };
+export type { ConfigFacet };
+/** The value used for a config without an effort or a Profile. */
+export const NONE = "none";
+
+/** A trial's value for a config facet: its field, or `none` when the config has no effort or Profile. */
+export const facetValue = (r: TrialRecord, k: ConfigFacet): string => r[k] || NONE;
+
+/** True when, for every config facet with a value, the trial's config has one of its values. Empty values are no pick. */
+const matchesConfig = (r: TrialRecord, f: ViewFilters) => CONFIG_FACETS.every((k) => { const v = valueSet(f[k] ?? []); return !v.length || v.includes(facetValue(r, k)); });
+
+/** A human config counts only its latest trial per task: each run grades the newest draft. Rows are of one task. */
+function latestHumanOnly(rows: TrialRecord[]): TrialRecord[] {
+  const latest = new Map<string, TrialRecord>();
+  for (const r of rows) {
+    if (!r.configKey.startsWith("human:")) continue;
+    const cur = latest.get(r.configKey);
+    if (!cur || cmp(`${r.startedAt ?? ""}\u0000${r.id}`, `${cur.startedAt ?? ""}\u0000${cur.id}`) > 0) latest.set(r.configKey, r);
+  }
+  return rows.filter((r) => !r.configKey.startsWith("human:") || latest.get(r.configKey) === r);
+}
+
+class Counter {
+  private trials = 0;
+  private configs = new Set<string>();
+  add(configKey: string) { this.trials++; this.configs.add(configKey); }
+  count(): LeftOutCount { return { trials: this.trials, configs: this.configs.size }; }
+}
+
+function otherVersion(store: Store, taskId: string, taskHash: string, names: Map<string, VersionName>): OtherTaskVersion {
+  return {
+    taskId, taskHash, label: store.getTaskVersion(taskHash)?.label ?? null, trials: 0,
+    gradingSetups: store.listGradingSetups(taskId).filter((g) => g.taskHash === taskHash).map((s) => ({ ...namedSetup(s, names), trials: 0 })),
+    link: null,
+  };
+}
+
+/**
+ * The grading version a link to an earlier task version opens, so the reader sees that version's trials: one by
+ * the judge in view when there is one (else any judge), then the one holding the most trials, then the newest.
+ * `setups` is oldest first. Null when there is none.
+ */
+function linkTarget(setups: CountedGradingSetup[], judge: JudgeConfig): string | null {
+  const byJudge = setups.filter((g) => g.judgeHarness === judge.harness && g.judgeModel === judge.model && (g.judgeEffort ?? null) === (judge.effort ?? null));
+  const pool = byJudge.length ? byJudge : setups;
+  let best: CountedGradingSetup | undefined;
+  for (const g of pool) if (!best || g.trials >= best.trials) best = g;   // >=: on a tie the later (newer) one wins
+  return best?.hash ?? null;
+}
+
+// ---- Task definitions --------------------------------------------------------------------------
+
+const snapshotOf = (t: Task): TaskSnapshot => ({ id: t.id, title: t.title, description: t.description, version: t.version, gates: t.gates, measures: t.measures });
+
+/**
+ * The criteria an earlier grading setup graded with, from its snapshot. The snapshot leaves out what cannot
+ * change a score, so `level` and measure labels come from today's task file where the id still exists
+ * (else "strong" and the measure id).
+ */
+function taskDefinition(task: Task, setup: GradingSetupRecord, version: number | null): TaskSnapshot {
+  const snap = setup.snapshot as unknown as GradingContent;
+  const today = new Map<string, Criterion>([...task.gates, ...task.measures.flatMap((m) => m.criteria)].map((c) => [c.id, c]));
+  const labels = new Map(task.measures.map((m) => [m.id, m.label]));
+  const crit = (c: CriterionContent): Criterion => ({ ...c, level: today.get(c.id)?.level ?? "strong" });
+  const byId = new Map(snap.criteria.map((c) => [c.id, c]));
+  const measures: Measure[] = snap.measures.map((m) => ({
+    id: m.id, label: labels.get(m.id) ?? m.id, weight: m.weight,
+    criteria: m.criteria.map((id) => byId.get(id)).filter((c): c is CriterionContent => !!c).map(crit),
+  }));
+  return { id: task.id, title: task.title, description: task.description, ...(version != null ? { version } : {}), gates: snap.gates.map(crit), measures };
+}
+
+// ---- Trials ------------------------------------------------------------------------------------
+
+function viewTrial(r: TrialRecord, g: GradingRecord | null, verdicts: ReturnType<Store["listVerdicts"]>): ViewTrial {
+  const byCriterion: Record<string, Verdict> = {};
+  for (const v of verdicts) byCriterion[v.criterionId] = { score: v.score, votes: v.votes, ...(v.error ? { error: v.error } : {}) };
+  const grades: Grades | undefined = g ? {
+    verdicts: byCriterion,
+    gatesPassed: g.gatesPassed ?? false,
+    measures: g.measures ?? {},
+    score: g.score ?? 0,
+    errors: verdicts.filter((v) => v.score == null).map((v) => v.criterionId),
+    judgeCostUsd: g.judgeCostUsd ?? 0,
+  } : undefined;
+  const status = r.status === "done" && g?.status === "invalid" ? "invalid" : (r.status as "done" | "failed" | "invalid");
+  return {
+    id: r.id, experimentId: r.batchId, batchId: r.batchId, taskId: r.taskId, taskHash: r.taskHash,
+    configId: r.configKey, configKey: r.configKey, configFile: r.configId, index: r.n, status,
+    startedAt: r.startedAt ?? undefined, endedAt: r.endedAt ?? undefined, durationMs: r.durationMs ?? undefined,
+    result: {
+      ok: r.status !== "failed", ...(r.error ? { error: r.error } : {}),
+      usage: { inputTokens: r.inputTokens ?? 0, outputTokens: r.outputTokens ?? 0, cacheReadTokens: r.cacheReadTokens ?? 0, cacheWriteTokens: r.cacheWriteTokens ?? 0 },
+      costUsd: r.costUsd, costSource: (r.costSource ?? "unknown") as "reported" | "estimated" | "unknown",
+      ...(r.turns != null ? { turns: r.turns } : {}),
+    },
+    grades,
+    ...(r.error ? { error: r.error } : g?.error ? { error: g.error } : {}),
+    gradingId: g?.id ?? null, gradedAt: g?.gradedAt ?? null,
+  };
+}
+
+// ---- Summary (score.ts does the numbers) -------------------------------------------------------
+
+/** The view's summary over `trials` (each with its row in `records`), for the tasks and suites given. Also used by compareGradings. */
+export function summarizeTrials(trials: ViewTrial[], records: Map<string, TrialRecord>, tasks: Record<string, ViewTask>, suites: Suite[]): View["summary"] {
+  const keys = [...new Set(trials.map((t) => t.configKey))].sort();
+  const configs: Record<string, AgentConfig> = {};
+  const files = new Map<string, Set<string>>();
+  for (const t of trials) {
+    // Every trial of a key has the same config fields (they make the key); the latest one's family wins.
+    configs[t.configKey] = configOf(records.get(t.id)!);
+    (files.get(t.configKey) ?? files.set(t.configKey, new Set()).get(t.configKey)!).add(t.configFile);
+  }
+  const exp: Experiment = {
+    schema: 2, id: "view", suiteIds: suites.map((s) => s.id),
+    tasks: Object.fromEntries(Object.entries(tasks).map(([id, t]) => [id, t.label])),
+    configIds: keys, trialsPerConfig: 0, judge: { id: "", label: "", harness: "claude", model: "", votes: 0 },
+    createdAt: "", status: "done", configs, suites: Object.fromEntries(suites.map((s) => [s.id, s])),
+  };
+  const defs = Object.values(tasks).map((t) => t.def as Task);
+  const s = summarize(exp, trials, defs);
+  return {
+    deadCriteria: s.deadCriteria,
+    configs: s.configs.map((c): ViewConfigSummary => {
+      const pooled: Record<string, Pooled> = {};
+      const conditions = (valid: ViewTrial[]) => {
+        const distinct = (pick: (r: TrialRecord) => string | null) => new Set(valid.map((t) => pick(records.get(t.id)!)).filter((x) => x != null)).size;
+        return { setups: distinct((r) => r.setupHash), profiles: distinct((r) => r.profileHash) };
+      };
+      const all: ViewTrial[] = [];
+      for (const taskId of Object.keys(tasks)) {
+        const valid = trials.filter((t) => t.configKey === c.configId && t.taskId === taskId && t.status === "done" && t.grades);
+        all.push(...valid);
+        const starts = valid.map((t) => t.startedAt).filter((x): x is string => !!x).sort();
+        pooled[taskId] = { n: valid.length, from: starts[0] ?? null, to: starts.at(-1) ?? null, batches: [...new Set(valid.map((t) => t.batchId))].sort(), ...conditions(valid) };
+      }
+      const partial: ViewConfigSummary["partial"] = {};
+      for (const suite of suites) {
+        const have = suite.tasks.filter((t) => c.tasks[t]?.score.mean != null).length;
+        partial[suite.id] = have === suite.tasks.length ? null : { have, of: suite.tasks.length };
+      }
+      return { ...c, configKey: c.configId, configFiles: [...files.get(c.configId)!].sort(), pooled, partial, conditions: conditions(all) };
+    }),
+  };
+}
+
+const configOf = (r: TrialRecord): AgentConfig => ({
+  id: r.configKey, harness: r.harness as AgentConfig["harness"], model: r.model,
+  ...(r.effort ? { effort: r.effort } : {}), ...(r.profile ? { profile: r.profile } : {}),
+  ...(r.provider ? { provider: r.provider } : {}), ...(r.family ? { family: r.family } : {}),
+});
+
+function fail(message: string): never { throw new Error(message); }