catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/services/runs-page.ts

@@ -1,290 +0,0 @@
-import { sessionKey } from "../domain/host.ts";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { budgetStatus } from "../domain/budget.ts";
-import { ID_PATTERN } from "../domain/ids.ts";
-import type { RunRecord } from "../domain/record.ts";
-import { dispatchPaths } from "../infra/dispatch-dir.ts";
-import { nonBlankLines } from "../infra/store.ts";
-import { spendOf } from "./budget.ts";
-import { dispatchState, listDispatches, liveDispatches } from "./dispatches.ts";
-import { lastActivity } from "./finalize.ts";
-import type { Deps } from "./ports.ts";
-import { findRun, listRuns, readRecords, type Run, runPaths } from "./run-store.ts";
-import { groupRuns, type SessionGroup } from "./session-view.ts";
-import { orchestratorWait, type OrchestratorWait } from "./orchestrator-wait.ts";
-
-/**
- * Spec §4: what the Runs tab shows. The top level is the sessions; a session's screen holds its runs, each with its
- * milestones and every role (live ones first); a role's screen holds its brief, reply and record.
- */
-
-export interface SessionRow {
-  /** the session id; null for "earlier runs" */
-  key: string | null;
-  name: string;
-  live: boolean;
-  runs: number;
-  liveRoles: number;
-  landed: number;
-  /** ISO time of its newest activity */
-  lastActivity: string;
-}
-
-export interface RoleRow {
-  run: string;
-  dispatchId: string;
-  name: string;
-  role: string;
-  rung: string;
-  /** running | starting while live; once finished, the record's status (`finished` until it has one) */
-  status: string;
-  live: boolean;
-  /** a live role's admission time: the page ticks its elapsed time from it */
-  since: string;
-  /** a finished role's seconds, from its record */
-  secs: number | null;
-  /** a live role's last command, file edit or message line */
-  lastEvent: string | null;
-  replyStatus: string | null;
-}
-
-export interface Milestone {
-  name: string;
-  landed: boolean;
-  /** the ledger's "what" once landed; before that, plan.md's line for the milestone ("" when it has none) */
-  what: string;
-}
-
-export interface SessionRun {
-  waiting?: OrchestratorWait | null;
-  id: string;
-  title: string;
-  repo: string;
-  createdAt: string;
-  continued: "here" | "elsewhere" | null;
-  continuedIn: string | null;
-  /** the budget's spent fraction, null without a cap */
-  budget: number | null;
-  milestones: Milestone[];
-  roles: RoleRow[];
-}
-
-export interface SessionDetail {
-  session: SessionRow;
-  runs: SessionRun[];
-  /** the run folders to watch for changes */
-  dirs: string[];
-}
-
-export interface RoleDetail {
-  run: string;
-  runTitle: string;
-  dispatchId: string;
-  name: string;
-  role: string;
-  rung: string;
-  /** running | starting | finished */
-  state: string;
-  brief: string;
-  reply: string;
-  record: RunRecord | null;
-}
-
-export interface MilestoneDetail {
-  run: string;
-  runTitle: string;
-  name: string;
-  landed: boolean;
-  what: string;
-  /** R/digests/<name>.md; null when land has not written one (not landed, or landed by 1.0) or it is empty */
-  digest: string | null;
-}
-
-const keyOf = (g: SessionGroup): string | null => (g.session ? sessionKey(g.session) : null);
-
-/** The runs that live on in a session now (it owns them): each run's live roles and landings count once. */
-const ownRuns = (g: SessionGroup): Run[] => g.runs.filter((x) => x.current).map((x) => x.run);
-
-function rowOf(deps: Deps, g: SessionGroup): SessionRow {
-  const own = ownRuns(g);
-  return {
-    key: keyOf(g),
-    name: g.session?.name ?? "earlier runs",
-    live: g.session?.live ?? false,
-    runs: g.runs.length,
-    liveRoles: own.reduce((n, r) => n + liveDispatches(r, deps.now()).length, 0),
-    landed: own.reduce((n, r) => n + Math.max(0, nonBlankLines(runPaths(r.dir).ledger).length - 1), 0),
-    lastActivity: new Date(g.lastActivity).toISOString(),
-  };
-}
-
-/** The Runs tab's top level: every session, newest activity first, "earlier runs" last. */
-export function sessionRows(deps: Deps): { rows: SessionRow[]; warnings: string[] } {
-  const { runs, corrupt } = listRuns();
-  return {
-    rows: groupRuns(runs).map((g) => rowOf(deps, g)),
-    warnings: corrupt.map((c) => `skipped run ${c.id}: ${c.reason}`),
-  };
-}
-
-/**
- * A milestone's line in plan.md: a heading, list item or plain line that opens with its id and a separator
- * (`## M1 — the jobs list`, `- **M2:** export`). The id stops at the separator, so `M1.L1 — …` is a lane's.
- */
-const PLAN_LINE =
-  /^\s*(?:#{1,6}\s+|[-*]\s+|\d+[.)]\s+)?(?:\*\*)?([A-Za-z0-9_-]+)(?::\*\*|(?:\*\*)?\s*(?:—|–|:|-))\s*(.+?)\s*$/;
-
-/** The description plan.md gives each of `names`, from the first line that opens with it; none for the rest. */
-function planWhat(run: Run, names: string[]): Map<string, string> {
-  const out = new Map<string, string>();
-  const file = runPaths(run.dir).plan;
-  if (names.length === 0 || !existsSync(file)) return out;
-  for (const line of readFileSync(file, "utf8").split("\n")) {
-    const m = PLAN_LINE.exec(line);
-    const name = m?.[1];
-    if (m && name && names.includes(name) && !out.has(name)) out.set(name, (m[2] ?? "").trim());
-  }
-  return out;
-}
-
-const byNumber = (a: string, b: string) => a.localeCompare(b, "en", { numeric: true });
-
-/**
- * The ledger's landed milestones, then each milestone a lane file names that has not landed, whatever its id:
- * lane `<milestone>.<lane>` belongs to the milestone before its first dot, as protocol.ts reads it. An open
- * milestone's description is plan.md's line for it, when there is one.
- */
-function milestonesOf(run: Run): Milestone[] {
-  const landed = nonBlankLines(runPaths(run.dir).ledger)
-    .slice(1)
-    .map((l) => l.split(" | "))
-    .map(([name, what]) => ({ name: (name ?? "").trim(), landed: true, what: (what ?? "").trim() }));
-  const lanes = existsSync(runPaths(run.dir).lanes) ? readdirSync(runPaths(run.dir).lanes) : [];
-  const names = [
-    ...new Set(
-      lanes
-        .filter((f) => f.endsWith(".md") && f.slice(0, -".md".length).includes("."))
-        .map((f) => f.split(".")[0] as string),
-    ),
-  ]
-    .filter((m) => m !== "" && !landed.some((l) => l.name === m))
-    .sort(byNumber);
-  const what = planWhat(run, names);
-  return [...landed, ...names.map((name) => ({ name, landed: false, what: what.get(name) ?? "" }))];
-}
-
-/** Each role's latest dispatch, live ones first, then the newest finished first. */
-function rolesOf(deps: Deps, run: Run): RoleRow[] {
-  const now = deps.now();
-  const records = new Map(readRecords(run).records.map((r) => [r.dispatchId, r]));
-  const latest = new Map<string, ReturnType<typeof listDispatches>[number]>();
-  for (const d of listDispatches(run)) latest.set(d.admit.name, d);
-  const rows = [...latest.values()].map((d): RoleRow => {
-    const r = records.get(d.admit.dispatchId);
-    const state = r ? "finished" : dispatchState(d, now);
-    const live = state !== "finished";
-    return {
-      run: run.id,
-      dispatchId: d.admit.dispatchId,
-      name: d.admit.name,
-      role: d.admit.role,
-      rung: d.admit.rung,
-      status: r?.status ?? state,
-      live,
-      since: d.admit.admittedAt,
-      secs: r?.secs ?? null,
-      lastEvent: live ? lastActivity(d) : null,
-      replyStatus: r?.replyStatus ?? null,
-    };
-  });
-  return rows.sort((a, b) =>
-    a.live !== b.live ? (a.live ? -1 : 1) : b.dispatchId.localeCompare(a.dispatchId),
-  );
-}
-
-function sessionRun(deps: Deps, x: SessionGroup["runs"][number]): SessionRun {
-  const run = x.run;
-  let budget: number | null = null;
-  try {
-    const b = budgetStatus(
-      spendOf(run, readRecords(run).records, liveDispatches(run, deps.now()), deps.now()),
-      deps.profiles.budgetFor?.(run.meta.repo) ?? deps.profiles.forRepo(run.meta.repo).budget,
-    );
-    budget = b?.fraction ?? null;
-  } catch {
-    // an unreadable profile: no bar, the rest of the page stands
-  }
-  return {
-    id: run.id,
-    waiting: orchestratorWait(run, deps.now()),
-    title: run.meta.title,
-    repo: run.meta.repo,
-    createdAt: run.meta.createdAt,
-    continued: x.continued,
-    continuedIn: x.continuedIn,
-    budget,
-    milestones: milestonesOf(run),
-    roles: rolesOf(deps, run),
-  };
-}
-
-/** A session's screen: its runs, newest first, each with its milestones and roles. */
-export function sessionDetail(deps: Deps, key: string | null): SessionDetail {
-  const g = groupRuns(listRuns().runs).find((x) => keyOf(x) === key);
-  if (!g) throw new Error(key === null ? "no earlier runs" : `no session "${key}" in the runs`);
-  return {
-    session: rowOf(deps, g),
-    runs: g.runs.map((x) => sessionRun(deps, x)),
-    dirs: g.runs.map((x) => x.run.dir),
-  };
-}
-
-const text = (file: string): string => {
-  try {
-    return readFileSync(file, "utf8");
-  } catch {
-    return "";
-  }
-};
-
-/** A role's screen: its brief, its reply and its record. */
-export function roleDetail(deps: Deps, runId: string, dispatchId: string): RoleDetail {
-  const run = findRun(runId);
-  const d = listDispatches(run).find((x) => x.admit.dispatchId === dispatchId);
-  if (!d) throw new Error(`no dispatch ${dispatchId} in run ${runId}`);
-  const record = readRecords(run).records.find((r) => r.dispatchId === dispatchId) ?? null;
-  const p = dispatchPaths(d.dir);
-  return {
-    run: run.id,
-    runTitle: run.meta.title,
-    dispatchId,
-    name: d.admit.name,
-    role: d.admit.role,
-    rung: d.admit.rung,
-    state: record ? "finished" : dispatchState(d, deps.now()),
-    brief: text(p.brief),
-    reply: text(p.reply),
-    record,
-  };
-}
-
-/** Spec 1.1 §10: a milestone's screen, its digest. */
-export function milestoneDetail(runId: string, name: string): MilestoneDetail {
-  const run = findRun(runId);
-  // the id rule land writes digests under (assertId): never a path out of the run folder
-  const valid = ID_PATTERN.test(name) && !name.includes("..");
-  const m = valid ? milestonesOf(run).find((x) => x.name === name) : undefined;
-  if (!m) throw new Error(`no milestone "${name}" in run ${runId}`);
-  const file = join(run.dir, "digests", `${name}.md`);
-  const text = existsSync(file) ? readFileSync(file, "utf8") : "";
-  return {
-    run: run.id,
-    runTitle: run.meta.title,
-    name,
-    landed: m.landed,
-    what: m.what,
-    // an empty file is no digest either: land writes the whole digest at once
-    digest: text.trim() ? text : null,
-  };
-}

package/src/services/source-derive.ts

@@ -1,397 +0,0 @@
-import { measuredOrBetter } from "../domain/bars.ts";
-import { calibrate, DIM_SOURCES, type FieldRef } from "../domain/calibration.ts";
-import {
-  DIMS,
-  type Dim,
-  type Family,
-  type FamilyFacts,
-  type ModelsFile,
-  outranks,
-  type Score,
-  ScoreSchema,
-  type ScoresFile,
-} from "../domain/catalog.ts";
-import {
-  EFFORT_ORDER,
-  defaultEffortOf,
-  type Derived,
-  familyEfforts,
-  type FitRow,
-  idMapper,
-  type IdMapper,
-  nearestEffort,
-  type SourceId,
-  type SourcesFile,
-  splitSourceRung,
-} from "../domain/sources.ts";
-import { type AaAnswer, parseArtificialAnalysis } from "../infra/sources/artificial-analysis.ts";
-import { parseArena } from "../infra/sources/arena.ts";
-import { parseEpoch } from "../infra/sources/epoch.ts";
-import { LITELLM_EFFORTS, parseLiteLlm } from "../infra/sources/litellm.ts";
-import { modelsDevFacts } from "../infra/sources/models-dev.ts";
-import { parseOpenRouterEndpoints } from "../infra/sources/openrouter-endpoints.ts";
-import { type OpenRouterModel, parseOpenRouterModels } from "../infra/sources/openrouter-models.ts";
-import type { SourceRow } from "../infra/sources/rows.ts";
-import { parseVectara } from "../infra/sources/vectara.ts";
-
-/** Each source's cached answer (its `data`) with its fetch time; a source never fetched is absent. */
-export type RawAnswers = Partial<Record<SourceId, { fetchedAt: string; data: unknown }>>;
-
-export interface DeriveContext {
-  models: ModelsFile;
-  scores: ScoresFile;
-  sources: SourcesFile;
-  now: number;
-}
-
-/** Spec 1.2 §3.5: a price that differs by more than this is a sync warning. */
-const PRICE_TOLERANCE = 0.1;
-/** Spec 1.2 §3.5: the models.dev provider that serves a backend key its own catalog. */
-const OPENCODE_KEYS = ["opencode", "opencode-go"] as const;
-
-interface Keyed {
-  key: string;
-  family: Family | null;
-  effort: string;
-  assumed: boolean;
-  row: SourceRow;
-}
-
-/**
- * (1.2 minor) the fields where less is better: when two of a source's rows land on one rung, the lower one
- * stands for it. Every other field keeps the higher.
- */
-export const LOWER_IS_BETTER: ReadonlySet<string> = new Set([
-  "cost_per_task",
-  "median_time_to_first_token_seconds",
-]);
-
-/** Whether `a` should stand for a rung over `b` on `field`. */
-const better = (field: string, a: number, b: number): boolean => (LOWER_IS_BETTER.has(field) ? a < b : a > b);
-
-/** The score sources' rows, by source (spec 1.2 §3.3). */
-function scoreRows(raw: RawAnswers): [SourceId, SourceRow[]][] {
-  const out: [SourceId, SourceRow[]][] = [];
-  const { arena, vectara, epoch } = raw;
-  const aa = raw["artificial-analysis"];
-  if (arena) out.push(["arena", parseArena(arena.data as Record<string, unknown>, arena.fetchedAt)]);
-  if (vectara) out.push(["vectara", parseVectara(String(vectara.data), vectara.fetchedAt)]);
-  if (epoch) out.push(["epoch", parseEpoch(epoch.data as Record<string, string>, epoch.fetchedAt)]);
-  if (aa) out.push(["artificial-analysis", parseArtificialAnalysis(aa.data as AaAnswer, aa.fetchedAt)]);
-  return out;
-}
-
-const round = (v: number) => Math.round(v * 1e4) / 1e4;
-
-/**
- * Spec 1.2 §3.4–§4.3: what the cached answers say. Each score source's ids are mapped onto the catalog's
- * families (unmatched ones listed, never guessed), each dimension's anchor gives `measured` values, every
- * other source is fitted onto the anchor and gives `calibrated` values when the fit may be used, and an
- * effort no source covers takes the nearest covered effort's value as `adjacent`. models.dev gives the facts;
- * OpenRouter and LiteLLM only cross-check them.
- */
-export function derive(raw: RawAnswers, ctx: DeriveContext): Derived {
-  const map = idMapper(ctx.models.families, ctx.sources.aliases);
-  const unmatched: Record<string, Set<string>> = {};
-  const table = new Map<string, Map<string, Keyed>>();
-  for (const [source, rows] of scoreRows(raw))
-    for (const row of rows) {
-      const { id, effort } = splitSourceRung(row.rung);
-      const family = map.family(id);
-      if (!family) (unmatched[source] ??= new Set()).add(id);
-      // spec 1.3 §7.1: a family with no effort (Composer) has one rung, #default, whatever effort a source names
-      const effortless = family !== null && familyEfforts(family).length === 0;
-      const e = effortless ? "default" : (effort ?? (family ? defaultEffortOf(ctx.sources, family) : ""));
-      const key = `${map.key(family?.id ?? id)}#${e}`;
-      const field = `${source}.${row.field}`;
-      const at = table.get(field) ?? new Map<string, Keyed>();
-      table.set(field, at);
-      const had = at.get(key);
-      if (!had || better(row.field, row.value, had.row.value))
-        at.set(key, {
-          key,
-          family,
-          effort: e,
-          assumed: effort === null && family !== null && !effortless,
-          row,
-        });
-    }
-  const valuesOf = (f: FieldRef) =>
-    new Map([...(table.get(`${f.source}.${f.field}`)?.values() ?? [])].map((k) => [k.key, k.row.value]));
-
-  const scores: Score[] = [];
-  const fits: FitRow[] = [];
-  const push = (dim: Dim, f: FieldRef, k: Keyed, value: number, extra: Partial<Score>) => {
-    if (!k.family) return;
-    scores.push({
-      rung: `${k.family.id}#${k.effort}`,
-      dim,
-      value: round(value),
-      benchmark: f.benchmark,
-      version: k.row.date,
-      url: k.row.url,
-      date: k.row.date,
-      confidence: "measured",
-      source: f.source,
-      ...(k.assumed ? { effortAssumed: true } : {}),
-      ...extra,
-    });
-  };
-  for (const dim of DIMS) {
-    const spec = DIM_SOURCES[dim];
-    let anchor: Map<string, number>;
-    if (spec.anchor === "shipped") {
-      anchor = new Map();
-      // the hand-typed values published for the rung; never the shipped keyless ones (they carry a source)
-      for (const s of ctx.scores.scores)
-        if (s.dim === dim && s.source === undefined && measuredOrBetter(s)) {
-          const { id, effort } = splitSourceRung(s.rung);
-          anchor.set(`${map.key(id)}#${effort}`, s.value);
-        }
-    } else {
-      const ref = spec.anchor;
-      anchor = valuesOf(ref);
-      for (const k of table.get(`${ref.source}.${ref.field}`)?.values() ?? [])
-        push(dim, ref, k, k.row.value, {});
-    }
-    for (const other of spec.others) {
-      const values = valuesOf(other);
-      if (values.size === 0) continue;
-      const r = calibrate(anchor, values);
-      fits.push({
-        dim,
-        source: other.source,
-        field: other.field,
-        n: r.n,
-        a: r.fit?.a ?? null,
-        b: r.fit?.b ?? null,
-        r2: r.fit?.r2 ?? null,
-        used: r.used,
-        ...(r.why ? { why: r.why } : {}),
-      });
-      const fit = r.used ? r.fit : null;
-      if (!fit) continue;
-      for (const k of table.get(`${other.source}.${other.field}`)?.values() ?? [])
-        push(dim, other, k, fit.a * k.row.value + fit.b, {
-          confidence: "calibrated",
-          fit: { source: other.source, field: other.field, a: fit.a, b: fit.b, r2: fit.r2, n: fit.n },
-        });
-    }
-  }
-  const shipped = new Set<string>();
-  for (const s of ctx.scores.scores)
-    if (s.confidence !== "inferred") {
-      const { id, effort } = splitSourceRung(s.rung);
-      const family = map.family(id);
-      if (family && effort !== null) shipped.add(`${family.id}#${effort}|${s.dim}`);
-    }
-  // (1.2 minor) a sync carries a value only up to a stronger effort: a low effort never takes a high one's
-  scores.push(
-    ...adjacent(ctx.models.families, scores, shipped, ctx.now, (f) => defaultEffortOf(ctx.sources, f), {
-      upwardOnly: true,
-    }),
-  );
-
-  const { facts, warnings } = factsOf(raw, ctx, map);
-  return {
-    schema: 1,
-    builtAt: new Date(ctx.now).toISOString(),
-    // (1.2 minor) readDerived validates every score: one bad row would make the whole file unreadable
-    scores: scores.filter((s) => ScoreSchema.safeParse(s).success),
-    facts,
-    fits,
-    unmatched: Object.fromEntries(Object.entries(unmatched).map(([s, ids]) => [s, [...ids].sort()])),
-    warnings,
-    features: aaFeatures(table),
-  };
-}
-
-/** Spec 1.2 §6.3: the Artificial Analysis numbers a stand-in is ranked on, as AA names them. */
-export const AA_FEATURES = [
-  "artificial_analysis_intelligence_index",
-  "hle",
-  "scicode",
-  "lcr",
-  "cost_per_task",
-  "median_output_tokens_per_second",
-] as const;
-
-/** Each catalog rung's AA stand-in features, from the rows `derive` keyed (never shipped: AA is keyed). */
-function aaFeatures(table: Map<string, Map<string, Keyed>>): Derived["features"] {
-  const out: Derived["features"] = {};
-  for (const field of AA_FEATURES)
-    for (const k of table.get(`artificial-analysis.${field}`)?.values() ?? []) {
-      if (!k.family) continue;
-      (out[`${k.family.id}#${k.effort}`] ??= {})[field] = k.row.value;
-    }
-  return out;
-}
-
-/**
- * Spec 1.2 §4.3 `adjacent`: for each family effort a dimension has no value at (neither one in `direct` nor
- * one `shipped` names, as `<family>#<effort>|<dim>`), the best value in `direct` at the nearest effort that
- * has one (the weaker on a tie); with `upwardOnly` (a sync's values, 1.2 minor), only a weaker effort's value
- * is carried, so Luna none never takes Luna max's. A sync spreads only its own values, and never onto a value the shipped file
- * carries; `rebuildShipped` spreads the shipped file's published values, with an empty `shipped`. A family that
- * one backend runs without an effort (Cursor's bare slug, spec 1.3 §7.1) also gets `#default`, carried from the
- * value nearest `defaultEffort(family)`.
- */
-export function adjacent(
-  families: Family[],
-  direct: Score[],
-  shipped: ReadonlySet<string>,
-  now: number,
-  defaultEffort: (f: Family) => string = () => "high",
-  o: { upwardOnly?: boolean } = {},
-): Score[] {
-  const rank = (e: string) => (EFFORT_ORDER as readonly string[]).indexOf(e);
-  const out: Score[] = [];
-  for (const f of families)
-    for (const dim of DIMS) {
-      const byEffort = new Map<string, Score>();
-      for (const s of direct) {
-        const { id, effort } = splitSourceRung(s.rung);
-        if (id !== f.id || s.dim !== dim || effort === null) continue;
-        const had = byEffort.get(effort);
-        if (!had || outranks(s, had, now)) byEffort.set(effort, s);
-      }
-      if (byEffort.size === 0) continue;
-      const efforts = familyEfforts(f);
-      const bare = efforts.length > 0 && Object.values(f.on).some((o) => o && o.efforts.length === 0);
-      for (const e of bare ? [...efforts, "default"] : efforts) {
-        if (byEffort.has(e) || shipped.has(`${f.id}#${e}|${dim}`)) continue;
-        const target = e === "default" ? defaultEffort(f) : e;
-        const from_ = [...byEffort.keys()].filter((x) => !o.upwardOnly || rank(x) <= rank(target));
-        const near = nearestEffort(target, from_);
-        const from = near ? byEffort.get(near) : undefined;
-        if (!near || !from) continue;
-        out.push({
-          ...from,
-          rung: `${f.id}#${e}`,
-          confidence: "adjacent",
-          note: `${from.source ?? from.benchmark} has it at ${near}; carried to this effort`,
-        });
-      }
-    }
-  return out;
-}
-
-const differs = (a: number, b: number) => b !== 0 && Math.abs(a - b) / b > PRICE_TOLERANCE;
-const money = (n: number) => `$${n}/M`;
-
-/** Spec 1.2 §3.5: models.dev's facts per family, OpenRouter's speed facts, and the cross-check warnings. */
-function factsOf(
-  raw: RawAnswers,
-  ctx: DeriveContext,
-  map: IdMapper,
-): { facts: Record<string, FamilyFacts>; warnings: string[] } {
-  const md = raw["models-dev"]?.data;
-  const orModels = raw["openrouter-models"] ? parseOpenRouterModels(raw["openrouter-models"].data) : [];
-  const liteLlm = raw.litellm ? parseLiteLlm(raw.litellm.data) : [];
-  const endpoints = raw["openrouter-endpoints"];
-  const speedRows = endpoints
-    ? parseOpenRouterEndpoints(endpoints.data as Record<string, unknown>, endpoints.fetchedAt)
-    : [];
-  const aa = raw["artificial-analysis"];
-  const aaRows = aa ? parseArtificialAnalysis(aa.data as AaAnswer, aa.fetchedAt) : [];
-  const facts: Record<string, FamilyFacts> = {};
-  const warnings: string[] = [];
-  for (const f of ctx.models.families) {
-    const x: FamilyFacts = { on: {}, speed: {} };
-    const vendor = (f as { vendor?: unknown }).vendor;
-    const own =
-      md && typeof vendor === "string" ? modelsDevFacts(md, vendor, modelsDevId(md, vendor, f, map)) : null;
-    if (own?.price) x.price = own.price;
-    if (own && own.toolUse !== null && own.imageIn !== null && own.reasoning !== null)
-      x.capabilities = { toolUse: own.toolUse, imageIn: own.imageIn, reasoning: own.reasoning };
-    if (own?.releaseDate) x.releaseDate = own.releaseDate;
-    for (const key of OPENCODE_KEYS) {
-      const on = f.on[key];
-      const got = md && on ? modelsDevFacts(md, key, on.id.slice(on.id.indexOf("/") + 1)) : null;
-      if (got)
-        x.on[key] = {
-          ...(got.efforts ? { efforts: got.efforts } : {}),
-          ...(got.context ? { context: got.context } : {}),
-        };
-    }
-    for (const r of speedRows) if (map.family(r.rung) === f) x.speed[`openrouter.${r.field}`] = r.value;
-    const defaultRung = `${map.key(f.id)}#${defaultEffortOf(ctx.sources, f)}`;
-    for (const r of aaRows) {
-      const { id, effort } = splitSourceRung(r.rung);
-      if (map.family(id) !== f || `${map.key(f.id)}#${effort}` !== defaultRung) continue;
-      if (/^median_|^cost_per_task$/.test(r.field)) x.speed[`artificial-analysis.${r.field}`] = r.value;
-    }
-    if (x.price || x.capabilities || x.releaseDate || Object.keys(x.on).length || Object.keys(x.speed).length)
-      facts[f.id] = x;
-    if (own?.price) warnings.push(...priceWarnings(f, own.price, orModels, liteLlm, map));
-    if (own?.efforts) warnings.push(...effortWarnings(f, own.efforts, liteLlm, map));
-  }
-  return { facts, warnings };
-}
-
-/**
- * The id of `vendor`'s models.dev model that is `f`: its own id, else the first that maps to it (spec 1.3 §7.1:
- * `gemini-3-8-flash` is Google's `gemini-3.8-flash`, `gemini-3-1-pro` its aliased `gemini-3.1-pro-preview`).
- */
-function modelsDevId(md: unknown, vendor: string, f: Family, map: IdMapper): string {
-  const ids = Object.keys((md as Record<string, { models?: object }>)[vendor]?.models ?? {});
-  return ids.includes(f.id) ? f.id : (ids.find((id) => map.family(id) === f) ?? f.id);
-}
-
-/** The first entry of `list` whose id maps to `f` (OpenRouter's `:batch` variants never do). */
-const entryFor = <T extends { id: string }>(list: T[], f: Family, map: IdMapper): T | undefined =>
-  list.find((m) => map.family(m.id) === f);
-
-function priceWarnings(
-  f: Family,
-  price: { input: number; output: number },
-  orModels: OpenRouterModel[],
-  liteLlm: ReturnType<typeof parseLiteLlm>,
-  map: IdMapper,
-): string[] {
-  const out: string[] = [];
-  for (const [name, other] of [
-    ["OpenRouter", entryFor(orModels, f, map)?.price],
-    ["LiteLLM", entryFor(liteLlm, f, map)?.price],
-  ] as const) {
-    if (!other) continue;
-    for (const side of ["input", "output"] as const)
-      if (differs(other[side], price[side]))
-        out.push(
-          `${f.id}: ${side} price ${money(price[side])} on models.dev, ${money(other[side])} on ${name} (more than 10 % apart)`,
-        );
-  }
-  return out;
-}
-
-function effortWarnings(
-  f: Family,
-  efforts: string[],
-  liteLlm: ReturnType<typeof parseLiteLlm>,
-  map: IdMapper,
-): string[] {
-  const entry = entryFor(liteLlm, f, map);
-  if (!entry) return [];
-  const out: string[] = [];
-  for (const e of LITELLM_EFFORTS) {
-    const says = entry.efforts[e];
-    if (says === undefined || says === efforts.includes(e)) continue;
-    out.push(
-      `${f.id}: LiteLLM says effort ${e} is ${says ? "" : "not "}supported; models.dev ${says ? "does not list" : "lists"} it`,
-    );
-  }
-  return out;
-}
-
-/** Plan 13 R-H: the OpenRouter id of each catalog family OpenRouter lists, one each, for the endpoints fetch. */
-export function openRouterIds(
-  orModelsData: unknown,
-  ctx: Pick<DeriveContext, "models" | "sources">,
-): string[] {
-  const map = idMapper(ctx.models.families, ctx.sources.aliases);
-  const models = parseOpenRouterModels(orModelsData);
-  return ctx.models.families.flatMap((f) => {
-    const m = entryFor(models, f, map);
-    return m ? [m.id] : [];
-  });
-}