catherd-cli 1.1.1 → 1.2.0

package/src/infra/sources/openrouter-endpoints.ts

@@ -0,0 +1,52 @@
+import { median } from "../../domain/util.ts";
+import { SourceError, type SourceTransport, sourceGet } from "./http.ts";
+import { isoDay, num, type SourceRow } from "./rows.ts";
+
+/** Spec 1.2 §3.1: per provider, uptime, latency and throughput over the last 30 minutes. */
+export const openRouterEndpointsUrl = (id: string): string =>
+  `https://openrouter.ai/api/v1/models/${id}/endpoints`;
+
+/**
+ * Plan 13 R-H: one request per OpenRouter id (one per catalog family OpenRouter lists), in parallel. An id
+ * OpenRouter no longer knows (404) is left out; any other failure fails the source, which keeps its last answer.
+ */
+export async function fetchOpenRouterEndpoints(
+  ids: readonly string[],
+  t: SourceTransport = {},
+): Promise<Record<string, unknown>> {
+  const got = await Promise.all(
+    ids.map(async (id) => {
+      try {
+        return [id, (await sourceGet(openRouterEndpointsUrl(id), t)).json()] as const;
+      } catch (e) {
+        if (e instanceof SourceError && e.status === 404) return null;
+        throw e instanceof SourceError ? new SourceError(`${id}: ${e.message}`, e.status, e.headers) : e;
+      }
+    }),
+  );
+  return Object.fromEntries(got.filter((x) => x !== null));
+}
+
+export const ENDPOINT_FIELDS = ["latency_last_30m", "throughput_last_30m", "uptime_last_30m"] as const;
+
+/** A statistic as a number, or as a percentile object (`{ p50: … }`) some answers carry. */
+const stat = (v: unknown): number | null =>
+  v !== null && typeof v === "object" ? num((v as { p50?: unknown }).p50) : num(v);
+
+/** One row per OpenRouter id and field: the median over its endpoints that report the field. */
+export function parseOpenRouterEndpoints(raw: Record<string, unknown>, fetchedAt: string): SourceRow[] {
+  const rows: SourceRow[] = [];
+  for (const [id, answer] of Object.entries(raw)) {
+    const endpoints = (answer as { data?: { endpoints?: unknown[] } } | null)?.data?.endpoints;
+    if (!Array.isArray(endpoints)) continue;
+    for (const field of ENDPOINT_FIELDS) {
+      const xs = endpoints
+        .map((e) => stat((e as Record<string, unknown> | null)?.[field]))
+        .filter((x): x is number => x !== null);
+      const value = median(xs);
+      if (value !== null)
+        rows.push({ rung: id, field, value, date: isoDay(fetchedAt), url: `https://openrouter.ai/${id}` });
+    }
+  }
+  return rows;
+}

