tickmarkr 1.90.8 → 1.91.0

package/dist/adapters/catalog-remote.d.ts

@@ -1,5 +1,8 @@
 export declare const MODELS_DEV_CATALOG_URL = "https://models.dev/api.json";
-export declare const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/api/v2/language/models/free";
+export declare const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/api/v2/data/llms/models";
+export declare const LIVEBENCH_TABLE_DATE = "2026_06_25";
+export declare const LIVEBENCH_TABLE_URL = "https://livebench.ai/table_2026_06_25.csv";
+export declare const LIVEBENCH_CATEGORIES_URL = "https://livebench.ai/categories_2026_06_25.json";
 export declare const CATALOG_CACHE_MAX_AGE_MS: number;
 export declare const CATALOG_REFRESH_TIMEOUT_MS = 10000;
 export interface CatalogCache {
@@ -7,6 +10,7 @@ export interface CatalogCache {
     fetchedAt: string;
     modelsDev: unknown;
     artificialAnalysis?: unknown;
+    liveBench?: unknown;
 }
 export interface CatalogReadResult {
     catalog: CatalogCache;
@@ -16,6 +20,7 @@ export interface CatalogReadResult {
 }
 export interface CatalogModelEvidence {
     modelId: string;
+    catalogId: string;
     inputCostPerMtok?: number;
     outputCostPerMtok?: number;
     contextWindow?: number;
@@ -23,11 +28,16 @@ export interface CatalogModelEvidence {
     features: string[];
     intelligenceIndex?: number;
     intelligenceIndexVersion?: string;
+    codingIndex?: number;
+    agenticCodingScore?: number;
+    codingScore?: number;
+    evidenceDate?: string;
 }
 type CatalogResponse = {
     ok: boolean;
     status: number;
     json: () => Promise<unknown>;
+    text: () => Promise<string>;
 };
 export type CatalogFetcher = (input: string | URL | Request, init?: RequestInit) => Promise<CatalogResponse>;
 export interface RefreshCatalogOptions {

package/dist/adapters/catalog-remote.js

@@ -2,7 +2,13 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 export const MODELS_DEV_CATALOG_URL = "https://models.dev/api.json";
-export const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/api/v2/language/models/free";
+export const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/api/v2/data/llms/models";
+// LiveBench ships one dated CSV per question-set release plus the category->task map that defines
+// the aggregates. Fetch the deployed site, NEVER raw.githubusercontent.com: same filename, 15 fewer
+// models on raw. ponytail: hand-bumped constant; doctor lints its age against the release listing.
+export const LIVEBENCH_TABLE_DATE = "2026_06_25";
+export const LIVEBENCH_TABLE_URL = `https://livebench.ai/table_${LIVEBENCH_TABLE_DATE}.csv`;
+export const LIVEBENCH_CATEGORIES_URL = `https://livebench.ai/categories_${LIVEBENCH_TABLE_DATE}.json`;
 export const CATALOG_CACHE_MAX_AGE_MS = 30 * 86_400_000;
 export const CATALOG_REFRESH_TIMEOUT_MS = 10_000;
 const ARTIFICIAL_ANALYSIS_PAGE_SIZE = 100;
@@ -94,28 +100,31 @@ function providerModels(modelsDev, preferred) {
     // no provider at all) used to ZERO the search space and blanket-uncover the whole adapter.
     // Fail open to the full scan instead — advisory evidence with a visible models.dev id beats none.
     const selected = preferred && preferredEntries.length > 0 ? preferredEntries : entries;
-    return selected
-        .map(([, provider]) => record(record(provider)?.models))
-        .filter((models) => models !== undefined);
+    return selected.flatMap(([providerKey, provider]) => {
+        const models = record(record(provider)?.models);
+        return models ? [{ providerKey, models }] : [];
+    });
 }
 function findModelsDevModel(catalog, provider, modelId) {
     // CLI namespaces prefix their catalog ids (kimi-code/k3 vs catalog key k3; omp's openai/gpt-4):
     // after exact key/id misses, retry with the bare segment after the last "/". Deterministic
     // provider order; first hit wins — acceptable for advisory evidence, never routing.
     const bare = modelId.includes("/") ? modelId.slice(modelId.lastIndexOf("/") + 1) : undefined;
-    for (const models of providerModels(catalog.modelsDev, provider)) {
+    for (const { providerKey, models } of providerModels(catalog.modelsDev, provider)) {
         const direct = record(models[modelId]);
         if (direct)
-            return direct;
-        const byId = Object.values(models).map(record).find((candidate) => candidate?.id === modelId);
-        if (byId)
-            return byId;
+            return { providerKey, models, recordId: modelId, model: direct };
+        for (const [recordId, value] of Object.entries(models)) {
+            const candidate = record(value);
+            if (candidate?.id === modelId)
+                return { providerKey, models, recordId, model: candidate };
+        }
     }
     if (bare) {
-        for (const models of providerModels(catalog.modelsDev, provider)) {
+        for (const { providerKey, models } of providerModels(catalog.modelsDev, provider)) {
             const direct = record(models[bare]);
             if (direct)
-                return direct;
+                return { providerKey, models, recordId: bare, model: direct };
         }
     }
     return undefined;
@@ -160,27 +169,129 @@ function artificialAnalysisIndex(value, identities, provider) {
             const n = nonNegative(candidate);
             if (n !== undefined) {
                 const version = root?.intelligence_index_version;
+                const coding = [
+                    evaluations?.artificial_analysis_coding_index,
+                    row.artificial_analysis_coding_index,
+                ].map(nonNegative).find((value) => value !== undefined);
                 return {
                     index: n,
                     ...((typeof version === "string" || typeof version === "number") ? { version: String(version) } : {}),
+                    ...(coding !== undefined ? { codingIndex: coding } : {}),
                 };
             }
         }
     }
     return undefined;
 }
+/**
+ * LiveBench ships the table as CSV and the category->task map as JSON. Every aggregate is derived
+ * from that map, never from a task-column list written here: a category reshuffle upstream must
+ * re-score us, not silently mis-score us.
+ */
+function parseLiveBenchTable(csv) {
+    const lines = csv.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const header = lines.shift()?.split(",").map((cell) => cell.trim());
+    if (header?.[0] !== "model")
+        return [];
+    return lines.flatMap((line) => {
+        const cells = line.split(",").map((cell) => cell.trim());
+        const model = cells[0];
+        if (!model)
+            return [];
+        const row = { model };
+        header.forEach((column, i) => {
+            const score = i > 0 && cells[i] !== "" ? finite(Number(cells[i])) : undefined;
+            if (score !== undefined)
+                row[column] = score;
+        });
+        // A scoreless row (truncated payload, blank cells) carries no evidence — it is not a fleet member.
+        return Object.keys(row).length > 1 ? [row] : [];
+    });
+}
+/**
+ * A probe is usable only if it can actually score the two categories we read: both must be arrays
+ * naming at least one task column the table really scored. Otherwise throw — an unusable probe must
+ * never overwrite the cached section (a truncated table plus `{}` categories is a failed fetch).
+ */
+function assertUsableLiveBench(rows, categories) {
+    const scored = new Set(rows.flatMap((row) => Object.keys(row).filter((key) => key !== "model")));
+    for (const name of ["Agentic Coding", "Coding"]) {
+        const tasks = categories[name];
+        if (!Array.isArray(tasks) || !tasks.some((task) => typeof task === "string" && scored.has(task))) {
+            throw new Error(`LiveBench categories name no scored "${name}" task`);
+        }
+    }
+}
+// LiveBench splits one model across reasoning-effort rows (`-max-effort`, `-xhigh`,
+// `-thinking-auto-medium-effort`); the highest effort is the model at its best. Rank by
+// hyphen-delimited token so `xhigh` never reads as `high`.
+const LIVEBENCH_EFFORT_RANK = { max: 5, xhigh: 4, high: 3, medium: 2, low: 1 };
+const liveBenchEffortRank = (residue) => residue.split("-").reduce((rank, token) => Math.max(rank, LIVEBENCH_EFFORT_RANK[token] ?? 0), 0);
+const liveBenchCategoryMean = (row, tasks) => {
+    const scores = (Array.isArray(tasks) ? tasks : [])
+        .map((task) => (typeof task === "string" ? finite(row[task]) : undefined))
+        .filter((score) => score !== undefined);
+    return scores.length > 0 ? scores.reduce((sum, score) => sum + score, 0) / scores.length : undefined;
+};
+/** LiveBench hyphenates where models.dev spaces: `Kimi K3` is `kimi-k3` in the table. */
+const liveBenchIdentity = (value) => value.trim().toLowerCase().replace(/\s+/g, "-");
+function liveBenchIndex(value, identities) {
+    const root = record(value);
+    if (!root || !Array.isArray(root.rows))
+        return undefined;
+    const wanted = identities.map(liveBenchIdentity).filter(Boolean);
+    let best;
+    for (const raw of root.rows) {
+        const row = record(raw);
+        const model = typeof row?.model === "string" ? liveBenchIdentity(row.model) : undefined;
+        if (!row || !model)
+            continue;
+        // Bare startsWith is a false-positive machine: `glm-5` would claim `glm-5.2`. The residue after
+        // the fleet id must be empty or an effort suffix.
+        const residue = wanted.map((identity) => model.startsWith(identity) ? model.slice(identity.length) : undefined)
+            .find((rest) => rest === "" || rest?.startsWith("-"));
+        if (residue === undefined)
+            continue;
+        const rank = liveBenchEffortRank(residue);
+        if (!best || rank > best.rank)
+            best = { row, rank };
+    }
+    if (!best)
+        return undefined;
+    const categories = record(root.categories);
+    const agenticCodingScore = liveBenchCategoryMean(best.row, categories?.["Agentic Coding"]);
+    const codingScore = liveBenchCategoryMean(best.row, categories?.["Coding"]);
+    return {
+        ...(agenticCodingScore !== undefined ? { agenticCodingScore } : {}),
+        ...(codingScore !== undefined ? { codingScore } : {}),
+        ...(typeof root.tableDate === "string" ? { tableDate: root.tableDate } : {}),
+    };
+}
 /** Resolve the alias identity first; the floating alias is only a fallback when identity is unknown. */
 export function resolveCatalogModel(catalog, query) {
     const modelId = query.resolvedModel ?? query.model;
-    const model = findModelsDevModel(catalog, query.provider, modelId);
-    if (!model)
+    const match = findModelsDevModel(catalog, query.provider, modelId);
+    if (!match)
         return undefined;
+    const { model } = match;
+    const catalogId = `${match.providerKey}/${match.recordId}`;
     const cost = record(model.cost);
     const limit = record(model.limit);
+    // LiveBench spells rows with the vendor-prefixed model name (`k3` is `kimi-k3` there), so
+    // models.dev `name` bridges a fleet id that is only the bare suffix. `family` must NEVER join
+    // this list: it is a LINEAGE label many models share — real models.dev has `glm` on every GLM and
+    // `gpt` on gpt-4o — so through it glm-5 would claim glm-5.2's row and an unbenchmarked gpt-4o
+    // would inherit a gpt-5.6 row's scores and evidenceDate. `name` is per-model; `family` is not.
+    const identities = [
+        modelId,
+        query.model,
+        ...(typeof model.name === "string" ? [model.name] : []),
+    ];
     const intelligence = artificialAnalysisIndex(catalog.artificialAnalysis, [
         modelId,
         ...(typeof model.name === "string" ? [model.name] : []),
     ], query.provider);
+    const liveBench = liveBenchIndex(catalog.liveBench, identities);
     const features = [
         ["reasoning", model.reasoning],
         ["tool-call", model.tool_call],
@@ -190,6 +301,7 @@ export function resolveCatalogModel(catalog, query) {
     ].filter((entry) => entry[1] === true).map((entry) => entry[0]);
     return {
         modelId,
+        catalogId,
         ...(nonNegative(cost?.input) !== undefined ? { inputCostPerMtok: nonNegative(cost?.input) } : {}),
         ...(nonNegative(cost?.output) !== undefined ? { outputCostPerMtok: nonNegative(cost?.output) } : {}),
         ...(positive(limit?.context) !== undefined ? { contextWindow: positive(limit?.context) } : {}),
@@ -198,10 +310,19 @@ export function resolveCatalogModel(catalog, query) {
         ...(intelligence !== undefined ? {
             intelligenceIndex: intelligence.index,
             ...(intelligence.version ? { intelligenceIndexVersion: intelligence.version } : {}),
+            ...(intelligence.codingIndex !== undefined ? { codingIndex: intelligence.codingIndex } : {}),
+        } : {}),
+        ...(liveBench !== undefined ? {
+            ...(liveBench.agenticCodingScore !== undefined ? { agenticCodingScore: liveBench.agenticCodingScore } : {}),
+            ...(liveBench.codingScore !== undefined ? { codingScore: liveBench.codingScore } : {}),
+            ...(liveBench.tableDate !== undefined ? { evidenceDate: liveBench.tableDate } : {}),
         } : {}),
     };
 }
-async function fetchJson(fetcher, url, init, timeoutMs) {
+const catalogSourceLabel = (url) => url.startsWith(MODELS_DEV_CATALOG_URL) ? "models.dev"
+    : url.startsWith(LIVEBENCH_TABLE_URL) || url.startsWith(LIVEBENCH_CATEGORIES_URL) ? "LiveBench"
+        : "Artificial Analysis";
+async function fetchCatalog(fetcher, url, init, timeoutMs, read) {
     const controller = new AbortController();
     let timer;
     const timeout = new Promise((_resolve, reject) => {
@@ -215,8 +336,8 @@ async function fetchJson(fetcher, url, init, timeoutMs) {
         const request = (async () => {
             const response = await fetcher(url, { ...init, signal: controller.signal });
             if (!response.ok)
-                throw new Error(`${url === MODELS_DEV_CATALOG_URL ? "models.dev" : "Artificial Analysis"} HTTP ${response.status}`);
-            return response.json();
+                throw new Error(`${catalogSourceLabel(url)} HTTP ${response.status}`);
+            return read(response);
         })();
         return await Promise.race([request, timeout]);
     }
@@ -245,7 +366,7 @@ async function fetchArtificialAnalysis(fetcher, apiKey, timeoutMs) {
     let intelligenceIndexVersion;
     for (let page = 1; page <= ARTIFICIAL_ANALYSIS_MAX_PAGES; page++) {
         const url = `${ARTIFICIAL_ANALYSIS_CATALOG_URL}?page=${page}&page_size=${ARTIFICIAL_ANALYSIS_PAGE_SIZE}`;
-        const value = await fetchJson(fetcher, url, { headers: { "x-api-key": apiKey } }, timeoutMs);
+        const value = await fetchCatalog(fetcher, url, { headers: { "x-api-key": apiKey } }, timeoutMs, (r) => r.json());
         const root = record(value);
         if (!root || !Array.isArray(root.data))
             throw new Error("Artificial Analysis catalog schema is invalid");
@@ -266,6 +387,19 @@ async function fetchArtificialAnalysis(fetcher, apiKey, timeoutMs) {
     }
     throw new Error(`Artificial Analysis catalog exceeds ${ARTIFICIAL_ANALYSIS_MAX_PAGES} pages`);
 }
+/** Keyless leg: one CSV plus the category map. Both URLs are pinned to the deployed livebench.ai. */
+async function fetchLiveBench(fetcher, timeoutMs) {
+    const csv = await fetchCatalog(fetcher, LIVEBENCH_TABLE_URL, {}, timeoutMs, (r) => r.text());
+    const categories = record(await fetchCatalog(fetcher, LIVEBENCH_CATEGORIES_URL, {}, timeoutMs, (r) => r.json()));
+    if (!categories)
+        throw new Error("LiveBench categories schema is invalid");
+    const rows = parseLiveBenchTable(csv);
+    // Orca import #3, write site: an empty probe is a failed probe, never an empty fleet.
+    if (rows.length === 0)
+        throw new Error("LiveBench table parsed to zero rows");
+    assertUsableLiveBench(rows, categories);
+    return { tableDate: LIVEBENCH_TABLE_DATE, categories, rows };
+}
 /**
  * The named, explicit refresh path. No other function in this module can reach fetch.
  * A failed refresh preserves the previous cache byte-for-byte and returns it fail-open.
@@ -276,21 +410,37 @@ export async function refreshCatalogCommand(opts) {
     try {
         const fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
         const timeoutMs = opts.timeoutMs ?? CATALOG_REFRESH_TIMEOUT_MS;
-        const modelsDev = await fetchJson(fetcher, MODELS_DEV_CATALOG_URL, {}, timeoutMs);
+        const modelsDev = await fetchCatalog(fetcher, MODELS_DEV_CATALOG_URL, {}, timeoutMs, (r) => r.json());
         if (!validModelsDevCatalog(modelsDev))
             throw new Error("models.dev catalog schema is invalid");
         const apiKey = opts.artificialAnalysisKey ?? process.env.ARTIFICIAL_ANALYSIS_API_KEY?.trim();
         const artificialAnalysis = apiKey
             ? await fetchArtificialAnalysis(fetcher, apiKey, timeoutMs)
             : undefined;
+        // The LiveBench leg is keyless and never costs the models.dev refresh: a failure keeps the
+        // previous section verbatim and names the leg in the warning.
+        let liveBench = current.catalog.liveBench;
+        let warning;
+        try {
+            liveBench = await fetchLiveBench(fetcher, timeoutMs);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warning = message.startsWith("LiveBench") ? message : `LiveBench refresh failed: ${message}`;
+        }
         const catalog = {
             schemaVersion: 1,
             fetchedAt: now().toISOString(),
             modelsDev,
             ...(artificialAnalysis !== undefined ? { artificialAnalysis } : {}),
+            ...(liveBench !== undefined ? { liveBench } : {}),
         };
         writeCatalogCache(opts.repoRoot, catalog);
-        return { updated: true, catalog: readCachedCatalog(opts.repoRoot, { now }) };
+        return {
+            updated: true,
+            catalog: readCachedCatalog(opts.repoRoot, { now }),
+            ...(warning !== undefined ? { warning } : {}),
+        };
     }
     catch (error) {
         return {

package/dist/adapters/catalog.js

@@ -147,6 +147,65 @@ export const CLI_CATALOG = [
             listModels: { argv: ["models", "ls", "--json"], parser: "json", path: "models", field: "selector" },
         },
     },
+    {
+        id: "agy",
+        binary: "agy",
+        // PROBE-agy-v190.md, recorded by hand 2026-08-13: `agy --version` → `1.1.12`. A bare semver
+        // banner, so the identity pins the shape, prefix-matched to survive patch bumps.
+        identity: "^\\d+\\.\\d+\\.\\d+",
+        // agy (Antigravity) is a multi-provider gateway: its model list spans google, anthropic and
+        // openai ids, so a selected model carries its real vendor — same posture as omp.
+        vendor: "mixed",
+        drive: {
+            // PROBE-agy-v190.md: three recorded traps shape every byte of this template. (1) `-p`
+            // consumes the NEXT argv as the prompt, so every flag precedes it. (2) tool writes land in
+            // cwd ONLY when cwd is workspace-added by ABSOLUTE path — without `--add-dir "$PWD"` (and
+            // with a relative `.`) the write is silently redirected to ~/.gemini/antigravity-cli/scratch
+            // while the model still claims DONE; dispatch runs through bash -lc, so the literal "$PWD"
+            // expands to the worktree at runtime. (3) --print-timeout defaults to 5m0s, which would kill
+            // any real worker task. --dangerously-skip-permissions: a permission prompt in print mode
+            // has no answerer.
+            headless: `agy --add-dir "$PWD" --dangerously-skip-permissions --print-timeout 240m --model {model} -p "$(cat {promptFile})"`,
+            // No interactive probe is recorded (PROBE-agy-v190.md names the falsifier) — null keeps the
+            // claim honest and the print fallback drives visible panes.
+            interactive: null,
+            trustDialog: {
+                kind: "none",
+                reason: "agy 1.1.12 rendered no workspace-trust prompt across five fresh-temp-repo print-mode probes (PROBE-agy-v190.md, 2026-08-13); interactive is null, so no dialog can reach a pane",
+            },
+            // `agy models` emits `id<TAB>label` rows behind a fetch banner — no parser projects that
+            // shape without admitting label words, so the list surface stays undeclared and doctor
+            // reports "no model-list surface" (claude-code posture).
+        },
+    },
+    {
+        id: "prime-agent",
+        binary: "prime-agent",
+        // PROBE-prime-agent-v190.md, recorded by hand 2026-08-13: `prime-agent --version` → `0.7.1`.
+        // Bare semver banner — shape-pinned, prefix-matched (agy precedent).
+        identity: "^\\d+\\.\\d+\\.\\d+",
+        // Multi-provider gateway (anthropic, google, openai model list) — the joined provider/model
+        // id carries the real vendor, same posture as omp and agy.
+        vendor: "mixed",
+        drive: {
+            // PROBE-prime-agent-v190.md: print mode executes tools unattended in cwd with NO approval
+            // flag needed (hello.txt probe: file in cwd, exit 0, 5.6s) and no trust prompt in fresh
+            // repos. `--model` accepts the joined provider/model form the listModels contract emits
+            // (verified: --model google/gemini-3.6-flash). Prompt rides "$(cat …)" — the `@file`
+            // attach syntax exists but its semantics were not probed, so the contract does not use it.
+            headless: `prime-agent -p --model {model} "$(cat {promptFile})"`,
+            // No interactive probe is recorded (PROBE-prime-agent-v190.md names the falsifier) — null
+            // keeps the claim honest and the print fallback drives visible panes.
+            interactive: null,
+            trustDialog: {
+                kind: "none",
+                reason: "prime-agent 0.7.1 rendered no workspace-trust or tool-approval prompt across three fresh-temp-repo print-mode probes (PROBE-prime-agent-v190.md, 2026-08-13); interactive is null, so no dialog can reach a pane",
+            },
+            // `prime-agent model list` is the pi-table shape: header `provider  model …`, first two
+            // columns join to the id `--model` accepts (live-verified 2026-08-13).
+            listModels: { argv: ["model", "list"], parser: "pi-table" },
+        },
+    },
 ].flatMap((entry) => typeof entry === "string"
     ? [{ id: entry, binary: entry, identity: ".+", vendor: null }]
     : [entry]);

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

@@ -4,19 +4,52 @@ import { type AuthHealth, type WorkerAdapter } from "./types.js";
 import { type CatalogModelEvidence, type CatalogReadResult } from "./catalog-remote.js";
 export declare const SEED_STAMPED = "2026-07-09";
 export declare const MODEL_STALE_DAYS = 30;
+/**
+ * Operator directive 2026-08-13 ("we should exclude all retired models"): the fleet models
+ * screen hides these classes BY DEFAULT — omp alone reports 218 ids, most of them dated
+ * snapshots, previews, and SKUs that can never carry a worker. Shape-based on purpose: a
+ * knowledge list of retired families rots, a suffix grammar does not. Hidden is never gone —
+ * the screen counts what it hid and one key reveals it, and CLASSIFIED models are never hidden
+ * regardless of shape (an operator who tiered a dated snapshot meant it).
+ */
+export declare function retiredModelReason(model: string): "dated snapshot" | "preview" | "non-worker" | "legacy family" | null;
 export declare const ttyVisual: () => boolean;
+/** Bases that band FLEET-RELATIVELY, most-trusted first (2026-08-13 ranking-sites assessment §4.3). */
+declare const RANKED_BASES: readonly ["agentic-coding", "intelligence"];
+type RankedBasis = typeof RANKED_BASES[number];
+export type CatalogSuggestionBasis = RankedBasis | "price";
 export interface CatalogModelAdvisory {
     coverage: "covered" | "uncovered";
     evidence?: CatalogModelEvidence;
     suggestion?: {
         tier: Tier;
         kind: "inference";
-        basis: "intelligence" | "price";
+        basis: CatalogSuggestionBasis;
         provenanceNote: string;
     };
     display: string;
 }
-export declare function catalogModelAdvisory(cfg: TickmarkrConfig, catalog: CatalogReadResult, adapter: string, model: string, resolvedModel?: string): CatalogModelAdvisory;
+/** A (adapter, model) pair under advisory at a call site; it joins that call's ranking universe. */
+export interface CatalogAdvisoryRow {
+    adapter: string;
+    model: string;
+    resolvedModel?: string;
+}
+/** Per-basis descending scores; a basis below MIN_RANKED_MODELS never appears, so it yields. */
+export type CatalogTierRanking = ReadonlyArray<{
+    basis: RankedBasis;
+    scores: number[];
+}>;
+/**
+ * The ranking universe: configured tier models ∪ the rows under advisory at THIS call site,
+ * restricted per basis to those that resolve it. Build it once per call — a band that depended on
+ * which adapter happened to be iterated first would not be a band. `resolvedModel` is the SAME
+ * resolver the call site hands its advisory rows: a configured claude alias (`opus`) is absent from
+ * models.dev under that spelling, so without it the fleet's own frontier models silently drop out
+ * of the universe they are supposed to anchor.
+ */
+export declare function catalogTierRanking(cfg: TickmarkrConfig, catalog: CatalogReadResult, rows?: readonly CatalogAdvisoryRow[], resolvedModel?: (adapter: string, model: string) => string | undefined): CatalogTierRanking;
+export declare function catalogModelAdvisory(cfg: TickmarkrConfig, catalog: CatalogReadResult, adapter: string, model: string, resolvedModel?: string, ranking?: CatalogTierRanking): CatalogModelAdvisory;
 /**
  * Whether the doctor should add its optional window column. Keep non-TTY default output stable for
  * machine consumers; an interactive seed-only matrix shows T14's fleet windows, and any explicit
@@ -55,3 +88,4 @@ export declare function fleetUnclassifiedModels(cfg: TickmarkrConfig, health: Re
     model: string;
     detectedAt?: string;
 }[];
+export {};