catherd-cli 0.2.0 → 1.0.0

package/src/routing/catalog.ts

@@ -1,227 +0,0 @@
-import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { createFetch } from "ofetch";
-import { z } from "zod";
-import { assetPath, readJsonFile } from "../files.ts";
-import { configDir, dataDir } from "../paths.ts";
-import {
-  type Capabilities,
-  type Catalog,
-  type CatalogEntry,
-  type CatalogModel,
-  DIFFICULTIES,
-  KINDS,
-  ROLE_NEEDS,
-  type Role,
-  type RungId,
-} from "../types.ts";
-
-const Caps = z.object({
-  toolCall: z.boolean(),
-  imageIn: z.boolean(),
-  imageOut: z.boolean(),
-  reasoning: z.boolean(),
-  context: z.number(),
-});
-const Model = z.object({
-  id: z.string().min(1),
-  backend: z.enum(["codex", "opencode", "claude"]),
-  efforts: z.array(z.string().min(1)).min(1),
-  capabilities: Caps,
-});
-const Scores = z.object({
-  repo_code: z.number().optional(),
-  terminal: z.number().optional(),
-  honesty: z.number().optional(),
-  secs_per_task: z.number().optional(),
-});
-const Bar = z.object({
-  repo_code: z.number().optional(),
-  terminal: z.number().optional(),
-  honesty: z.number().optional(),
-});
-const Rung = z.string().regex(/^.+#[^#]+$/, "expected model#effort");
-
-const CatalogSchema = z.object({
-  version: z.string(),
-  models: z.array(Model),
-  entries: z.array(z.object({ rung: Rung, scores: Scores, costRank: z.number() })),
-  bars: z.record(z.enum(KINDS), z.record(z.enum(DIFFICULTIES), Bar)),
-  treatLike: z.record(Rung, Rung),
-});
-
-const OverrideSchema = z.object({
-  models: z
-    .record(
-      z.string().min(1),
-      z
-        .object({ backend: Model.shape.backend, efforts: Model.shape.efforts, capabilities: Caps.partial() })
-        .partial(),
-    )
-    .optional(),
-  entries: z
-    .record(Rung, z.object({ scores: Scores.optional(), costRank: z.number().optional() }))
-    .optional(),
-  bars: z.partialRecord(z.enum(KINDS), z.partialRecord(z.enum(DIFFICULTIES), Bar)).optional(),
-  treatLike: z.record(Rung, Rung).optional(),
-});
-export type CatalogOverride = z.infer<typeof OverrideSchema>;
-
-const SnapshotSchema = z.object({
-  fetchedAt: z.string(),
-  models: z.record(z.string(), Caps.extend({ efforts: z.array(z.string()) })),
-});
-export type ModelsDevSnapshot = {
-  fetchedAt: string;
-  models: Record<string, Capabilities & { efforts: string[] }>;
-};
-
-export const snapshotPath = (): string => join(dataDir(), "models-dev.json");
-export const overridePath = (): string => join(configDir(), "catalog.override.json");
-
-export function loadCatalog(): Catalog {
-  const c: Catalog = readJsonFile(CatalogSchema, assetPath("catalog/catalog.json"));
-  const snapshot = [snapshotPath(), assetPath("catalog/models-dev.json")].find((f) => existsSync(f));
-  if (snapshot) {
-    const known = new Set(c.models.map((m) => m.id));
-    for (const [id, { efforts, ...capabilities }] of Object.entries(
-      readJsonFile(SnapshotSchema, snapshot).models,
-    )) {
-      if (!known.has(id))
-        c.models.push({ id, backend: "opencode", efforts: ["default", ...efforts], capabilities });
-    }
-  }
-  return existsSync(overridePath()) ? applyOverride(c, readJsonFile(OverrideSchema, overridePath())) : c;
-}
-
-function applyOverride(c: Catalog, o: CatalogOverride): Catalog {
-  const file = overridePath();
-  for (const [id, m] of Object.entries(o.models ?? {})) {
-    const cur = modelOf(c, id);
-    if (cur) {
-      if (m.backend) cur.backend = m.backend;
-      if (m.efforts) cur.efforts = m.efforts;
-      cur.capabilities = { ...cur.capabilities, ...m.capabilities };
-      continue;
-    }
-    const full = Model.safeParse({ id, ...m });
-    if (!full.success)
-      throw new Error(`catherd: ${file}: new model "${id}" needs a backend, efforts and every capability`);
-    c.models.push(full.data);
-  }
-  for (const [rung, e] of Object.entries(o.entries ?? {})) {
-    const cur = c.entries.find((x) => x.rung === rung);
-    if (cur) {
-      cur.scores = { ...cur.scores, ...e.scores };
-      cur.costRank = e.costRank ?? cur.costRank;
-    } else if (e.costRank === undefined) {
-      throw new Error(`catherd: ${file}: new entry "${rung}" needs a costRank`);
-    } else {
-      c.entries.push({ rung, scores: e.scores ?? {}, costRank: e.costRank });
-    }
-  }
-  for (const kind of KINDS) {
-    for (const d of DIFFICULTIES) {
-      const bar = o.bars?.[kind]?.[d];
-      if (bar) c.bars[kind][d] = bar;
-    }
-  }
-  for (const [rung, like] of Object.entries(o.treatLike ?? {})) {
-    if (!c.entries.some((e) => e.rung === like)) {
-      throw new Error(`catherd: ${file}: "${rung}" is treated like "${like}", which has no scores`);
-    }
-    c.treatLike[rung] = like;
-  }
-  return c;
-}
-
-export function modelOf(c: Catalog, id: string): CatalogModel | undefined {
-  return c.models.find((m) => m.id === id);
-}
-
-export function capableFor(role: Role, m: CatalogModel): boolean {
-  return Object.entries(ROLE_NEEDS[role]).every(([k, need]) => {
-    const have = m.capabilities[k as keyof Capabilities];
-    return typeof need === "number" ? Number(have) >= need : have === need;
-  });
-}
-
-export function entryFor(c: Catalog, rung: RungId): CatalogEntry | undefined {
-  const own = c.entries.find((e) => e.rung === rung);
-  if (own) return own;
-  const like = c.treatLike[rung];
-  const borrowed = like === undefined ? undefined : c.entries.find((e) => e.rung === like);
-  return borrowed && { ...borrowed, rung };
-}
-
-export function isScored(c: Catalog, rung: RungId): boolean {
-  return entryFor(c, rung) !== undefined;
-}
-
-/** Merges one "treat like" into <config>/catalog.override.json, keeping every other field. */
-export function saveTreatLike(rung: RungId, like: RungId): void {
-  const base = loadCatalog();
-  if (!base.entries.some((e) => e.rung === like)) {
-    throw new Error(`catherd: ${overridePath()}: "${rung}" is treated like "${like}", which has no scores`);
-  }
-  const file = overridePath();
-  const current: CatalogOverride = existsSync(file) ? readJsonFile(OverrideSchema, file) : {};
-  const next: CatalogOverride = { ...current, treatLike: { ...current.treatLike, [rung]: like } };
-  mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
-}
-
-export const MODELS_DEV_URL = "https://models.dev/api.json";
-
-interface ModelsDevModel {
-  tool_call?: boolean;
-  reasoning?: boolean;
-  status?: string;
-  modalities?: { input?: string[]; output?: string[] };
-  limit?: { context?: number };
-  // models.dev lists a bare "no effort" option as null alongside the named efforts.
-  reasoning_options?: { type: string; values?: (string | null)[] }[];
-}
-export type ModelsDevApi = Record<
-  string,
-  { id?: string; models?: Record<string, ModelsDevModel> } | undefined
->;
-
-export function trimModelsDev(api: ModelsDevApi, fetchedAt: string): ModelsDevSnapshot {
-  const models: ModelsDevSnapshot["models"] = {};
-  for (const [provider, p] of Object.entries(api)) {
-    for (const [id, m] of Object.entries(p?.models ?? {})) {
-      const imageOut = m.modalities?.output?.includes("image") ?? false;
-      if (m.status === "deprecated" || !(m.tool_call || imageOut)) continue;
-      models[`${provider}/${id}`] = {
-        toolCall: m.tool_call ?? false,
-        imageIn: m.modalities?.input?.includes("image") ?? false,
-        imageOut,
-        reasoning: m.reasoning ?? false,
-        context: m.limit?.context ?? 0,
-        efforts: (m.reasoning_options?.find((r) => r.type === "effort")?.values ?? []).filter(
-          (v): v is string => typeof v === "string",
-        ),
-      };
-    }
-  }
-  return { fetchedAt, models };
-}
-
-export async function refreshModelsDev(
-  o: { fetchImpl?: typeof fetch; to?: string } = {},
-): Promise<{ models: number }> {
-  const api = await createFetch({ fetch: o.fetchImpl ?? globalThis.fetch })<ModelsDevApi>(MODELS_DEV_URL, {
-    retry: 2,
-    retryDelay: 1000,
-    timeout: 60_000,
-  });
-  const snap = trimModelsDev(typeof api === "object" && api !== null ? api : {}, new Date().toISOString());
-  const count = Object.keys(snap.models).length;
-  if (count === 0) throw new Error("catherd: models.dev returned no models; the previous snapshot is kept");
-  const to = o.to ?? snapshotPath();
-  mkdirSync(dirname(to), { recursive: true });
-  writeFileSync(`${to}.tmp`, `${JSON.stringify(snap)}\n`);
-  renameSync(`${to}.tmp`, to);
-  return { models: count };
-}

package/src/routing/commands.ts

@@ -1,22 +0,0 @@
-import { defineCommand } from "citty";
-import { loadCatalog, refreshModelsDev, snapshotPath } from "./catalog.ts";
-
-const refresh = defineCommand({
-  meta: { name: "refresh", description: "Refresh the local models.dev snapshot" },
-  async run() {
-    try {
-      const { models } = await refreshModelsDev();
-      console.log(
-        `catherd: ${models} models from models.dev → ${snapshotPath()} (catalog: ${loadCatalog().models.length} models)`,
-      );
-    } catch (e) {
-      console.error(`catherd: catalog refresh failed: ${(e as Error).message}`);
-      process.exitCode = 1;
-    }
-  },
-});
-
-export const catalogCommand = defineCommand({
-  meta: { name: "catalog", description: "The model catalog" },
-  subCommands: { refresh },
-});

package/src/routing/jev.ts

@@ -1,185 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createFetch } from "ofetch";
-import { z } from "zod";
-import { appendJsonl } from "../core/runstore.ts";
-import { configDir } from "../paths.ts";
-
-export const JEV_URL = "https://api.typesafe.ai/v1/systemone";
-export const JEV_MODEL = "jev-1.13.0";
-
-export interface JevQuestion {
-  type: "choice";
-  instructions: string;
-  criteria: Record<string, string>;
-}
-export type JevQuestions = Record<string, JevQuestion>;
-export interface JevAnswer {
-  choice: string;
-  confidence: number;
-  probabilities: Record<string, number>;
-}
-export type JevAnswers = Record<string, JevAnswer>;
-export interface JevOpts {
-  fetchImpl?: typeof fetch;
-  retryDelayMs?: number;
-}
-export interface JevLogRow {
-  ts: string;
-  questions: string[];
-  answers: JevAnswers | null;
-  used: string;
-  source: "jev" | "default";
-  why: string;
-}
-
-// Versioned with JEV_MODEL. difficulty, finding and same-defect are verbatim from the
-// codex-orchestration jev.sh that ran on 2026-09-23/24; kind is new, and the recorded fixtures used it.
-export const QUESTIONS = {
-  kind: {
-    type: "choice",
-    instructions: "What kind of work does the lane in the state describe?",
-    criteria: {
-      repo_code: "Code and tests inside an application or library repository",
-      terminal: "Shell, build, CI, infrastructure or environment work, where the terminal is the main tool",
-      ui: "User-interface work judged on screen: layout, styling, components",
-      prose: "Writing that is not code: docs, a changelog, release notes, a merge request body",
-      research: "Finding facts to answer a question, with no change to the product",
-    },
-  },
-  difficulty: {
-    type: "choice",
-    instructions: "How hard is the work described in the state for a coding agent?",
-    criteria: {
-      copy: "Mechanical: rename, move, copy an existing pattern verbatim",
-      build: "New code that follows an existing pattern in the repo",
-      logic: "Non-trivial logic: state, concurrency, data invariants, edge cases",
-      hard: "Unclear cause, cross-system design, or no pattern to follow",
-    },
-  },
-  finding: {
-    type: "choice",
-    instructions: "A reviewer reported `finding` on the work planned in `lane`. Where is the defect?",
-    criteria: {
-      design: "The plan itself is wrong: its decisions, signatures or data shapes cannot meet the goal",
-      code: "The plan is sound and the code does not implement it correctly",
-      unclear: "The finding does not say enough to tell",
-    },
-  },
-  "same-defect": {
-    type: "choice",
-    instructions:
-      "Does `after` report the same underlying defect as `before`, even if worded differently or at another line?",
-    criteria: { yes: "Same underlying defect", no: "A different defect" },
-  },
-} satisfies JevQuestions;
-
-const RETRY_CODES = [429, ...Array.from({ length: 100 }, (_, i) => 500 + i)];
-
-const Reply = z.object({
-  answers: z.record(
-    z.string(),
-    z.object({
-      choice: z.string(),
-      confidence: z.number(),
-      probabilities: z.record(z.string(), z.number()).default(() => ({})),
-    }),
-  ),
-});
-
-const credentialsFile = () => join(configDir(), "credentials.json");
-
-/** The key file TypeSafe's own tools use, so a user who already has one never types it again. */
-export const typesafeKeyFile = (): string =>
-  join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "typesafe", "api_key");
-
-export function jevKey(): string | null {
-  const env = process.env.TYPESAFE_API_KEY?.trim();
-  if (env) return env;
-  try {
-    const k: unknown = JSON.parse(readFileSync(credentialsFile(), "utf8")).typesafeApiKey;
-    if (typeof k === "string" && k.trim()) return k.trim();
-  } catch {}
-  if (!existsSync(typesafeKeyFile())) return null;
-  return readFileSync(typesafeKeyFile(), "utf8").trim() || null;
-}
-
-export function saveJevKey(key: string): void {
-  mkdirSync(configDir(), { recursive: true });
-  writeFileSync(credentialsFile(), `${JSON.stringify({ typesafeApiKey: key.trim() }, null, 2)}\n`, {
-    mode: 0o600,
-  });
-  // writeFileSync's mode applies only when it creates the file.
-  chmodSync(credentialsFile(), 0o600);
-}
-
-export async function callJev(
-  q: JevQuestions,
-  state: Record<string, string>,
-  o: JevOpts & { key?: string | null } = {},
-): Promise<{ answers: JevAnswers | null; error: string | null }> {
-  const key = o.key === undefined ? jevKey() : o.key;
-  if (!key) return { answers: null, error: "no key" };
-  const base = o.retryDelayMs ?? 1000;
-  let raw: unknown;
-  try {
-    raw = await createFetch({ fetch: o.fetchImpl ?? globalThis.fetch })(JEV_URL, {
-      method: "POST",
-      headers: { authorization: `Bearer ${key}` },
-      body: { model: JEV_MODEL, state, questions: q },
-      retry: 3,
-      retryDelay: (ctx) => base * (4 - Number(ctx.options.retry)),
-      retryStatusCodes: RETRY_CODES,
-      timeout: 30_000,
-    });
-  } catch (e) {
-    const status = (e as { status?: number }).status;
-    return { answers: null, error: status ? `http ${status}` : "network error" };
-  }
-  const parsed = Reply.safeParse(raw);
-  if (!parsed.success) return { answers: null, error: "unexpected response" };
-  const answers: JevAnswers = {};
-  for (const [id, question] of Object.entries(q)) {
-    const a = parsed.data.answers[id];
-    if (!a || !Object.hasOwn(question.criteria, a.choice))
-      return { answers: null, error: `no valid answer to ${id}` };
-    answers[id] = a;
-  }
-  return { answers, error: null };
-}
-
-export function logJev(runDir: string, row: Omit<JevLogRow, "ts">): void {
-  appendJsonl(join(runDir, "jev.jsonl"), { ts: new Date().toISOString(), ...row });
-}
-
-export async function askJev(
-  q: JevQuestions,
-  state: Record<string, string>,
-  o: JevOpts & { runDir?: string } = {},
-): Promise<JevAnswers | null> {
-  const { answers, error } = await callJev(q, state, o);
-  if (o.runDir) {
-    logJev(o.runDir, {
-      questions: Object.keys(q),
-      answers,
-      used: answers
-        ? Object.entries(answers)
-            .map(([id, a]) => `${id}=${a.choice}`)
-            .join(" ")
-        : "none",
-      source: answers ? "jev" : "default",
-      why: error ?? "raw answers, no threshold applied",
-    });
-  }
-  return answers;
-}
-
-export async function testJevKey(key: string, o: JevOpts = {}): Promise<boolean> {
-  const { answers } = await callJev(
-    { difficulty: QUESTIONS.difficulty },
-    { lane: "Rename the variable total to sum in src/cart.ts." },
-    { ...o, key },
-  );
-  return answers !== null;
-}

