catherd-cli 1.4.0 → 2.0.0-beta.20261022113309

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,33 +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(),
-  /** 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(),
@@ -103,236 +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>>>;
 }
 
-/**
- * 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;
-  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][])
-        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: {},
   };
 }
 
@@ -342,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 {
@@ -358,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. */
@@ -431,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/changes.ts

@@ -33,6 +33,28 @@ export function changedPaths(before: Snapshot, after: Snapshot): string[] {
     .sort();
 }
 
+/** Spec 1.5 plan 21: a writer's implicit docs lane, when its brief names no Owns. */
+export const DOCS_OWNS = ["docs/**", "*.md"];
+
+/** The paths of an `Owns:` line in a brief (as a lane file writes it), or null when it has none. */
+export function briefOwns(brief: string): string[] | null {
+  const line = /^Owns:\s*(.+)$/m.exec(brief)?.[1];
+  const paths = line
+    ?.split(",")
+    .map((p) => p.trim().replace(/^`|`$/g, ""))
+    .filter(Boolean);
+  return paths?.length ? paths : null;
+}
+
+/**
+ * Whether `path` is inside an Owns entry: a path covers what is under it, and the other way round (as lanes'
+ * Owns always did); `dir/**` covers what is under dir; `*.ext` (no slash) is any file with that extension.
+ */
+export function ownsPath(path: string, entry: string): boolean {
+  if (entry.startsWith("*.") && !entry.includes("/")) return path.endsWith(entry.slice(1));
+  return overlaps([path], [entry.replace(/\/\*\*$/, "")]).length > 0;
+}
+
 /**
  * Spec §4.4: `changedOwned` are the changes inside the lane's Owns; `violations` the ones outside it
  * that no overlapping dispatch owns either. `strict` is false for a laneless dispatch that may write
@@ -44,7 +66,7 @@ export function splitChanges(
   others: string[],
   strict: boolean,
 ): { changedOwned: string[]; violations: string[] } {
-  const inside = (p: string, paths: string[]) => overlaps([p], paths).length > 0;
+  const inside = (p: string, paths: string[]) => paths.some((entry) => ownsPath(p, entry));
   return {
     changedOwned: changed.filter((p) => inside(p, owns)),
     violations: strict ? changed.filter((p) => !inside(p, owns) && !inside(p, others)) : [],

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);
 }
 
@@ -51,35 +49,27 @@ export const CHATGPT_UNIT_USD = 0.019;
 export interface Cost {
   /** 0: paid from a subscription; 1: metered. Every tier-0 rung ranks before any tier-1 rung. */
   tier: 0 | 1;
-  /** comparable across billing modes, in list-price dollars per task; null when unknown */
+  /**
+   * comparable across billing modes, in list-price dollars per task; 0 for an unpriced rung paid from a plan or
+   * subscription (it spends nothing beyond the flat fee); null for an unpriced metered one
+   */
   value: number | null;
   mode: BillingMode;
 }
 
 /**
- * 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.
+ * 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 { tier: mode === "metered" ? 1 : 0, value: null, 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"
@@ -17,9 +16,13 @@ export type ErrorCode =
   | "E_ADMIT_OVERLAP"
   | "E_ADMIT_ID"
   | "E_ADMIT_THREAD"
+  | "E_ADMIT_PAUSED"
+  | "E_ADMIT_ORDER"
   | "E_LANE_INVALID"
   | "E_LAND_GATE"
+  | "E_TREE"
   | "E_CLIMB_DESIGN"
+  | "E_CLIMB_ENV"
   | "E_JEV_KEY"
   | "E_JEV_NETWORK"
   | "E_JEV_RESPONSE"
@@ -28,10 +31,11 @@ export type ErrorCode =
   | "E_IO_PATH"
   | "E_IO_UNEXPECTED"
   | "E_INPUT_INVALID"
+  | "E_ROLE_SCOPE"
   | "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>)";

package/src/domain/fail-lines.ts

@@ -0,0 +1,26 @@
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+
+/**
+ * The lines of a check's output that name a failure, stripped of colour, timings and counters so two runs compare
+ * equal: at most 60 lines of at most 300 characters (t3herd `failLines`).
+ */
+export function checkFailLines(out: string): string[] {
+  const seen = new Set<string>();
+  for (const raw of out.split("\n")) {
+    const line = raw
+      .replace(ANSI, "")
+      .replace(/\s*[[(]\s*\d+(\.\d+)?\s*(ms|s|m)\s*[\])]/g, "")
+      .replace(/\b\d+(\.\d+)?(ms|s)\b/g, "")
+      .trim();
+    const vuln = line.match(/^Vulnerability #\d+: (GO-\d{4}-\d+)/)?.[1];
+    if (vuln) seen.add(`vulnerability ${vuln}`);
+    else if (/(^|\s)(FAIL|FAILED|✗|✕|×)(\s|:|$)|^\(fail\)|^--- FAIL|^not ok\b|\bpanic:|^error:/.test(line))
+      seen.add(line.slice(0, 300));
+    if (seen.size >= 60) break;
+  }
+  return [...seen];
+}
+
+/** The lines of `fails` the base does not have; all of them when there is no base record. */
+export const newFails = (fails: string[], base: string[] | null): string[] =>
+  fails.filter((f) => !base?.includes(f));