tickmarkr 1.90.8 → 1.92.0

package/dist/adapters/model-lints.js

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { DEFAULT_CONFIG, TIER_RANK } from "../config/config.js";
 import { buildTaskPrompt } from "./prompt.js";
-import { MODEL_ID_RE } from "./types.js";
+import { channelKey, MODEL_ID_RE } from "./types.js";
 import { resolveCatalogModel } from "./catalog-remote.js";
 export const SEED_STAMPED = "2026-07-09";
 // knowledge past this age gets a "rerun tickmarkr doctor" nudge (BLOCKED_POLL_MS-style named constant).
@@ -15,6 +15,29 @@ const DAY_MS = 86400000;
 // 2026-08-12 (D-OBS-11: cursor's residual lint list was still mostly effort variants of configured bases).
 const LINT_VARIANT_RE = /^auto$|-(fast|minimal|none|low|medium|high|xhigh|max|thinking)$/;
 const LINT_CAP = 5;
+/**
+ * Operator directive 2026-08-13 ("we should exclude all retired models"): the fleet models
+ * screen hides these classes BY DEFAULT — omp alone reports 218 ids, most of them dated
+ * snapshots, previews, and SKUs that can never carry a worker. Shape-based on purpose: a
+ * knowledge list of retired families rots, a suffix grammar does not. Hidden is never gone —
+ * the screen counts what it hid and one key reveals it, and CLASSIFIED models are never hidden
+ * regardless of shape (an operator who tiered a dated snapshot meant it).
+ */
+export function retiredModelReason(model) {
+    const bare = model.includes("/") ? model.slice(model.lastIndexOf("/") + 1) : model;
+    // vendor-dated pins: claude-3-5-sonnet-20241022, claude-opus-4-1-20250805, *-preview-10-2025
+    if (/-20\d{6}$/.test(bare))
+        return "dated snapshot";
+    if (/-preview(?:-\d{2}-20\d{2})?$/.test(bare))
+        return "preview";
+    // SKUs that cannot carry a worker seat: media, embedding, retrieval, and browsing surfaces
+    if (/(?:^|-)(?:embed(?:ding)?s?|tts|whisper|audio|image|vision|ocr|rerank|moderation|computer-use|deep-research)(?:-|$)/.test(bare))
+        return "non-worker";
+    // superseded generations still reported by CLIs long after retirement
+    if (/^(?:gemini-1\.|claude-3-|gpt-3\.|gpt-4-)/.test(bare))
+        return "legacy family";
+    return null;
+}
 const TTY_LINT_CAP = 3;
 const DEFAULT_STATE_DIR = ".tickmarkr";
 const doctorJsonRef = (stateDir) => ` — see ${stateDir}/doctor.json`;
@@ -23,33 +46,100 @@ const LEGACY_DOCTOR_SEED_PREFER_DISPOSITION = "auto-prefer is routing around it"
 export const ttyVisual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 // ponytail: chars/4 token heuristic — good enough for advisory plan lint; no tokenizer dep.
 const CHARS_PER_TOKEN = 4;
-const intelligenceTier = (index) => index >= 65 ? "frontier" : index >= 40 ? "mid" : "cheap";
+/** Bases that band FLEET-RELATIVELY, most-trusted first (2026-08-13 ranking-sites assessment §4.3). */
+const RANKED_BASES = ["agentic-coding", "intelligence"];
+/**
+ * D-2 (2026-08-13 ranking-sites assessment): the retired `index >= 65 → frontier` cut was calibrated
+ * against an older, higher-ceilinged AA index. After the v4.x rescale the best model in existence
+ * scored 63.05, so NOTHING could ever be frontier. An absolute cut against a vendor index that gets
+ * rescaled is the defect CLASS — the fix is a rank among the models we actually hold same-basis
+ * evidence for, not a new magic number. Three is the floor: thirds over two models is a coin toss.
+ */
+const MIN_RANKED_MODELS = 3;
+/** Rank r of n, 0-based: top third → frontier, middle third → mid, bottom third → cheap. */
+const bandOfRank = (rank, total) => rank * 3 < total ? "frontier" : rank * 3 < total * 2 ? "mid" : "cheap";
+const basisScore = (evidence, basis) => basis === "agentic-coding" ? evidence.agenticCodingScore : evidence.intelligenceIndex;
 const priceTier = (outputPerMtok) => outputPerMtok >= 12 ? "frontier" : outputPerMtok >= 2 ? "mid" : "cheap";