package/src/routing/route.ts

@@ -1,155 +0,0 @@
-import {
-  type Catalog,
-  DIFFICULTIES,
-  KINDS,
-  type Profile,
-  type Role,
-  type RouteDecision,
-  type RungId,
-} from "../types.ts";
-import { callJev, type JevAnswers, type JevOpts, logJev, QUESTIONS } from "./jev.ts";
-import { candidates, defaultLadder, select } from "./select.ts";
-
-const ROUTE_MIN = 0.75;
-const FINDING_MIN = 0.75;
-const SAME_DEFECT_MIN = 0.7;
-// spec §11b: at 80% of budget spent, the start rung is the cheapest bar-clearing one, regardless
-// of objective, so a run that is close to its budget stops paying for speed or a favored model.
-const BUDGET_FORCE = 0.8;
-
-function read<T extends string>(
-  answers: JevAnswers | null,
-  id: string,
-  options: readonly T[],
-): { value: T; confidence: number } | null {
-  const a = answers?.[id];
-  return a && (options as readonly string[]).includes(a.choice)
-    ? { value: a.choice as T, confidence: a.confidence }
-    : null;
-}
-
-/** The cheapest bar-clearing pick, whatever the profile's own objective. */
-function cheapestPick(
-  p: Profile,
-  c: Catalog,
-  role: Role,
-  kind: string | undefined,
-  difficulty: string | undefined,
-): { rung: RungId; ladder: RungId[] } {
-  const costP = p.objective === "cost" ? p : { ...p, objective: "cost" as const };
-  const isKind = (k: string): k is (typeof KINDS)[number] => (KINDS as readonly string[]).includes(k);
-  const isDifficulty = (d: string): d is (typeof DIFFICULTIES)[number] =>
-    (DIFFICULTIES as readonly string[]).includes(d);
-  return kind && difficulty && isKind(kind) && isDifficulty(difficulty)
-    ? select(costP, c, role, kind, difficulty)
-    : defaultLadder(costP, c, role);
-}
-
-export async function route(
-  o: {
-    runDir: string;
-    profile: Profile;
-    catalog: Catalog;
-    role: Role;
-    laneText: string;
-    budget?: { spentFraction: number };
-  } & JevOpts,
-): Promise<RouteDecision> {
-  const { profile: p, catalog: c, role } = o;
-  if (candidates(p, c, role).length <= 1) {
-    return {
-      kind: null,
-      difficulty: null,
-      confidence: { kind: null, difficulty: null },
-      source: "default",
-      ...defaultLadder(p, c, role),
-    };
-  }
-  const { answers, error } = await callJev(
-    { kind: QUESTIONS.kind, difficulty: QUESTIONS.difficulty },
-    { lane: o.laneText },
-    o,
-  );
-  const kind = read(answers, "kind", KINDS);
-  const difficulty = read(answers, "difficulty", DIFFICULTIES);
-  let pick = defaultLadder(p, c, role);
-  let source: "jev" | "default" = "default";
-  if (kind && difficulty && Math.min(kind.confidence, difficulty.confidence) >= ROUTE_MIN) {
-    pick = select(p, c, role, kind.value, difficulty.value);
-    source = "jev";
-  }
-  if ((o.budget?.spentFraction ?? 0) >= BUDGET_FORCE) {
-    pick = cheapestPick(p, c, role, kind?.value, difficulty?.value);
-  }
-  logJev(o.runDir, {
-    questions: ["kind", "difficulty"],
-    answers,
-    used: `${role} ${pick.rung}`,
-    source,
-    why:
-      error ??
-      `kind ${kind?.confidence}, difficulty ${difficulty?.confidence}: ${source === "jev" ? "both ≥" : "below"} ${ROUTE_MIN}`,
-  });
-  return {
-    kind: kind?.value ?? null,
-    difficulty: difficulty?.value ?? null,
-    confidence: { kind: kind?.confidence ?? null, difficulty: difficulty?.confidence ?? null },
-    source,
-    ...pick,
-  };
-}
-
-async function decide<T extends string>(
-  runDir: string,
-  id: "finding" | "same-defect",
-  state: Record<string, string>,
-  options: readonly T[],
-  min: number,
-  fallback: T,
-  o: JevOpts,
-): Promise<{ value: T; confidence: number | null; source: "jev" | "default" }> {
-  const { answers, error } = await callJev({ [id]: QUESTIONS[id] }, state, o);
-  const a = read(answers, id, options);
-  const sure = a !== null && a.confidence >= min;
-  const value = sure ? a.value : fallback;
-  const source = sure ? "jev" : "default";
-  logJev(runDir, {
-    questions: [id],
-    answers,
-    used: value,
-    source,
-    why: error ?? `${a?.confidence} ${sure ? "≥" : "<"} ${min}`,
-  });
-  return { value, confidence: a?.confidence ?? null, source };
-}
-
-export function askFinding(
-  runDir: string,
-  laneText: string,
-  finding: string,
-  o: JevOpts = {},
-): Promise<{ value: "design" | "code" | "unclear"; confidence: number | null; source: "jev" | "default" }> {
-  return decide(
-    runDir,
-    "finding",
-    { lane: laneText, finding },
-    ["design", "code", "unclear"] as const,
-    FINDING_MIN,
-    "code",
-    o,
-  );
-}
-
-export function askSameDefect(
-  runDir: string,
-  before: string,
-  after: string,
-  o: JevOpts = {},
-): Promise<{ value: "yes" | "no"; confidence: number | null; source: "jev" | "default" }> {
-  return decide(runDir, "same-defect", { before, after }, ["yes", "no"] as const, SAME_DEFECT_MIN, "no", o);
-}
-
-export function nextRung(ladder: RungId[], current: RungId): RungId | null {
-  const i = ladder.indexOf(current);
-  return i >= 0 && i < ladder.length - 1 ? (ladder[i + 1] as RungId) : null;
-}

