catherd-cli 1.4.0 → 2.0.0-beta.20261022113309

package/src/infra/sources/litellm.ts

@@ -1,58 +0,0 @@
-import { z } from "zod";
-import { type SourceTransport, sourceGet } from "./http.ts";
-import { perMillion } from "./openrouter-models.ts";
-import { num } from "./rows.ts";
-
-/** Spec 1.2 §3.1: price and effort support, a cross-check only (MIT). */
-export const LITELLM_URL =
-  "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
-
-export const fetchLiteLlm = async (t: SourceTransport = {}): Promise<unknown> =>
-  (await sourceGet(LITELLM_URL, t)).json();
-
-/** The efforts LiteLLM flags per model (`supports_<effort>_reasoning_effort`). */
-export const LITELLM_EFFORTS = ["none", "minimal", "low", "xhigh", "max"] as const;
-
-export interface LiteLlmModel {
-  id: string;
-  provider: string;
-  /** dollars per million tokens */
-  price: { input: number; output: number; cached: number | null } | null;
-  context: number | null;
-  /** effort → whether LiteLLM says the model supports it; absent when it does not say */
-  efforts: Partial<Record<(typeof LITELLM_EFFORTS)[number], boolean>>;
-}
-
-/** Spec 1.2 §3.5: the vendors' own APIs, whose prices the catalog's are. */
-const FIRST_PARTY = new Set(["openai", "anthropic"]);
-
-const EntrySchema = z.looseObject({ litellm_provider: z.string() });
-
-/** The first-party entries of LiteLLM's price file: an OpenAI or Anthropic provider, a key with no `/`. */
-export function parseLiteLlm(raw: unknown): LiteLlmModel[] {
-  if (!raw || typeof raw !== "object") return [];
-  const out: LiteLlmModel[] = [];
-  for (const [id, v] of Object.entries(raw as Record<string, unknown>)) {
-    const e = EntrySchema.safeParse(v);
-    if (!e.success || !FIRST_PARTY.has(e.data.litellm_provider) || id.includes("/")) continue;
-    const entry = e.data as Record<string, unknown>;
-    const input = perMillion(entry.input_cost_per_token);
-    const output = perMillion(entry.output_cost_per_token);
-    const efforts: LiteLlmModel["efforts"] = {};
-    for (const effort of LITELLM_EFFORTS) {
-      const flag = entry[`supports_${effort}_reasoning_effort`];
-      if (typeof flag === "boolean") efforts[effort] = flag;
-    }
-    out.push({
-      id,
-      provider: e.data.litellm_provider,
-      price:
-        input !== null && output !== null
-          ? { input, output, cached: perMillion(entry.cache_read_input_token_cost) }
-          : null,
-      context: num(entry.max_input_tokens),
-      efforts,
-    });
-  }
-  return out;
-}

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

@@ -1,59 +0,0 @@
-import { z } from "zod";
-import { type SourceTransport, sourceGet } from "./http.ts";
-import { num } from "./rows.ts";
-
-/** Spec 1.2 §3.1: efforts, context, output limit, price, tool calling, modalities, release date (MIT). */
-export const MODELS_DEV_URL = "https://models.dev/api.json";
-
-export const fetchModelsDev = async (t: SourceTransport = {}): Promise<unknown> =>
-  (await sourceGet(MODELS_DEV_URL, t)).json();
-
-/** What catherd reads of one models.dev model; each field null when the source does not say. */
-export interface ModelFacts {
-  efforts: string[] | null;
-  context: number | null;
-  output: number | null;
-  /** dollars per million tokens */
-  price: { input: number; cached: number; output: number } | null;
-  toolUse: boolean | null;
-  imageIn: boolean | null;
-  reasoning: boolean | null;
-  releaseDate: string | null;
-}
-
-const ModelSchema = z.looseObject({
-  reasoning: z.boolean().optional(),
-  reasoning_options: z
-    .array(z.looseObject({ type: z.string(), values: z.array(z.string()).optional() }))
-    .optional(),
-  tool_call: z.boolean().optional(),
-  release_date: z.string().optional(),
-  modalities: z.looseObject({ input: z.array(z.string()).optional() }).optional(),
-  limit: z.looseObject({ context: z.unknown(), output: z.unknown() }).optional(),
-  cost: z.looseObject({ input: z.unknown(), output: z.unknown(), cache_read: z.unknown() }).optional(),
-});
-
-/**
- * Spec 1.2 §3.5: `provider`'s model `id` in models.dev's api.json (a provider id such as `openai` or
- * `opencode-go`, and the model id within it); null when absent or unreadable.
- */
-export function modelsDevFacts(raw: unknown, provider: string, id: string): ModelFacts | null {
-  const p = (raw as Record<string, { models?: Record<string, unknown> }> | null)?.[provider];
-  const parsed = ModelSchema.safeParse(p?.models?.[id]);
-  if (!parsed.success) return null;
-  const m = parsed.data;
-  const efforts = m.reasoning_options?.find((o) => o.type === "effort")?.values ?? null;
-  const input = num(m.cost?.input);
-  const output = num(m.cost?.output);
-  return {
-    efforts,
-    context: num(m.limit?.context),
-    output: num(m.limit?.output),
-    price:
-      input !== null && output !== null ? { input, cached: num(m.cost?.cache_read) ?? input, output } : null,
-    toolUse: m.tool_call ?? null,
-    imageIn: m.modalities?.input ? m.modalities.input.includes("image") : null,
-    reasoning: m.reasoning ?? null,
-    releaseDate: m.release_date ?? null,
-  };
-}

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

