@visual-z/xeno 0.1.0

package/src/core/project.ts

@@ -0,0 +1,372 @@
+/**
+ * projectContext: log -> what the model sees.
+ *
+ * Pure. The whole architecture rests on this being a function rather than a
+ * mutable array: the log is the truth, the context is one recomputable projection
+ * of it, so a bad projection is a bug you fix and re-run rather than information
+ * you destroyed.
+ *
+ * Two properties worth stating because tests pin them:
+ *
+ *   IDENTITY. With no handoff, the projection is the identity mapping of harness
+ *   events onto messages. Segment 0 therefore behaves exactly like a harness with
+ *   no context management at all, which is what makes the design adoptable in
+ *   stages -- nothing is paid for until a boundary actually fires.
+ *
+ *   APPEND-ONLY WITHIN A SEGMENT. Appending an event only appends to the
+ *   projection; it never rewrites an earlier message. That is what keeps the
+ *   prompt prefix byte-stable, so every turn reads the whole accumulated prefix
+ *   from cache and writes only the delta. In-place eviction would invalidate the
+ *   prefix on every request and never amortise the write cost -- the failure mode
+ *   Beyond Compaction (arXiv:2606.11213) documents for incremental eviction.
+ *
+ * The message shape below is structurally the Anthropic Messages shape, which is
+ * the target wire format. It is declared locally rather than imported so the core
+ * carries no SDK dependency; mapping to other providers belongs in an adapter,
+ * not here.
+ */
+
+import type { LogEvent, AssistantBlock } from "./events.ts";
+import { assertNever } from "./exhaustive.ts";
+import { type Handoff, emitHandoff } from "./handoff.ts";
+
+export type ContentBlock =
+  | { type: "text"; text: string }
+  /**
+   * The provider's own thinking block, replayed verbatim. It is carried as
+   * opaque rather than reconstructed because the API rejects modified blocks,
+   * and a reconstructed one would lose the signature the next request needs.
+   */
+  | { type: "thinking"; raw: unknown }
+  | { type: "tool_use"; id: string; name: string; input: unknown; wire?: unknown }
+  | { type: "tool_result"; tool_use_id: string; content: string; is_error?: boolean };
+
+export interface Message {
+  role: "user" | "assistant";
+  content: ContentBlock[];
+}
+
+/**
+ * System prompt and tool definitions. Must be byte-identical across every segment
+ * (decision D6): they render at the front of the prefix, so any change there
+ * invalidates the cache for the entire conversation. The non-obvious consequence
+ * is that project context files must NOT be re-read into `system` at a boundary --
+ * they belong in the handoff instead.
+ */
+export interface FrozenPrefix {
+  system: string;
+  tools: readonly unknown[];
+}
+
+export interface ProjectInput {
+  frozen: FrozenPrefix;
+  /** Previous segment's handoff, or null for segment 0. */
+  handoff: Handoff | null;
+  events: readonly LogEvent[];
+  /** Log location given to the model so it can grep for anything the handoff omits. */
+  logHint?: { manifestPath: string; segmentPath: string };
+}
+
+export interface ProjectResult {
+  system: string;
+  tools: readonly unknown[];
+  messages: Message[];
+  /**
+   * Pairing violations. A tool_use with no matching tool_result is a 400 from the
+   * API, so it is reported here -- at the pure boundary, where it is debuggable --
+   * rather than being discovered as a request failure.
+   */
+  violations: ProjectViolation[];
+}
+
+export interface ProjectViolation {
+  code: "UNPAIRED_TOOL_USE" | "ORPHAN_TOOL_RESULT" | "EMPTY_PROJECTION";
+  detail: string;
+}
+
+/**
+ * The only event types that replay as messages.
+ *
+ * Model-annotated events (claim, decision, pitfall, ...) are deliberately absent.
+ * They are a sidecar index over tool calls the model already made, so the
+ * tool_use/tool_result pair is what replays; including the annotation too would
+ * show the model its own notes twice. Within a segment the model sees its raw tool
+ * calls; across a boundary it sees them distilled into the handoff.
+ *
+ * `cut` is absent for a different reason: it is a boundary marker about the log,
+ * not a thing that happened in the conversation.
+ *
+ * `rewind` is here conditionally, and it is the one event whose replayability
+ * is a property of the event rather than of its type. After a "both" rewind
+ * the context and the disk agree, so saying anything would carry the undone
+ * work back in another form. After a partial one they disagree, and a model
+ * planning against the wrong picture is the whole failure mode -- so it is
+ * told, with paths.
+ *
+ * `interrupt` is a one-line harness note after the cancelled user message,
+ * not a new role: the model has to tell "asked and withdrew" from "asked
+ * two things". It is a following message rather than a mutation of the user
+ * turn so appending the event only appends to the projection (P7).
+ */
+type ReplayEvent = Extract<LogEvent, { t: "user" | "guidance" | "interrupt" | "assistant" | "tool_result" | "rewind" | "snapshot" }>;
+
+function replayable(e: LogEvent): e is ReplayEvent {
+  if (e.t === "rewind") return e.mode !== "both";
+  if (e.t === "snapshot") return e.undeclared.length > 0;
+  return e.t === "user" || e.t === "guidance" || e.t === "interrupt" || e.t === "assistant" || e.t === "tool_result";
+}
+
+/**
+ * The one thing a divergence message must produce.
+ *
+ * Named because it is the contract, not decoration: it is the automated form
+ * of the remedy Claude Code leaves to the person to remember after a partial
+ * restore, and a test asserting the message happened has to assert something
+ * only the message can say.
+ */
+export const REREAD_INSTRUCTION =
+  "Re-read any file before editing it. Do not rely on what earlier messages say its contents are.";
+
+/**
+ * What an interrupt has to tell the model, as one line.
+ *
+ * A cancelled generation was never delivered, so the projection must not
+ * invent assistant text; the note is the whole of what the harness observed.
+ * Same role as the user turn so we do not mint a role the wire format lacks.
+ */
+export const INTERRUPT_NOTE =
+  "The user cancelled this turn before a reply was delivered.";
+
+/**
+ * What a partial rewind has to tell the model, as plain prose.
+ *
+ * Prose rather than a structured block because it is addressed to the model,
+ * and the one thing it must produce is a re-read before an edit. That
+ * instruction is Claude Code's documented remedy for the same desync, left
+ * there to the person to remember; the paths make it actionable.
+ */
+export function renderRewindMessage(e: Extract<LogEvent, { t: "rewind" }>): Message {
+  const where = e.prompt ? `the point where you were asked: ${e.prompt}` : "an earlier point";
+  let lines: string[];
+  switch (e.mode) {
+    case "files":
+      lines = [
+        `The workspace was moved back to ${where}.`,
+        "",
+        "Your messages above still describe edits that are no longer on disk.",
+        "The conversation was not moved; only the files were.",
+      ];
+      break;
+    case "context":
+      lines = [
+        `This conversation was moved back to ${where}.`,
+        "",
+        "The workspace was NOT moved. Files exist that nothing above accounts",
+        "for, because the turns that made them are no longer in this context.",
+      ];
+      break;
+    case "both":
+      // Unreachable through the projection, which filters "both" out before
+      // getting here. Spelled out rather than folded into the other branch:
+      // falling through would have produced a message telling the model the
+      // two had diverged when the entire point of "both" is that they did
+      // not, and nothing would have failed.
+      throw new Error("a \"both\" rewind has nothing to tell the model: context and disk agree");
+    default:
+      return assertNever(e.mode, "renderRewindMessage");
+  }
+
+  if (e.divergence.length > 0) {
+    lines.push("", "Where they disagree:");
+    for (const path of e.divergence) lines.push(`  ${path}`);
+  }
+  lines.push("", REREAD_INSTRUCTION);
+
+  return { role: "user", content: [{ type: "text", text: lines.join("\n") }] };
+}
+
+/**
+ * Render the handoff as the opening user message of a new segment.
+ *
+ * It is a user message rather than part of `system` for two reasons: `system` has
+ * to stay byte-stable (D6), and a handoff is untrusted-ish derived content, not an
+ * operator instruction -- it does not belong in the operator channel.
+ */
+export function renderHandoffMessage(
+  handoff: Handoff,
+  logHint?: { manifestPath: string; segmentPath: string },
+): Message {
+  const yaml = emitHandoff(handoff);
+
+  const parts = [
+    "You are continuing earlier work in a new context window.",
+    "",
+    "The state below was derived mechanically from the session log -- it is not a",
+    "summary and nothing was paraphrased. Fields that are absent were absent from",
+    "the log, not judged unimportant.",
+    "",
+    "```yaml",
+    yaml.trimEnd(),
+    "```",
+  ];
+
+  if (logHint) {
+    parts.push(
+      "",
+      "The full log is on disk and nothing has been deleted from it. When you need a",
+      "detail this state does not carry, read it rather than guessing:",
+      `  - segment index: ${logHint.manifestPath}`,
+      `  - previous segment: ${logHint.segmentPath}`,
+      "Each line is one JSON event. Search it with history; read a line range with read,",
+      "or filter with bash and jq. The grep tool skips the log directory.",
+    );
+  }
+
+  const unverified = handoff.state.unverified_claims.length;
+  if (unverified > 0) {
+    parts.push(
+      "",
+      `${unverified} earlier completion ${unverified === 1 ? "claim was" : "claims were"} not matched`,
+      "to a passing command in the log. They are listed under state.unverified_claims",
+      "and must be treated as NOT done.",
+    );
+  }
+
+  if (handoff.file_anchors.length > 0) {
+    parts.push(
+      "",
+      "file_anchors records the digest each file had when it was last touched. Re-read",
+      "a file before relying on it; if the digest differs, the environment changed",
+      "underneath this state.",
+    );
+  }
+
+  return { role: "user", content: [{ type: "text", text: parts.join("\n") }] };
+}
+
+export function projectContext(input: ProjectInput): ProjectResult {
+  const violations: ProjectViolation[] = [];
+  const messages: Message[] = [];
+
+  if (input.handoff) {
+    messages.push(renderHandoffMessage(input.handoff, input.logHint));
+  }
+
+  const events = input.events.filter(replayable);
+
+  // Tool results are buffered so that every result for one assistant turn lands in
+  // a SINGLE user message. Splitting them across messages teaches the model to stop
+  // issuing parallel calls, which is a silent, permanent capability regression.
+  let pending: ContentBlock[] = [];
+  const flushPending = () => {
+    if (pending.length > 0) {
+      messages.push({ role: "user", content: pending });
+      pending = [];
+    }
+  };
+
+  /** tool_use ids emitted by the most recent assistant turn and not yet answered. */
+  let awaiting = new Set<string>();
+
+  for (const e of events) {
+    if (e.t === "snapshot") {
+      flushPending();
+      messages.push({ role: "user", content: [{ type: "text",
+        text: `Workspace observation: changes outside declared file edits: ${e.undeclared.join(", ")}. ${REREAD_INSTRUCTION}`,
+      }] });
+      continue;
+    }
+    if (e.t === "rewind") {
+      // Flushed first for the same reason a user turn is: it opens a user
+      // message, and a pending tool_result batch has to close before it.
+      flushPending();
+      messages.push(renderRewindMessage(e));
+      continue;
+    }
+    if (e.t === "user" || e.t === "guidance") {
+      flushPending();
+      if (awaiting.size > 0) {
+        violations.push({
+          code: "UNPAIRED_TOOL_USE",
+          detail: `user turn ${e.id} follows unanswered tool_use ${[...awaiting].join(", ")}`,
+        });
+        awaiting = new Set();
+      }
+      messages.push({ role: "user", content: [{ type: "text", text: e.text }] });
+      continue;
+    }
+    if (e.t === "interrupt") {
+      // Own message so the preceding user turn stays byte-stable (P7). A
+      // look-ahead mutation of that turn would rewrite it once a later
+      // event (tool_use, another user) was already projected after it.
+      flushPending();
+      messages.push({ role: "user", content: [{ type: "text", text: INTERRUPT_NOTE }] });
+      continue;
+    }
+
+    if (e.t === "assistant") {
+      flushPending();
+      if (awaiting.size > 0) {
+        violations.push({
+          code: "UNPAIRED_TOOL_USE",
+          detail: `assistant turn ${e.id} follows unanswered tool_use ${[...awaiting].join(", ")}`,
+        });
+      }
+      messages.push({ role: "assistant", content: e.blocks.map(toContentBlock) });
+      awaiting = new Set(
+        e.blocks.filter((b) => b.type === "tool_use").map((b) => (b as { call_id: string }).call_id),
+      );
+      continue;
+    }
+
+    // tool_result
+    if (!awaiting.has(e.call_id)) {
+      violations.push({
+        code: "ORPHAN_TOOL_RESULT",
+        detail: `tool_result ${e.id} answers unknown call ${e.call_id}`,
+      });
+      continue;
+    }
+    awaiting.delete(e.call_id);
+    pending.push({
+      type: "tool_result",
+      tool_use_id: e.call_id,
+      content: e.content,
+      ...(e.ok ? {} : { is_error: true }),
+    });
+  }
+
+  flushPending();
+
+  if (awaiting.size > 0) {
+    violations.push({
+      code: "UNPAIRED_TOOL_USE",
+      detail: `segment ends with unanswered tool_use ${[...awaiting].join(", ")}`,
+    });
+  }
+
+  if (messages.length === 0) {
+    violations.push({ code: "EMPTY_PROJECTION", detail: "no replayable events" });
+  }
+
+  return {
+    system: input.frozen.system,
+    tools: input.frozen.tools,
+    messages,
+    violations,
+  };
+}
+
+function toContentBlock(b: AssistantBlock): ContentBlock {
+  switch (b.type) {
+    case "tool_use":
+      return { type: "tool_use", id: b.call_id, name: b.name, input: b.input, ...(b.wire === undefined ? {} : { wire: b.wire }) };
+    case "thinking":
+      // Only the raw block crosses back to the API; `text` exists for display.
+      return { type: "thinking", raw: b.raw };
+    case "text":
+      return b;
+    default:
+      return assertNever(b, "toContentBlock");
+  }
+}

