tickmarkr 2.3.0 → 2.4.1

package/dist/adapters/qwen.js

@@ -0,0 +1,153 @@
+import { spawnSync } from "node:child_process";
+import { parseWorkerResult } from "./prompt.js";
+import { channelsFromConfig, shq, } from "./types.js";
+export const QWEN_VERSION_IDENTITY = /^\d+\.\d+\.\d+/;
+const QWEN_SKIP_UPDATE = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE=true";
+function decodeQwenEvents(events) {
+    const text = [];
+    let failed = false;
+    let resultText;
+    let errorText;
+    let denialText;
+    for (const event of events) {
+        if (!event || typeof event !== "object")
+            continue;
+        if ("type" in event && event.type === "assistant" && "message" in event) {
+            const message = event.message;
+            if (message && typeof message === "object" && "content" in message && Array.isArray(message.content)) {
+                for (const content of message.content) {
+                    if (!content || typeof content !== "object" || !(("type" in content) && content.type === "text"))
+                        continue;
+                    if ("text" in content && typeof content.text === "string")
+                        text.push(content.text);
+                }
+            }
+        }
+        if ("is_error" in event && event.is_error === true)
+            failed = true;
+        if ("type" in event && event.type === "result") {
+            if (!(("subtype" in event) && event.subtype === "success"))
+                failed = true;
+            if ("result" in event && typeof event.result === "string" && event.result.trim()) {
+                resultText ??= event.result.trim();
+            }
+            // A no-auth host answers `result/error_during_execution` with the cause under `error.message`
+            // (verbatim: .planning/assessments/2026-09-04-qwen-live-worker-form/no-auth-home.stdout).
+            const error = "error" in event ? event.error : undefined;
+            if (error && typeof error === "object" && "message" in error && typeof error.message === "string" && error.message.trim()) {
+                errorText ??= error.message.trim();
+            }
+        }
+        if ("permission_denials" in event && Array.isArray(event.permission_denials) && event.permission_denials.length > 0) {
+            failed = true;
+            denialText ??= event.permission_denials.map(String).join(", ");
+        }
+        if (!("stats" in event) || !event.stats || typeof event.stats !== "object" || !("models" in event.stats))
+            continue;
+        const models = event.stats.models;
+        if (!models || typeof models !== "object")
+            continue;
+        for (const model of Object.values(models)) {
+            if (!model || typeof model !== "object" || !("api" in model))
+                continue;
+            const api = model.api;
+            if (!api || typeof api !== "object" || !("totalErrors" in api))
+                continue;
+            if (typeof api.totalErrors === "number" && api.totalErrors > 0)
+                failed = true;
+        }
+    }
+    const assistantText = text.join("\n");
+    const apiError = assistantText.match(/\[API Error:[^\n]*/)?.[0];
+    if (apiError)
+        failed = true;
+    if (!failed)
+        return { assistantText };
+    return {
+        assistantText,
+        failure: apiError ?? errorText ?? resultText ?? (denialText ? `qwen permission denied: ${denialText}` : "qwen reported a startup failure"),
+    };
+}
+// OBS-903: the daemon hands the adapter the WHOLE captured stream, never qwen's bare stdout — the
+// launch script's banner and TICKMARKR_EXIT line sit around it and the subprocess driver appends stderr
+// (the headless yolo warning) into the same buffer. The event array is located, not assumed: the bare
+// buffer first, then the outermost `[{` … `}]` span. A live PONG completion read as "unparseable" and
+// merged only through the harvest path until this (clause-4 probe, RULING-222-42).
+function eventArray(raw) {
+    const start = raw.indexOf("[{");
+    const end = raw.lastIndexOf("}]");
+    for (const text of [raw.trim(), start !== -1 && end > start ? raw.slice(start, end + 2) : ""]) {
+        if (!text.startsWith("["))
+            continue;
+        try {
+            const parsed = JSON.parse(text);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* try the next shape */ }
+    }
+    return undefined;
+}
+// Decode qwen's JSON envelope before scanning only decoded assistant text for the worker trailer.
+export function parseQwenResult(raw, nonce) {
+    const malformed = {
+        ok: false,
+        summary: raw.trim() ? "unparseable qwen JSON event stream" : "qwen produced no JSON event stream",
+        deviations: [],
+        raw,
+        cause: raw.trim() ? "malformed-verdict" : "empty-output",
+    };
+    const parsed = eventArray(raw);
+    if (!parsed)
+        return malformed;
+    const decoded = decodeQwenEvents(parsed);
+    if (decoded.failure !== undefined) {
+        return {
+            ok: false,
+            summary: decoded.failure,
+            deviations: [],
+            raw,
+            cause: "startup-failure",
+        };
+    }
+    return { ...parseWorkerResult(decoded.assistantText, nonce), raw };
+}
+function probeQwen() {
+    const result = spawnSync("qwen", ["--version"], { encoding: "utf8", timeout: 10_000 });
+    if (result.error || result.status !== 0)
+        return { installed: false, authed: false, models: [] };
+    const version = (result.stdout || result.stderr).trim().split("\n")[0] ?? "";
+    if (!QWEN_VERSION_IDENTITY.test(version)) {
+        return { installed: false, authed: false, models: [], note: `qwen binary identity mismatch: ${version || "empty version"}` };
+    }
+    return {
+        installed: true,
+        authed: true,
+        version,
+        models: [],
+        note: "auth assumed; verified at dispatch (qwen reports API failures inside exit-0 success envelopes)",
+    };
+}
+export const qwen = {
+    id: "qwen",
+    vendor: "alibaba",
+    probeCwd: "neutral",
+    probe: async () => probeQwen(),
+    channels: (cfg) => channelsFromConfig("qwen", cfg),
+    hardcodedFlags: { binary: "qwen", flags: ["--safe-mode", "--approval-mode", "-m", "-o", "-p"] },
+    headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --safe-mode --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
+    // OBS-905: qwen has NO interactive form. The `-i "$(cat prompt)"` TUI launch put the whole prompt in
+    // argv (the OBS-889 leak-and-census shape) and produced a rendered transcript the JSON decoder above
+    // can never read — under the herdr driver every qwen task read "unparseable" and merged only by harvest.
+    // The headless form runs in the visible pane and the same parser reads it in every driver; the daemon's
+    // mode-fallback branch (daemon.ts, `icmd === null`) journals the choice once per run.
+    interactiveCommand: () => null,
+    invoke(task, _cwd, assignment, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, assignment.model) };
+    },
+    parse: parseQwenResult,
+    trustDialog: {
+        kind: "none",
+        reason: "qwen 0.21.15 showed no workspace-trust prompt in a fresh repository during the recorded interactive probe (.planning/assessments/2026-09-03-qwen-cli-probe/README.md, 2026-09-03); enabling security.folderTrust falsifies this declaration",
+    },
+};