@@ -1,52 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,69 +0,0 @@
-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

@@ -1,48 +0,0 @@
-// 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

@@ -1,201 +0,0 @@
-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 { defaultEffortOf, 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,
-    (f) => defaultEffortOf(ctx.sources, f),
-  );
-  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/doctor-sources.ts

@@ -1,76 +0,0 @@
-import type { Profile } from "../domain/profile.ts";
-import { type StandInToConfirm, standInsToConfirm } from "../domain/profile-rules.ts";
-import { loadCatalog } from "./catalog-service.ts";
-import type { Check } from "./doctor-checks.ts";
-import { runnableBackends } from "./profile-store.ts";
-import { sourcesStatus, TTL_MS } from "./source-sync.ts";
-
-const HOUR = 3_600_000;
-const DAY = 24 * HOUR;
-
-/** An age as doctor prints it: minutes under an hour, hours under two days, else days. */
-export function ageText(ms: number): string {
-  if (ms < HOUR) return `${Math.max(1, Math.round(ms / 60_000))} min`;
-  if (ms < 2 * DAY) return `${Math.round(ms / HOUR)} h`;
-  return `${Math.round(ms / DAY)} d`;
-}
-
-/** Spec 1.2 §6.1, §9: the stand-ins to confirm across `profiles`, one per canonical rung. */
-export function standInsToConfirmIn(profiles: Profile[]): StandInToConfirm[] {
-  if (profiles.length === 0) return [];
-  const c = loadCatalog({ timings: false });
-  const seen = new Map<string, StandInToConfirm>();
-  for (const p of profiles)
-    for (const x of standInsToConfirm(p, c, runnableBackends()))
-      if (!seen.has(x.canonical)) seen.set(x.canonical, x);
-  return [...seen.values()];
-}
-
-/** `gpt-5.6-terra#high (repo_code, terminal, honesty)`, the rung and the dimensions a stand-in fills. */
-const confirmText = (xs: StandInToConfirm[]): string =>
-  `stand-ins to confirm: ${xs.map((x) => `${x.canonical} (${x.dims.map((d) => d.dim).join(", ")})`).join(", ")}`;
-
-/**
- * Spec 1.2 §9: the `sources` row: each source's age and last error, whether an Artificial Analysis key is
- * set, its requests left today (`x-ratelimit-remaining` of its last answer), and the linked profiles'
- * stand-ins to confirm (`confirm`, spec 1.2 §6.1). `info` before the first sync (routing uses the shipped
- * scores); a warning when a source fails or has not been fetched for two TTLs (a day), since background
- * syncs would have refreshed it. It reads the sync's state only: no request.
- */
-export function sourcesCheck(now = Date.now(), confirm: StandInToConfirm[] = []): Check {
-  const s = sourcesStatus();
-  const shown = s.sources.filter((x) => x.source !== "artificial-analysis" || s.aaKey);
-  const keyless = s.sources.filter((x) => x.source !== "artificial-analysis");
-  const sameDay =
-    s.rateLimitAt !== null && s.rateLimitAt.slice(0, 10) === new Date(now).toISOString().slice(0, 10);
-  const left =
-    s.rateLimitRemaining === null
-      ? ""
-      : sameDay
-        ? `, ${s.rateLimitRemaining} requests left today`
-        : `, ${s.rateLimitRemaining} requests left on ${s.rateLimitAt?.slice(0, 10)}`;
-  const aa = `${s.aaKey ? `Artificial Analysis key set${left}` : "no Artificial Analysis key"}${confirm.length ? `; ${confirmText(confirm)}` : ""}`;
-  const base = { id: "sources", label: "sources" };
-  if (keyless.every((x) => x.fetchedAt === null && x.error === null))
-    return {
-      ...base,
-      state: "info",
-      word: "not synced",
-      detail: `routing uses the shipped scores; ${aa}`,
-      fix: "catherd catalog sync",
-    };
-  const parts = shown.map(
-    (x) =>
-      `${x.source} ${x.fetchedAt ? ageText(now - Date.parse(x.fetchedAt)) : "never"}${x.error ? ` (${x.error})` : ""}`,
-  );
-  const failing = shown.some((x) => x.error !== null);
-  const stale = keyless.some((x) => x.fetchedAt === null || now - Date.parse(x.fetchedAt) > 2 * TTL_MS);
-  const warn = failing || stale;
-  return {
-    ...base,
-    state: warn ? "warn" : "ok",
-    word: failing ? "failing" : stale ? "stale" : "fresh",
-    detail: `${parts.join(", ")}; ${aa}`,
-    ...(warn ? { fix: "catherd catalog sync --force" } : {}),
-  };
-}