tickmarkr 1.90.7 → 1.91.0

package/dist/adapters/model-lints.js

@@ -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,
@@ -256,7 +356,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];
@@ -312,25 +417,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 +444,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 +453,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/cli/commands/doctor.d.ts

@@ -2,12 +2,19 @@ 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>;
     resolveClaudeAliasIdentity?: (cwd: string, alias: ClaudeAlias) => string | undefined;
     catalog?: CatalogReadResult;
     catalogNow?: () => Date;
+    /** init's between-acts surface: status rows only — the model matrix and inline drift stay
+     *  behind `tickmarkr doctor` (files are still written; only the RETURNED string shrinks). */
+    compact?: boolean;
 };
 export declare function runnerIgnoreFinding(cwd: string): {
     verdict: "pass" | "warn";
@@ -55,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>;

package/dist/cli/commands/doctor.js

@@ -8,12 +8,16 @@ import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnin
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { BANNER, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
-import { catalogModelAdvisory, declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
+import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { kimi, probeKimiDoctorTurn } from "../../adapters/kimi.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
-import { readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
+import { LIVEBENCH_TABLE_DATE, readCachedCatalog, refreshCatalogCommand } 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 const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
+export const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
@@ -205,6 +209,20 @@ export function selfShadowFinding(ownVersion, cwd = process.cwd(), resolve = res
         detail: `stale tickmarkr/tkr binaries on PATH: ${listing} (running ${ownVersion}) — a seat with different PATH order silently runs the old binary; remove the stale install root`,
     };
 }
+/**
+ * §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 function liveBenchStalenessFinding(now) {
+    const pinnedMs = Date.parse(`${LIVEBENCH_TABLE_DATE.replace(/_/g, "-")}T00:00:00Z`);
+    const days = Math.floor((now.getTime() - pinnedMs) / 86_400_000);
+    if (!Number.isFinite(days) || days <= LIVEBENCH_TABLE_MAX_AGE_DAYS)
+        return undefined;
+    return `LiveBench table pinned at ${LIVEBENCH_TABLE_DATE} is ${days} days old (>${LIVEBENCH_TABLE_MAX_AGE_DAYS}d) — list ${LIVEBENCH_RELEASES_URL} for a newer table_<date>.csv and bump LIVEBENCH_TABLE_DATE (advisory — tickmarkr never fetches that listing)`;
+}
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     if (_argv.length === 1 && _argv[0] === "--refresh-catalog") {
         const refreshed = await refreshCatalogCommand({ repoRoot: cwd, now: opts.catalogNow });
@@ -272,7 +290,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     writeDoctor(cwd, health);
     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})` : ""}`;
         const healthy = h.installed && (a.id !== kimi.id || h.authed);
         return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
@@ -340,22 +359,29 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             rows.push(attentionRow(`${role} runs on ${sel.adapter}:${sel.model} — NOT installed; that gate will fail closed until you install it or remap cfg.${role}`));
         }
     }
-    rows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual(), stateDir: stateDirName(cwd), overlayPreferShapes: overlayPreferShapes(cwd) }).map(attentionRow));
+    // OBS-505 residue: advisory lints collect apart from the capability/trust rows so the compact
+    // init journey can elide them behind the doctor pointer (one measured lint line ran 282 chars —
+    // pure wrap noise between two TUIs). Full doctor output is byte-identical: they rejoin in order.
+    const lintRows = [];
+    const liveBenchStale = liveBenchStalenessFinding(opts.catalogNow?.() ?? new Date());
+    if (liveBenchStale)
+        lintRows.push(attentionRow(liveBenchStale));
+    lintRows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual(), stateDir: stateDirName(cwd), overlayPreferShapes: overlayPreferShapes(cwd) }).map(attentionRow));
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
-        rows.push(attentionRow(exclusionLine(excluded)));
-    rows.push(...denyPreferCollisions(cfg).map((c) => attentionRow(denyPreferCollisionLine(c))));
+        lintRows.push(attentionRow(exclusionLine(excluded)));
+    lintRows.push(...denyPreferCollisions(cfg).map((c) => attentionRow(denyPreferCollisionLine(c))));
     const aliasExcluded = modelAliasExclusions(cfg, adapters, health);
     if (aliasExcluded.length)
-        rows.push(attentionRow(modelAliasLine(aliasExcluded)));
-    rows.push(...binaryShadowWarnings(adapters, health, cwd).map(attentionRow));
+        lintRows.push(attentionRow(modelAliasLine(aliasExcluded)));
+    lintRows.push(...binaryShadowWarnings(adapters, health, cwd).map(attentionRow));
     // HYG-07(a): doctor just probed fresh (probeAll above), so servability attribution is current by construction.
     const servable = servableExclusions(cfg, adapters, health);
     if (servable.length)
-        rows.push(attentionRow(servabilityLine(servable)));
+        lintRows.push(attentionRow(servabilityLine(servable)));
     // v1.65 T3: hardcoded-flag drift — advisory warn rows only. Runs AFTER writeDoctor so the verdicts
     // can never leak into doctor.json, and discoverChannels/routing never read them.
-    rows.push(...flagDriftWarnings(adapters, health).map(attentionRow));
+    lintRows.push(...flagDriftWarnings(adapters, health).map(attentionRow));
     // OBS-145: resolved-identity drift is the same class of display-only doctor warning. Stamps live
     // beside the alias-owning adapter; the comparison runs only for configured floating aliases and
     // never enters health/doctor.json, config, channel discovery, learned profiles, or route().
@@ -374,7 +400,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
                 continue; // advisory source failure is unknown, never a doctor failure
             }
             if (resolvedIdentity && resolvedIdentity !== stampedIdentity) {
-                rows.push(attentionRow(`resolved-identity drift: claude-code:${alias} resolved to ${resolvedIdentity}, stamped identity ${stampedIdentity} — reclassify per benchmark policy (advisory — routing unchanged)`));
+                lintRows.push(attentionRow(`resolved-identity drift: claude-code:${alias} resolved to ${resolvedIdentity}, stamped identity ${stampedIdentity} — reclassify per benchmark policy (advisory — routing unchanged)`));
             }
         }
     }
@@ -413,13 +439,23 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const trunc = (s, n) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
     const dateOf = (iso) => iso.slice(0, 10);
     const showWindows = hasWindowsConfig(cfg);
+    const unclassifiedByAdapter = new Map(adapters.flatMap((a) => {
+        const h = health[a.id];
+        if (!h?.installed)
+            return [];
+        const classified = cfg.tiers[a.id]?.models ?? {};
+        return [[a.id, (h.models ?? []).filter((m) => !(m in classified))]];
+    }));
+    // Every model under advisory in THIS report bands against one universe, built before any row
+    // renders — otherwise an adapter's band would depend on where it sits in the iteration.
+    const catalogRanking = catalogTierRanking(cfg, catalog, [...unclassifiedByAdapter].flatMap(([adapter, models]) => models.map((model) => ({ adapter, model, resolvedModel: resolvedCatalogModel(adapter, model) }))), resolvedCatalogModel);
     const modelStatus = adapters.flatMap((a) => {
         const h = health[a.id];
         if (!h?.installed)
             return [];
         const classified = cfg.tiers[a.id]?.models ?? {};
         const models = Object.keys(classified);
-        const unclassified = (h.models ?? []).filter((m) => !(m in classified));
+        const unclassified = unclassifiedByAdapter.get(a.id) ?? [];
         if (!models.length && !unclassified.length)
             return [];
         const w = Math.max(8, ...models.map((m) => m.length));
@@ -443,7 +479,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             // Keep the historical count as an index, but it is no longer the whole report: every model gets
             // a cache-backed evidence or explicit uncovered line. Neither branch changes cfg, health, or route().
             rows.push(`    ${dim(`(${unclassified.length} more listed, unclassified)`)}`);
-            const advisories = unclassified.map((model) => catalogModelAdvisory(cfg, catalog, a.id, model, resolvedCatalogModel(a.id, model)));
+            const advisories = unclassified.map((model) => catalogModelAdvisory(cfg, catalog, a.id, model, resolvedCatalogModel(a.id, model), catalogRanking));
             // Q128s exhibit #4 / operator directive 2026-08-12: ~600 per-model advisory rows buried the six
             // decision-grade flags on a real machine. Default view keeps ONLY rows that ask the operator for a
             // decision (tier suggestions); the no-decision bulk (uncovered + covered evidence-only) compresses
@@ -471,5 +507,16 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const header = visual()
         ? `${statusRow("pass", `${title("tickmarkr doctor")} ${legend("· capability matrix")}`)}\n${rule()}`
         : "tickmarkr doctor — capability matrix:";
-    return `${header}\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`;
+    if (opts.compact) {
+        // Operator field report 2026-08-13: the full matrix mid-init-journey is clutter between two
+        // TUIs. Every file side effect above already happened; the pointer line is the contract.
+        // Advisory lints elide with the matrix (OBS-505 residue) — capability, trust, and fail-closed
+        // judge/consult rows stay; the counted pointer names what moved behind `tickmarkr doctor`.
+        const elided = [
+            ...(lintRows.length ? [`${lintRows.length} advisory lint${lintRows.length === 1 ? "" : "s"}`] : []),
+            "model matrix",
+        ].join(" and ");
+        return `${header}\n${rows.join("\n")}\n  ${dim(`${elided} elided — \`tickmarkr doctor\` prints them in full${drift ? "; drift overlay written" : ""}`)}\nwrote ${stateDirName(cwd)}/doctor.json`;
+    }
+    return `${header}\n${[...rows, ...lintRows].join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`;
 }

package/dist/cli/commands/fleet.js

@@ -2,7 +2,9 @@ import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileS
 import { dirname } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse } from "../../adapters/registry.js";
-import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
+import { catalogModelAdvisory, catalogTierRanking, fleetUnclassifiedModels } from "../../adapters/model-lints.js";
+import { readCachedCatalog } from "../../adapters/catalog-remote.js";
+import { CLAUDE_ALIAS_IDENTITY_STAMPS, readClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { fleetEditableFromConfig, fleetEditableEquals, formatFleetPrint, globalConfigDir, overlayBytesLoadError, renderFleetOverlayWrite, repoOverlayPath, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
 import { projectFleetWhy, renderFleetWhy } from "../../config/fleet-why.js";
 import { SHAPES, TIERS } from "../../graph/schema.js";
@@ -162,17 +164,43 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     const initial = fleetEditableFromConfig(cfg);
     const editable = structuredClone(initial);
     const health = cached;
+    // OBS-508: the same catalog evidence doctor's drift overlay prints now rides each unclassified
+    // row — it prefills the classify flow and feeds the bulk `s` stage. Suggestions stay advisory:
+    // only the review-diff confirm writes, so "tickmarkr never applies" holds with less typing.
+    const catalog = readCachedCatalog(cwd);
+    // The same alias→identity resolution doctor hands its advisory rows: models.dev has never heard of
+    // `opus`, so without it the fleet's own frontier models drop out of the universe they are supposed
+    // to anchor and fleet bands a different set than doctor for one fleet. The stored identity wins;
+    // the stamped one backs it up. No probe — fleet never re-probes, doctor is the sensor (and doctor
+    // is the seat that lints a stamp the live identity has drifted away from).
+    const resolvedCatalogModel = (adapter, model) => adapter !== "claude-code" || !(model in CLAUDE_ALIAS_IDENTITY_STAMPS)
+        ? undefined
+        : readClaudeAliasIdentity(cwd, model) ?? CLAUDE_ALIAS_IDENTITY_STAMPS[model];
+    // One ranking universe for the whole screen: every unclassified row bands fleet-relatively
+    // against the same set, so a suggestion never depends on which adapter group renders first.
+    const unclassifiedRows = fleetUnclassifiedModels(cfg, health, adapters)
+        .map((row) => ({ ...row, resolvedModel: resolvedCatalogModel(row.adapter, row.model) }));
+    const catalogRanking = catalogTierRanking(cfg, catalog, unclassifiedRows, resolvedCatalogModel);
     const modelGroups = adapters
         .filter((adapter) => health[adapter.id]?.installed)
         .map((adapter) => {
-        const unclassified = fleetUnclassifiedModels(cfg, health, adapters).filter((row) => row.adapter === adapter.id);
+        const unclassified = unclassifiedRows.filter((row) => row.adapter === adapter.id);
         return {
             adapter: adapter.id,
             rows: [
                 ...Object.entries(editable.tiers[adapter.id] ?? {}).map(([model, value]) => ({ model, tier: value?.tier })),
                 ...unclassified
                     .filter((row) => !editable.tiers[adapter.id]?.[row.model])
-                    .map((row) => ({ model: row.model, detectedAt: row.detectedAt })),
+                    .map((row) => {
+                    const advisory = catalogModelAdvisory(cfg, catalog, adapter.id, row.model, row.resolvedModel, catalogRanking);
+                    return {
+                        model: row.model,
+                        detectedAt: row.detectedAt,
+                        ...(advisory.suggestion
+                            ? { suggestion: { tier: advisory.suggestion.tier, note: advisory.suggestion.provenanceNote } }
+                            : {}),
+                    };
+                }),
             ],
         };
     });