catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/domain/brief.ts

@@ -1,4 +1,4 @@
-import { replyContract } from "./role-prompts.ts";
+import { replyContract, roleSections } from "./role-prompts.ts";
 import { ROLE_MCP_SERVER, roleMcpTools } from "./role-tools.ts";
 import type { Role } from "./roles.ts";
 
@@ -13,6 +13,10 @@ export interface BriefContext {
   scratch: string | null;
   /** whether the role's harness lists the catherd_role tools */
   roleServer: boolean;
+  /** the catherd version whose `lock` a worker's text names */
+  version: string;
+  /** the plan's preamble, which applies to every task (plan 32); null when the run has none for this role */
+  context: string | null;
 }
 
 /** The CLI form of each role server tool, which any role can run from its shell. */
@@ -28,6 +32,8 @@ function cliForm(tool: string, run: string): string {
       return `catherd gate check ${run} --milestone <M> --item <item> --command <command> --paths <path,…>`;
     case "gate_pass":
       return `catherd gate pass ${run} --item <item> --command <command> --paths <path,…> --evidence <evidence>`;
+    case "gate_run":
+      return `catherd gate run ${run} --milestone <M> --command <command> [--at <base checkout>]`;
     default:
       return tool;
   }
@@ -66,14 +72,21 @@ export function roleNotes(c: BriefContext): string {
   return lines.join("\n");
 }
 