+const round1 = (n) => Math.round(n * 10) / 10;
+function catalogEvidenceFor(cfg, catalog, row) {
+    return resolveCatalogModel(catalog.catalog, {
+        // A tier vendor is NULLABLE (config.ts:64) — null means "declared as having none at tier level, so
+        // each model must declare its own". `resolveCatalogModel` takes an optional provider HINT
+        // (catalog-remote.ts:218), and "no hint" is `undefined` there, so null normalizes to undefined rather
+        // than travelling as a third state. Neither T17 nor T19 could see this seam: their files[] are
+        // disjoint, so no ordering edge was derived, they dispatched 7ms apart, and each worktree was cut
+        // before the other's change existed. Both gates passed truthfully; only the merged pair fails to
+        // compile (OBS-371).
+        provider: cfg.tiers[row.adapter]?.vendor ?? undefined,
+        model: row.model,
+        ...(row.resolvedModel ? { resolvedModel: row.resolvedModel } : {}),
+    });
+}
+/**
+ * The ranking universe: configured tier models ∪ the rows under advisory at THIS call site,
+ * restricted per basis to those that resolve it. Build it once per call — a band that depended on
+ * which adapter happened to be iterated first would not be a band. `resolvedModel` is the SAME
+ * resolver the call site hands its advisory rows: a configured claude alias (`opus`) is absent from
+ * models.dev under that spelling, so without it the fleet's own frontier models silently drop out
+ * of the universe they are supposed to anchor.
+ */
+export function catalogTierRanking(cfg, catalog, rows = [], resolvedModel) {
+    // Orca import #1: the vendored catalog is a shipped default (`catalogOrigin: spec` in orca's terms),
+    // never a fetched observation — it may not seed a ranking any more than it may seed a suggestion.
+    if (catalog.source === "vendored")
+        return [];
+    const configured = Object.entries(cfg.tiers).flatMap(([adapter, entry]) => Object.keys(entry.models).map((model) => ({ adapter, model, resolvedModel: resolvedModel?.(adapter, model) })));
+    // The resolver supplies the matched `<providerKey>/<recordId>`: caller spellings never define
+    // identity, aliases of one record collapse, and equal bare ids under distinct providers do not.
+    const universe = new Map();
+    for (const row of [...configured, ...rows]) {
+        const evidence = catalogEvidenceFor(cfg, catalog, row);
+        if (evidence)
+            universe.set(evidence.catalogId, evidence);
+    }
+    const members = [...universe.values()];
+    return RANKED_BASES.flatMap((basis) => {
+        const scores = members
+            .map((member) => basisScore(member, basis))
+            .filter((score) => score !== undefined)
+            .sort((a, b) => b - a);
+        return scores.length >= MIN_RANKED_MODELS ? [{ basis, scores }] : [];
+    });
+}
+/** First basis that both clears the floor AND can place this model; ties share the better band. */
+function rankedSuggestion(ranking, evidence) {
+    for (const { basis, scores } of ranking) {
+        const score = basisScore(evidence, basis);
+        if (score === undefined)
+            continue;
+        const rank = scores.filter((other) => other > score).length;
+        // Every suggestion names its evidence source AND its date: an AA band that omits the index
+        // version is exactly the silent-rescale defect D-2 shipped to everyone.
+        const source = basis === "agentic-coding"
+            ? `LiveBench Agentic Coding ${round1(score)} (LiveBench table ${evidence.evidenceDate ?? "date not reported"})`
+            : `Artificial Analysis Intelligence Index ${round1(score)} (intelligence index version ${evidence.intelligenceIndexVersion ?? "not reported"})`;
+        return { basis, tier: bandOfRank(rank, scores.length), basisNote: `fleet-relative rank ${rank + 1}/${scores.length} by ${source}` };
+    }
+    return undefined;
+}
 function catalogEvidenceNote(evidence, catalog) {
     const cost = evidence.inputCostPerMtok !== undefined && evidence.outputCostPerMtok !== undefined
         ? `$${evidence.inputCostPerMtok}/$${evidence.outputCostPerMtok} per Mtok`
         : "not reported";
     const features = evidence.features.length ? evidence.features.join(",") : "none reported";
+    const agentic = evidence.agenticCodingScore !== undefined
+        ? `; LiveBench Agentic Coding=${round1(evidence.agenticCodingScore)}${evidence.evidenceDate ? ` (table ${evidence.evidenceDate})` : ""}`
+        : "";
     const intelligence = evidence.intelligenceIndex !== undefined
         ? `; Artificial Analysis Intelligence Index=${evidence.intelligenceIndex}${evidence.intelligenceIndexVersion ? ` (version ${evidence.intelligenceIndexVersion})` : ""}`
         : "";
     const freshness = catalog.stale ? `${catalog.source} stale cache` : catalog.source;
-    return `models.dev id=${evidence.modelId}; cost=${cost}; context=${evidence.contextWindow ?? "not reported"}; features=${features}${intelligence}; catalog=${freshness}; fetchedAt=${catalog.catalog.fetchedAt}`;
+    return `models.dev id=${evidence.modelId}; cost=${cost}; context=${evidence.contextWindow ?? "not reported"}; features=${features}${agentic}${intelligence}; catalog=${freshness}; fetchedAt=${catalog.catalog.fetchedAt}`;
 }
