tickmarkr 1.35.0 → 1.36.0

package/dist/adapters/claude-code.js

@@ -38,6 +38,7 @@ export function probeVersion(bin) {
 export const claudeCode = {
     id: "claude-code",
     vendor: "anthropic",
+    probeCwd: "neutral",
     probe: async () => probeVersion("claude"),
     channels: (cfg) => channelsFromConfig("claude-code", cfg),
     // --strict-mcp-config --mcp-config '{"mcpServers":{}}': pin the MCP surface to empty so fresh-worktree

package/dist/adapters/grok.js

@@ -83,6 +83,7 @@ export const grok = {
     // FLEET-04 cross-vendor honesty: xai is diversity-distinct from anthropic/openai/cursor/zhipu.
     // MUST equal tiers.grok.vendor (a test pins the equality).
     vendor: "xai",
+    probeCwd: "neutral",
     probe: async () => {
         const h = probeVersion("grok");
         if (!h.installed)

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

@@ -1,11 +1,13 @@
-import type { DrovrConfig } from "../config/config.js";
+import { type DrovrConfig } from "../config/config.js";
 import { type AuthHealth, type WorkerAdapter } from "./types.js";
 export declare const SEED_STAMPED = "2026-07-09";
 export declare const MODEL_STALE_DAYS = 30;
 export declare const ttyVisual: () => boolean;
+export declare function seedPreferLints(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], overlayPreferShapes?: ReadonlySet<string>): string[];
 export declare function modelLints(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     tty?: boolean;
     stateDir?: string;
+    overlayPreferShapes?: ReadonlySet<string>;
 }): string[];
 export declare function formatModelAuthLine(excluded: {
     key: string;

package/dist/adapters/model-lints.js

@@ -1,3 +1,4 @@
+import { DEFAULT_CONFIG, TIER_RANK } from "../config/config.js";
 import { MODEL_ID_RE } from "./types.js";
 // date the tiers seeds were last live-verified (Phase 6/7 reseed) — surfaced when an adapter has no list surface.
 export const SEED_STAMPED = "2026-07-09";
@@ -13,6 +14,34 @@ const TTY_LINT_CAP = 3;
 const DEFAULT_STATE_DIR = ".drovr";
 const doctorJsonRef = (stateDir) => ` — see ${stateDir}/doctor.json`;
 export const ttyVisual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const adapterHasAuthedChannel = (adapterId, shape, cfg, health, adapters) => {
+    const entry = cfg.routing.map[shape];
+    const minTier = entry?.tier ?? cfg.routing.floors[shape] ?? "cheap";
+    const a = adapters.find((x) => x.id === adapterId);
+    const h = health[adapterId];
+    if (!a || !h?.installed || typeof a.channels !== "function")
+        return false;
+    if (!h.modelAuth || !Object.keys(h.modelAuth).length)
+        return true; // no per-model probe data — compat, not dead
+    return a.channels(cfg).some((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier] && h.modelAuth?.[c.model]?.authed === true);
+};
+// OBS-30 T2: warn when a built-in seed prefer names an adapter with zero authed channels this probe pass.
+export function seedPreferLints(cfg, health, adapters, overlayPreferShapes = new Set()) {
+    const lints = [];
+    for (const shape of Object.keys(cfg.routing.map)) {
+        if (overlayPreferShapes.has(shape))
+            continue;
+        for (const p of DEFAULT_CONFIG.routing.map[shape]?.prefer ?? []) {
+            const adapterId = p.includes(":") ? p.slice(0, p.indexOf(":")) : p;
+            if (!cfg.tiers[adapterId])
+                continue;
+            if (!adapterHasAuthedChannel(adapterId, shape, cfg, health, adapters)) {
+                lints.push(`routing seed names dead adapter '${adapterId}' for shape '${shape}' — auto-prefer is routing around it`);
+            }
+        }
+    }
+    return lints;
+}
 // Diffs detected models (doctor.json) against configured tiers, both directions, per adapter id in cfg.tiers.
 // No `  ! ` prefix here — the consumer (doctor rows / plan lints) owns that. Pre-v1.5 doctor.json (models:[], no
 // modelsDetectedAt) is the compat baseline: `?.`/`?? []` everywhere, no zod (would reject old files).
@@ -54,6 +83,7 @@ export function modelLints(cfg, health, adapters, opts) {
                 lints.push(`${id}: model knowledge is ${days} days old — rerun tickmarkr doctor`);
         }
     }
+    lints.push(...seedPreferLints(cfg, health, adapters, opts?.overlayPreferShapes));
     return lints;
 }
 // T2/T6: one lint per exclusion, naming the probe reason and date. TTY truncates reasons to 60 chars and

package/dist/adapters/opencode.js

@@ -16,6 +16,7 @@ export function parseOpencodeModels(raw) {
 export const opencode = {
     id: "opencode",
     vendor: "mixed",
+    probeCwd: "neutral",
     probe: async () => probeVersion("opencode"),
     channels: (cfg) => channelsFromConfig("opencode", cfg),
     headlessCommand: (promptFile, model) => `opencode run -m ${shq(model)} "$(cat ${shq(promptFile)})"`,

package/dist/adapters/pi.js

@@ -37,6 +37,7 @@ export const pi = {
     // FLEET-04: cross-vendor review honesty — GLM's provider (pi's own label is "zai"; either is
     // diversity-distinct from anthropic/openai/cursor/mixed). Must equal tiers.pi.vendor.
     vendor: "zhipu",
+    probeCwd: "neutral",
     probe: async () => {
         const h = probeVersion("pi");
         if (!h.installed)

package/dist/adapters/registry.d.ts

@@ -1,4 +1,5 @@
-import type { DrovrConfig } from "../config/config.js";
+import { type DrovrConfig } from "../config/config.js";
+import { type RoutingProfile } from "../route/profile.js";
 import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "./types.js";
 export declare function allAdapters(opts?: {
     fakeScriptPath?: string;
@@ -7,6 +8,21 @@ export declare function getAdapter(id: string, adapters: WorkerAdapter[]): Worke
 export declare function probeAll(adapters: WorkerAdapter[]): Promise<Record<string, AuthHealth>>;
 export type ProbeModelStatus = "ok" | "timeout" | "failed";
 export type ProbeModelProgress = (adapter: string, model: string, status: ProbeModelStatus, durationMs: number) => void;
+export interface AutoPreferDoc {
+    derivedAt: string;
+    [shape: string]: string[] | string;
+}
+export declare const pendingAutoPreferKey: unique symbol;
+export declare const DOCTOR_ROUTING_STALE_MS: number;
+export declare function deriveAutoPrefer(cfg: DrovrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>, profile?: RoutingProfile): AutoPreferDoc;
+export declare function readAutoPrefer(repoRoot: string): AutoPreferDoc | null;
+export declare function routingPreferContext(repoRoot: string, cfg: DrovrConfig, opts?: {
+    globalDir?: string;
+}): {
+    autoPrefer?: AutoPreferDoc;
+    doctorFresh: boolean;
+    overlayPreferShapes: ReadonlySet<string>;
+};
 export declare function probeModels(cfg: DrovrConfig, repoRoot: string, adapters: WorkerAdapter[], health: Record<string, AuthHealth>, onProgress?: ProbeModelProgress): Promise<void>;
 export declare function writeDoctor(repoRoot: string, health: Record<string, AuthHealth>): void;
 export declare function readDoctor(repoRoot: string): Record<string, AuthHealth> | null;

package/dist/adapters/registry.js

@@ -1,10 +1,13 @@
 import { existsSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { overlayPreferShapes, TIER_RANK } from "../config/config.js";
 import { modelLints, suggestOverlay } from "./model-lints.js";
 import { HerdrDriver } from "../drivers/herdr.js";
 import { drovrDir, stateDirName } from "../graph/graph.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../route/preference.js";
+import { learnedScore } from "../route/profile.js";
+import { marginalCostRank } from "../route/router.js";
 import { sh } from "../run/git.js";
 import { claudeCode } from "./claude-code.js";
 import { codex } from "./codex.js";
@@ -47,6 +50,57 @@ function probeFailure(code, stdout, stderr, timedOut, timeoutMs = MODEL_PROBE_TI
         ? output.slice(0, 240) || `probe exited ${code}`
         : undefined;
 }
+export const pendingAutoPreferKey = Symbol.for("tickmarkr.pendingAutoPrefer");
+const median = (xs) => {
+    const s = [...xs].sort((a, b) => a - b);
+    const m = Math.floor(s.length / 2);
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+// ponytail: 24h TTL matches plan.ts staleness — promote to config when an operator asks.
+export const DOCTOR_ROUTING_STALE_MS = 24 * 60 * 60 * 1000;
+export function deriveAutoPrefer(cfg, adapters, health, profile) {
+    const derivedAt = new Date().toISOString();
+    const out = { derivedAt };
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        const minTier = entry?.tier ?? cfg.routing.floors[shape] ?? "cheap";
+        const ranked = [];
+        for (const a of adapters) {
+            const h = health[a.id];
+            if (!h?.installed || !h?.authed || typeof a.channels !== "function")
+                continue;
+            const qualifying = a.channels(cfg).filter((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier] && h.modelAuth?.[c.model]?.authed === true);
+            if (!qualifying.length)
+                continue;
+            const durations = qualifying
+                .map((c) => h.modelAuth?.[c.model]?.durationMs)
+                .filter((d) => typeof d === "number");
+            ranked.push({
+                adapter: a.id,
+                mc: Math.min(...qualifying.map(marginalCostRank)),
+                dur: durations.length ? median(durations) : Number.POSITIVE_INFINITY,
+                learned: profile ? Math.max(...qualifying.map((c) => learnedScore(profile, shape, channelKey(c), c.channel))) : 0,
+            });
+        }
+        ranked.sort((a, b) => a.mc - b.mc || a.dur - b.dur || b.learned - a.learned);
+        out[shape] = ranked.map((r) => r.adapter);
+    }
+    return out;
+}
+export function readAutoPrefer(repoRoot) {
+    const raw = readDoctorFile(repoRoot);
+    if (!raw || typeof raw.autoPrefer !== "object" || raw.autoPrefer === null)
+        return null;
+    return raw.autoPrefer;
+}
+export function routingPreferContext(repoRoot, cfg, opts = {}) {
+    const age = doctorAgeMs(repoRoot);
+    const doctorFresh = age !== null && age <= DOCTOR_ROUTING_STALE_MS;
+    return {
+        autoPrefer: doctorFresh ? readAutoPrefer(repoRoot) ?? undefined : undefined,
+        doctorFresh,
+        overlayPreferShapes: overlayPreferShapes(repoRoot, opts),
+    };
+}
 const probeModelStatus = (v) => v.authed ? "ok" : v.reason?.includes("timed out") ? "timeout" : "failed";
 // v1.21: one bounded, headless call per configured model; detected-but-unclassified models never enter this loop.
 export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
@@ -62,6 +116,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
             return;
         const verdicts = {};
         const priorModelAuth = priorHealth?.[a.id]?.modelAuth;
+        const probeRoot = a.probeCwd === "neutral" ? mkdtempSync(join(tmpdir(), "tickmarkr-probe-")) : repoRoot;
         // models probe concurrently too (v1.33.5) — sequential chains made init wall time Σ(models×60s)
         // on the slowest adapter (measured 96s); each probe is one tiny prompt, safe to overlap.
         // Capped at MODEL_PROBE_CONCURRENCY per adapter (v1.33.5 regression: 4 concurrent codex exec
@@ -78,12 +133,12 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
                 else {
                     const promptFile = join(mkdtempSync(join(tmpdir(), "drovr-auth-")), "probe.md");
                     writeFileSync(promptFile, MODEL_PROBE_PROMPT);
-                    const r = await sh(a.headlessCommand(promptFile, model), repoRoot, MODEL_PROBE_TIMEOUT_MS);
+                    const r = await sh(a.headlessCommand(promptFile, model), probeRoot, MODEL_PROBE_TIMEOUT_MS);
                     if (r.timedOut && priorTimedOut) {
                         verdict = { authed: false, reason: `probe timed out (repeat — retry skipped) (${MODEL_PROBE_TIMEOUT_MS}ms)`, probedAt, durationMs: Date.now() - t0 };
                     }
                     else if (r.timedOut) {
-                        const r2 = await sh(a.headlessCommand(promptFile, model), repoRoot, MODEL_PROBE_TIMEOUT_MS);
+                        const r2 = await sh(a.headlessCommand(promptFile, model), probeRoot, MODEL_PROBE_TIMEOUT_MS);
                         if (r2.timedOut) {
                             verdict = { authed: false, reason: `probe timed out twice (${MODEL_PROBE_TIMEOUT_MS}ms)`, probedAt, durationMs: Date.now() - t0 };
                         }
@@ -106,6 +161,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
         });
         h.modelAuth = verdicts;
     }));
+    health[pendingAutoPreferKey] = deriveAutoPrefer(cfg, adapters, health);
 }
 // T2: caps concurrent probes per adapter at 2 — v1.33.5 regression, 4 concurrent codex exec in one
 // repo made ALL 4 time out where sequential passed 2/4 (suspected CLI self-contention).
@@ -121,12 +177,24 @@ async function mapLimit(items, limit, fn) {
     await Promise.all(workers);
 }
 const doctorPath = (repoRoot) => join(repoRoot, stateDirName(repoRoot), "doctor.json");
+function readDoctorFile(repoRoot) {
+    return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+}
 export function writeDoctor(repoRoot, health) {
     drovrDir(repoRoot);
-    writeFileSync(doctorPath(repoRoot), JSON.stringify(health, null, 2) + "\n");
+    const pending = health[pendingAutoPreferKey];
+    const payload = { ...health };
+    delete payload[pendingAutoPreferKey];
+    if (pending)
+        payload.autoPrefer = pending;
+    writeFileSync(doctorPath(repoRoot), JSON.stringify(payload, null, 2) + "\n");
 }
 export function readDoctor(repoRoot) {
-    return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+    const raw = readDoctorFile(repoRoot);
+    if (!raw)
+        return null;
+    const { autoPrefer: _, ...health } = raw;
+    return health;
 }
 export function discoverChannels(cfg, adapters, health) {
     const base = adapters

package/dist/adapters/types.d.ts

@@ -72,6 +72,7 @@ export declare function matchesTrustDialog(paneText: string, dialog: TrustDialog
 export interface WorkerAdapter {
     id: string;
     vendor: string;
+    probeCwd?: "repo" | "neutral";
     probe(): Promise<AuthHealth>;
     channels(cfg: DrovrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;

package/dist/cli/commands/doctor.js

@@ -1,9 +1,9 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, probeAll, probeModels, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { allAdapters, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { drovrDir, stateDirName } from "../../graph/graph.js";
 import { modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
-import { loadConfig } from "../../config/config.js";
+import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
 // same gate + palette as status's audit-ledger frame: styled only on a real TTY, plain otherwise
@@ -91,7 +91,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             rows.push(`  ! ${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) }).map((l) => `  ! ${l}`));
+    rows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual(), stateDir: stateDirName(cwd), overlayPreferShapes: overlayPreferShapes(cwd) }).map((l) => `  ! ${l}`));
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         rows.push(`  ! ${exclusionLine(excluded)}`);
@@ -143,6 +143,20 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             rows.push(`    (${unclassified.length} more listed, unclassified)`);
         return rows;
     });
-    const modelSummary = modelStatus.length ? `\nmodel status:\n${modelStatus.join("\n")}` : "";
+    const autoPrefer = readAutoPrefer(cwd);
+    const preferStatus = autoPrefer
+        ? Object.keys(cfg.routing.map).flatMap((shape) => {
+            const auto = autoPrefer[shape];
+            if (!Array.isArray(auto))
+                return [];
+            const seed = DEFAULT_CONFIG.routing.map[shape]?.prefer ?? [];
+            if (!auto.length && !seed.length)
+                return []; // nothing derived, nothing seeded — an empty line is noise
+            return [`    prefer ${shape} (auto): ${auto.join(" > ")} — seed was [${seed.join(", ")}]`];
+        })
+        : [];
+    const modelSummary = modelStatus.length || preferStatus.length
+        ? `\nmodel status:\n${[...modelStatus, ...preferStatus].join("\n")}`
+        : "";
     return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
 }

package/dist/config/config.d.ts

@@ -177,6 +177,9 @@ export declare class ConfigError extends Error {
 }
 export declare const DEFAULT_CONFIG: DrovrConfig;
 export declare function globalConfigDir(): string;
+export declare function overlayPreferShapes(repoRoot: string, opts?: {
+    globalDir?: string;
+}): ReadonlySet<string>;
 export declare function loadConfig(repoRoot: string, opts?: {
     globalDir?: string;
 }): DrovrConfig;

package/dist/config/config.js

@@ -262,6 +262,19 @@ export function globalConfigDir() {
     const legacy = join(base, "drovr");
     return existsSync(join(next, "config.yaml")) || !existsSync(join(legacy, "config.yaml")) ? next : legacy;
 }
+export function overlayPreferShapes(repoRoot, opts = {}) {
+    const shapes = new Set();
+    for (const layer of [readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml")), readYaml(join(repoRoot, stateDirName(repoRoot), "config.yaml"))]) {
+        const map = layer?.routing?.map;
+        if (!map)
+            continue;
+        for (const [shape, entry] of Object.entries(map)) {
+            if (entry && Object.prototype.hasOwnProperty.call(entry, "prefer") && entry.prefer !== null)
+                shapes.add(shape);
+        }
+    }
+    return shapes;
+}
 export function loadConfig(repoRoot, opts = {}) {
     const globalCfg = readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml"));
     const repoCfg = readYaml(join(repoRoot, stateDirName(repoRoot), "config.yaml"));

package/dist/route/router.d.ts

@@ -18,9 +18,17 @@ export interface Route {
     provenance: string;
     deviation?: RouteDeviation;
 }
+export interface RoutingPreferContext {
+    autoPrefer?: {
+        derivedAt: string;
+        [shape: string]: string[] | string;
+    };
+    doctorFresh: boolean;
+    overlayPreferShapes: ReadonlySet<string>;
+}
 export declare class RoutingError extends Error {
     constructor(msg: string);
 }
 export declare function marginalCostRank(c: BillingChannel): number;
-export declare function route(task: Task, cfg: DrovrConfig, channels: BillingChannel[], profile?: RoutingProfile): Route;
+export declare function route(task: Task, cfg: DrovrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: DrovrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile): Assignment | null;

package/dist/route/router.js

@@ -2,6 +2,19 @@ import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
 import { disallowedBy } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore } from "./profile.js";
+const autoPreferList = (doc, shape) => {
+    const v = doc?.[shape];
+    return Array.isArray(v) ? v : undefined;
+};
+const preferFromAuto = (shape, preferCtx) => !!preferCtx?.doctorFresh && !!preferCtx.autoPrefer && !preferCtx.overlayPreferShapes.has(shape) &&
+    autoPreferList(preferCtx.autoPrefer, shape) !== undefined;
+const effectivePrefer = (shape, entry, preferCtx) => {
+    if (preferCtx?.overlayPreferShapes.has(shape))
+        return entry?.prefer;
+    if (preferCtx?.doctorFresh && preferCtx.autoPrefer)
+        return autoPreferList(preferCtx.autoPrefer, shape) ?? entry?.prefer;
+    return entry?.prefer;
+};
 export class RoutingError extends Error {
     constructor(msg) {
         super(msg);
@@ -31,10 +44,11 @@ function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
 }
-export function route(task, cfg, channels, profile) {
+export function route(task, cfg, channels, profile, preferCtx) {
     const lints = [];
     const floor = cfg.routing.floors[task.shape];
     const entry = cfg.routing.map[task.shape];
+    const prefer = effectivePrefer(task.shape, entry, preferCtx);
     const prefActive = !!(cfg.routing.allow || cfg.routing.deny);
     const disallowedPin = (via, model, kind) => {
         const d = disallowedBy({ adapter: via, model }, cfg.routing);
@@ -95,12 +109,12 @@ export function route(task, cfg, channels, profile) {
     if (entry?.tier)
         lintFloor(entry.tier, "map tier");
     if (prefActive)
-        for (const p of entry?.prefer ?? [])
+        for (const p of prefer ?? [])
             preflightPrefer(p);
     // key order is a contract: prefer > marginal cost > tier (cheapest sufficient) > learned score (v1.6 ROUTE-06)
     // > discovery order (same-tier fairness, D2). The learned score is the LAST key — it decides only the
     // discovery-order tail, never a pin/floor/prefer/cost/tier boundary (they all sort above it, ROUTE-08).
-    const staticCmp = (a, b) => preferIndex(a, entry?.prefer) - preferIndex(b, entry?.prefer) || marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier];
+    const staticCmp = (a, b) => preferIndex(a, prefer) - preferIndex(b, prefer) || marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier];
     const eligibleRaw = channels.filter((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier]);
     if (!eligibleRaw.length) {
         let msg = `${task.id}: no channel at tier>=${minTier}; available: ${channels.map(channelKey).join(", ") || "(none)"}`;
@@ -137,19 +151,19 @@ export function route(task, cfg, channels, profile) {
         // entries, while intra-entry order (cost > tier > bonus > score) and every cold path stay byte-identical.
         // Cold reduces to preferIndex || cost || tier ≡ staticCmp (proof P1); rep keys use the group HEAD so
         // the probed group's budget self-extinguishes at EXPLORE_CAP (P4); flat lexicographic K is total (P5).
-        const prefer = entry?.prefer ?? [];
+        const preferBands = prefer ?? [];
         const groupCmp = (a, b) => marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier] ||
             bonusOf(b) - bonusOf(a) || scoreOf(b) - scoreOf(a);
         const heads = new Map();
         for (const c of [...eligibleRaw].sort(groupCmp)) {
-            const g = preferIndex(c, prefer);
+            const g = preferIndex(c, preferBands);
             if (!heads.has(g))
                 heads.set(g, c);
         }
         const keyOf = new Map(eligibleRaw.map((c) => {
-            const g = preferIndex(c, prefer);
+            const g = preferIndex(c, preferBands);
             const rep = heads.get(g);
-            return [channelKey(c), [g < prefer.length ? 0 : 1, -bonusOf(rep), -scoreOf(rep), g,
+            return [channelKey(c), [g < preferBands.length ? 0 : 1, -bonusOf(rep), -scoreOf(rep), g,
                     marginalCostRank(c), TIER_RANK[c.tier], -bonusOf(c), -scoreOf(c)]];
         }));
         const kOf = (c) => keyOf.get(channelKey(c));
@@ -180,8 +194,11 @@ export function route(task, cfg, channels, profile) {
                 "tier cheap (default)";
     // name the key that actually broke the tie: prefer outranks the marginal-cost/tier keys, so if the
     // winner matched a prefer entry, prefer decided it — not "cheapest sufficient tier" (ROUTE-03, WR-01)
-    const chosenBy = learnedChosen || (entry?.prefer && preferIndex(eligible[0], entry.prefer) < entry.prefer.length
-        ? "via prefer" : "cheapest sufficient tier");
+    const preferVia = preferFromAuto(task.shape, preferCtx)
+        ? `via prefer (auto-modernized ${preferCtx.autoPrefer.derivedAt.slice(0, 10)})`
+        : "via prefer";
+    const chosenBy = learnedChosen || (prefer && preferIndex(eligible[0], prefer) < prefer.length
+        ? preferVia : "cheapest sufficient tier");
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }
 export function nextChannel(current, task, cfg, channels, tried, profile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.35.0",
+  "version": "1.36.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",