package/src/infra/sources/openrouter-models.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { type SourceTransport, sourceGet } from "./http.ts";
+import { num } from "./rows.ts";
+
+/** Spec 1.2 §3.1: price and context cross-check; a model appears here the day it ships. */
+export const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+
+export const fetchOpenRouterModels = async (t: SourceTransport = {}): Promise<unknown> =>
+  (await sourceGet(OPENROUTER_MODELS_URL, t)).json();
+
+export interface OpenRouterModel {
+  /** `author/slug`, as the endpoints path takes it */
+  id: string;
+  context: number | null;
+  /** dollars per million tokens */
+  price: { input: number; output: number; cached: number | null } | null;
+  efforts: string[] | null;
+  defaultEffort: string | null;
+}
+
+const ModelSchema = z.looseObject({
+  id: z.string(),
+  context_length: z.unknown(),
+  pricing: z
+    .looseObject({ prompt: z.unknown(), completion: z.unknown(), input_cache_read: z.unknown() })
+    .optional(),
+  reasoning: z
+    .looseObject({ supported_efforts: z.array(z.string()).optional(), default_effort: z.string().optional() })
+    .optional(),
+});
+
+/** A per-token price (a number or decimal string) per million tokens, without float noise (0.000002 × 1e6). */
+export const perMillion = (v: unknown): number | null => {
+  const n = num(v);
+  return n === null ? null : Math.round(n * 1e12) / 1e6;
+};
+
+/** Every model of OpenRouter's `/models` answer; a malformed entry is skipped. */
+export function parseOpenRouterModels(raw: unknown): OpenRouterModel[] {
+  const data = (raw as { data?: unknown[] } | null)?.data;
+  if (!Array.isArray(data)) return [];
+  const out: OpenRouterModel[] = [];
+  for (const entry of data) {
+    const m = ModelSchema.safeParse(entry);
+    if (!m.success) continue;
+    const input = perMillion(m.data.pricing?.prompt);
+    const output = perMillion(m.data.pricing?.completion);
+    out.push({
+      id: m.data.id,
+      context: num(m.data.context_length),
+      price:
+        input !== null && output !== null
+          ? { input, output, cached: perMillion(m.data.pricing?.input_cache_read) }
+          : null,
+      efforts: m.data.reasoning?.supported_efforts ?? null,
+      defaultEffort: m.data.reasoning?.default_effort ?? null,
+    });
+  }
+  return out;
+}

package/src/infra/sources/rows.ts

@@ -0,0 +1,38 @@
+/**
+ * Spec 1.2 §3.3: what a score source's parser returns, one number each. `rung` is the source's own model id,
+ * with `#<effort>` when the source names one (catherd's effort word); `date` is the day the source measured or
+ * published it, else the day it was fetched; `url` is where the value can be checked.
+ */
+export interface SourceRow {
+  rung: string;
+  field: string;
+  value: number;
+  date: string;
+  url: string;
+}
+
+/** The `YYYY-MM-DD` of an ISO time. */
+export const isoDay = (iso: string): string => iso.slice(0, 10);
+
+/** `candidate` when it is an http(s) URL, else `fallback`. */
+export const urlOr = (candidate: unknown, fallback: string): string =>
+  typeof candidate === "string" && /^https?:\/\//.test(candidate.trim()) && URL.canParse(candidate.trim())
+    ? candidate.trim()
+    : fallback;
+
+/** `v` as a finite number (numbers and numeric strings), else null. */
+export function num(v: unknown): number | null {
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : Number.NaN;
+  return Number.isFinite(n) ? n : null;
+}
+
+/** One row per rung and field: a source that lists a model twice (Epoch: one row per agent) keeps the highest. */
+export function keepHighest(rows: SourceRow[]): SourceRow[] {
+  const best = new Map<string, SourceRow>();
+  for (const r of rows) {
+    const k = `${r.rung}\u0000${r.field}`;
+    const had = best.get(k);
+    if (!had || r.value > had.value) best.set(k, r);
+  }
+  return [...best.values()];
+}

package/src/infra/sources/vectara.ts