+const TASK_OPEN = "<task>\n";
+const TASK_CLOSE = "\n</task>";
+
 /**
- * The brief admission writes: the orchestrator's text, the lane file, the role's notes, then its reply contract,
- * each once. A failover stand-in that reruns an earlier brief gets the lane file as it stands now and its own notes,
- * never two copies.
+ * The brief admission writes: the role's sections around its task (the daemon's text, the lane file and the
+ * role's notes), each once. A failover stand-in that reruns an earlier brief gets the lane file as it stands now and
+ * its own notes, never two copies.
  */
 export function composeBrief(brief: string, c: BriefContext): string {
   const contract = replyContract(c.role);
   let body = brief.trimEnd();
+  const open = body.indexOf(TASK_OPEN);
+  const close = body.lastIndexOf(TASK_CLOSE);
+  if (open >= 0 && close > open) body = body.slice(open + TASK_OPEN.length, close).trim();
+  // a 1.5-era brief rerun ends with its contract
   if (body.endsWith(contract)) body = body.slice(0, -contract.length).trimEnd();
   if (c.lane) {
     const open = LANE_OPEN(c.lane.id);
@@ -86,6 +99,8 @@ export function composeBrief(brief: string, c: BriefContext): string {
   }
   const notesStart = body.lastIndexOf("\n\ncatherd: you are ");
   if (notesStart >= 0) body = body.slice(0, notesStart).trimEnd();
-  const parts = [body, ...(c.lane ? [laneBlock(c.lane.id, c.lane.text)] : []), roleNotes(c), contract];
-  return `${parts.filter(Boolean).join("\n\n")}\n`;
+  const task = [body, ...(c.lane ? [laneBlock(c.lane.id, c.lane.text)] : []), roleNotes(c)]
+    .filter(Boolean)
+    .join("\n\n");
+  return `${roleSections(c.role, c.version, { context: c.context, task })}\n`;
 }

package/src/domain/catalog.ts

@@ -1,59 +1,17 @@
 import { z } from "zod";
 import { type Rung, parseRung } from "./ids.ts";
-import { DIFFICULTIES, type Difficulty, KINDS, type Kind } from "./lane.ts";
 import type { Role } from "./roles.ts";
-
-/**
- * Spec §5.2 and 1.2 §5.1: the scored dimensions, each in its anchor's unit. `agentic`, `steer` and `frontend`
- * (1.2) carry no shipped bar yet.
- */
-export const DIMS = ["repo_code", "terminal", "honesty", "agentic", "steer", "frontend"] as const;
-export type Dim = (typeof DIMS)[number];
-
-/**
- * Spec 1.2 §4.3: how a value was obtained, best first. The 1.0 levels (`verified`, `secondary`,
- * `inferred`) keep their names, so an older override file stays valid.
- */
-export const CONFIDENCE = [
-  "verified",
-  "measured",
-  "calibrated",
-  "adjacent",
-  "secondary",
-  "inferred",
-] as const;
-export type Confidence = (typeof CONFIDENCE)[number];
-export const RANK = Object.fromEntries(CONFIDENCE.map((c, i) => [c, i])) as Record<Confidence, number>;
-/** Spec 1.2 §4.3: a value older than this many days counts one level lower. */
-export const STALE_DAYS = 90;
-const DAY_MS = 86_400_000;
+import { type IndexFile, slopKey } from "./slopalytics.ts";
 
 /**
  * Spec §7.1 `billing` keys: a rung's backend, except that opencode's Go models (`opencode-go/…`) are billed
  * apart from its Zen models (`opencode/…`).
  */
-export const BILLING_KEYS = [
-  "codex",
-  "claude",
-  "claude-code",
-  "opencode-go",
-  "opencode",
-  "cursor",
-  "grok",
-  "antigravity",
-] as const;
+export const BILLING_KEYS = ["codex", "claude", "claude-code", "opencode-go", "opencode", "cursor"] as const;
 export type BillingKey = (typeof BILLING_KEYS)[number];
 
 /** The keys a family's `on` map uses; the native `claude` pseudo-backend runs claude-code's model ids. */
-const MODEL_KEYS = [
-  "codex",
-  "claude-code",
-  "opencode-go",
-  "opencode",
-  "cursor",
-  "grok",
-  "antigravity",
-] as const;
+const MODEL_KEYS = ["codex", "claude-code", "opencode-go", "opencode", "cursor"] as const;
 type ModelKey = (typeof MODEL_KEYS)[number];
 
 export function billingKeyOf(r: Rung): BillingKey {
@@ -63,38 +21,25 @@ export function billingKeyOf(r: Rung): BillingKey {
 
 const modelKeyOf = (k: BillingKey): ModelKey => (k === "claude" ? "claude-code" : k);
 
-const BackendModelSchema = z.object({
-  id: z.string().min(1),
-  efforts: z.array(z.string().min(1)),
-  context: z.number().int().positive(),
-});
+const BackendModelSchema = z.object({ id: z.string().min(1) });
 
-/** `vendor` and `status` (current or legacy) stay in the data as documentation; nothing reads them. */
+/**
+ * What catherd knows of a model that Slopalytics does not: its capabilities, how a plan weighs it and the
+ * model id each backend runs it under. `vendor` and `status` stay in the data as documentation.
+ */
 const FamilySchema = z.looseObject({
   id: z.string().min(1),
   name: z.string(),
   capabilities: z.object({ toolUse: z.boolean(), imageIn: z.boolean(), reasoning: z.boolean() }),
-  /** API list price, dollars per million tokens */
-  price: z.object({ input: z.number(), cached: z.number(), output: z.number() }),
   /** chatgpt-plan: messages per 5 hours relative to GPT-6 Luna (spec §5.3) */
   planWeight: z.number().positive().optional(),
   /** claude-plan: billed as usage credits, not from the plan's limits */
   meteredOnPlan: z.boolean().default(false),
   on: z.partialRecord(z.enum(MODEL_KEYS), BackendModelSchema),
   notes: z.record(z.string(), z.string()).default({}),
-  /** the day the vendor released it (models.dev), a stand-in feature (spec 1.2 §6.3) */
-  releaseDate: z.iso.date().optional(),
-  /**
-   * spec 1.5 plan 24: the family this one succeeds in the same line (GPT-6.1 Sol after GPT-6 Sol): until a
-   * value of its own arrives, a rung takes at least its predecessor's value at the same effort
-   */
-  predecessor: z.string().min(1).optional(),
-  /** a sync's speed facts (spec 1.2 §4.1), `<source>.<field>` → value; they never carry a bar */
-  speed: z.record(z.string(), z.number()).optional(),
 });
 export type Family = z.infer<typeof FamilySchema>;
 
-/** `sources` (where the data came from) stays in the file as documentation; nothing reads it. */
 export const ModelsFileSchema = z.looseObject({
   schema: z.literal(1),
   version: z.string(),
@@ -108,242 +53,62 @@ export const ModelsFileSchema = z.looseObject({
 });
 export type ModelsFile = z.infer<typeof ModelsFileSchema>;
 
-/** A canonical rung: `<canonical model id>#<effort>`, the key scores and treat-likes use. */
-export const CanonicalRung = z.string().regex(/^[^:#\s]+#[^#\s]+$/, "a canonical rung is model#effort");
-
-/** Spec 1.2 §4.2: `anchor = a·x + b`, fitted on `n` rungs both sources cover, with its R². */
-export const FitSchema = z.object({
-  source: z.string(),
-  field: z.string(),
-  a: z.number(),
-  b: z.number(),
-  r2: z.number(),
-  n: z.number().int(),
-});
-export type Fit = z.infer<typeof FitSchema>;
-
-export const ScoreSchema = z.object({
-  rung: CanonicalRung,
-  dim: z.enum(DIMS),
-  value: z.number(),
-  benchmark: z.string(),
-  version: z.string(),
-  url: z.url(),
-  date: z.iso.date(),
-  confidence: z.enum(CONFIDENCE),
-  note: z.string().optional(),
-  /** spec 1.2 §4.3: the source a synced value came from (absent: the shipped file or the user's override) */
-  source: z.string().optional(),
-  /** a calibrated value: the fit that mapped it onto the anchor */
-  fit: FitSchema.optional(),
-  /** the source named no effort, so the family's default effort was assumed (spec 1.2 §3.4) */
-  effortAssumed: z.boolean().optional(),
-});
-export type Score = z.infer<typeof ScoreSchema>;
-
-const BarSchema = z.partialRecord(z.enum(DIMS), z.number());
-type Bars = Record<Kind, Record<Difficulty, Partial<Record<Dim, number>>>>;
-const BarsSchema = z.record(z.enum(KINDS), z.record(z.enum(DIFFICULTIES), BarSchema));
-
-/** Spec 1.2 §5.2: per dimension and difficulty, where the default threshold came from. */
-const BarsWhySchema = z.partialRecord(z.enum(DIMS), z.partialRecord(z.enum(DIFFICULTIES), z.string()));
-
-/**
- * `catalog/scores.json`: the hand-typed and keyless values (spec 1.2 §7), the shipped treat-likes, and the
- * default bars with the `barsWhy` line of each threshold (spec 1.2 §5.2).
- */
-export const ScoresFileSchema = z.looseObject({
-  schema: z.literal(1),
-  version: z.string(),
-  benchmarks: z.record(z.enum(DIMS), z.object({ benchmark: z.string(), version: z.string() })),
-  scores: z.array(ScoreSchema),
-  treatLike: z.record(CanonicalRung, z.object({ like: CanonicalRung, note: z.string() })),
-  bars: BarsSchema,
-  barsWhy: BarsWhySchema.default({}),
-});
-export type ScoresFile = z.infer<typeof ScoresFileSchema>;
-
-/** An override's bar: per dimension a threshold, or `null` to remove the default's (spec 1.2 §5.2). */
-const OverrideBarSchema = z.partialRecord(z.enum(DIMS), z.number().nullable());
-
-/**
- * `<config>/catalog.override.json` (spec §3.5): the user's treat-likes, scores and bars. Its bars override
- * the default bars per dimension (spec 1.2 §5.2): a number sets that threshold, `null` removes it, and a
- * dimension it does not name keeps the default's.
- */
-export const OverrideSchema = z.looseObject({
-  schema: z.literal(1).default(1),
-  treatLike: z.record(CanonicalRung, CanonicalRung).default({}),
-  scores: z.array(ScoreSchema).default([]),
-  bars: z.partialRecord(z.enum(KINDS), z.partialRecord(z.enum(DIFFICULTIES), OverrideBarSchema)).default({}),
-});
-export type Override = z.infer<typeof OverrideSchema>;
-
-/** Spec 1.2 §6.1: the rung whose value a rung without one uses on a dimension, as `inferred`. */
-export interface InferredStandIn {
-  like: string;
-  /** spec 1.2 §6.3's distance between the two */
-  distance: number;
-  /** the features that distance rests on */
-  features: string[];
-}
-
-interface Listed {
+export interface Listed {
   id: string;
   efforts: string[];
   context: number | null;
   imageIn: boolean;
 }
 
-/** Everything routing reads, merged from the three layers plus the user's override and own timings. */
+/** One model at one effort on the Slopalytics index: the one number routing ranks on, and what it costs and does. */
+export interface Pair {
+  intelligence: number;
+  price: { input: number; output: number } | null;
+  speed: number | null;
+  context: number | null;
+}
+
+/** Everything routing reads: the shipped families, the Slopalytics index, and each backend's listing. */
 export interface Catalog {
   families: Family[];
   backends: ModelsFile["backends"];
-  /** canonical rung → its best-sourced value per dimension (the override's win) */
-  scores: Record<string, Partial<Record<Dim, Score>>>;
-  treatLike: Record<string, { like: string; source: "shipped" | "user" }>;
-  bars: Bars;
-  /** where each default threshold came from (spec 1.2 §5.2), by dimension and difficulty */
-  barsWhy: ScoresFile["barsWhy"];
+  /** Slopalytics family (`slopKey`) → effort → pair */
+  index: Record<string, Record<string, Pair>>;
+  /** when the proxy fetched the index; null with no index */
+  indexedAt: string | null;
+  /** ascending intelligences of every indexed pair of the shipped families: what the bars are percentiles of */
+  pool: number[];
   /** per backend id, the last `listModels()`; absent when never listed */
   listed: Record<string, { fetchedAt: string; models: Listed[] }>;
-  /** `<canonical rung>|<kind or *>` → median seconds, only with ≥ 5 samples (spec §5.2) */
-  secs: Record<string, number>;
-  /** canonical rung → the Artificial Analysis stand-in features a sync read for it (spec 1.2 §6.3) */
-  features: Record<string, Record<string, number>>;
-  /**
-   * canonical rung → per dimension it has no value for (of its own or through a treat-like), the stand-in
-   * whose value it uses as `inferred` (spec 1.2 §6.1); filled by the stand-in ranking (services/standins.ts)
-   */
-  inferred: Record<string, Partial<Record<Dim, InferredStandIn>>>;
-  /** the thresholds the user's override set or removed, as `<kind>/<difficulty>/<dim>` (route says "your override") */
-  userBars?: string[];
 }
 
-/**
- * Spec 1.2 §3.5: what a sync learned about a family. `price`, `capabilities` and the opencode backends'
- * `efforts` and `context` come from models.dev; `speed` holds facts that never carry a bar (spec 1.2 §4.1),
- * as `<source>.<field>` → value.
- */
-export const FamilyFactsSchema = z.object({
-  price: z.object({ input: z.number(), cached: z.number(), output: z.number() }).optional(),
-  capabilities: z.object({ toolUse: z.boolean(), imageIn: z.boolean(), reasoning: z.boolean() }).optional(),
-  on: z
-    .partialRecord(
-      z.enum(MODEL_KEYS),
-      z.object({ efforts: z.array(z.string()).optional(), context: z.number().int().positive().optional() }),
-    )
-    .default({}),
-  releaseDate: z.string().optional(),
-  speed: z.record(z.string(), z.number()).default({}),
-});
-export type FamilyFacts = z.infer<typeof FamilyFactsSchema>;
-
-/**
- * Spec 1.2 §3.5: the families with a sync's facts laid over them. The shipped file stays the floor: a fact
- * the sync lacks keeps the shipped one, and a backend keeps every effort it ships with.
- */
-export function applyFacts(families: Family[], facts: Record<string, FamilyFacts>): Family[] {
-  return families.map((f) => {
-    const x = facts[f.id];
-    if (!x) return f;
-    const on = { ...f.on };
-    for (const key of MODEL_KEYS) {
-      const cur = on[key];
-      const got = x.on[key];
-      if (!cur || !got) continue;
-      on[key] = {
-        ...cur,
-        efforts: [...cur.efforts, ...(got.efforts ?? []).filter((e) => !cur.efforts.includes(e))],
-        context: got.context ?? cur.context,
-      };
-    }
-    // a sync may add a capability, never remove one the shipped file gives (the floor)
-    const got = x.capabilities;
-    const capabilities = got
-      ? {
-          toolUse: f.capabilities.toolUse || got.toolUse,
-          imageIn: f.capabilities.imageIn || got.imageIn,
-          reasoning: f.capabilities.reasoning || got.reasoning,
-        }
-      : f.capabilities;
-    return {
-      ...f,
-      price: x.price ?? f.price,
-      capabilities,
-      on,
-      ...(x.releaseDate || f.releaseDate ? { releaseDate: x.releaseDate ?? f.releaseDate } : {}),
-      ...(Object.keys(x.speed).length ? { speed: x.speed } : {}),
-    };
-  });
-}
-
-/** Spec 1.2 §4.3: the level a value counts at: its own, one lower once it is older than STALE_DAYS. */
-export function effectiveRank(s: Score, now: number): number {
-  const stale = now - Date.parse(s.date) > STALE_DAYS * DAY_MS;
-  return Math.min(RANK[s.confidence] + (stale ? 1 : 0), CONFIDENCE.length - 1);
-}
-
-/** Spec 1.2 §4.3: `a` beats `b` at a better level, or at the same level with a newer date. */
-export function outranks(a: Score, b: Score, now: number): boolean {
-  const ra = effectiveRank(a, now);
-  const rb = effectiveRank(b, now);
-  return ra < rb || (ra === rb && a.date > b.date);
-}
-
-/**
- * The catalog routing reads: the shipped files, the synced values (spec 1.2 §3), each backend's listing and
- * the user's override, which always wins. Between shipped and synced values the better level wins, then the
- * newer date (spec 1.2 §4.3); `now` dates the 90-day drop.
- */
 export function buildCatalog(o: {
   models: ModelsFile;
-  scores: ScoresFile;
-  synced?: Score[];
-  facts?: Record<string, FamilyFacts>;
-  override?: Override;
+  index: IndexFile | null;
   listed?: Catalog["listed"];
-  secs?: Catalog["secs"];
-  features?: Catalog["features"];
-  now?: number;
 }): Catalog {
-  const now = o.now ?? Date.now();
-  const scores: Catalog["scores"] = {};
-  const put = (s: Score, force: boolean) => {
-    const cur = (scores[s.rung] ??= {});
-    const had = cur[s.dim];
-    if (force || !had || outranks(s, had, now)) cur[s.dim] = s;
-  };
-  for (const s of o.scores.scores) put(s, false);
-  for (const s of o.synced ?? []) put(s, false);
-  // the user's values say so whatever source they were copied with, for route's provenance (spec 1.2 §5.3)
-  for (const s of o.override?.scores ?? []) put({ ...s, source: "override" }, true);
-  const treatLike: Catalog["treatLike"] = {};
-  for (const [rung, t] of Object.entries(o.scores.treatLike))
-    treatLike[rung] = { like: t.like, source: "shipped" };
-  for (const [rung, like] of Object.entries(o.override?.treatLike ?? {}))
-    treatLike[rung] = { like, source: "user" };
-  const bars = structuredClone(o.scores.bars) as Bars;
-  const userBars: string[] = [];
-  for (const kind of KINDS)
-    for (const d of DIFFICULTIES)
-      for (const [dim, min] of Object.entries(o.override?.bars[kind]?.[d] ?? {}) as [Dim, number | null][]) {
-        userBars.push(`${kind}/${d}/${dim}`);
-        if (min === null) delete bars[kind][d][dim];
-        else bars[kind][d][dim] = min;
-      }
+  const index: Catalog["index"] = {};
+  for (const r of o.index?.models ?? [])
+    (index[slopKey(r.family)] ??= {})[r.effort] = {
+      intelligence: r.intelligence,
+      price:
+        r.inputPrice !== null && r.outputPrice !== null
+          ? { input: r.inputPrice, output: r.outputPrice }
+          : null,
+      speed: r.speed,
+      context: r.context,
+    };
+  const shippedKeys = new Set(o.models.families.map((f) => slopKey(f.id)));
+  const pool = [...shippedKeys]
+    .flatMap((k) => Object.values(index[k] ?? {}).map((p) => p.intelligence))
+    .sort((a, b) => a - b);
   return {
-    families: o.facts ? applyFacts(o.models.families, o.facts) : o.models.families,
+    families: o.models.families,
     backends: o.models.backends,
-    scores,
-    treatLike,
-    bars,
-    barsWhy: o.scores.barsWhy,
+    index,
+    indexedAt: o.index?.fetchedAt ?? null,
+    pool,
     listed: o.listed ?? {},
-    secs: o.secs ?? {},
-    features: o.features ?? {},
-    inferred: {},
-    userBars,
   };
 }
 
@@ -353,12 +118,16 @@ export interface RungInfo {
   parsed: Rung;
   key: BillingKey;
   family: Family | null;
-  /** `<family id or backend model id>#<effort>`: the key scores, treat-likes and timings use */
+  /** `<family id or backend model id>#<effort>`: the key run evidence uses */
   canonical: string;
+  /** the model's Slopalytics family key */
+  slop: string;
   efforts: string[];
   context: number | null;
   /** true when the backend's last listing has it, false when that listing lacks it, null with no listing */
   listed: boolean | null;
+  /** the rung's index entry; null when it is not indexed */
+  pair: Pair | null;
 }
 
 function familyOf(c: Catalog, r: Rung): Family | null {
@@ -369,67 +138,42 @@ function familyOf(c: Catalog, r: Rung): Family | null {
 /** The backend's listing; the native `claude` backend has none of its own: it runs claude-code's models. */
 const listingOf = (c: Catalog, backend: string) => c.listed[backend === "claude" ? "claude-code" : backend];
 
-/** A rung's catalog facts; `rung` must parse (E_ADMIT_RUNG otherwise). */
+/**
+ * A rung's catalog facts; `rung` must parse (E_ADMIT_RUNG otherwise). Its pair is the index's record for the
+ * model's Slopalytics family at its effort; `#default` takes the family's `default` record, else its only one.
+ */
 export function rungInfo(c: Catalog, rung: string): RungInfo {
   const parsed = parseRung(rung);
   const key = billingKeyOf(parsed);
   const family = familyOf(c, parsed);
-  const shipped = family?.on[modelKeyOf(key)];
+  const slop = slopKey(family?.id ?? parsed.model);
   const listing = listingOf(c, parsed.backend);
   const found = listing?.models.find((m) => m.id === parsed.model);
+  const indexed = c.index[slop] ?? {};
+  const only = Object.values(indexed);
+  const pair =
+    indexed[parsed.effort] ?? (parsed.effort === "default" && only.length === 1 ? (only[0] as Pair) : null);
   return {
     rung,
     parsed,
     key,
     family,
     canonical: `${family?.id ?? parsed.model}#${parsed.effort}`,
-    efforts: found?.efforts ?? shipped?.efforts ?? [],
-    context: found?.context ?? shipped?.context ?? null,
+    slop,
+    efforts: found?.efforts ?? Object.keys(indexed),
+    context: found?.context ?? pair?.context ?? null,
     listed: listing && listing.models.length > 0 ? found !== undefined : null,
+    pair,
   };
 }
 
-/**
- * The rung's scores: per dimension its own value, else that of the rung it is treated like (a sync may score
- * a rung on some dimensions only), else its inferred stand-in's (spec 1.2 §6.1). `via` names the treat-like
- * when it lends any value and `borrowed` the dimensions it lends; `inferred` the dimensions an inferred
- * stand-in fills and `standIns` whose values they are. null when it has no value at all.
- */
-export function scoresOf(
-  c: Catalog,
-  canonical: string,
-): {
-  values: Partial<Record<Dim, number>>;
-  records: Partial<Record<Dim, Score>>;
-  via: string | null;
-  borrowed: Dim[];
-  inferred: Dim[];
-  standIns: Partial<Record<Dim, string>>;
-} | null {
-  const own = c.scores[canonical] ?? {};
-  const like = c.treatLike[canonical]?.like ?? null;
-  const lent = like ? (c.scores[like] ?? {}) : {};
-  const guessed = c.inferred[canonical] ?? {};
-  const values: Partial<Record<Dim, number>> = {};
-  const records: Partial<Record<Dim, Score>> = {};
-  const borrowed: Dim[] = [];
-  const inferred: Dim[] = [];
-  const standIns: Partial<Record<Dim, string>> = {};
-  for (const d of DIMS) {
-    const stand = guessed[d];
-    const r = own[d] ?? lent[d] ?? (stand ? c.scores[stand.like]?.[d] : undefined);
-    if (!r) continue;
-    records[d] = r;
-    values[d] = r.value;
-    if (own[d]) continue;
-    if (lent[d]) borrowed.push(d);
-    else if (stand) {
-      inferred.push(d);
-      standIns[d] = stand.like;
-    }
+/** The rung's index entry; null when it is not a rung or not indexed. */
+export function pairOf(c: Catalog, rung: string): Pair | null {
+  try {
+    return rungInfo(c, rung).pair;
+  } catch {
+    return null;
   }
-  if (Object.keys(records).length === 0) return null;
-  return { values, records, via: borrowed.length ? like : null, borrowed, inferred, standIns };
 }
 
 /** Spec §4 roles: what a rung must offer to be placed on a role. */
@@ -442,6 +186,7 @@ export const ROLE_NEEDS: Record<Role, { toolUse?: true; imageIn?: true; imageGen
   artist: { imageGen: true },
   writer: { toolUse: true },
   researcher: { toolUse: true },
+  judge: { toolUse: true },
 };
 
 /**

package/src/domain/cost.ts

@@ -1,4 +1,4 @@
-import type { BillingKey, Family } from "./catalog.ts";
+import type { BillingKey, Family, Pair } from "./catalog.ts";
 
 /** Spec §5.3: how the user pays for each billing key. */
 export const BILLING_MODES = ["chatgpt-plan", "claude-plan", "subscription", "metered"] as const;
@@ -12,8 +12,6 @@ export const DEFAULT_BILLING: Record<BillingKey, BillingMode> = {
   "opencode-go": "subscription",
   opencode: "metered",
   cursor: "metered",
-  grok: "metered",
-  antigravity: "metered",
 };
 
 /**
@@ -38,10 +36,10 @@ const REF_TASK = { input: 60_000, cached: 400_000, output: 18_000 };
 
 export const effortFactor = (effort: string): number => EFFORT_FACTOR[effort] ?? 1;
 
-/** Estimated list-price dollars for one task at `effort`. */
-export function taskUsd(price: Family["price"], effort: string): number {
+/** Estimated list-price dollars for one task at `effort`; cached input costs a tenth of the input price. */
+export function taskUsd(price: { input: number; output: number }, effort: string): number {
   const perTask =
-    REF_TASK.input * price.input + REF_TASK.cached * price.cached + REF_TASK.output * price.output;
+    REF_TASK.input * price.input + REF_TASK.cached * (price.input / 10) + REF_TASK.output * price.output;
   return (perTask / 1_000_000) * effortFactor(effort);
 }
 
@@ -60,31 +58,18 @@ export interface Cost {
 }
 
 /**
- * Spec §5.3. Every mode yields list-price dollars per task, so plans compare with each other. Spec 1.5 plan 24:
- * a rung catherd has no price for costs 0 within its tier when a plan or subscription pays for it, so it can
- * start a lane (the profile's ladder order then breaks the tie); a metered one stays unknown, last in its tier.
- * chatgpt-plan scales the official quota weight (Luna 1, Sol 20, Astra 60) by the effort factor;
- * claude-plan uses API prices as the proxy, with Fable metered (catherd cannot tell Pro from Max);
- * Go's share of its monthly dollar limit is dollars / limit, which orders the same as dollars.
+ * Spec §5.3. Every mode yields list-price dollars per task, so plans compare with each other. chatgpt-plan scales
+ * the official quota weight (Luna 1, Sol 20, Astra 60) by the effort factor; claude-plan uses API prices as the
+ * proxy, with Fable metered (catherd cannot tell Pro from Max); Go's share of its monthly dollar limit is
+ * dollars / limit, which orders the same as dollars. A pair with no price costs 0 within its tier when a plan or
+ * subscription pays for it, so it can start a lane; a metered one stays unknown, last in its tier.
  */
-export function costOf(family: Family | null, effort: string, mode: BillingMode): Cost {
-  if (!family) return mode === "metered" ? { tier: 1, value: null, mode } : { tier: 0, value: 0, mode };
-  const usd = taskUsd(family.price, effort);
-  switch (mode) {
-    case "chatgpt-plan":
-      return {
-        tier: 0,
-        value:
-          family.planWeight === undefined ? usd : family.planWeight * CHATGPT_UNIT_USD * effortFactor(effort),
-        mode,
-      };
-    case "claude-plan":
-      return { tier: family.meteredOnPlan ? 1 : 0, value: usd, mode };
-    case "subscription":
-      return { tier: 0, value: usd, mode };
-    case "metered":
-      return { tier: 1, value: usd, mode };
-  }
+export function costOf(family: Family | null, pair: Pair | null, effort: string, mode: BillingMode): Cost {
+  if (mode === "chatgpt-plan" && family?.planWeight !== undefined)
+    return { tier: 0, value: family.planWeight * CHATGPT_UNIT_USD * effortFactor(effort), mode };
+  const metered = mode === "metered" || (mode === "claude-plan" && family?.meteredOnPlan === true);
+  if (!pair?.price) return metered ? { tier: 1, value: null, mode } : { tier: 0, value: 0, mode };
+  return { tier: metered ? 1 : 0, value: taskUsd(pair.price, effort), mode };
 }
 
 /** Cheaper first: tier, then value, an unknown value last. */

package/src/domain/errors.ts

@@ -1,7 +1,6 @@
 export type ErrorCode =
   | "E_CONFIG_INVALID"
   | "E_CONFIG_NEWER_SCHEMA"
-  | "E_CONFIG_KEYBIND"
   | "E_BACKEND_MISSING"
   | "E_BACKEND_TOO_OLD"
   | "E_BACKEND_NOT_LOGGED_IN"
@@ -21,6 +20,7 @@ export type ErrorCode =
   | "E_ADMIT_ORDER"
   | "E_LANE_INVALID"
   | "E_LAND_GATE"
+  | "E_TREE"
   | "E_CLIMB_DESIGN"
   | "E_CLIMB_ENV"
   | "E_JEV_KEY"
@@ -35,7 +35,7 @@ export type ErrorCode =
   | "E_RUNTIME_TOO_OLD";
 
 /**
- * How to get a newer catherd. `bunx catherd-cli@latest` alone opens the newest one's dashboard and upgrades
+ * How to get a newer catherd. `bunx catherd-cli@latest` alone prints the newest one's help and upgrades
  * nothing that is installed (audit N12).
  */
 export const UPGRADE = "bun add -g catherd-cli@latest (or run bunx catherd-cli@latest <command>)";