package/src/core/prompts.ts

@@ -0,0 +1,83 @@
+/**
+ * Prompt-template expansion. Pure: the file is read in store.
+ *
+ * `{{name}}` is filled with the remainder of `/template rest`. An empty
+ * remainder keeps the placeholder and names it — emptying it would drop a
+ * sentence from the prompt with no trace (feat-skills-and-prompts design).
+ */
+
+import { parseFrontmatter } from "./frontmatter.ts";
+
+export interface PromptTemplate {
+  readonly name: string;
+  readonly description: string;
+  readonly argumentHint?: string;
+  readonly content: string;
+  readonly filePath: string;
+}
+
+const PLACEHOLDER = /\{\{([A-Za-z_][A-Za-z0-9_-]*)\}\}/g;
+
+export function expandTemplate(
+  content: string,
+  arg: string,
+): { text: string; diagnostics: readonly string[] } {
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (const match of content.matchAll(PLACEHOLDER)) {
+    const name = match[1]!;
+    if (!seen.has(name)) {
+      seen.add(name);
+      names.push(name);
+    }
+  }
+  if (arg.length > 0) {
+    return { text: content.replace(PLACEHOLDER, arg), diagnostics: [] };
+  }
+  return {
+    text: content,
+    diagnostics: names.map((name) => `unfilled placeholder: ${name}`),
+  };
+}
+
+export function parsePromptTemplate(input: {
+  readonly filePath: string;
+  readonly text: string;
+}): { template: PromptTemplate | null; diagnostics: readonly string[] } {
+  const parsed = parseFrontmatter(input.text);
+  const diagnostics = [...parsed.diagnostics];
+  const base = fileName(input.filePath);
+  const name = base.replace(/\.md$/i, "").toLowerCase();
+  if (name.length === 0) {
+    diagnostics.push(`${input.filePath}: prompt template has no name`);
+    return { template: null, diagnostics };
+  }
+
+  const descField = parsed.fields["description"];
+  let description = typeof descField === "string" ? descField.trim() : "";
+  if (description.length === 0) {
+    const first = parsed.body.split("\n").find((line) => line.trim().length > 0);
+    description = first === undefined ? "" : first.trim();
+  }
+
+  const hintField = parsed.fields["argument-hint"];
+  const argumentHint = typeof hintField === "string" ? hintField : undefined;
+
+  return {
+    template: {
+      name,
+      description,
+      content: parsed.body,
+      filePath: input.filePath,
+      ...(argumentHint !== undefined ? { argumentHint } : {}),
+    },
+    diagnostics,
+  };
+}
+
+/** Path basename without node:path, so this module stays core-pure. */
+function fileName(path: string): string {
+  const trimmed = path.replace(/[\\/]+$/, "");
+  const slash = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  return slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
+}

