tickmarkr 1.90.8 → 1.92.0

package/dist/cli/commands/doctor.js

@@ -6,14 +6,18 @@ import { detectPackageManager, turboContinueFindings } from "../../gates/baselin
 import { version } from "./version.js";
 import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, resolveShellBinary, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 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 { BANNER, compactTokens, 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 });
@@ -266,13 +284,27 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const modelProbeAdapters = kimiTurnEnabled && health.kimi.authed === false
         ? adapters.filter((a) => a !== kimiAdapter)
         : adapters;
+    // One rewriting stderr line instead of a scrolling line per model (operator report 2026-08-14:
+    // 20 probe lines buried the journey). Totals print once at the end; non-TTY stays silent.
+    let probeOk = 0;
+    let probeBad = 0;
     await probeModels(cfg, cwd, modelProbeAdapters, health, probeProgressTTY
-        ? (adapter, model, status, durationMs) => console.error(`  ${adapter}:${model} ${status} (${(durationMs / 1000).toFixed(1)}s)`)
+        ? (adapter, model, status, durationMs) => {
+            if (status === "ok")
+                probeOk += 1;
+            else
+                probeBad += 1;
+            process.stderr.write(`\r\x1b[2K  probed ${probeOk + probeBad} channels · ${probeOk} ok${probeBad ? ` · ${probeBad} failed` : ""} · ${adapter}:${model} ${status} (${(durationMs / 1000).toFixed(1)}s)`);
+        }
         : undefined);
+    if (probeProgressTTY && probeOk + probeBad > 0) {
+        process.stderr.write(`\r\x1b[2K  probed ${probeOk + probeBad} channels · ${probeOk} ok${probeBad ? ` · ${probeBad} failed` : ""}\n`);
+    }
     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);
     });
@@ -314,11 +346,15 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     // v1.22 T5: workspace-trust pre-flight — per installed adapter: trusted | seeded | action-required | n/a.
     // action-required names the exact one-time command (or dialog) the operator must run once.
     rows.push(legend("workspace trust:"));
+    // Declutter (operator report 2026-08-14): n/a trust rows carried zero decisions — nine of them
+    // drowned the one action-required line. They compress to a single dim roster; actionable rows keep
+    // their own verdict lines.
+    const trustNa = [];
     for (const a of adapters) {
         if (!health[a.id]?.installed)
             continue;
         if (!a.trust) {
-            rows.push(`  ${dim("=")} ${kvRow(a.id, "trust: n/a").slice(2)}`);
+            trustNa.push(a.id);
             continue;
         }
         try {
@@ -335,27 +371,36 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             rows.push(alignedStatusRow("warn", a.id, `trust: action-required — run ONCE: (trust check failed: ${e instanceof Error ? e.message : String(e)})`));
         }
     }
+    if (trustNa.length)
+        rows.push(`  ${dim("=")} ${dim(`n/a (${trustNa.length}): ${trustNa.join(", ")}`)}`);
     for (const [role, sel] of [["judge", cfg.judge], ["consult", cfg.consult]]) {
         if (!health[sel.adapter]?.installed) {
             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 +419,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,29 +458,43 @@ 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));
         const rows = [`  ${dim(a.id)}`];
         for (const m of models) {
             const v = h.modelAuth?.[m];
+            // probe wall clock (ProbedModelAuth.durationMs) — pre-v1.91 doctor.json rows lack it
+            const probedMs = v?.durationMs;
+            const probed = probedMs !== undefined ? dim(` ${(probedMs / 1000).toFixed(1)}s`) : "";
             const auth = !v
                 ? dim("unknown")
                 : v.authed
-                    ? ok("authed")
+                    ? `${ok("authed")}${probed}`
                     : `${fail("unauthed:")} ${trunc(v.reason ?? "probe failed", 40)} (${dateOf(v.probedAt)})`;
             const d = disallowedBy({ adapter: a.id, model: m }, cfg.routing);
             const denied = d?.by === "deny" ? d.entry : "—";
             const pref = preferRanks({ adapter: a.id, model: m }, cfg).map((p) => `${p.shape}#${p.rank}`).join(",") || "—";
+            const window = declaredModelWindow(cfg, a.id, m);
             const windowCol = showWindows
-                ? ` ${String(declaredModelWindow(cfg, a.id, m) ?? "—").padEnd(8)}`
+                ? ` ${(window !== undefined ? compactTokens(window) : "—").padEnd(5)}`
                 : "";
             rows.push(`    ${m.padEnd(w)} ${classified[m].padEnd(8)}${windowCol} ${auth}  ${dim("denied=")}${denied}  ${dim("prefer=")}${pref}`);
         }