@@ -0,0 +1,69 @@
+import { type SourceTransport, sourceGet } from "./http.ts";
+import { isoDay, num, type SourceRow } from "./rows.ts";
+
+/** Spec 1.2 §3.1: the leaderboard is a markdown table in the repository's README (Apache-2.0). */
+export const VECTARA_URL =
+  "https://raw.githubusercontent.com/vectara/hallucination-leaderboard/main/README.md";
+export const VECTARA_PAGE = "https://github.com/vectara/hallucination-leaderboard";
+
+export const fetchVectara = async (t: SourceTransport = {}): Promise<string> =>
+  (await sourceGet(VECTARA_URL, t)).text();
+
+const MONTHS = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+];
+
+/** "Last updated on September 22, 2026" as `2026-09-22`; null when the README has no such line. */
+export function vectaraDate(markdown: string): string | null {
+  const m = /Last updated on ([A-Za-z]+) (\d{1,2}), (\d{4})/.exec(markdown);
+  const month = m ? MONTHS.indexOf((m[1] as string).toLowerCase()) : -1;
+  if (!m || month < 0) return null;
+  return `${m[3]}-${String(month + 1).padStart(2, "0")}-${(m[2] as string).padStart(2, "0")}`;
+}
+
+const cells = (line: string) =>
+  line
+    .trim()
+    .replace(/^\||\|$/g, "")
+    .split("|")
+    .map((c) => c.trim());
+
+/**
+ * Two rows per model of the README's table: `factual_consistency` and `hallucination_rate`, in percent. The
+ * model keeps its `vendor/` prefix and names no effort.
+ */
+export function parseVectara(markdown: string, fetchedAt: string): SourceRow[] {
+  const lines = markdown.split("\n");
+  const head = lines.findIndex((l) => /^\|\s*Model\s*\|/i.test(l));
+  if (head < 0) return [];
+  const columns = cells(lines[head] as string).map((c) => c.toLowerCase());
+  const at = (name: string) => columns.findIndex((c) => c.startsWith(name));
+  const [consistency, hallucination] = [at("factual consistency"), at("hallucination rate")];
+  const date = vectaraDate(markdown) ?? isoDay(fetchedAt);
+  const rows: SourceRow[] = [];
+  for (const line of lines.slice(head + 2)) {
+    if (!line.trim().startsWith("|")) break;
+    const c = cells(line);
+    const model = c[0];
+    if (!model) continue;
+    for (const [field, i] of [
+      ["factual_consistency", consistency],
+      ["hallucination_rate", hallucination],
+    ] as const) {
+      const value = i < 0 ? null : num((c[i] ?? "").replace("%", ""));
+      if (value !== null) rows.push({ rung: model, field, value, date, url: VECTARA_PAGE });
+    }
+  }
+  return rows;
+}

package/src/infra/sources/zip.ts

@@ -0,0 +1,48 @@
+// Plan 13 R-F: Epoch ships its tables as one zip. Reading it needs only the central directory and
+// raw deflate (`Bun.inflateSync`), so there is no dependency for it.
+
+const EOCD = 0x06054b50;
+const CENTRAL = 0x02014b50;
+const LOCAL = 0x04034b50;
+
+/**
+ * The files of a zip archive whose names `want` accepts, by name: stored (method 0) or deflated (8). Throws
+ * on a malformed archive or another method. ZIP64 archives are not read (Epoch's is 2 MB).
+ */
+export function unzip(
+  bytes: Uint8Array,
+  want: (name: string) => boolean = () => true,
+): Map<string, Uint8Array> {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let end = -1;
+  // the end record is 22 bytes plus a comment of up to 64 KiB
+  for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 22 - 0xffff); i--)
+    if (dv.getUint32(i, true) === EOCD) {
+      end = i;
+      break;
+    }
+  if (end < 0) throw new Error("not a zip archive");
+  const count = dv.getUint16(end + 10, true);
+  let at = dv.getUint32(end + 16, true);
+  const decode = new TextDecoder();
+  const out = new Map<string, Uint8Array>();
+  for (let k = 0; k < count; k++) {
+    if (dv.getUint32(at, true) !== CENTRAL) throw new Error("a malformed zip directory");
+    const method = dv.getUint16(at + 10, true);
+    const size = dv.getUint32(at + 20, true);
+    const nameLen = dv.getUint16(at + 28, true);
+    const extraLen = dv.getUint16(at + 30, true);
+    const commentLen = dv.getUint16(at + 32, true);
+    const local = dv.getUint32(at + 42, true);
+    const name = decode.decode(bytes.subarray(at + 46, at + 46 + nameLen));
+    at += 46 + nameLen + extraLen + commentLen;
+    if (!want(name)) continue;
+    if (dv.getUint32(local, true) !== LOCAL) throw new Error(`a malformed zip entry: ${name}`);
+    const start = local + 30 + dv.getUint16(local + 26, true) + dv.getUint16(local + 28, true);
+    const data = bytes.subarray(start, start + size);
+    if (method === 0) out.set(name, data);
+    else if (method === 8) out.set(name, Bun.inflateSync(data.slice()));
+    else throw new Error(`zip method ${method} is not read: ${name}`);
+  }
+  return out;
+}