-export function catalogModelAdvisory(cfg, catalog, adapter, model, resolvedModel) {
+export function catalogModelAdvisory(cfg, catalog, adapter, model, resolvedModel, ranking) {
     const entry = cfg.tiers[adapter];
-    const evidence = resolveCatalogModel(catalog.catalog, {
-        // A tier vendor is NULLABLE (config.ts:64) — null means "declared as having none at tier level, so
-        // each model must declare its own". `resolveCatalogModel` takes an optional provider HINT
-        // (catalog-remote.ts:218), and "no hint" is `undefined` there, so null normalizes to undefined rather
-        // than travelling as a third state. Neither T17 nor T19 could see this seam: their files[] are
-        // disjoint, so no ordering edge was derived, they dispatched 7ms apart, and each worktree was cut
-        // before the other's change existed. Both gates passed truthfully; only the merged pair fails to
-        // compile (OBS-371).
-        provider: entry?.vendor ?? undefined,
-        model,
-        ...(resolvedModel ? { resolvedModel } : {}),
-    });
+    const row = { adapter, model, resolvedModel };
+    const evidence = catalogEvidenceFor(cfg, catalog, row);
     if (!evidence) {
         return {
             coverage: "uncovered",
@@ -57,18 +147,28 @@ export function catalogModelAdvisory(cfg, catalog, adapter, model, resolvedModel
         };
     }
     const note = catalogEvidenceNote(evidence, catalog);
-    const basis = evidence.intelligenceIndex !== undefined
-        ? { basis: "intelligence", tier: intelligenceTier(evidence.intelligenceIndex) }
-        : entry?.channel === "api" && evidence.outputCostPerMtok !== undefined
-            ? { basis: "price", tier: priceTier(evidence.outputCostPerMtok) }
-            : undefined;
+    // Orca import #1, read site: a shipped default must never launder into a fleet-reported suggestion.
+    if (catalog.source === "vendored") {
+        return {
+            coverage: "covered",
+            evidence,
+            display: `${model} → ${note}; the vendored catalog is a shipped default, not fetched evidence — no tier suggestion (run tickmarkr doctor --refresh-catalog)`,
+        };
+    }
+    const ranked = rankedSuggestion(ranking ?? catalogTierRanking(cfg, catalog, [row]), evidence);
+    const basis = ranked
+        ?? (entry?.channel === "api" && evidence.outputCostPerMtok !== undefined
+            // composer-2.5's permanent home: it has zero public benchmark evidence anywhere, so price is
+            // the only basis it will ever have. Unchanged absolute thresholds — price is not rescaled.
+            ? { basis: "price", tier: priceTier(evidence.outputCostPerMtok), basisNote: "price-derived fallback — no fleet-relative ranking basis covers this model" }
+            : undefined);
     if (!basis) {
         const reason = entry?.channel === "sub" && evidence.outputCostPerMtok !== undefined
             ? "subscription billing; no price-derived suggestion"
             : "no tier suggestion from available evidence";
         return { coverage: "covered", evidence, display: `${model} → ${note}; ${reason}` };
     }
-    const provenanceNote = `SUGGESTED ${basis.tier} (${basis.basis} inference, not a measurement) — ${note}; operator confirmation required`;
+    const provenanceNote = `SUGGESTED ${basis.tier} (${basis.basis} inference, not a measurement) — ${basis.basisNote}; ${note}; operator confirmation required`;
     return {
         coverage: "covered",
         evidence,
@@ -219,6 +319,33 @@ function collectSeedPreferLints(cfg, health, adapters, overlayPreferShapes, disp
 export function seedPreferLints(cfg, health, adapters, overlayPreferShapes = new Set()) {
     return collectSeedPreferLints(cfg, health, adapters, overlayPreferShapes, DECLARED_SEED_PREFER_DISPOSITION);
 }
+// v1.92: dead-pool lint — mirrors the dead-adapter seed lint above. A pool naming zero
+// doctor-found channels renders advisory here; plan/run stays the fail-loud authority (the
+// router's exhaustion RoutingError). Liveness mirrors adapterHasAuthedChannel's compat rule:
+// an installed adapter without per-model probe data counts live, not dead.
+export function deadPoolLints(cfg, health, adapters) {
+    const lints = [];
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        const pool = entry.pool;
+        if (!pool)
+            continue;
+        const live = pool.channels.some((id) => {
+            const a = adapters.find((x) => x.id === id.slice(0, id.indexOf(":")));
+            const h = a && health[a.id];
+            if (!a || !h?.installed || typeof a.channels !== "function")
+                return false;
+            const c = a.channels(cfg).find((ch) => channelKey(ch) === id);
+            if (!c)
+                return false;
+            if (!h.modelAuth || !Object.keys(h.modelAuth).length)
+                return true; // no per-model probe data — compat, not dead
+            return h.modelAuth[c.model]?.authed === true;
+        });
+        if (!live)
+            lints.push(`routing.map.${shape}.pool names no live channel — declared: ${pool.channels.join(", ")}`);
+    }
+    return lints;
+}
 // v1.54 T3: dead-steering sweep — operator prefer entries (routing.map overlay shapes, review.prefer,
 // consult.prefer) that can never match an installed channel are named at plan time; v1.53 T2 pins the
 // no-match case as a silent no-op, which makes a typo invisible. Advisory only: reads config + doctor
@@ -256,7 +383,12 @@ export function modelLints(cfg, health, adapters, opts) {
     for (const adapter of adapters) {
         const id = adapter.id;
         if (!adapter.listModels) {
-            lints.push(`${id}: no model-list surface — seeds stamped ${SEED_STAMPED}; verify manually`);
+            // v1.90 / OBS-504: the seeds-stamped wording presumes a seeded tier table. agy ships routable
+            // but UNCLASSIFIED (no listModels, no seed models) — for that shape the honest sentence names
+            // the classification debt, not a seed stamp with nothing behind it.
+            lints.push(Object.keys(cfg.tiers[id]?.models ?? {}).length > 0
+                ? `${id}: no model-list surface — seeds stamped ${SEED_STAMPED}; verify manually`
+                : `${id}: no model-list surface and no configured models — classify per benchmark policy to open channels`);
             continue;
         }
         const h = health[id];
@@ -292,6 +424,7 @@ export function modelLints(cfg, health, adapters, opts) {
         ? LEGACY_DOCTOR_SEED_PREFER_DISPOSITION
         : DECLARED_SEED_PREFER_DISPOSITION;
     lints.push(...collectSeedPreferLints(cfg, health, adapters, opts?.overlayPreferShapes ?? new Set(), seedDisposition));
+    lints.push(...deadPoolLints(cfg, health, adapters));
     return lints;
 }
 // T2/T6: one lint per exclusion, naming the probe reason and date. TTY truncates reasons to 60 chars and
@@ -312,25 +445,20 @@ export function formatModelAuthLine(excluded, tty, stateDir = DEFAULT_STATE_DIR)
 // `<id>: null` tombstones (deepMerge deletes the key). Pure function: no fs, no routing contact.
 // Returns "" when no adapter has a delta. Mirrors modelLints' per-adapter guards exactly.
 export function suggestOverlay(cfg, health, adapters, stateDir = DEFAULT_STATE_DIR, opts = {}) {
-    const blocks = [];
-    for (const adapter of adapters) {
+    // Pass 1 — decide WHAT each adapter drifts by. Pass 2 renders, after every addition this call
+    // will print has joined one ranking universe: a fleet-relative band must not depend on which
+    // adapter happened to be iterated first.
+    const drifts = adapters.flatMap((adapter) => {
         const id = adapter.id;
         if (!adapter.listModels)
-            continue; // no list surface → nothing to diff (mirror modelLints)
+            return []; // no list surface → nothing to diff (mirror modelLints)
         const h = health[id];
         const detected = h?.models ?? [];
         if (detected.length === 0)
-            continue; // no detection data → don't guess a delta
+            return []; // no detection data → don't guess a delta
         const configured = Object.keys(cfg.tiers[id]?.models ?? {});
-        const date = h?.modelsDetectedAt?.split("T")[0]; // best-effort day stamp
-        const detNote = date ? ` (detected ${date})` : "";
-        const lines = [];
         // Tombstones: configured ids the CLI no longer reports. Ids are operator-authored (from cfg) → MODEL_ID_RE only.
-        for (const model of configured) {
-            if (detected.includes(model) || !MODEL_ID_RE.test(model))
-                continue;
-            lines.push(`      ${model}: null   # tombstone: ${id} no longer reports this id${detNote}${referenceWarning(cfg, id, model)}`);
-        }
+        const tombstones = configured.filter((model) => !detected.includes(model) && MODEL_ID_RE.test(model));
         // Additions: detected ids not in cfg. WHOLE line commented, no tier (MODEL-06). Ids come from an external
         // CLI → MODEL_ID_RE (defense-in-depth, T-21-01) + the variant filter (cursor's ~193 parameterized ids).
         // RELATIONAL gate (no capability judgment — "looks like an embedding model" is auto-tiering's cousin, the
@@ -344,6 +472,7 @@ export function suggestOverlay(cfg, health, adapters, stateDir = DEFAULT_STATE_D
         // not silently. ponytail: not worth a per-adapter heuristic to quiet cursor at the price of codex signal.
         const cfgPrefixes = new Set(configured.map(providerPrefix));
         const cfgCanon = new Set(configured.map(canonical));
+        const additions = [];
         let omitted = 0;
         for (const model of detected) {
             if (configured.includes(model) || !MODEL_ID_RE.test(model) || LINT_VARIANT_RE.test(model))
@@ -352,8 +481,23 @@ export function suggestOverlay(cfg, health, adapters, stateDir = DEFAULT_STATE_D
                 omitted++;
                 continue;
             }
+            additions.push(model);
+        }
+        return [{ id, date: h?.modelsDetectedAt?.split("T")[0], tombstones, additions, omitted }]; // date: best-effort day stamp
+    });
+    const ranking = opts.catalog
+        ? catalogTierRanking(cfg, opts.catalog, drifts.flatMap(({ id, additions }) => additions.map((model) => ({ adapter: id, model, resolvedModel: opts.resolvedModel?.(id, model) }))), opts.resolvedModel)
+        : [];
+    const blocks = [];
+    for (const { id, date, tombstones, additions, omitted } of drifts) {
+        const detNote = date ? ` (detected ${date})` : "";
+        const lines = [];
+        for (const model of tombstones) {
+            lines.push(`      ${model}: null   # tombstone: ${id} no longer reports this id${detNote}${referenceWarning(cfg, id, model)}`);
+        }
+        for (const model of additions) {
             const advisory = opts.catalog
-                ? catalogModelAdvisory(cfg, opts.catalog, id, model, opts.resolvedModel?.(id, model))
+                ? catalogModelAdvisory(cfg, opts.catalog, id, model, opts.resolvedModel?.(id, model), ranking)
                 : undefined;
             const guidance = advisory?.suggestion
                 ? `provenance note (operator confirmation required): ${advisory.suggestion.provenanceNote}; choose a tier, then uncomment`

package/dist/adapters/registry.js

@@ -65,8 +65,21 @@ export function probeVersionShell(bin, cwd = process.cwd()) {
     if (!resolved)
         return { installed: false, authed: false, models: [] };
     const r = shellSpawnSync(`${shq(resolved)} --version`, cwd);
-    if (r.code !== 0)
-        return { installed: false, authed: false, models: [], binaryPaths: all };
+    if (r.code !== 0) {
+        // OBS-503: a resolved binary whose --version CRASHES under the worker shell is not "not
+        // installed" — a stale node on the login-shell PATH (bash -lc re-derives PATH) crashes every
+        // `#!/usr/bin/env node` CLI at dispatch while the operator's interactive shell runs it fine.
+        // installed stays false (dispatch runs through this same shell and would crash identically —
+        // fail closed), but the note names the real failure so doctor never prints a lie.
+        const reason = `${r.stderr}\n${r.stdout}`.replace(/\s+/g, " ").trim();
+        return {
+            installed: false,
+            authed: false,
+            models: [],
+            binaryPaths: all,
+            note: `found at ${resolved} but \`--version\` exited ${r.code} under the worker shell (bash -lc)${reason ? ` — ${reasonTail(reason)}` : ""}`,
+        };
+    }
     return {
         installed: true,
         authed: true,
@@ -241,7 +254,13 @@ export function parseDeclaredModels(raw, parser, path, field) {
     else if (parser === "pi-table") {
         const lines = raw.trim().split("\n");
         const header = lines.findIndex((line) => /^provider\s+model\b/i.test(line.trim()));
-        values = header === -1 ? [] : lines.slice(header + 1).map((line) => {
+        // OBS-506: a missing header previously fell through to a REASONLESS empty result, so the
+        // "never silently" warning below the parser could not fire — prime-agent's stderr-routed
+        // table produced a silent zero for a whole doctor run. An absent table names itself.
+        if (header === -1) {
+            return { models: [], reason: `no \`provider model …\` table header in ${raw.trim() ? `${lines.length} line(s) of output` : "empty output"}` };
+        }
+        values = lines.slice(header + 1).map((line) => {
             const [provider, model] = line.trim().split(/\s+/);
             return provider && model ? `${provider}/${model}` : "";
         });
@@ -301,7 +320,11 @@ function declarativeAdapter(entry) {
                 const result = shellSpawnSync(cmd, process.cwd(), 15000);
                 if (result.code !== 0)
                     return [];
-                const { models, reason } = parseDeclaredModels(result.stdout, drive.listModels.parser, drive.listModels.path, drive.listModels.field);
+                const { models, reason } = parseDeclaredModels(
+                // OBS-506: prime-agent prints its model table to STDERR (stdout 0 bytes, live-verified
+                // 2026-08-13) — the same stream convention probeVersionShell already tolerates for
+                // version banners. Fall back only when stdout is EMPTY, never merge the streams.
+                result.stdout.trim() ? result.stdout : result.stderr, drive.listModels.parser, drive.listModels.path, drive.listModels.field);
                 // Listing stays advisory (fail-open to []), but never silently: an empty projection names why.
                 if (models.length === 0 && reason)
                     console.warn(`tickmarkr: ${entry.id} listed no models — ${reason}`);
@@ -344,8 +367,10 @@ export async function probeAll(adapters, opts = {}) {
         if (bin) {
             const shell = probeVersionShell(bin, cwd);
             h = { ...h, installed: shell.installed, version: shell.version ?? h.version };
+            // OBS-503: the shell probe's note replaces the adapter probe's own — keeping a bare-spawn
+            // success note ("auth verified via …") next to installed:false stores a self-contradiction.
             if (!shell.installed)
-                h = { ...h, installed: false, authed: false };
+                h = { ...h, installed: false, authed: false, note: shell.note };
         }
         out[a.id] = h;
     }));
@@ -618,7 +643,8 @@ export function initDoctorReuse(repoRoot, fresh) {
 export function formatDoctorReport(cwd, cfg, health, adapters, opts = {}) {
     const rows = adapters.map((a) => {
         const h = health[a.id];
-        const state = !h?.installed ? "not installed" : `${h.version ?? "installed"}${h.note ? ` (${h.note})` : ""}`;
+        // OBS-503: a crash-on-version verdict carries its reason in note — print it instead of the lie.
+        const state = !h?.installed ? (h?.note ?? "not installed") : `${h.version ?? "installed"}${h.note ? ` (${h.note})` : ""}`;
         return `  ${h?.installed ? "✓" : "✗"} ${a.id.padEnd(14)} ${state}`;
     });
     rows.push(`  ${HerdrDriver.available() ? "✓" : "✗"} herdr          ${HerdrDriver.available() ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"}`);

package/dist/brand.d.ts

@@ -80,3 +80,5 @@ export declare const kvRow: (key: string, value: string, keyWidth?: number) => s
 export type Verdict = "pass" | "fail" | "warn" | "neutral";
 /** Status row: verdict glyph FIRST, then the label — glyph-first, distinct shape per verdict. */
 export declare const statusRow: (verdict: Verdict, label: string) => string;
+/** Compact token counts for tables: 1048576 → "1m", 262144 → "262k" (UI-free — safe for doctor). */
+export declare function compactTokens(tokens: number): string;

package/dist/brand.js

@@ -160,3 +160,16 @@ const VERDICT = {
 };
 /** Status row: verdict glyph FIRST, then the label — glyph-first, distinct shape per verdict. */
 export const statusRow = (verdict, label) => `${VERDICT[verdict]()} ${label}`;
+/** Compact token counts for tables: 1048576 → "1m", 262144 → "262k" (UI-free — safe for doctor). */
+export function compactTokens(tokens) {
+    if (!Number.isFinite(tokens) || tokens <= 0)
+        return "0";
+    if (tokens >= 1_000_000) {
+        const m = tokens / 1_000_000;
+        const rounded = m >= 10 ? Math.round(m) : Math.round(m * 10) / 10;
+        return `${String(rounded).replace(/\.0$/, "")}m`;
+    }
+    if (tokens >= 1000)
+        return `${Math.round(tokens / 1000)}k`;
+    return String(tokens);
+}

package/dist/cli/commands/doctor.d.ts

@@ -2,6 +2,10 @@ import { type ClaudeAlias } from "../../adapters/claude-code.js";
 import type { WorkerAdapter } from "../../adapters/types.js";
 import { type KimiDoctorTurnResult } from "../../adapters/kimi.js";
 import { type CatalogReadResult } from "../../adapters/catalog-remote.js";
+/** Where a newer `table_<date>.csv` is discovered — the deployed site builds filenames by
+ *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
+export declare const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
+export declare const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
 export type DoctorOpts = {
     banner?: boolean;
     kimiTurnProbe?: (cwd: string) => Promise<KimiDoctorTurnResult>;
@@ -58,4 +62,12 @@ export declare function selfShadowFinding(ownVersion: string, cwd?: string, reso
     verdict: "pass" | "fail";
     detail: string;
 } | undefined;
+/**
+ * §4.4: `LIVEBENCH_TABLE_DATE` is a hand-bumped constant, and a constant nobody lints is a stale
+ * constant — the pinned table ages silently while every tier suggestion keeps citing it. Warns past
+ * 90 days, naming the pinned date and the listing where a newer table is discovered.
+ * ponytail: a LINT, never a fetch — doctor stays cache-only (T17); the operator (or RELEASING.md's
+ * release-time check) reads the listing and bumps the constant.
+ */
+export declare function liveBenchStalenessFinding(now: Date): string | undefined;
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;