tickmarkr 1.91.0 → 1.92.1

package/README.md

@@ -147,18 +147,20 @@ Configure which agent CLIs and models tickmarkr may route before your first run:
 
 ```bash
 tickmarkr doctor          # probe auth + capabilities (run after install or credential changes)
-tickmarkr fleet           # interactive editor (requires a TTY) — six steps, confirm to write
+tickmarkr fleet           # interactive fleet browser (requires a TTY) — review diff to write
 tickmarkr fleet --print   # effective fleet state (repo > global > defaults), non-interactive
 tickmarkr plan            # lint the resolved routing table against your spec
 tickmarkr run             # dispatch with the fleet you confirmed
 ```
 
-`tickmarkr doctor` is a pure sensor; `tickmarkr fleet` is the actuator. The editor walks **six
-steps** — probe data, agent CLIs, model tiers, routing mode, shape routing with a **candidate
-picker**, and steering preferences — and ends in a unified diff of your repo config overlay.
-Nothing is written until you confirm; pressing Enter through every step leaves config unchanged.
-Step 5/6 uses an arrow-driven candidate picker ranked by the production router; step 3 may ask
-for a benchmark-provenance note when you classify a new model.
+`tickmarkr doctor` is a pure sensor; `tickmarkr fleet` is the actuator. The browser is one
+two-pane surface: the left rail lists views (**All models**, **Shapes**, **Steering**) and every
+installed agent CLI with its auth state and model count; the right pane is a searchable model list
+with tier, context, price, and probe-latency columns. `Space` allows/denies, `Enter` classifies an
+unclassified model (with a required benchmark-provenance note) or pins a classified one to a shape,
+`m` opens the routing-mode presets, and `w` renders the unified diff of your repo config overlay.
+Nothing is written until you confirm the diff with `y`; quitting leaves config unchanged. The
+Shapes view pins from a candidate picker ranked by the production router.
 
 Routing-mode semantics, pin/floor/prefer precedence, review and consult steering syntax,
 provenance rules, and `--quality` / `--mode` flags are documented in
@@ -166,8 +168,9 @@ provenance rules, and `--quality` / `--mode` flags are documented in
 
 ## Steering
 
-Fleet step 6/6 sets `review.prefer` and `consult.prefer`; routing modes (`risk-based`,
-`partner-led`, `staff-led`) are chosen in step 4/6. Full grammar — including when review
+The fleet browser's **Steering** view sets `review.prefer` and `consult.prefer`; routing modes
+(`risk-based`, `partner-led`, `staff-led`) are applied from the presets overlay (`m`). Full
+grammar — including when review
 prefer may name a **bare adapter** versus `adapter:model`, and why consult prefer entries
 require **`adapter:model`** form — plus `tickmarkr run --supersedes` rerun control, is in
 **[FLEET.md](https://github.com/alzahrani-khalid/tickmarkr/blob/main/FLEET.md)**.

package/dist/adapters/model-lints.d.ts

@@ -67,6 +67,7 @@ export type RoutedAssignment = {
 /** Advisory only — absent windows config or undeclared model window ⇒ no lint. */
 export declare function contextWindowLints(tasks: ReadonlyArray<Task>, assignments: ReadonlyArray<RoutedAssignment>, cfg: TickmarkrConfig, repoRoot: string): string[];
 export declare function seedPreferLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], overlayPreferShapes?: ReadonlySet<string>): string[];
+export declare function deadPoolLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[]): string[];
 export declare function preferEntryLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, mapShapes?: ReadonlySet<string>): string[];
 export declare function modelLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     tty?: boolean;

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).
@@ -319,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
@@ -397,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

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.js

@@ -6,7 +6,7 @@ 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, catalogTierRanking, declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { loadConfig, overlayPreferShapes } from "../../config/config.js";
@@ -284,9 +284,22 @@ 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];
@@ -333,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 {
@@ -354,6 +371,8 @@ 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}`));
@@ -462,16 +481,20 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         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}`);
         }
@@ -518,5 +541,10 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         ].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`;
+    // 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,15 +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 { catalogModelAdvisory, catalogTierRanking, 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";
@@ -106,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)
@@ -148,22 +158,37 @@ 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.
@@ -181,21 +206,45 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     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 = 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) => {
                     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 } }
                             : {}),
@@ -212,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;
@@ -278,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,
@@ -292,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,
@@ -303,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,
@@ -359,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 },
@@ -389,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) => [
@@ -412,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)";
@@ -424,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`";