package/src/services/catalog-refresh.ts

@@ -0,0 +1,200 @@
+import { writeFileSync } from "node:fs";
+import { isDeepStrictEqual } from "node:util";
+import { barPool, deriveBars } from "../domain/bars.ts";
+import {
+  buildCatalog,
+  DIMS,
+  type Dim,
+  type ModelsFile,
+  outranks,
+  type Score,
+  type ScoresFile,
+  scoresOf,
+} from "../domain/catalog.ts";
+import { DIFFICULTIES, type Difficulty, KINDS, type Kind } from "../domain/lane.ts";
+import type { SourcesFile } from "../domain/sources.ts";
+import type { SourceTransport } from "../infra/sources/http.ts";
+import { adjacent, derive, type RawAnswers } from "./source-derive.ts";
+import { cachedAnswers, syncSources } from "./source-sync.ts";
+
+/** Spec 1.2 §7: a value that moved by more than this is listed in the refresh PR. */
+const MOVED = 0.05;
+
+export interface RefreshReport {
+  /** the day the data was read, `scores.json`'s new `version` */
+  date: string;
+  /** canonical rungs with no value in the shipped file before, and at least one now */
+  newlyScored: string[];
+  /** values that moved by more than 5 %, and values that appeared or went away on a rung already scored */
+  moved: { rung: string; dim: Dim; from: number | null; to: number | null }[];
+  /** every default threshold that moved, appeared or went away */
+  barsMoved: { kind: Kind; difficulty: Difficulty; dim: Dim; from: number | null; to: number | null }[];
+  /** shipped treat-likes dropped because their rung now has a value of its own on every dimension they lent */
+  standInsDropped: string[];
+}
+
+const key = (s: Pick<Score, "rung" | "dim">) => `${s.rung} ${s.dim}`;
+
+/** One value per rung and dimension, the one that outranks the others (spec 1.2 §4.3), in file order. */
+function best(scores: Score[], now: number): Score[] {
+  const out = new Map<string, Score>();
+  for (const s of scores) {
+    const had = out.get(key(s));
+    if (!had || outranks(s, had, now)) out.set(key(s), s);
+  }
+  return [...out.values()].sort(
+    (a, b) => a.rung.localeCompare(b.rung) || DIMS.indexOf(a.dim) - DIMS.indexOf(b.dim),
+  );
+}
+
+/**
+ * Spec 1.2 §5.2, §7: `catalog/scores.json` rebuilt from the keyless sources' answers. It keeps every hand-typed
+ * value (one with no `source`), replaces the keyless values with what `raw` says now (Artificial Analysis is
+ * never shipped, whatever `raw` holds), spreads every published value to the family's other efforts as
+ * `adjacent` (plan 14 Ruling 3), keeps one value per rung and dimension, derives the default bars with their
+ * `barsWhy`, and drops a shipped treat-like its rung no longer needs.
+ */
+export function rebuildShipped(
+  raw: RawAnswers,
+  ctx: { models: ModelsFile; scores: ScoresFile; sources: SourcesFile; now: number },
+): { file: ScoresFile; report: RefreshReport } {
+  const date = new Date(ctx.now).toISOString().slice(0, 10);
+  const { "artificial-analysis": _aa, ...keyless } = raw;
+  // hand-typed values, less the ones an earlier rebuild spread: those are spread again below
+  const hand = ctx.scores.scores.filter((s) => s.source === undefined && s.confidence !== "adjacent");
+  const synced = derive(keyless, { ...ctx, scores: { ...ctx.scores, scores: hand } }).scores.filter(
+    (s) => s.source !== "artificial-analysis" && s.confidence !== "adjacent",
+  );
+  const direct = best([...hand, ...synced], ctx.now);
+  // an inferred value is catherd's guess for its own rung only: it is never carried to another effort
+  const spread = adjacent(
+    ctx.models.families,
+    direct.filter((s) => s.confidence !== "inferred"),
+    new Set(),
+    ctx.now,
+  );
+  const scores = best([...direct, ...spread], ctx.now);
+  const benchmark = (d: Dim) => {
+    const b = ctx.scores.benchmarks[d];
+    return `${b.benchmark} ${b.version}`;
+  };
+  const { bars, barsWhy } = deriveBars(barPool(scores), benchmark, date);
+
+  const draft: ScoresFile = { ...ctx.scores, version: date, scores, bars, barsWhy };
+  const c = buildCatalog({ models: ctx.models, scores: { ...draft, treatLike: ctx.scores.treatLike } });
+  const treatLike: ScoresFile["treatLike"] = {};
+  const standInsDropped: string[] = [];
+  for (const [rung, t] of Object.entries(ctx.scores.treatLike))
+    if (scoresOf(c, rung)?.borrowed.length) treatLike[rung] = t;
+    else standInsDropped.push(rung);
+  const file: ScoresFile = { ...draft, treatLike };
+  return { file, report: { date, ...diffShipped(ctx.scores, file), standInsDropped } };
+}
+
+const rungsOf = (f: ScoresFile) => new Set(f.scores.map((s) => s.rung));
+
+/** What moved between two shipped files (spec 1.2 §7's PR body). */
+function diffShipped(
+  before: ScoresFile,
+  after: ScoresFile,
+): Pick<RefreshReport, "newlyScored" | "moved" | "barsMoved"> {
+  const had = rungsOf(before);
+  const newlyScored = [...rungsOf(after)].filter((r) => !had.has(r)).sort();
+  const was = new Map(before.scores.map((s) => [key(s), s.value]));
+  const now = new Map(after.scores.map((s) => [key(s), s.value]));
+  const moved: RefreshReport["moved"] = [];
+  for (const k of [...new Set([...was.keys(), ...now.keys()])].sort()) {
+    const [rung, dim] = k.split(" ") as [string, Dim];
+    if (newlyScored.includes(rung)) continue;
+    const from = was.get(k) ?? null;
+    const to = now.get(k) ?? null;
+    const far =
+      from === null || to === null || (from === 0 ? to !== 0 : Math.abs(to - from) / Math.abs(from) > MOVED);
+    if (far) moved.push({ rung, dim, from, to });
+  }
+  const barsMoved: RefreshReport["barsMoved"] = [];
+  for (const kind of KINDS)
+    for (const difficulty of DIFFICULTIES)
+      for (const dim of DIMS) {
+        const from = before.bars[kind]?.[difficulty]?.[dim] ?? null;
+        const to = after.bars[kind]?.[difficulty]?.[dim] ?? null;
+        if (from !== to) barsMoved.push({ kind, difficulty, dim, from, to });
+      }
+  return { newlyScored, moved, barsMoved };
+}
+
+/** Whether the rebuilt file says anything new: its date and `barsWhy` wording alone never count. */
+export function shippedChanged(before: ScoresFile, after: ScoresFile): boolean {
+  // as the file reads back: no undefined fields, whatever the key order
+  const strip = (f: ScoresFile): unknown => JSON.parse(JSON.stringify({ ...f, version: "", barsWhy: null }));
+  return !isDeepStrictEqual(strip(before), strip(after));
+}
+
+const num = (v: number | null) => (v === null ? "none" : String(v));
+
+/** Spec 1.2 §7: the refresh PR's body: rungs newly scored, values moved by more than 5 %, bars that moved. */
+export function refreshBody(r: RefreshReport): string {
+  const out = [
+    `Weekly refresh of the shipped scores from the keyless public sources (data of ${r.date}).`,
+    "",
+    "Artificial Analysis values are never shipped. Merging this releases a patch through the Release workflow.",
+    "",
+    `### Rungs newly scored (${r.newlyScored.length})`,
+    "",
+    ...(r.newlyScored.length ? r.newlyScored.map((x) => `- \`${x}\``) : ["none"]),
+    "",
+    `### Values moved by more than 5 % (${r.moved.length})`,
+    "",
+    ...(r.moved.length
+      ? ["| rung | dimension | was | now |", "| --- | --- | --- | --- |"].concat(
+          r.moved.map((m) => `| \`${m.rung}\` | ${m.dim} | ${num(m.from)} | ${num(m.to)} |`),
+        )
+      : ["none"]),
+    "",
+    `### Bars that moved (${r.barsMoved.length})`,
+    "",
+    ...(r.barsMoved.length
+      ? ["| kind | difficulty | dimension | was | now |", "| --- | --- | --- | --- | --- |"].concat(
+          r.barsMoved.map(
+            (b) => `| ${b.kind} | ${b.difficulty} | ${b.dim} | ${num(b.from)} | ${num(b.to)} |`,
+          ),
+        )
+      : ["none"]),
+  ];
+  if (r.standInsDropped.length)
+    out.push(
+      "",
+      "### Shipped stand-ins no longer needed",
+      "",
+      ...r.standInsDropped.map((x) => `- \`${x}\` now has values of its own`),
+    );
+  return `${out.join("\n")}\n`;
+}
+
+/**
+ * Spec 1.2 §7, `scripts/catalog-refresh.ts`: syncs every keyless source now (no Artificial Analysis key, the
+ * TTL ignored) into the current data folder, rebuilds the shipped file from the answers and, when it says
+ * anything new, writes it to `out`. A keyless source that fails writes nothing: a refresh never ships a file
+ * that lost a source's values (plan 14 Ruling 11).
+ */
+export async function refreshShipped(o: {
+  out: string;
+  current: ScoresFile;
+  models: ModelsFile;
+  sources: SourcesFile;
+  transport?: SourceTransport;
+  now?: () => number;
+}): Promise<{ changed: boolean; failed: { source: string; error: string }[]; report: RefreshReport | null }> {
+  const now = o.now ?? Date.now;
+  const sync = await syncSources({ force: true, aaKey: null, transport: o.transport, now });
+  if (sync.failed.length) return { changed: false, failed: sync.failed, report: null };
+  const { file, report } = rebuildShipped(cachedAnswers(), {
+    models: o.models,
+    scores: o.current,
+    sources: o.sources,
+    now: now(),
+  });
+  const changed = shippedChanged(o.current, file);
+  if (changed) writeFileSync(o.out, `${JSON.stringify(file, null, 2)}\n`);
+  return { changed, failed: [], report };
+}