@@ -443,7 +502,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
@@ -474,7 +533,18 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     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.
-        return `${header}\n${rows.join("\n")}\n  ${dim(`model matrix elided — \`tickmarkr doctor\` prints it in full${drift ? "; drift overlay written" : ""}`)}\nwrote ${stateDirName(cwd)}/doctor.json`;
+        // 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.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`;
+    // Attention rows earn a counted section header so the matrix, the lints, and the model table
+    // read as three sections instead of one undifferentiated wall (operator report 2026-08-14).
+    const lintSection = lintRows.length
+        ? `\n${legend(`attention (${lintRows.length}):`)}\n${lintRows.join("\n")}`
+        : "";
+    return `${header}\n${rows.join("\n")}${lintSection}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`;
 }

package/dist/cli/commands/fleet-picker.js

@@ -19,7 +19,7 @@ export function candidateRow(c, pricing) {
 // order — route() returns a map pin first and fail-louds on its exclusion, which would collapse
 // the picker to a single row. No hidden mutation: fresh cfg objects only.
 export function shapeCandidates(task, cfg, channels, profile) {
-    const { pin: _pin, ...entry } = cfg.routing.map[task.shape] ?? {};
+    const { pin: _pin, pool: _pool, ...entry } = cfg.routing.map[task.shape] ?? {};
     const map = { ...cfg.routing.map, [task.shape]: entry };
     return rankCandidates(task, { ...cfg, routing: { ...cfg.routing, map } }, channels, profile);
 }

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

@@ -29,13 +29,13 @@ export declare function fleet(argv: string[], cwd?: string, adapters?: WorkerAda
     code: number;
 }>;
 /** Everything between the doctor-reuse gate and the Ink render, packaged for reuse: `tickmarkr init`
- * runs the same editor (preset-first) without re-owning the assembly or the write funnel. `commit`
- * remains the single config actuator — it maps editor results to the command's exact result strings
- * and performs the one guarded overlay write. */
+ * runs the same editor (entry="presets": Esc is HOME to the preset overlay, never a bare quit)
+ * without re-owning the assembly or the write funnel. `commit` remains the single config actuator —
+ * it maps editor results to the command's exact result strings and performs the one guarded
+ * overlay write. */
 export declare function assembleFleetEditor(cwd: string, adapters: WorkerAdapter[], io: FleetIO, opts: {
     globalDir: string;
     entry?: "presets" | "probe";
-    fresh?: boolean;
 }): Promise<{
     props: FleetEditorProps;
     commit: (result: FleetEditorResult) => string;

package/dist/cli/commands/fleet.js

@@ -1,13 +1,17 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 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 { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, modelAuthExclusions } from "../../adapters/registry.js";
+import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, 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";
+import { doctor } from "./doctor.js";
 import { candidateRow, costSignal, shapeCandidates } from "./fleet-picker.js";
 import { route } from "../../route/router.js";
+import { disallowedBy } from "../../route/preference.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
@@ -104,10 +108,18 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     }
     if (!why && !interactive)
         return { out: NON_TTY_MSG, code: 1 };
-    const assembled = await assembleFleetEditor(cwd, adapters, io, {
-        globalDir,
-        fresh: values.fresh ?? false,
-    });
+    // OBS-528: `--fresh` parsed since v1.92 but nothing ever RAN the probe — it forced the reuse
+    // gate false and guaranteed the "probe data missing or stale" refusal. The law stands — the
+    // EDITOR never probes (previews stay cache-only, `r` still exits to the operator) — but the
+    // command may run the sensor up front, exactly like init's act 2: a stale cache (or --fresh)
+    // probes first, visibly, then the editor assembles from what the probe just recorded.
+    if (!why && interactive) {
+        const { reuse } = initDoctorReuse(cwd, values.fresh ?? false);
+        if (!reuse) {
+            output.write(`${await doctor([], cwd, adapters, { banner: false, compact: true })}\n`);
+        }
+    }
+    const assembled = await assembleFleetEditor(cwd, adapters, io, { globalDir });
     if ("unavailable" in assembled)
         return { out: assembled.unavailable, code: 1 };
     if (why)
@@ -146,33 +158,98 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     return assembled.commit(result);
 }
 /** Everything between the doctor-reuse gate and the Ink render, packaged for reuse: `tickmarkr init`
- * runs the same editor (preset-first) without re-owning the assembly or the write funnel. `commit`
- * remains the single config actuator — it maps editor results to the command's exact result strings
- * and performs the one guarded overlay write. */
+ * runs the same editor (entry="presets": Esc is HOME to the preset overlay, never a bare quit)
+ * without re-owning the assembly or the write funnel. `commit` remains the single config actuator —
+ * it maps editor results to the command's exact result strings and performs the one guarded
+ * overlay write. */
 export async function assembleFleetEditor(cwd, adapters, io, opts) {
     const globalDir = opts.globalDir;
-    const { reuse, health: cached } = initDoctorReuse(cwd, opts.fresh ?? false);
+    const { reuse, health: cached } = initDoctorReuse(cwd, false);
     if (!reuse || !cached) {
         return {
-            unavailable: "tickmarkr fleet: probe data missing or stale — run `tickmarkr doctor` first (fleet never re-probes; doctor is the sensor)",
+            unavailable: "tickmarkr fleet: probe data missing or stale — run `tickmarkr doctor` first, or `tickmarkr fleet` interactively (it runs the probe itself when the cache is stale; --fresh forces one)",
         };
     }
     const rm = resolveRunMode(cwd, { globalDir });
     const cfg = rm.cfg;
-    const initial = fleetEditableFromConfig(cfg);
-    const editable = structuredClone(initial);
     const health = cached;
+    // v1.92: the discovered fleet universe — every channel the adapters actually SERVE, discovered
+    // blind to both membership scopes (deny and allow). Membership is an allow-complement, which is
+    // only computable against the served universe: cfg.tiers alone would drop served-but-unclassified
+    // channels (adapter-declared extras) out of the fleet the moment any exclusion is staged.
+    // fleetEditableFromConfig folds routing.allow into the editor's exclusion sets with it, and the
+    // writer emits the minimal allow form from it. The same pool later ranks every preview.
+    const { deny: _diskDeny, allow: _diskAllow, ...routingScopeBlind } = cfg.routing;
+    const previewChannels = discoverChannels({ ...cfg, routing: routingScopeBlind }, adapters, health);
+    const universe = adapters
+        .filter((adapter) => health[adapter.id]?.installed)
+        .map((adapter) => ({
+        adapter: adapter.id,
+        models: [...new Set(previewChannels.filter((c) => c.adapter === adapter.id).map((c) => c.model))],
+    }));
+    const initial = fleetEditableFromConfig(cfg, universe);
+    const editable = structuredClone(initial);
+    // 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);
+    // OBS-508 follow-through: the browser renders the metadata the assembler always had — catalog
+    // ctx/price evidence and doctor's model-probe wall clock — as columns instead of dropping them.
+    const rowEvidence = (adapter, model, evidence) => {
+        const probed = health[adapter]?.modelAuth?.[model];
+        const contextWindow = evidence?.contextWindow ?? declaredModelWindow(cfg, adapter, model);
+        const out = {
+            ...(contextWindow !== undefined ? { contextWindow } : {}),
+            ...(evidence?.outputWindow !== undefined ? { outputWindow: evidence.outputWindow } : {}),
+            ...(evidence?.inputCostPerMtok !== undefined ? { inputCostPerMtok: evidence.inputCostPerMtok } : {}),
+            ...(evidence?.outputCostPerMtok !== undefined ? { outputCostPerMtok: evidence.outputCostPerMtok } : {}),
+            ...(probed?.durationMs !== undefined ? { probeMs: probed.durationMs } : {}),
+            // OBS-519: doctor already recorded the failed verdict — a rate-limited/unauthed model must
+            // not render identically to a healthy row on the surface that edits its fleet membership.
+            ...(probed?.authed === false ? { unauthed: probed.reason ?? "probe failed" } : {}),
+        };
+        return Object.keys(out).length > 0 ? out : undefined;
+    };
     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,
+            channel: cfg.tiers[adapter.id]?.channel,
             rows: [
-                ...Object.entries(editable.tiers[adapter.id] ?? {}).map(([model, value]) => ({ model, tier: value?.tier })),
+                ...Object.entries(editable.tiers[adapter.id] ?? {}).map(([model, value]) => {
+                    const advisory = catalogModelAdvisory(cfg, catalog, adapter.id, model, resolvedCatalogModel(adapter.id, model), catalogRanking);
+                    const evidence = rowEvidence(adapter.id, model, advisory.coverage === "covered" ? advisory.evidence : undefined);
+                    return { model, tier: value?.tier, ...(evidence ? { evidence } : {}) };
+                }),
                 ...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);
+                    const evidence = rowEvidence(adapter.id, row.model, advisory.coverage === "covered" ? advisory.evidence : undefined);
+                    return {
+                        model: row.model,
+                        detectedAt: row.detectedAt,
+                        ...(evidence ? { evidence } : {}),
+                        ...(advisory.suggestion
+                            ? { suggestion: { tier: advisory.suggestion.tier, note: advisory.suggestion.provenanceNote } }
+                            : {}),
+                    };
+                }),
             ],
         };
     });
