@visual-z/xeno 0.7.1 → 0.8.0

package/src/store/workspace.ts

@@ -1,32 +1,18 @@
 /**
- * Workspace scanning, reconciliation and restore.
+ * A bounded content scan of a workspace: relative path -> digest, and one
+ * version digest over the whole set.
  *
- * The tree can move a cursor between nodes; this is what lets the files move
- * with it. Two properties shape everything here:
- *
- *   TURN GRANULARITY. The workspace is scanned once per turn, not per tool
- *   call. Per-call is too fine to be meaningful -- the documented criticism
- *   of character-level versioning is that a single keystroke is not a change
- *   -- and a turn is the same unit as "a message and the edit it produced".
- *
- *   TWO INDEPENDENT SOURCES. A tool's effect says what the tool CLAIMED to
- *   do; a scan says what ACTUALLY changed. bash can write anywhere and its
- *   effect records only an exit code, so without the scan an edit outside
- *   every declared path would be invisible -- and a restore would silently
- *   fail to undo it. Comparing the two makes that detectable, which is the
- *   same rule the handoff applies to the model: claims are checked, not
- *   believed.
- *
- * A restore moves the workspace and nothing else. Migrations, sent requests
- * and started processes do not come back, and applyRestore says so rather
- * than implying it undid the world.
+ * Session file history no longer comes from per-turn scans. P.3 replaced them
+ * with journaled checkpoints and source fingerprints (workspace-observation.ts,
+ * WorkspaceLifecycle), and S.3 removed the compatibility mode that still
+ * scanned. What remains is the scanner itself and the default ignore list the
+ * search and file index share.
  */
 