package/src/routing/select.ts

@@ -1,90 +0,0 @@
-import {
-  type Catalog,
-  type Difficulty,
-  type Kind,
-  type Profile,
-  type Role,
-  type RungId,
-  rungOf,
-  type ScoreDim,
-} from "../types.ts";
-import { capableFor, entryFor, modelOf } from "./catalog.ts";
-
-export function candidates(p: Profile, c: Catalog, role: Role): RungId[] {
-  const rc = p.roles[role];
-  if (!rc.enabled) return [];
-  const scored: { rung: RungId; costRank: number; secs: number }[] = [];
-  for (const [id, efforts] of Object.entries(rc.models)) {
-    const m = modelOf(c, id);
-    if (!m || !capableFor(role, m)) continue;
-    for (const effort of new Set(efforts)) {
-      const rung = rungOf(id, effort);
-      const entry = m.efforts.includes(effort) ? entryFor(c, rung) : undefined;
-      if (entry) {
-        scored.push({
-          rung,
-          costRank: entry.costRank,
-          secs: entry.scores.secs_per_task ?? Number.POSITIVE_INFINITY,
-        });
-      }
-    }
-  }
-  const [first, second] =
-    p.objective === "speed" ? (["secs", "costRank"] as const) : (["costRank", "secs"] as const);
-  // Infinity - Infinity is NaN, which `||` passes over and sort reads as a tie.
-  return scored.sort((a, b) => a[first] - b[first] || a[second] - b[second]).map((s) => s.rung);
-}
-
-export function clearsBar(c: Catalog, rung: RungId, kind: Kind, difficulty: Difficulty): boolean {
-  const scores = entryFor(c, rung)?.scores;
-  if (!scores) return false;
-  return Object.entries(c.bars[kind][difficulty]).every(
-    ([dim, min]) => min === undefined || (scores[dim as ScoreDim] ?? Number.NEGATIVE_INFINITY) >= min,
-  );
-}
-
-export function defaultLadder(p: Profile, c: Catalog, role: Role): { rung: RungId; ladder: RungId[] } {
-  const all = candidates(p, c, role);
-  if (all.length === 0) {
-    throw new Error(`catherd: role "${role}" has no enabled, capable, scored model; run profile_validate`);
-  }
-  const i = Math.max(0, all.indexOf(p.roles[role].defaultRung ?? ""));
-  return { rung: all[i] as RungId, ladder: all.slice(i) };
-}
-
-/**
- * OVERRIDES cross-plan fix 2: under `objective: "speed"`, the objective picks only the start rung
- * (the fastest bar-clearing candidate). The climb ladder above it is the other bar-clearing
- * candidates at least as strong as the start on the kind's primary dimension (terminal for
- * terminal work, repo_code otherwise), weakest first, costRank breaking ties — so a lane never
- * climbs onto a weaker rung. `objective: "cost"` keeps the plain cost-then-secs order, unchanged.
- */
-function speedLadder(c: Catalog, clearing: RungId[], kind: Kind): { rung: RungId; ladder: RungId[] } {
-  const start = clearing[0] as RungId;
-  const dim: ScoreDim = kind === "terminal" ? "terminal" : "repo_code";
-  const strengthOf = (r: RungId) => entryFor(c, r)?.scores[dim] ?? Number.NEGATIVE_INFINITY;
-  const startStrength = strengthOf(start);
-  const rest = clearing
-    .filter((r) => r !== start && strengthOf(r) >= startStrength)
-    .sort(
-      (a, b) =>
-        strengthOf(a) - strengthOf(b) || (entryFor(c, a)?.costRank ?? 0) - (entryFor(c, b)?.costRank ?? 0),
-    );
-  return { rung: start, ladder: [start, ...rest] };
-}
-
-export function select(
-  p: Profile,
-  c: Catalog,
-  role: Role,
-  kind: Kind,
-  difficulty: Difficulty,
-): { rung: RungId; ladder: RungId[] } {
-  const all = candidates(p, c, role);
-  if (all.length === 1) return { rung: all[0] as RungId, ladder: all };
-  const clearing = all.filter((r) => clearsBar(c, r, kind, difficulty));
-  if (clearing.length === 0) return defaultLadder(p, c, role);
-  return p.objective === "speed"
-    ? speedLadder(c, clearing, kind)
-    : { rung: clearing[0] as RungId, ladder: clearing };
-}