package/src/services/catalog-service.ts

@@ -31,9 +31,13 @@ import { assetPath } from "../infra/assets.ts";
 import { withFileLock } from "../infra/filelock.ts";
 import { log } from "../infra/log.ts";
 import { configDir } from "../infra/paths.ts";
+import { readDerived } from "../infra/sources/cache.ts";
 import { ensurePrivateDir, readVersioned, writeJsonAtomic } from "../infra/store.ts";
 import type { CatalogFilter } from "./ports.ts";
 import { listRuns, readAgentRuns, readRecords, readRoutes } from "./run-store.ts";
+import { valuesUsed } from "./provenance.ts";
+import { type EvidenceTable, evidenceLine, evidenceOf, runEvidence } from "./run-evidence.ts";
+import { withStandIns } from "./standins.ts";
 
 const DAY_MS = 24 * 3_600_000;
 /** Spec §5.2: `secs_per_task` counts once a rung has this many of the user's own runs. */
@@ -41,14 +45,14 @@ const MIN_SAMPLES = 5;
 
 let models: ModelsFile | null = null;
 let scores: ScoresFile | null = null;
-const shippedModels = (): ModelsFile =>
+export const shippedModels = (): ModelsFile =>
   (models ??= readVersioned(assetPath("catalog/models.json"), ModelsFileSchema, 1));