package/src/core/queue.ts

@@ -0,0 +1,60 @@
+/**
+ * When a typed message may enter the log.
+ *
+ * The queue itself is UI state: a line the user may still retract. The log
+ * is what happened. nextDelivery is the only decision — it says which
+ * queued line is legal to deliver at this phase, or none. The caller
+ * records the user event; this file never does.
+ *
+ * after_tools is the first legal moment to insert a user message, for the
+ * same pairing reason switchModel already refuses a half-round: a tool_use
+ * without its tool_result is a 400 (project.ts UNPAIRED_TOOL_USE).
+ */
+
+import { assertNever } from "./exhaustive.ts";
+
+export type QueueKind = "steering" | "followup";
+
+export interface QueuedMessage {
+  readonly kind: QueueKind;
+  readonly text: string;
+}
+
+/**
+ * Where the turn is. after_tools means every tool_use of this assistant
+ * round already has a result. turn_end means send() has returned. idle
+ * is the editor waiting — leftover lines still deliver, steering first.
+ */
+export type Phase = "after_tools" | "turn_end" | "idle";
+
+/**
+ * Which queued message may be written to the log right now.
+ *
+ * Same kind stays in enqueue order. Steering as a group always precedes
+ * follow-up: a follow-up is defined as "after the whole send", so it
+ * cannot win while a steering line is still waiting.
+ */
+export function nextDelivery(
+  queue: readonly QueuedMessage[],
+  phase: Phase,
+): QueuedMessage | null {
+  switch (phase) {
+    case "after_tools":
+      return firstOfKind(queue, "steering");
+    case "turn_end":
+    case "idle":
+      return firstOfKind(queue, "steering") ?? firstOfKind(queue, "followup");
+    default:
+      return assertNever(phase, "nextDelivery");
+  }
+}
+
+function firstOfKind(
+  queue: readonly QueuedMessage[],
+  kind: QueueKind,
+): QueuedMessage | null {
+  for (const item of queue) {
+    if (item.kind === kind) return item;
+  }
+  return null;
+}