package/dist/adapters/registry.js

@@ -399,6 +399,17 @@ function reasonTail(output) {
     const sp = tail.indexOf(" ");
     return sp === -1 ? tail : tail.slice(sp + 1);
 }
+function parsedStartupFailureReason(adapter, output) {
+    try {
+        const parsed = adapter.parse(output, "tickmarkr-model-probe");
+        const cause = parsed.cause;
+        if (!parsed.ok && cause === "startup-failure" && parsed.summary.trim()) {
+            return reasonTail(parsed.summary.trim().replace(/\s+/g, " "));
+        }
+    }
+    catch { /* adapter parse is advisory for probe diagnostics */ }
+    return undefined;
+}
 function probeFailure(code, stdout, stderr, timedOut, timeoutMs = MODEL_PROBE_TIMEOUT_MS) {
     // SIGKILL-timeout is not exit-1: report the budget, never the masked kill code (v1.27 T1).
     if (timedOut)
@@ -456,7 +467,8 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
                         if (r.timedOut && !retry && priorModelAuth?.[model]?.reason?.includes("timed out") === true) {
                             return { verdict: v(false, `probe timed out (repeat — retry skipped) (${MODEL_PROBE_TIMEOUT_MS}ms)`), timedOut: true };
                         }
-                        const reason = probeFailure(r.code, r.stdout, r.stderr, r.timedOut, MODEL_PROBE_TIMEOUT_MS);
+                        const output = `${r.stderr}\n${r.stdout}`.trim();
+                        const reason = parsedStartupFailureReason(a, output) ?? probeFailure(r.code, r.stdout, r.stderr, r.timedOut, MODEL_PROBE_TIMEOUT_MS);
                         if (!reason)
                             return { verdict: v(true), timedOut: false };
                         if (!retry)

package/dist/adapters/types.d.ts

@@ -124,6 +124,7 @@ export declare const ADAPTER_PROMPT_GLYPHS: {
     readonly pi: ">";
     readonly grok: ">";
     readonly kimi: ">";
+    readonly qwen: ">";
     readonly omp: ">";
     readonly agy: ">";
     readonly "prime-agent": ">";

package/dist/adapters/types.js

@@ -151,6 +151,7 @@ export const ADAPTER_PROMPT_GLYPHS = {
     "pi": ">",
     "grok": ">",
     "kimi": ">",
+    "qwen": ">",
     "omp": ">",
     "agy": ">",
     "prime-agent": ">",

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

@@ -1 +1,4 @@
+import { type SourceScopeFinding } from "../../compile/collateral.js";
+import { compileSource } from "../../compile/index.js";
+export declare function nativeSourceScopeErrors(graph: ReturnType<typeof compileSource>, findings: readonly SourceScopeFinding[]): string[];
 export declare function compile(argv: string[], cwd?: string, harnessFrom?: string | undefined): Promise<string>;

package/dist/cli/commands/compile.js

@@ -1,12 +1,28 @@
 import { isAbsolute, join } from "node:path";
 import { parseArgs } from "node:util";
-import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
+import { collateralLints, sourceScopeFindings, sourceScopeLints, } from "../../compile/collateral.js";
+import { CompileError } from "../../compile/common.js";
 import { compileSource } from "../../compile/index.js";
-import { saveGraph, stateDirName } from "../../graph/graph.js";
+import { clearCompileRefusal, saveCompileRefusal, saveGraph, stateDirName } from "../../graph/graph.js";
 import { formatPriorFindingEvidence, readPriorRunEvidence } from "../../run/journal.js";
 import { shGit } from "../../run/git.js";
 import { acquireRunLock, releaseRunLock } from "../../run/lock.js";
 import { harnessLine, resolveHarness } from "../harness.js";
+export function nativeSourceScopeErrors(graph, findings) {
+    const byId = new Map(graph.tasks.map((task) => [task.id, task]));
+    const errors = [];
+    for (const finding of findings) {
+        const task = byId.get(finding.taskId);
+        if (!task)
+            continue;
+        for (const path of finding.paths) {
+            if (task.goal.includes(`scope-waiver: ${path}`))
+                continue;
+            errors.push(`${task.id}: ${path} requires scope-waiver: ${path} in the task goal`);
+        }
+    }
+    return errors;
+}
 async function mergedPendingDiagnostics(cwd, pending, merges) {
     const head = await shGit("git rev-parse HEAD", cwd);
     const base = head.code === 0 ? head.stdout.trim() : "";
@@ -33,44 +49,85 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
         options: {
             type: { type: "string" },
             "dry-run": { type: "boolean" },
+            strict: { type: "boolean" },
         },
         allowPositionals: true,
     });
     const src = positionals[0];
     if (!src)
-        throw new Error("usage: tickmarkr compile <spec-dir-or-md> [--type speckit|prd|gsd|native] [--dry-run]");
-    // resolve against the target repo, not the process cwd (the CLI test passes a tmp repo)
-    // Both modes reach the same pure compiler; --dry-run only removes the lock/write side effect below.
-    const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd);
-    // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
-    // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
-    // remain the source compiler's answer.
-    const prior = readPriorRunEvidence(cwd, g.tasks);
-    const mergedPending = await mergedPendingDiagnostics(cwd, new Set(g.tasks.filter((task) => task.status === "pending").map((task) => task.id)), prior.merges);
-    const stateDir = stateDirName(cwd);
-    if (!values["dry-run"]) {
-        // HARD-01 / Sol #3: hold the same link(2) run lock as the daemon around saveGraph so compile
-        // cannot swap graph.json under an active run between the daemon's read and act.
-        acquireRunLock(cwd, "compile");
-        try {
-            saveGraph(cwd, g);
+        throw new Error("usage: tickmarkr compile <spec-dir-or-md> [--type speckit|prd|gsd|native] [--dry-run] [--strict]");
+    const sourcePath = isAbsolute(src) ? src : join(cwd, src);
+    let stateWriteStarted = false;
+    try {
+        // Resolve against the target repo, not the process cwd (the CLI test passes a tmp repo).
+        // Both modes reach the same pure compiler; --dry-run removes every state write below.
+        const g = compileSource(sourcePath, values.type, cwd, // repo root: gsd stores context[0] repo-relative so workers resolve it inside their worktree
+        (plan) => plan, { strict: values.strict });
+        const sourceFindings = sourceScopeFindings(g.tasks, cwd);
+        const scopeLints = [
+            ...collateralLints(g.tasks, cwd),
+            ...sourceScopeLints(g.tasks, cwd, sourceFindings),
+        ];
+        const diagnostics = scopeLints.length
+            ? `\nscope lints:\n${scopeLints.map((lint) => `  ! ${lint}`).join("\n")}`
+            : "";
+        const unwaived = g.spec.source === "native" ? nativeSourceScopeErrors(g, sourceFindings) : [];
+        if (unwaived.length > 0) {
+            throw new CompileError(`${src} has unwaived native source-scope authoring errors:\n${unwaived.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
+        }
+        // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
+        // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
+        // remain the source compiler's answer.
+        const prior = readPriorRunEvidence(cwd, g.tasks);
+        const mergedPending = await mergedPendingDiagnostics(cwd, new Set(g.tasks.filter((task) => task.status === "pending").map((task) => task.id)), prior.merges);
+        const stateDir = stateDirName(cwd);
+        if (!values["dry-run"]) {
+            // HARD-01 / Sol #3: hold the same link(2) run lock as the daemon around both truth records so
+            // compile cannot swap graph.json under an active run between the daemon's read and act.
+            stateWriteStarted = true;
+            acquireRunLock(cwd, "compile");
+            try {
+                saveGraph(cwd, g);
+                clearCompileRefusal(cwd);
+            }
+            finally {
+                releaseRunLock(cwd);
+            }
         }
-        finally {
-            releaseRunLock(cwd);
+        const summary = values["dry-run"]
+            ? `validated ${src} (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)}) — dry run; no graph written`
+            : `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
+        const priorFindings = prior.findings.length
+            ? `\nprior-run evidence:\n${prior.findings.map((finding) => `  ${formatPriorFindingEvidence(finding)}`).join("\n")}`
+            : "";
+        const mergeHistory = mergedPending.length
+            ? `\nmerge history:\n${mergedPending.map((line) => `  ${line}`).join("\n")}`
+            : "";
+        return `${harnessLine(resolveHarness(harnessFrom))}\n${summary}${diagnostics}${priorFindings}${mergeHistory}`;
+    }
+    catch (error) {
+        // A dry run is a pure validation query. A real authoring refusal records the negative result
+        // without replacing the last good graph; run treats this sibling as newer truth than that graph.
+        // State-write failures are excluded: a live daemon's lock refusal is not a verdict on the spec.
+        if (!values["dry-run"] && !stateWriteStarted) {
+            try {
+                acquireRunLock(cwd, "compile-refusal");
+                try {
+                    saveCompileRefusal(cwd, {
+                        refusedAt: new Date().toISOString(),
+                        source: sourcePath,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                finally {
+                    releaseRunLock(cwd);
+                }
+            }
+            catch {
+                // The refusal record is best-effort when a live run owns the state boundary. That lock
+                // verdict must never replace the compile error that tells the operator what to repair.
+            }
         }
+        throw error;
     }
-    const summary = values["dry-run"]
-        ? `validated ${src} (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)}) — dry run; no graph written`
-        : `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
-    const scopeLints = [...collateralLints(g.tasks, cwd), ...sourceScopeLints(g.tasks, cwd)];
-    const diagnostics = scopeLints.length
-        ? `\nscope lints:\n${scopeLints.map((lint) => `  ! ${lint}`).join("\n")}`
-        : "";
-    const priorFindings = prior.findings.length
-        ? `\nprior-run evidence:\n${prior.findings.map((finding) => `  ${formatPriorFindingEvidence(finding)}`).join("\n")}`
-        : "";
-    const mergeHistory = mergedPending.length
-        ? `\nmerge history:\n${mergedPending.map((line) => `  ${line}`).join("\n")}`
-        : "";
-    return `${harnessLine(resolveHarness(harnessFrom))}\n${summary}${diagnostics}${priorFindings}${mergeHistory}`;
 }

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

@@ -1,7 +1,7 @@
 import { type ClaudeAlias } from "../../adapters/claude-code.js";
 import type { WorkerAdapter } from "../../adapters/types.js";
 import { type KimiDoctorTurnResult } from "../../adapters/kimi.js";
-import { type CatalogReadResult } from "../../adapters/catalog-remote.js";
+import { type CatalogFetcher, type CatalogReadResult } from "../../adapters/catalog-remote.js";
 import { type ShResult } from "../../run/git.js";
 import { type VitestListResult } from "../../gates/acceptance.js";
 /** Where a newer `table_<date>.csv` is discovered — the deployed site builds filenames by
@@ -14,6 +14,7 @@ export type DoctorOpts = {
     resolveClaudeAliasIdentity?: (cwd: string, alias: ClaudeAlias) => string | undefined;
     catalog?: CatalogReadResult;
     catalogNow?: () => Date;
+    catalogFetcher?: CatalogFetcher;
     /** init's between-acts surface: status rows only — the model matrix and inline drift stay
      *  behind `tickmarkr doctor` (files are still written; only the RETURNED string shrinks). */
     compact?: boolean;
@@ -91,8 +92,8 @@ export declare function selfShadowFinding(ownVersion: string, cwd?: string, reso
  * §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.
+ * ponytail: the listing itself is never fetched; the operator (or RELEASING.md's release-time
+ * check) reads it and bumps the constant.
  */
 export declare function liveBenchStalenessFinding(now: Date): string | undefined;
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;

package/dist/cli/commands/doctor.js

@@ -15,13 +15,14 @@ import { HerdrDriver } from "../../drivers/herdr.js";
 import { ORCA_FIXTURE_VERSION, parseEnvelope, resolveOrcaCliBinary } from "../../drivers/orca.js";
 import { kimi, probeKimiDoctorTurn } from "../../adapters/kimi.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
-import { LIVEBENCH_TABLE_DATE, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
+import { CATALOG_REFRESH_TIMEOUT_MS, LIVEBENCH_TABLE_DATE, formatCatalogRefreshLegs, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
 import { sh } from "../../run/git.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.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 initialFetch = globalThis.fetch;
 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)}`;
@@ -336,8 +337,8 @@ export function selfShadowFinding(ownVersion, cwd = process.cwd(), resolve = res
  * §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.
+ * ponytail: the listing itself is never fetched; the operator (or RELEASING.md's release-time
+ * check) reads it and bumps the constant.
  */
 export function liveBenchStalenessFinding(now) {
     const pinnedMs = Date.parse(`${LIVEBENCH_TABLE_DATE.replace(/_/g, "-")}T00:00:00Z`);
@@ -348,17 +349,32 @@ export function liveBenchStalenessFinding(now) {
 }
 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 });
+        const refreshed = await refreshCatalogCommand({ repoRoot: cwd, fetcher: opts.catalogFetcher, now: opts.catalogNow });
         return refreshed.updated
-            ? `tickmarkr doctor --refresh-catalog: model catalog refreshed${refreshed.warning ? `; ${refreshed.warning}` : ""}`
-            : `tickmarkr doctor --refresh-catalog: catalog refresh unavailable — ${refreshed.warning ?? "unknown failure"}; retained ${refreshed.catalog.source} catalog`;
+            ? `tickmarkr doctor --refresh-catalog: model catalog refreshed — ${formatCatalogRefreshLegs(refreshed.legs)}${refreshed.warning ? `; ${refreshed.warning}` : ""}`
+            : `tickmarkr doctor --refresh-catalog: catalog refresh unavailable — ${formatCatalogRefreshLegs(refreshed.legs)}${refreshed.warning ? `; ${refreshed.warning}` : ""}`;
     }
     // Operator directive 2026-08-12 (declutter): long per-model lists render only when asked for.
     const listAllModels = _argv.includes("--models");
     const cfg = loadConfig(cwd);
-    // T17: synchronous/cache-only by operator ruling. The only network-bearing catalog function is the
-    // separately invoked refreshCatalogCommand; ordinary doctor never calls it.
-    const catalog = opts.catalog ?? readCachedCatalog(cwd, { now: opts.catalogNow });
+    let catalog = opts.catalog ?? readCachedCatalog(cwd, { now: opts.catalogNow });
+    let catalogRefreshLine;
+    // RULING-222-17 reverses cache-only for these two operator-facing commands only. The refresh
+    // remains age-guarded; compile, plan, and run never import this path.
+    const catalogRefreshAllowed = process.env.VITEST !== "true"
+        || opts.catalogFetcher !== undefined
+        || opts.catalogNow !== undefined
+        || globalThis.fetch !== initialFetch;
+    if (!opts.catalog && catalog.stale && catalogRefreshAllowed) {
+        const refreshed = await refreshCatalogCommand({
+            repoRoot: cwd,
+            fetcher: opts.catalogFetcher,
+            timeoutMs: CATALOG_REFRESH_TIMEOUT_MS,
+            now: opts.catalogNow,
+        });
+        catalog = refreshed.catalog;
+        catalogRefreshLine = formatCatalogRefreshLegs(refreshed.legs);
+    }
     // banner at START — the logo greets the operator before the ~60s probe wait, never trailing it (operator report 2026-07-17)
     if (opts.banner !== false && visual())
         process.stdout.write(BANNER);
@@ -455,6 +471,9 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     if (catalog.warning) {
         rows.push(attentionRow(`model catalog cache unreadable — ${catalog.warning}; using vendored fallback (advisory — routing unchanged)`));
     }
+    if (catalogRefreshLine) {
+        rows.push(attentionRow(`model catalog auto-refresh — ${catalogRefreshLine}`));
+    }
     // v1.48 T1 / v1.86 T12: advisory sweep for known agent CLIs with no drive contract. Presence is
     // resolved through the worker's login shell; advisory targets are never executed or written to health.
     rows.push(...detectCandidateClis({ cwd }).map(({ binary, path }) => alignedStatusRow("warn", binary, `detected at ${path} (no drive contract — not routable)`)));

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

@@ -1,3 +1,4 @@
+import { type CatalogFetcher, type CatalogReadResult } from "../../adapters/catalog-remote.js";
 import type { WorkerAdapter } from "../../adapters/types.js";
 import type { FleetEditorResult } from "../../tui/ink/fleet-app.js";
 type FleetEditorProps = Parameters<typeof import("../../tui/ink/fleet-app.js").runFleetInkEditor>[0];
@@ -16,6 +17,8 @@ export type FleetIO = {
     output?: FleetOutput;
     debug?: boolean;
     reloadGuard?: (bytes: string) => string | null;
+    catalogFetcher?: CatalogFetcher;
+    catalogNow?: () => Date;
 };
 export type FleetWriteHooks = {
     readPrior?: (path: string) => string;
@@ -36,6 +39,7 @@ export declare function fleet(argv: string[], cwd?: string, adapters?: WorkerAda
 export declare function assembleFleetEditor(cwd: string, adapters: WorkerAdapter[], io: FleetIO, opts: {
     globalDir: string;
     entry?: "presets" | "probe";
+    catalog?: CatalogReadResult;
 }): Promise<{
     props: FleetEditorProps;
     commit: (result: FleetEditorResult) => string;

package/dist/cli/commands/fleet.js

@@ -3,7 +3,7 @@ import { dirname } from "node:path";
 import { parseArgs } from "node:util";
 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 { CATALOG_REFRESH_TIMEOUT_MS, formatCatalogRefreshLegs, readCachedCatalog, refreshCatalogCommand } 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";
@@ -14,6 +14,7 @@ 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 initialFetch = globalThis.fetch;
 const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
 const QUIT = "fleet: quit without writing";
 // v1.60 T3: every preview surface ranks with the SAME exploration setting as the candidate picker
@@ -96,6 +97,24 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     const input = io.input ?? process.stdin;
     const output = io.output ?? process.stdout;
     const interactive = input.isTTY === true && output.isTTY === true;
+    let catalog = readCachedCatalog(cwd, { now: io.catalogNow });
+    let refreshReason = "";
+    let catalogRefreshAttempted = false;
+    const catalogRefreshAllowed = process.env.VITEST !== "true"
+        || io.catalogFetcher !== undefined
+        || io.catalogNow !== undefined
+        || globalThis.fetch !== initialFetch;
+    if (catalog.stale && catalogRefreshAllowed) {
+        const refreshed = await refreshCatalogCommand({
+            repoRoot: cwd,
+            fetcher: io.catalogFetcher,
+            timeoutMs: CATALOG_REFRESH_TIMEOUT_MS,
+            now: io.catalogNow,
+        });
+        catalogRefreshAttempted = true;
+        catalog = refreshed.catalog;
+        refreshReason = `fleet: catalog auto-refresh — ${formatCatalogRefreshLegs(refreshed.legs)}`;
+    }
     if (print) {
         // v1.51 T4: the print surface names the mode and its source layer right under the header —
         // comment-prefixed so the YAML body stays machine-parseable and regex-stable.
@@ -104,10 +123,10 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const nl = body.indexOf("\n");
         // Steering comes from the same resolved config snapshot the editor consumes below,
         // not from another parse of either raw overlay.
-        return `${body.slice(0, nl)}\n# mode: ${rm.mode.mode} (${rm.source})${body.slice(nl)}${formatFleetSteering(rm.cfg)}`;
+        return `${body.slice(0, nl)}\n# mode: ${rm.mode.mode} (${rm.source})${refreshReason ? `\n# ${refreshReason}` : ""}${body.slice(nl)}${formatFleetSteering(rm.cfg)}`;
     }
     if (!why && !interactive)
-        return { out: NON_TTY_MSG, code: 1 };
+        return { out: `${refreshReason ? `${refreshReason}\n` : ""}${NON_TTY_MSG}`, code: 1 };
     // 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
@@ -116,14 +135,14 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     if (!why && interactive) {
         const { reuse } = initDoctorReuse(cwd, values.fresh ?? false);
         if (!reuse) {
-            output.write(`${await doctor([], cwd, adapters, { banner: false, compact: true })}\n`);
+            output.write(`${await doctor([], cwd, adapters, { banner: false, compact: true, ...(catalogRefreshAttempted ? { catalog } : {}), catalogFetcher: io.catalogFetcher, catalogNow: io.catalogNow })}\n`);
         }
     }
-    const assembled = await assembleFleetEditor(cwd, adapters, io, { globalDir });
+    const assembled = await assembleFleetEditor(cwd, adapters, io, { globalDir, catalog });
     if ("unavailable" in assembled)
-        return { out: assembled.unavailable, code: 1 };
+        return { out: `${refreshReason ? `${refreshReason}\n` : ""}${assembled.unavailable}`, code: 1 };
     if (why)
-        return assembled.renderWhy();
+        return `${refreshReason ? `${refreshReason}\n` : ""}${assembled.renderWhy()}`;
     // Keep Ink out of print, non-TTY, and missing-probe paths: the component runtime belongs
     // exclusively to the interactive editor. The capture window brackets only the dynamic Ink
     // import — keys typed while the module loads land in props.initialInput, never get dropped.
@@ -155,7 +174,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     }
     assembled.props.initialInput = initialInput;
     const result = await runFleetInkEditor(assembled.props);
-    return assembled.commit(result);
+    return `${refreshReason ? `${refreshReason}\n` : ""}${assembled.commit(result)}`;
 }
 /** Everything between the doctor-reuse gate and the Ink render, packaged for reuse: `tickmarkr init`
  * runs the same editor (entry="presets": Esc is HOME to the preset overlay, never a bare quit)
@@ -192,7 +211,7 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     // 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);
+    const catalog = opts.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;
@@ -203,9 +222,32 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         : 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)
+    const detectedRows = fleetUnclassifiedModels(cfg, health, adapters)
         .map((row) => ({ ...row, resolvedModel: resolvedCatalogModel(row.adapter, row.model) }));
-    const catalogRanking = catalogTierRanking(cfg, catalog, unclassifiedRows, resolvedCatalogModel);
+    const catalogRanking = catalogTierRanking(cfg, catalog, detectedRows, resolvedCatalogModel);
+    const foldedRows = [];
+    const folds = new Map();
+    for (const row of detectedRows) {
+        const advisory = catalogModelAdvisory(cfg, catalog, row.adapter, row.model, row.resolvedModel, catalogRanking);
+        const evidence = advisory.coverage === "covered" ? advisory.evidence : undefined;
+        const score = evidence?.agenticCodingScore ?? evidence?.intelligenceIndex ?? evidence?.codingScore;
+        const next = { ...row, advisory, ...(score !== undefined ? { score } : {}) };
+        const foldKey = evidence ? `${row.adapter}:${evidence.catalogId}` : undefined;
+        const first = foldKey ? folds.get(foldKey) : undefined;
+        if (first) {
+            first.foldedModels ??= [first.model];
+            first.foldedModels.push(row.model);
+        }
+        else {
+            foldedRows.push(next);
+            if (foldKey)
+                folds.set(foldKey, next);
+        }
+    }
+    const unclassifiedRows = foldedRows.sort((a, b) => Number(!!b.advisory.suggestion) - Number(!!a.advisory.suggestion)
+        || (b.detectedAt ?? "").localeCompare(a.detectedAt ?? "")
+        || (b.score ?? Number.NEGATIVE_INFINITY) - (a.score ?? Number.NEGATIVE_INFINITY)
+        || a.model.localeCompare(b.model));
     // 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) => {
@@ -239,14 +281,17 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
                 ...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);
+                    const evidence = rowEvidence(adapter.id, row.classifyModel ?? row.model, row.advisory.coverage === "covered" ? row.advisory.evidence : undefined);
                     return {
                         model: row.model,
                         detectedAt: row.detectedAt,
+                        ...(row.classifyModel ? { classifyModel: row.classifyModel } : {}),
+                        ...(row.variants ? { variants: row.variants } : {}),
+                        ...(row.foldedModels ? { foldedModels: row.foldedModels } : {}),
+                        ...(row.score !== undefined ? { score: row.score } : {}),
                         ...(evidence ? { evidence } : {}),
-                        ...(advisory.suggestion
-                            ? { suggestion: { tier: advisory.suggestion.tier, note: advisory.suggestion.provenanceNote } }
+                        ...(row.advisory.suggestion
+                            ? { suggestion: { tier: row.advisory.suggestion.tier, note: row.advisory.suggestion.provenanceNote } }
                             : {}),
                     };
                 }),