-const shippedScores = (): ScoresFile =>
+export const shippedScores = (): ScoresFile =>
   (scores ??= readVersioned(assetPath("catalog/scores.json"), ScoresFileSchema, 1));
 
 export const overridePath = (): string => join(configDir(), "catalog.override.json");
 
-function readOverride(): Override {
+export function readOverride(): Override {
   const file = overridePath();
   return existsSync(file) ? readVersioned(file, OverrideSchema, 1) : OverrideSchema.parse({});
 }
@@ -116,15 +120,24 @@ export function measuredSecs(base: Catalog): Catalog["secs"] {
 
 /**
  * The shipped catalog with every listing (in `repo` for a backend listed per repository), the user's
- * override and, unless `timings: false`, own timings.
+ * override (or `override` in its place: what a change to it would make) and, unless `timings: false`, own
+ * timings.
  */
-export function loadCatalog(o: { timings?: boolean; repo?: string } = {}): Catalog {
-  const base = buildCatalog({
-    models: shippedModels(),
-    scores: shippedScores(),
-    override: readOverride(),
-    listed: listedModels(o.repo),
-  });
+export function loadCatalog(o: { timings?: boolean; repo?: string; override?: Override } = {}): Catalog {
+  // spec 1.2 §3.2: whatever the last sync derived; without one (first run, offline), the shipped values alone
+  const synced = readDerived();
+  // spec 1.2 §6.1: every value a rung lacks on a dimension the bars use comes from its nearest stand-in
+  const base = withStandIns(
+    buildCatalog({
+      models: shippedModels(),
+      scores: shippedScores(),
+      synced: synced?.scores,
+      facts: synced?.facts,
+      features: synced?.features,
+      override: o.override ?? readOverride(),
+      listed: listedModels(o.repo),
+    }),
+  );
   return o.timings === false ? base : { ...base, secs: measuredSecs(base) };
 }
 
@@ -250,7 +263,9 @@ export async function saveTreatLike(rung: string, like: string): Promise<{ rung:
     throw new CatherdError("E_CONFIG_INVALID", `${rung} cannot be treated like itself`, {
       fix: "name a different, scored rung",
     });
-  if (c.scores[from])
+  // a rung a sync scored on some dimensions may still borrow the others; one with every value `to` lends may not
+  const own = c.scores[from] ?? {};
+  if (DIMS.filter((d) => c.scores[to]?.[d]).every((d) => own[d]))
     throw new CatherdError(
       "E_CONFIG_INVALID",
       `${from} has scores of its own; a treat-like would not change it`,
@@ -276,6 +291,30 @@ export async function saveTreatLike(rung: string, like: string): Promise<{ rung:
   return { rung: from, like: to };
 }
 
+/** A rung given as `backend:model#effort` or `model#effort`, as the canonical rung the override keys it by. */
+export const canonicalRung = (rung: string): string => canonicalOf(loadCatalog({ timings: false }), rung);
+
+/**
+ * Spec 1.2 §6.4 `treat-like --clear|--reset`: removes the user's treat-likes for `rungs` (canonical), or every
+ * one with `"all"`, from catalog.override.json; the shipped ones are not the user's to remove. Returns the
+ * mappings removed. Leaves the override's other fields as they are.
+ */
+export async function removeTreatLikes(rungs: string[] | "all"): Promise<[string, string][]> {
+  if (!existsSync(overridePath())) return [];
+  let removed: [string, string][] = [];
+  await withFileLock(overridePath(), () => {
+    const cur = readOverride();
+    const gone = Object.entries(cur.treatLike).filter(([r]) => rungs === "all" || rungs.includes(r));
+    removed = gone;
+    if (gone.length === 0) return;
+    const treatLike = Object.fromEntries(
+      Object.entries(cur.treatLike).filter(([r]) => !gone.some(([g]) => g === r)),
+    );
+    writeJsonAtomic(overridePath(), { ...cur, schema: 1, treatLike });
+  });
+  return removed;
+}
+
 /** The backend a billing or harness key bills or isolates: `opencode-go` is a provider of the opencode backend. */
 export const backendOfKey = (key: string) => (key === "opencode-go" ? "opencode" : key);
 
@@ -285,21 +324,34 @@ function rungRows(
   model: string,
   efforts: string[],
   billing: Partial<Record<string, BillingMode>>,
+  evidence: EvidenceTable,
 ) {
   return (efforts.length ? efforts : ["default"]).map((effort) => {
     const rung = `${backend}:${model}#${effort}`;
     const info = rungInfo(c, rung);
     const s = scoresOf(c, info.canonical);
-    const scored: Record<string, { value: number; benchmark: string; confidence: string }> = {};
-    for (const d of DIMS) {
-      const r = s?.records[d];
-      if (r)
-        scored[d] = {
-          value: r.value,
-          benchmark: `${r.benchmark} ${r.version}`,
-          confidence: s?.via ? "inferred" : r.confidence,
-        };
-    }
+    const scored: Record<
+      string,
+      {
+        value: number;
+        benchmark: string;
+        confidence: string;
+        source: string;
+        date: string;
+        /** spec 1.2 §5.3: the rung a borrowed or inferred value belongs to */
+        from?: string;
+      }
+    > = {};
+    for (const v of valuesUsed(c, info.canonical))
+      scored[v.dim] = {
+        value: v.value,
+        benchmark: v.benchmark,
+        // a value lent by a treat-like or a stand-in is catherd's guess for this rung, whatever its own confidence
+        confidence: v.inferred ? "inferred" : v.confidence,
+        source: v.source,
+        date: v.date,
+        ...(v.from ? { from: v.from } : {}),
+      };
     const like = c.treatLike[info.canonical] ?? null;
     return {
       rung,
@@ -308,6 +360,8 @@ function rungRows(
       scores: scored,
       treatLike: s?.via ? like : null,
       cost: costOf(info.family, effort, billing[info.key] ?? DEFAULT_BILLING[info.key]),
+      /** spec 1.2 §8: catherd's own runs on it, over every kind; never used for routing */
+      evidence: evidenceLine(evidenceOf(evidence, info.canonical)),
     };
   });
 }
@@ -324,6 +378,9 @@ export interface CatalogModel {
   roles: Role[];
   listed: boolean | null;
   notes: Record<string, string>;
+  /** spec 1.2 §4.1: the family's API price, dollars per million tokens, and its speed facts */
+  price: Family["price"] | null;
+  speed: Record<string, number>;
   rungs: ReturnType<typeof rungRows>;
 }
 
@@ -336,6 +393,7 @@ export function catalogQuery(
   billing: Partial<Record<string, BillingMode>> = {},
 ): { total: number; models: CatalogModel[] } {
   const c = loadCatalog({ timings: false, repo: f.repo });
+  const evidence = runEvidence(c);
   const rows: CatalogModel[] = [];
   const known = new Set<string>();
   const entry = (backend: string, model: string, fam: Family | null): CatalogModel => {
@@ -352,7 +410,9 @@ export function catalogQuery(
       roles: ROLES.filter((r) => capableFor(c, probe, r)),
       listed: probe.listed,
       notes: fam?.notes ?? {},
-      rungs: rungRows(c, backend, model, probe.efforts, billing),
+      price: fam?.price ?? null,
+      speed: fam?.speed ?? {},
+      rungs: rungRows(c, backend, model, probe.efforts, billing, evidence),
     };
   };
   for (const fam of c.families)