package/src/core/read-bounds.ts

@@ -0,0 +1,15 @@
+/** N.12: recoverable file bounds are observation metadata, not model guesses. */
+export function readBounds(total: number, first: unknown, last: unknown):
+  { ok: true; start: number; end: number; notice: string } | { ok: false; message: string } {
+  if (!Number.isSafeInteger(total) || total < 1) throw new RangeError("split text must contain at least one line");
+  const start = first === undefined ? 1 : first, end = last === undefined ? total : last;
+  const bounds = `total lines: ${total}; valid range: 1-${total}`;
+  if (typeof start !== "number" || typeof end !== "number" || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < 1) {
+    return { ok: false, message: `read start and end must be positive safe integers (${bounds})` };
+  }
+  if (start > total) return { ok: false, message: `read start ${start} is beyond end of file (${bounds}); choose a start in that range` };
+  if (end < start) return { ok: false, message: `read end ${end} precedes start ${start} (${bounds})` };
+  const actualEnd = Math.min(end, total);
+  return { ok: true, start, end: actualEnd,
+    notice: `[Read selection: lines ${start}-${actualEnd}; total lines: ${total}; ${actualEnd < total ? `next start: ${actualEnd + 1}` : "end of file"}.]` };
+}

package/src/core/recall-analysis.ts