-import { readdir, rm, stat, lstat } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import type { Dirent } from "node:fs";
-import { join, dirname, relative, sep, isAbsolute } from "node:path";
-import type { Effect } from "../core/events.ts";
-import { blobAddress, digestFile, verifyBlob, restoreBlob } from "./blobs.ts";
+import { join, relative, sep } from "node:path";
+import { blobAddress, digestFile } from "./blobs.ts";
 
 export interface ScanLimits {
   maxFiles: number;
@@ -68,28 +54,6 @@ export type ScanResult =
   | { ok: true; files: FileSet }
   | { ok: false; error: string };
 
-export interface ScanDelta {
-  added: FileSet;
-  changed: FileSet;
-  removed: string[];
-}
-
-export interface Reconciliation {
-  /** Changed on disk with no tool claiming it -- usually a shell command. */
-  undeclared: string[];
-  /** A tool claimed an edit the disk does not show. */
-  declaredButUnchanged: string[];
-}
-
-export interface RestoreResult {
-  restored: string[];
-  removed: string[];
-  /** Target files whose content is no longer in the blob store. */
-  unrecoverable: string[];
-  /** What this restore did not and could not touch. */
-  note: string;
-}
-
 function isIgnored(rel: string, ignore: readonly string[]): boolean {
   const parts = rel.split(sep);
   return ignore.some((i) => parts.includes(i));
@@ -149,114 +113,3 @@ export async function scanWorkspace(
     return error ? { ok: false, error } : { ok: true, files };
   } catch (error) { return { ok: false, error: `incomplete workspace scan: ${String(error)}` }; }
 }
-
-export function diffScans(before: FileSet, after: FileSet): ScanDelta {
-  const added: FileSet = {};
-  const changed: FileSet = {};
-  const removed: string[] = [];
-
-  for (const [path, sha] of Object.entries(after)) {
-    const was = before[path];
-    if (was === undefined) added[path] = sha;
-    else if (was !== sha) changed[path] = sha;
-  }
-  for (const path of Object.keys(before)) {
-    if (!(path in after)) removed.push(path);
-  }
-  return { added, changed, removed: removed.sort() };
-}
-
-export function reconcile(effects: readonly Effect[], observed: ScanDelta): Reconciliation {
-  // Only edits claim to change the workspace. A read claims nothing, and a
-  // command claims only its exit code -- which is exactly why the scan is
-  // needed to see what a command did.
-  const declared = new Set(
-    effects.filter((e) => e.kind === "edit").map((e) => e.path),
-  );
-  const touched = [
-    ...Object.keys(observed.added),
-    ...Object.keys(observed.changed),
-    ...observed.removed,
-  ];
-
-  return {
-    undeclared: touched.filter((p) => !declared.has(p)).sort(),
-    declaredButUnchanged: [...declared].filter((p) => !touched.includes(p)).sort(),
-  };
-}
-
-/**
- * Replays deltas up to and including `toNode` to get the file set at that
- * point. Pure, so a restore can be planned and inspected before anything is
- * written.
- */
-export function planRestore(
-  deltas: readonly (ScanDelta & { node: number })[],
-  toNode: number,
-): FileSet {
-  const files: FileSet = {};
-  for (const d of deltas) {
-    if (d.node > toNode) break;
-    for (const [path, sha] of Object.entries(d.added)) files[path] = sha;
-    for (const [path, sha] of Object.entries(d.changed)) files[path] = sha;
-    for (const path of d.removed) delete files[path];
-  }
-  return files;
-}
-
-export async function applyRestore(
-  root: string,
-  store: string,
-  target: FileSet,
-  ignore: readonly string[],
-): Promise<RestoreResult> {
-  const restored: string[] = [];
-  const unrecoverable: string[] = [];
-
-  // Validate the complete plan before its first write or deletion. Missing
-  // objects and a failed scan cannot be interpreted as an empty target (H).
-  const current = await scanWorkspace(root, ignore);
-  if (!current.ok) throw new Error(current.error);
-  for (const [path, sha] of Object.entries(target)) {
-    if (isAbsolute(path) || path.split(/[\\/]/).some((p) => p === "..") || isIgnored(path, ignore)) {
-      throw new Error(`unsafe restore path: ${path}`);
-    }
-    let parent = dirname(join(root, path));
-    while (parent !== root && parent.startsWith(root + sep)) {
-      try { if ((await lstat(parent)).isSymbolicLink()) throw new Error(`restore path crosses symlink: ${path}`); }
-      catch (error) { if ((error as { code?: string }).code !== "ENOENT") throw error; }
-      parent = dirname(parent);
-    }
-    if (!await verifyBlob(store, sha)) unrecoverable.push(path);
-  }
-  if (unrecoverable.length > 0) return {
-    restored: [], removed: [], unrecoverable: unrecoverable.sort(),
-    note: "Restore not applied: missing snapshot objects. Workspace and cursor remain unchanged.",
-  };
-
-  for (const [path, sha] of Object.entries(target)) {
-    const abs = join(root, path);
-    await restoreBlob(store, sha, abs);
-    restored.push(path);
-  }
-
-  // Anything present but not in the target was created after this point.
-  const removed: string[] = [];
-  if (current.ok) {
-    for (const path of Object.keys(current.files)) {
-      if (path in target) continue;
-      await rm(join(root, path), { force: true });
-      removed.push(path);
-    }
-  }
-
-  return {
-    restored: restored.sort(),
-    removed: removed.sort(),
-    unrecoverable: unrecoverable.sort(),
-    note:
-      "Restored the workspace only. Anything outside it is not undone: " +
-      "database migrations, requests already sent, processes already " +
-      "started, and files outside the workspace root all remain as they are.",
-  };
-}

package/src/tui/ui/screen.ts

@@ -96,7 +96,7 @@ export class Screen {
   private sidebarWanted = true;
   private status: StatusModel | undefined;
   private dockState: DockState = { model: "", thinking: "", busy: false, activity: "" };
-  private transientActivity: { readonly label: string; readonly startedAt: number; readonly timeoutMs: number } | undefined;
+  private transientActivity: { readonly label: string; readonly startedAt: number; readonly timeoutMs: number; readonly detail?: string } | undefined;
   private home: Greeting | undefined;
   private greetingPlayed = false;
   private greetingFrame = MASCOT_FRAMES;
@@ -349,8 +349,9 @@ export class Screen {
     this.paintEdges();
   }
 
-  setTransientActivity(activity: { readonly label: string; readonly timeoutMs: number } | undefined): void {
-    this.transientActivity = activity ? { ...activity, startedAt: Date.now() } : undefined;
+  /** `startedAt` keeps the elapsed clock running when a long activity only refreshes its detail line. */
+  setTransientActivity(activity: { readonly label: string; readonly timeoutMs: number; readonly startedAt?: number; readonly detail?: string } | undefined): void {
+    this.transientActivity = activity ? { ...activity, startedAt: activity.startedAt ?? Date.now() } : undefined;
     this.syncActivity();
     this.paintEdges();
   }
@@ -427,7 +428,7 @@ export class Screen {
     const activity = this.transientActivity!;
     const elapsed = Math.max(0, Math.floor((Date.now() - activity.startedAt) / 1000));
     const deadline = Math.max(1, Math.ceil(activity.timeoutMs / 1000));
-    return `${activity.label} · ${elapsed}s / ${deadline}s max`;
+    return `${activity.label} · ${elapsed}s / ${deadline}s max${activity.detail ? ` · ${activity.detail}` : ""}`;
   }
 
   /** The spinner's current interval (tests). */

package/src/tui/ui/status.ts

@@ -30,7 +30,9 @@ export interface StatusModel {
   readonly version: string;
   /** `/name`, else the first prompt; null for a session with neither. */
   readonly title: string | null;
-  readonly goal?: { readonly text: string; readonly status: string; readonly execution: string; readonly observations: number; readonly retries: number };
+  readonly goal?: { readonly text: string; readonly status: string; readonly execution: string; readonly observations: number; readonly retries: number;
+    /** S.1: one glyph per rung (ran, tests the change, independent, human) and the reading of them, prepared by apps. */
+    readonly ladder?: { readonly glyphs: string; readonly summary: string } };
   readonly workspace: string;
   readonly workspaceShort: string;
   readonly branch: string | null;
@@ -203,7 +205,9 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
   ] });
   const context = model.context;
   if (model.goal) blocks.push({ list: false, items: [], head: [
-    [{ text: "Goal", role: "text", bold: true }, { text: ` · ${model.goal.status}`, role: model.goal.status === "verified" ? "success" : "warning" }],
+    [{ text: "Goal", role: "text", bold: true }, { text: ` · ${model.goal.status}`, role: model.goal.status === "verified" || model.goal.status === "checked" ? "success" : model.goal.status === "not_applicable" ? "muted" : "warning" }],
+    ...(model.goal.ladder ? [[{ text: model.goal.ladder.glyphs, role: "text" }] as Line,
+      ...wrap(model.goal.ladder.summary, w, 2).map(text => [{ text, role: "muted" }] as Line)] : []),
     ...wrap(firstLine(model.goal.text), w, 2).map(text => [{ text, role: "text" }] as Line),
     [{ text: model.goal.execution, role: "muted" }],
     [{ text: `${model.goal.observations} observations · ${model.goal.retries} retries`, role: "muted" }],

package/src/core/benchmark.ts

@@ -1,195 +0,0 @@
-/** Evaluation contracts, separate from production policies (research M.3). */
-import { shuffled } from "./experiment.ts";
-
-export const LONGBENCH_SOURCE = {
-  revision: "2b48e494f2c7a2f0af81aae178e05c7e1dde0fe9",
-  sha256: "15d61c22d92c96900b3c4948b6aeea218d3214b676a65df48e7b8555604c7fe2",
-  scorerRevision: "2e00731f8d0bff23dc4325161044d0ed8af94c1e",
-} as const;
-
-export const BENCHMARK_ARMS = ["node", "replay", "mask"] as const;
-export type BenchmarkArm = typeof BENCHMARK_ARMS[number];
-export type Choice = "A" | "B" | "C" | "D";
-export interface BenchmarkItem {
-  _id: string;
-  domain: string;
-  sub_domain: string;
-  difficulty: "easy" | "hard";
-  length: "short" | "medium" | "long";
-  question: string;
-  choice_A: string;
-  choice_B: string;
-  choice_C: string;
-  choice_D: string;
-  answer: Choice;
-  context: string;
-}
-
-function isBenchmarkItem(value: unknown): value is BenchmarkItem {
-  if (typeof value !== "object" || value === null) return false;
-  const row = value as Record<string, unknown>;
-  for (const key of ["_id", "domain", "sub_domain", "question", "choice_A", "choice_B", "choice_C", "choice_D", "context"]) {
-    if (typeof row[key] !== "string" || row[key].length === 0) return false;
-  }
-  return (row["answer"] === "A" || row["answer"] === "B" || row["answer"] === "C" || row["answer"] === "D") &&
-    (row["difficulty"] === "easy" || row["difficulty"] === "hard") &&
-    (row["length"] === "short" || row["length"] === "medium" || row["length"] === "long");
-}
-
-export function parseBenchmark(data: unknown): BenchmarkItem[] {
-  if (!Array.isArray(data) || data.length === 0) throw new Error("empty or invalid benchmark");
-  const ids = new Set<string>();
-  return data.map((item: unknown) => {
-    if (!isBenchmarkItem(item)) throw new Error("invalid benchmark item");
-    if (ids.has(item._id)) throw new Error(`duplicate benchmark id: ${item._id}`);
-    ids.add(item._id);
-    return item;
-  });
-}
-
-/** Exact LongBench v2 pred.py extraction, pinned in docs/benchmarks.md (MIT). */
-export function extractBenchmarkAnswer(response: string): Choice | null {
-  const plain = response.replaceAll("*", "");
-  return (plain.match(/The correct answer is \(([A-D])\)/)?.[1] ??
-    plain.match(/The correct answer is ([A-D])/)?.[1] ?? null) as Choice | null;
-}
-
-/** Domain-balanced sampling; neither correctness nor answer labels enter selection. */
-export function sampleBenchmark(items: readonly BenchmarkItem[], count: number, seed: number): BenchmarkItem[] {
-  if (!Number.isSafeInteger(count) || count < 1 || count > items.length) throw new RangeError("invalid sample count");
-  const domains = [...new Set(items.map((item) => item.domain))].sort();
-  const buckets = shuffled(domains, seed).map((domain, index) => shuffled(
-    items.filter((item) => item.domain === domain).toSorted((a, b) => a._id.localeCompare(b._id)), seed + index + 1,
-  ));
-  const out: BenchmarkItem[] = [];
-  for (let round = 0; out.length < count; round++) {
-    for (const bucket of buckets) {
-      const item = bucket[round];
-      if (item !== undefined && out.length < count) out.push(item);
-    }
-  }
-  return out;
-}
-
-export interface BenchmarkJob { id: string; arm: BenchmarkArm }
-export type HarnessProfile = "control" | "enhanced";
-export interface HarnessJob { id: string; arm: "node" | "replay"; profile: HarnessProfile }
-
-/** A Latin rotation balances each treatment's position before running any model. */
-export function harnessSchedule(items: readonly BenchmarkItem[], seed: number): HarnessJob[] {
-  const treatments = shuffled([
-    { arm: "node", profile: "control" }, { arm: "replay", profile: "control" },
-    { arm: "node", profile: "enhanced" }, { arm: "replay", profile: "enhanced" },
-  ] as const, seed);
-  const offsets = shuffled(items.map((_, index) => index % treatments.length), seed + 1);
-  return items.flatMap((item, index) => treatments.map((_, position) => ({
-    id: item._id, ...treatments[(position + offsets[index]!) % treatments.length]!,
-  })));
-}
-
-export function summarizeHarness(plan: readonly HarnessJob[], results: readonly (BenchmarkOutcome & { profile: HarnessProfile })[]) {
-  return (["control", "enhanced"] as const).flatMap((profile) => summarizeBenchmark(
-    plan.filter((job) => job.profile === profile), results.filter((result) => result.profile === profile),
-  ).filter((row) => row.planned > 0).map((row) => ({ profile, ...row })));
-}
-/** Pair nearby in time, randomize treatment order inside each task, once before running. */
-export function benchmarkSchedule(items: readonly BenchmarkItem[], seed: number): BenchmarkJob[] {
-  // Balance all six orders before shuffling. Adjacent LCG seeds yield correlated
-  // first draws and can accidentally put the same arm last in every block.
-  const orders: readonly (readonly BenchmarkArm[])[] = [
-    ["node", "replay", "mask"], ["node", "mask", "replay"], ["replay", "node", "mask"],
-    ["replay", "mask", "node"], ["mask", "node", "replay"], ["mask", "replay", "node"],
-  ];
-  const balanced = shuffled(items.map((_, index) => orders[index % orders.length]!), seed);
-  return items.flatMap((item, index) => balanced[index]!.map((arm) => ({ id: item._id, arm })));
-}
-
-/** Split losslessly, including surrogate pairs; chunks are files, not a context truncation. */
-export function benchmarkChunks(context: string, size = 16_000): string[] {
-  if (!Number.isSafeInteger(size) || size < 2) throw new RangeError("chunk size must be at least two");
-  const chunks: string[] = [];
-  for (let start = 0; start < context.length;) {
-    let end = Math.min(context.length, start + size);
-    const last = context.charCodeAt(end - 1);
-    if (end < context.length && last >= 0xd800 && last <= 0xdbff) end--;
-    chunks.push(context.slice(start, end));
-    start = end;
-  }
-  return chunks;
-}
-
-/** Explicit field selection prevents evaluator-only metadata from leaking to the agent. */
-export function benchmarkPrompt(item: BenchmarkItem, chunks: number): string {
-  return `Answer the question using the complete source document in corpus/part-00000.txt through corpus/part-${String(chunks - 1).padStart(5, "0")}.txt. ` +
-    "The numbered files concatenate in order to the original document; none of it was removed. Use read and grep to examine the evidence.\n\n" +
-    `Question: ${item.question}\nChoices:\n(A) ${item.choice_A}\n(B) ${item.choice_B}\n(C) ${item.choice_C}\n(D) ${item.choice_D}\n\n` +
-    'Format your final response as follows: "The correct answer is (insert answer here)".';
-}
-
-export interface BenchmarkPrice { input: number; output: number; cacheRead: number; cacheWrite?: number }
-export interface BenchmarkUsage { input_tokens: number; output_tokens: number; cache_read_input_tokens: number; cache_creation_input_tokens: number }
-
-/** A conservative allowance, not a tokenizer: wire bytes plus framing, at uncached peak rates. */
-export function requestReservation(wireBytes: number, maxOutput: number, price: BenchmarkPrice): number {
-  if (!Number.isSafeInteger(wireBytes) || wireBytes < 0 || !Number.isSafeInteger(maxOutput) || maxOutput < 1) throw new RangeError("invalid request size");
-  return ((wireBytes + 4096) * price.input + maxOutput * price.output) / 1_000_000;
-}
-
-export function measuredCharge(usage: BenchmarkUsage, price: BenchmarkPrice): number | null {
-  const counts = [usage.input_tokens, usage.output_tokens, usage.cache_read_input_tokens, usage.cache_creation_input_tokens];
-  if (counts.some((value) => !Number.isSafeInteger(value) || value < 0) ||
-      usage.input_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens === 0 || usage.output_tokens === 0) return null;
-  return (usage.input_tokens * price.input + usage.cache_creation_input_tokens * (price.cacheWrite ?? price.input) +
-    usage.cache_read_input_tokens * price.cacheRead + usage.output_tokens * price.output) / 1_000_000;
-}
-
-export function canReserve(charged: number, reserve: number, budget: number): boolean {
-  if (![charged, reserve, budget].every(Number.isFinite) || charged < 0 || reserve <= 0 || budget <= 0) return false;
-  return charged + reserve <= budget;
-}
-
-/** Unknown outcomes keep their reservation; an unexpectedly high bill is never clipped. */
-export function settledCharge(reserve: number, measured: number | null): number {
-  return measured === null ? reserve : measured;
-}
-
-export function wilsonInterval(correct: number, total: number): [number, number] | null {
-  if (!Number.isSafeInteger(total) || !Number.isSafeInteger(correct) || correct < 0 || total < correct) throw new RangeError("invalid score");
-  if (total === 0) return null;
-  const z = 1.959963984540054;
-  const p = correct / total;
-  const d = 1 + z * z / total;
-  const center = (p + z * z / (2 * total)) / d;
-  const radius = z * Math.sqrt(p * (1 - p) / total + z * z / (4 * total * total)) / d;
-  return [Math.max(0, center - radius), Math.min(1, center + radius)];
-}
-
-export interface BenchmarkOutcome {
-  id: string;
-  arm: BenchmarkArm;
-  status: "answered" | "error" | "budget" | "stopped";
-  correct: boolean;
-}
-
-export function summarizeBenchmark(plan: readonly BenchmarkJob[], outcomes: readonly BenchmarkOutcome[]) {
-  const planned = new Set(plan.map((job) => `${job.id}/${job.arm}`));
-  const seen = new Set<string>();
-  for (const outcome of outcomes) {
-    const key = `${outcome.id}/${outcome.arm}`;
-    if (!planned.has(key) || seen.has(key)) throw new Error("unknown or duplicate benchmark outcome");
-    if (outcome.correct && outcome.status !== "answered") throw new Error("unfinished result cannot be correct");
-    seen.add(key);
-  }
-  return BENCHMARK_ARMS.map((arm) => {
-    const rows = outcomes.filter((row) => row.arm === arm);
-    const total = plan.filter((job) => job.arm === arm).length;
-    const correct = rows.filter((row) => row.correct).length;
-    const attempted = rows.length;
-    const answered = rows.filter((row) => row.status === "answered").length;
-    return { arm, planned: total, attempted, answered, correct, missing: total - attempted,
-      accuracy: attempted > 0 ? correct / attempted : null,
-      interval95: wilsonInterval(correct, attempted),
-      plannedSolvedFraction: total > 0 ? correct / total : null,
-      complete: attempted === total };
-  });
-}

package/src/core/evaluation-coverage.ts

@@ -1,74 +0,0 @@
-/** R12c: missing final rows cannot erase attempted work or measured charges. */
-import type { EvalJob, EvalResult } from "./experiment.ts";
-import { recoveryCase } from "./recovery-corpus.ts";
-import { TOOL_MODE_FACTORS, isToolModeTask, isToolModeMetrics } from "./tool-mode-protocol.ts";
-
-export interface BillingRecord {
-  kind: "reserved" | "settled"; request: number; inputSha256: string;
-  reservation: number; charge: number; measured: number | null; ledgerCharged: number;
-}
-export function requestAccounting(records: readonly BillingRecord[], before: number) {
-  const nonnegative = (n: unknown): n is number => typeof n === "number" && Number.isFinite(n) && n >= 0;
-  if (!nonnegative(before)) throw Error("invalid trial ledger start");
-  let charged = before, pending: BillingRecord | undefined, requests = 0, known = 0, unknown = 0;
-  for (const row of records) {
-    if (![row.reservation, row.charge, row.ledgerCharged].every(nonnegative) || row.measured !== null && !nonnegative(row.measured) ||
-        !Number.isSafeInteger(row.request) || row.request < 1 || !/^[a-f0-9]{64}$/.test(row.inputSha256)) throw Error("invalid billing record");
-    if (row.kind === "reserved") {
-      if (pending || row.request !== ++requests || row.measured !== null || row.charge !== row.reservation) throw Error("invalid reservation order");
-      pending = row; charged += row.reservation;
-    } else if (row.kind === "settled") {
-      if (!pending || row.request !== pending.request || row.inputSha256 !== pending.inputSha256 || row.reservation !== pending.reservation ||
-          row.charge !== (row.measured ?? row.reservation)) throw Error("invalid settlement identity");
-      charged += row.charge - pending.reservation;
-      if (row.measured === null) unknown += row.reservation; else known += row.measured;
-      pending = undefined;
-    } else throw Error("invalid billing record kind");
-    if (row.ledgerCharged !== charged) throw Error("billing ledger sequence changed");
-  }
-  return { requests, charged, knownCostSubtotal: known, unsettledRequests: pending ? 1 : 0,
-    unsettledReservation: pending?.reservation ?? 0, unknownSettlementReserve: unknown,
-    fullyMeasured: !pending && records.filter(row => row.kind === "settled").every(row => row.measured !== null) };
-}
-export type RequestAccounting = ReturnType<typeof requestAccounting>;
-export type TrialCoverage = { id: string; accounting: RequestAccounting; tail: "complete" | "truncated";
-  result?: EvalResult; interruption: "deadline" | "caller" | null; partialMetrics?: EvalResult["recovery"] };
-
-export function summarizeRecoveryCoverage(jobs: readonly EvalJob[], trials: readonly TrialCoverage[], mechanical: boolean) {
-  const ids = new Set(jobs.map(job => job.id)), byId = new Map(trials.map(trial => [trial.id, trial]));
-  if (ids.size !== jobs.length || byId.size !== trials.length || trials.some(trial => !ids.has(trial.id) || trial.result && trial.result.id !== trial.id)) throw Error("invalid recovery coverage identities");
-  const group = (selected: readonly EvalJob[]) => {
-    const rows = selected.flatMap(job => byId.has(job.id) ? [byId.get(job.id)!] : []), finalized = rows.filter(row => row.result);
-    const passed = finalized.filter(row => row.result!.scenarioPassed).length;
-    const unknown = rows.filter(row => !row.result || row.tail !== "complete" || !row.accounting.fullyMeasured).length;
-    const known = rows.reduce((n, row) => n + row.accounting.knownCostSubtotal, 0);
-    const cost = !mechanical && rows.length === selected.length && unknown === 0 ? known : null;
-    const metrics = rows.flatMap(row => row.result?.recovery ?? row.partialMetrics ?? []);
-    const modes = finalized.flatMap(row => row.result?.toolMode ?? []);
-    if (modes.some(mode => !isToolModeMetrics(mode))) throw Error("invalid tool mode measurements");
-    const toolMode = selected.some(job => isToolModeTask(job.task)) ? { observed: modes.length, missing: selected.length - modes.length,
-      queryCalls: modes.reduce((n, mode) => n + mode.queryCalls, 0),
-      primitiveCalls: modes.reduce((n, mode) => n + mode.primitiveCalls, 0), sourcesComplete: modes.filter(mode => mode.sourceComplete).length,
-      meanElapsedMs: modes.length === selected.length && modes.length > 0 ? modes.reduce((n, mode) => n + mode.elapsedMs, 0) / modes.length : null } : undefined;
-    return { ...(toolMode ? { toolMode } : {}), planned: selected.length, attempted: rows.length, finalized: finalized.length, incomplete: rows.length - finalized.length,
-      unattempted: selected.length - rows.length, failed: finalized.length - passed, passed, plannedPassFraction: selected.length ? passed / selected.length : null,
-      cancelled: rows.filter(row => row.interruption === "caller").length, timedOut: rows.filter(row => row.interruption === "deadline").length,
-      requests: rows.reduce((n, row) => n + row.accounting.requests, 0), truncatedRequestLogs: rows.filter(row => row.tail === "truncated").length,
-      knownCostSubtotal: mechanical ? null : known, costUsd: cost,
-      unsettledRequests: rows.reduce((n, row) => n + row.accounting.unsettledRequests, 0),
-      unsettledReservationUsd: mechanical ? null : rows.reduce((n, row) => n + row.accounting.unsettledReservation, 0),
-      unknownSettlementReserveUsd: mechanical ? null : rows.reduce((n, row) => n + row.accounting.unknownSettlementReserve, 0),
-      unknownCostTrials: mechanical ? rows.length : unknown, costPerScenarioSuccess: cost !== null && passed > 0 ? cost / passed : null,
-      unverifiedEndings: finalized.filter(row => row.result!.unverifiedEnding).length,
-      recovery: { observed: metrics.length, missing: selected.length - metrics.length,
-        firstToolSuccess: metrics.filter(row => row.firstToolSuccess === true).length,
-        firstToolUnknown: metrics.filter(row => row.firstToolSuccess === null).length,
-        firstPassTaskSuccess: metrics.filter(row => row.firstPassTaskSuccess === true).length,
-        ...Object.fromEntries((["toolCalls", "outerCalls", "nestedCalls", "unresolvedCalls", "toolFailures", "classifiedFailures", "unclassifiedFailures", "recoveryCalls", "unchangedFailureRetries", "originalEvidenceRetrievals", "unsupportedClaims"] as const)
-          .map(key => [key, metrics.reduce((n, row) => n + row[key], 0)])) } };
-  };
-  const toolModes = jobs.some(job => isToolModeTask(job.task));
-  return { ...group(jobs), arms: (toolModes ? TOOL_MODE_FACTORS : ["profile", "workingSet", "strictVerification"]).flatMap(factor => ["control", "treatment"].map(arm =>
-    ({ factor, arm, ...group(jobs.filter(job => job.factor === factor && job.arm === arm)) }))),
-    partitions: toolModes ? [] : ["development", "holdout"].map(partition => ({ partition, ...group(jobs.filter(job => recoveryCase(job.task)?.partition === partition)) })) };
-}