@@ -184,18 +261,38 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     ]));
     const channels = discoverChannels(cfg, adapters, health);
     const profile = loadRoutingProfile(cwd, cfg, { preview: true });
-    const previewCfg = (mode, map) => ({
-        ...cfg,
-        routing: { ...cfg.routing, map, floors: modeCfgs[mode].cfg.routing.floors },
-    });
-    const modeSpend = (mode, map) => {
+    const previewCfg = (mode, map, deny) => {
+        // mirror the writer: only the adapters/models scopes are fleet-editable; workers deny survives
+        const nextDeny = { ...cfg.routing.deny };
+        if (deny.adapters.length)
+            nextDeny.adapters = deny.adapters;
+        else
+            delete nextDeny.adapters;
+        if (deny.models.length)
+            nextDeny.models = deny.models;
+        else
+            delete nextDeny.models;
+        const routing = {
+            ...routingScopeBlind,
+            map,
+            floors: modeCfgs[mode].cfg.routing.floors,
+            ...(Object.keys(nextDeny).length ? { deny: nextDeny } : {}),
+        };
+        return { ...cfg, routing };
+    };
+    // route() never deny-filters its pool — that contract lives in discoverChannels — so every
+    // preview call rebuilds the pool the staged deny would discover
+    const previewPool = (cfgPreview) => previewChannels.filter((c) => disallowedBy(c, cfgPreview.routing) === null);
+    const modeSpend = (mode, map, deny) => {
         const tierCount = {};
         let subs = 0;
         let apiN = 0;
         let apiUsd = 0;
+        const cfgPreview = previewCfg(mode, map, deny);
+        const pool = previewPool(cfgPreview);
         for (const shape of SHAPES) {
             try {
-                const assignment = route(previewTask(shape), previewCfg(mode, map), channels, profile, undefined, undefined, PREVIEW_EXPLORE).assignment;
+                const assignment = route(previewTask(shape), cfgPreview, pool, profile, undefined, undefined, PREVIEW_EXPLORE).assignment;
                 tierCount[assignment.tier] = (tierCount[assignment.tier] ?? 0) + 1;
                 if (assignment.channel === "sub")
                     subs += 1;
@@ -250,13 +347,20 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
             ? { declaredAt: `routing.floors.${shape}` }
             : { declaredAt: "routing.mode" };
     };
-    const projectedShapeRows = (mode, map) => {
+    const projectedShapeRows = (mode, map, deny) => {
+        const cfgPreview = previewCfg(mode, map, deny);
+        const pool = previewPool(cfgPreview);
         const values = SHAPES.map((shape) => {
             try {
-                const routed = route(previewTask(shape), previewCfg(mode, map), channels, profile, undefined, undefined, PREVIEW_EXPLORE);
+                const routed = route(previewTask(shape), cfgPreview, pool, profile, undefined, undefined, PREVIEW_EXPLORE);
                 const assignment = routed.assignment;
-                const effective = `${assignment.adapter}:${assignment.model} (${assignment.channel}, ${assignment.tier})  ${costSignal(assignment, cfg.pricing)}`;
-                const mapProducedValue = map[shape]?.pin !== undefined || routed.provenance.includes("via prefer");
+                // OBS-531: a pooled shape used to render only the routed WINNER — indistinguishable from
+                // a pin. The declaration is the operator's decision; the winner is today's dice.
+                const declaredPool = map[shape]?.pool;
+                const poolPrefix = declaredPool ? `pool(${declaredPool.mode}·${declaredPool.channels.length}) → ` : "";
+                const effective = `${poolPrefix}${assignment.adapter}:${assignment.model} (${assignment.channel}, ${assignment.tier})  ${costSignal(assignment, cfg.pricing)}`;
+                const mapProducedValue = map[shape]?.pin !== undefined || map[shape]?.pool !== undefined
+                    || routed.provenance.includes("via prefer");
                 return {
                     id: shape,
                     effective,
@@ -264,7 +368,8 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
                 };
             }
             catch (error) {
-                const mapProducedValue = map[shape]?.pin !== undefined || (map[shape]?.prefer?.length ?? 0) > 0;
+                const mapProducedValue = map[shape]?.pin !== undefined || map[shape]?.pool !== undefined
+                    || (map[shape]?.prefer?.length ?? 0) > 0;
                 return {
                     id: shape,
                     effective: error.message,
@@ -275,12 +380,49 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         });
         return projectFleetWhy(values, { repoRoot: cwd, globalDir });
     };
-    const routedShapeRows = (mode, map) => projectedShapeRows(mode, map).map(({ id, label }) => ({ id, label }));
-    const candidatesForShape = (shape, mode, map) => shapeCandidates(previewTask(shape), previewCfg(mode, map), channels, profile).map((candidate) => ({
-        id: `${candidate.assignment.adapter}:${candidate.assignment.model}`,
-        label: candidateRow(candidate, cfg.pricing),
-        pin: { via: candidate.assignment.adapter, model: candidate.assignment.model },
-    }));
+    const routedShapeRows = (mode, map, deny) => projectedShapeRows(mode, map, deny).map(({ id, label }) => ({ id, label }));
+    // OBS-530: the picker silently omitted every excluded channel — the operator asked "why is X
+    // missing" three times in one session and the answer lived only in config archaeology. One dim
+    // line now names each bucket. Static buckets (unauthed, unclassified) computed once; the
+    // staged-vs-disk split recomputed per open because it ranks against the SESSION's deny state.
+    const unauthedClis = adapters
+        .filter((adapter) => health[adapter.id]?.installed && health[adapter.id]?.authed === false)
+        .map((adapter) => adapter.id);
+    const unauthedModelCount = modelAuthExclusions(cfg, adapters, health).length;
+    const excludedNoteFor = (deny) => {
+        let stagedOut = 0;
+        let denied = 0;
+        const stagedRouting = previewCfg(rm.mode.mode, {}, deny).routing;
+        for (const channel of previewChannels) {
+            if (disallowedBy(channel, stagedRouting) === null)
+                continue;
+            if (disallowedBy(channel, cfg.routing) === null)
+                stagedOut += 1;
+            else
+                denied += 1;
+        }
+        const parts = [];
+        if (stagedOut)
+            parts.push(`${stagedOut} staged out this session`);
+        if (denied)
+            parts.push(`${denied} denied in config`);
+        if (unauthedModelCount)
+            parts.push(`${unauthedModelCount} unauthed`);
+        if (unauthedClis.length)
+            parts.push(`${unauthedClis.join("/")} CLI unauthed`);
+        if (unclassifiedRows.length)
+            parts.push(`${unclassifiedRows.length} unclassified (never routed)`);
+        return parts.length ? `not offered: ${parts.join(" · ")} — the models view explains each row` : undefined;
+    };
+    const candidatesForShape = (shape, mode, map, deny) => {
+        const cfgPreview = previewCfg(mode, map, deny);
+        const rows = shapeCandidates(previewTask(shape), cfgPreview, previewPool(cfgPreview), profile).map((candidate) => ({
+            id: `${candidate.assignment.adapter}:${candidate.assignment.model}`,
+            label: candidateRow(candidate, cfg.pricing),
+            pin: { via: candidate.assignment.adapter, model: candidate.assignment.model },
+        }));
+        return { rows, excludedNote: excludedNoteFor(deny) };
+    };
     const preferUniverse = [
         ...new Set(channels.flatMap((channel) => [
             channel.adapter,
@@ -331,6 +473,7 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         const write = {
             initial,
             edited: staged,
+            universe,
             ...(modeChanged ? { mode: state.selectedMode } : {}),
             ...(judgeChanged && judgeSeat ? { judge: judgeSeat } : {}),
             steering: { initial: initialSteering, edited: state.steering },
@@ -361,7 +504,7 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         initialMode: rm.mode.mode,
         modeOptions: ROUTING_MODES.map((mode) => ({ id: mode, gloss: MODE_GLOSS[mode] })),
         initialMap: editable.map,
-        modePreview: (mode, map) => [modeSpend(mode, map), ...floorPreview(mode)],
+        modePreview: (mode, map, deny) => [modeSpend(mode, map, deny), ...floorPreview(mode)],
         shapeRows: routedShapeRows,
         candidatesForShape,
         preferOptionsForShape: (_shape, current) => [
@@ -384,7 +527,7 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         if (result.kind === "quit")
             return QUIT;
         if (result.kind === "refresh") {
-            return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
+            return "fleet: probe refresh requested — re-run `tickmarkr fleet --fresh` (doctor is the sensor; the editor itself never re-probes)";
         }
         if (result.kind === "no-changes")
             return "fleet: no overlay changes (empty diff)";
@@ -396,11 +539,29 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         if (!write)
             throw new Error("fleet write reached confirmation without a staged overlay mutation");
         writeFleetOverlay(result.review.path, (prior) => renderFleetOverlayWrite(prior, write));
-        return `fleet: wrote ${result.review.path}`;
+        // OBS-529: a freshly classified model has no probe verdict (doctor probes CONFIGURED models,
+        // and it was not configured at probe time), so it stays unroutable — invisible in every
+        // picker — until the next probe. Name the step, or the classify flow reads as broken.
+        const unprobed = [];
+        for (const [adapter, models] of Object.entries(write.edited.tiers)) {
+            for (const [model, assigned] of Object.entries(models)) {
+                if (assigned === null || assigned === undefined)
+                    continue;
+                if (JSON.stringify(write.initial.tiers[adapter]?.[model]) === JSON.stringify(assigned))
+                    continue;
+                if (health[adapter]?.modelAuth?.[model] === undefined)
+                    unprobed.push(`${adapter}:${model}`);
+            }
+        }
+        const head = `fleet: wrote ${result.review.path}`;
+        if (!unprobed.length)
+            return head;
+        const named = unprobed.slice(0, 3).join(", ") + (unprobed.length > 3 ? `, +${unprobed.length - 3} more` : "");
+        return `${head}\nfleet: ${unprobed.length} newly classified model(s) have no probe verdict yet (${named}) — run \`tickmarkr fleet --fresh\` to probe them; unverified models stay unroutable`;
     };
     return {
         props,
         commit,
-        renderWhy: () => renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map)),
+        renderWhy: () => renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map, { adapters: editable.denyAdapters, models: editable.denyModels })),
     };
 }

package/dist/cli/commands/init.js

@@ -275,9 +275,10 @@ async function installAgentFiles(cwd, force, docs, notes) {
     }
 }
 // The consolidated wizard (operator directive 2026-08-12): init walks three acts in one
-// command — preferences (Ink form) → discovery (doctor, the sensor) → fleet (presets or the
-// full editor). The readline asks this replaced live on in git history; the Ink act keeps the
-// same four questions and the same defaults, so `--yes` and non-TTY paths are unchanged.
+// command — preferences (Ink form) → discovery (doctor, the sensor) → fleet (the browser opens
+// on the models view; the presets overlay raises on the first Shapes entry). The readline asks
+// this replaced live on in git history; the Ink act keeps the same four questions and the same
+// defaults, so `--yes` and non-TTY paths are unchanged.
 async function runInitWizard(cwd, input, output) {
     // Dynamic import, deliberately (same seam as fleet.ts): the Ink/React runtime must stay out of
     // the non-TTY and --yes paths — init runs in CI and agent shells where importing Ink at module
@@ -395,7 +396,8 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
             : `using probe results from ${formatDoctorAgeForInit(ageMs)} ago — run tickmarkr doctor to refresh (or init --fresh)\n${formatDoctorReport(cwd, loadConfig(cwd), health, allAdapters(), { wrote: false })}`
         : await doctor([], cwd, undefined, { banner: false, compact: interactive });
     // Act 3 — fleet. The compact discovery surface prints BETWEEN the acts so the operator reads
-    // what the presets screen ranks with; the final summary then carries a pointer, not a repeat.
+    // what the fleet browser (and its presets overlay, raised on the first Shapes entry) ranks
+    // with; the final summary then carries a pointer, not a repeat.
     if (interactive) {
         output.write(`${doc}\n`);
         doc = "discovery shown above — full matrix any time with `tickmarkr doctor`";