@@ -0,0 +1,90 @@
+/**
+ * Pre-registered F2 analysis (docs/tasks/bench-recall-pilot.md). Pure.
+ *
+ * The unit is a (seed, ratio) block: arms in one block face byte-identical
+ * pages and questions, blocks are independent, stages within a run are not.
+ */
+export interface RecallStageRow {
+  stage: number; kind: "recent" | "recall" | "latest"; distance: number;
+  visibleThroughout: boolean | null; verdict: { ok: boolean; reason: string }; status: string;
+}
+export interface RecallRunRow {
+  arm: string; ratio: number; seed: number; planned: number; unrun: number; boundaries: number;
+  knownCost: number; reservedUnknown: number; stages: RecallStageRow[]; modelFiles: string[];
+}
+
+/** Two-sided exact sign test; ties are dropped before counting. */
+export function signTest(differences: readonly number[]): { positive: number; negative: number; ties: number; p: number } {
+  const positive = differences.filter((d) => d > 0).length, negative = differences.filter((d) => d < 0).length;
+  const n = positive + negative, k = Math.min(positive, negative);
+  let tail = 0;
+  for (let i = 0; i <= k; i++) tail += binomial(n, i) / 2 ** n;
+  return { positive, negative, ties: differences.length - n, p: n === 0 ? 1 : Math.min(1, 2 * tail) };
+}
+
+function binomial(n: number, k: number): number {
+  let out = 1;
+  for (let i = 1; i <= k; i++) out = out * (n - k + i) / i;
+  return out;
+}
+
+export function median(values: readonly number[]): number | null {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b), mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid]! : (sorted[mid - 1]! + sorted[mid]!) / 2;
+}
+
+/** Non-recent accuracy over planned questions: an unrun stage counts as wrong, never as missing. */
+export function memoryAccuracy(run: RecallRunRow, planned: readonly RecallStageRow["kind"][]): number | null {
+  const asked = planned.filter((kind) => kind !== "recent").length;
+  if (asked === 0) return null;
+  return run.stages.filter((row) => row.kind !== "recent" && row.verdict.ok).length / asked;
+}
+
+export interface BlockDifference { seed: number; ratio: number; a: number | null; b: number | null; difference: number | null }
+
+export function pairedBlocks(runs: readonly RecallRunRow[], a: string, b: string, ratios: readonly number[],
+  plannedKinds: (seed: number, ratio: number) => readonly RecallStageRow["kind"][]): BlockDifference[] {
+  const blocks = [...new Set(runs.filter((run) => ratios.includes(run.ratio)).map((run) => `${run.seed}/${run.ratio}`))].sort();
+  return blocks.map((key) => {
+    const [seed, ratio] = key.split("/").map(Number) as [number, number];
+    const kinds = plannedKinds(seed, ratio);
+    const find = (arm: string) => runs.find((run) => run.arm === arm && run.seed === seed && run.ratio === ratio);
+    const ra = find(a), rb = find(b);
+    const accA = ra ? memoryAccuracy(ra, kinds) : null, accB = rb ? memoryAccuracy(rb, kinds) : null;
+    return { seed, ratio, a: accA, b: accB, difference: accA === null || accB === null ? null : accA - accB };
+  });
+}
+
+export function compare(blocks: readonly BlockDifference[]) {
+  // A block missing either arm is reported, never silently imputed.
+  const complete = blocks.filter((block) => block.difference !== null).map((block) => block.difference!);
+  return { blocks: blocks.length, complete: complete.length, medianDifference: median(complete), ...signTest(complete) };
+}
+
+/** Pre-registered decision: p < 0.05 and median difference ≥ 10 points. */
+export function decide(primary: ReturnType<typeof compare>): "advantage" | "no_advantage_measured" {
+  return primary.complete > 0 && primary.p < 0.05 && (primary.medianDifference ?? 0) >= 0.10 ? "advantage" : "no_advantage_measured";
+}
+
+export function describeArm(runs: readonly RecallRunRow[], arm: string, ratio: number) {
+  const rows = runs.filter((run) => run.arm === arm && run.ratio === ratio);
+  const stages = rows.flatMap((run) => run.stages), memory = stages.filter((row) => row.kind !== "recent");
+  const evicted = memory.filter((row) => row.visibleThroughout === false);
+  const latest = stages.filter((row) => row.kind === "latest");
+  const correct = stages.filter((row) => row.verdict.ok).length;
+  const cost = rows.reduce((sum, run) => sum + run.knownCost, 0);
+  const rate = (n: number, d: number) => d === 0 ? null : n / d;
+  return {
+    arm, ratio, runs: rows.length, stages: stages.length, unrun: rows.reduce((n, run) => n + run.unrun, 0),
+    recentAccuracy: rate(stages.filter((row) => row.kind === "recent" && row.verdict.ok).length, stages.filter((row) => row.kind === "recent").length),
+    memoryAccuracy: rate(memory.filter((row) => row.verdict.ok).length, memory.length),
+    evictionRate: rate(evicted.length, memory.length),
+    evictedAccuracy: rate(evicted.filter((row) => row.verdict.ok).length, evicted.length),
+    staleLatest: rate(latest.filter((row) => row.verdict.reason === "stale").length, latest.length),
+    boundaries: rows.reduce((n, run) => n + run.boundaries, 0),
+    cost, costPerCorrect: correct === 0 ? null : cost / correct,
+    reservedUnknown: rows.reduce((n, run) => n + run.reservedUnknown, 0),
+    runsWithModelFiles: rows.filter((run) => run.modelFiles.length > 0).length,
+  };
+}