orcacompass 0.0.0-stage → 0.1.0

package/dist/placements/agents/cursor.js

@@ -0,0 +1,102 @@
+import { join } from 'node:path';
+import { EFFORT_LADDER, parseEffort } from '../../routing/effort.js';
+import { listModels, savedNote } from './list-cache.js';
+const EFFORT_SUFFIX = /-(none|minimal|low|medium|high|xhigh|extra-high|max)$/;
+const THINKING = /-thinking(?=-|$)/g;
+// Older Cursor Claude ids put the version first: claude-4.6-sonnet is Anthropic's claude-sonnet-4-6.
+const OLD_CLAUDE = /^claude-(\d+(?:\.\d+)?)-(sonnet|opus|haiku)$/;
+/** Cursor bakes effort, speed and thinking into the id: claude-opus-5-thinking-high-fast. */
+export function normalizeCursorId(id) {
+    let base = id;
+    const fast = base.endsWith('-fast');
+    if (fast)
+        base = base.slice(0, -'-fast'.length);
+    const thinking = base.search(THINKING) >= 0;
+    base = base.replace(THINKING, '');
+    const m = EFFORT_SUFFIX.exec(base);
+    const effort = m ? parseEffort(m[1]) : undefined;
+    if (m)
+        base = base.slice(0, m.index);
+    if (base.startsWith('cursor-'))
+        base = base.slice('cursor-'.length);
+    const old = OLD_CLAUDE.exec(base);
+    if (old)
+        base = `claude-${old[2]}-${old[1].replace('.', '-')}`;
+    return { base, ...(effort ? { effort } : {}), fast, thinking };
+}
+function parseList(text) {
+    const variants = [];
+    for (const line of text.split(/\r?\n/)) {
+        const m = /^(\S+) - (.+)$/.exec(line.trim());
+        if (m)
+            variants.push({ id: m[1], label: m[2] });
+    }
+    return variants;
+}
+// Fast variants burn more usage; thinking matches what --effort means on the claude/codex routes.
+const better = (a, b) => a.fast !== b.fast ? !a.fast : a.thinking !== b.thinking ? a.thinking : false;
+function toLaunchModels(variants, deps) {
+    const groups = new Map();
+    for (const v of variants) {
+        const g = groups.get(v.base) ?? { byEffort: new Map(), cursorTrained: false };
+        groups.set(v.base, g);
+        if (v.id.startsWith('cursor-'))
+            g.cursorTrained = true;
+        if (v.effort) {
+            const cur = g.byEffort.get(v.effort);
+            if (!cur || better(v, cur))
+                g.byEffort.set(v.effort, v);
+        }
+        else if (!g.fallback || better(v, g.fallback)) {
+            g.fallback = v;
+        }
+    }
+    return [...groups].map(([base, g]) => {
+        // The unsuffixed id is Cursor's default, i.e. medium effort.
+        if (g.fallback && g.byEffort.size > 0 && !g.byEffort.has('medium'))
+            g.byEffort.set('medium', g.fallback);
+        // Drop fast-only levels so a request snaps to a non-fast id instead of silently picking one.
+        if ([...g.byEffort.values()].some((v) => !v.fast)) {
+            for (const [e, v] of g.byEffort)
+                if (v.fast)
+                    g.byEffort.delete(e);
+        }
+        const efforts = EFFORT_LADDER.filter((e) => g.byEffort.has(e));
+        const chosen = [...g.byEffort.values(), ...(g.fallback ? [g.fallback] : [])];
+        const meta = deps.index[base];
+        const own = g.cursorTrained || base.startsWith('composer') || base === 'auto';
+        const bucket = own ? 'bucket:Cursor Models' : 'bucket:Other Models';
+        return {
+            agent: 'cursor',
+            modelId: base,
+            ...(meta ? { meta } : {}),
+            efforts,
+            effortSource: 'provider',
+            launch: {
+                kind: 'variant',
+                ids: Object.fromEntries(efforts.map((e) => [e, g.byEffort.get(e).id])),
+                ...(g.fallback ? { defaultId: g.fallback.id } : {}),
+            },
+            // Heuristic: Orca only reports the two Cursor buckets, not which models draw on which.
+            poolNames: ['monthly', bucket],
+            ...(chosen.every((v) => v.fast) ? { fast: true } : {}),
+            ...(chosen.some((v) => v.label.includes('NO ZDR')) ? { noZdr: true } : {}),
+        };
+    });
+}
+export function locateCursor(deps) {
+    const extra = deps.env.LOCALAPPDATA ? [join(deps.env.LOCALAPPDATA, 'cursor-agent')] : [];
+    return deps.find('cursor-agent', extra);
+}
+export async function discoverCursor(deps) {
+    const exe = locateCursor(deps);
+    if (!exe)
+        return { agent: 'cursor', installed: false, models: [], note: 'cursor-agent not found' };
+    const listing = await listModels(deps, exe, ['models'], 'cursor', parseList);
+    if (!listing.items) {
+        const note = listing.signedOut ? `not signed in: ${listing.error}` : `cursor-agent models failed: ${listing.error}`;
+        return { agent: 'cursor', installed: true, models: [], note, ...(listing.signedOut ? { signedOut: true } : {}) };
+    }
+    const note = savedNote('cursor-agent models', listing, deps.now);
+    return { agent: 'cursor', installed: true, models: toLaunchModels(listing.items.map((m) => ({ id: m.id, label: m.label ?? '', ...normalizeCursorId(m.id) })), deps), ...(note ? { note } : {}) };
+}

package/dist/placements/agents/deps.js

@@ -0,0 +1,19 @@
+import { readdirSync, readFileSync } from 'node:fs';
+/** Reads a UTF-8 file, or undefined when it is missing or unreadable. */
+export function readTextFile(p) {
+    try {
+        return readFileSync(p, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Names in a directory, or none when it is missing or unreadable. */
+export function listDirectory(p) {
+    try {
+        return readdirSync(p);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/placements/agents/grok.js

@@ -0,0 +1,92 @@
+import { join } from 'node:path';
+import { homeDir } from '../../paths.js';
+import { EFFORT_LADDER, parseEffort } from '../../routing/effort.js';
+import { listModels, savedNote } from './list-cache.js';
+// Orca's effort choices for grok (it passes them on as --reasoning-effort).
+const EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+// Orca's grok catalog seed caps these models; other ids get the full menu, as in Orca.
+const CEILINGS = { 'grok-4.7': 'xhigh', 'grok-4.6': 'xhigh', 'grok-4.5': 'high' };
+/**
+ * grok's own model cache (~/.grok/models_cache.json, written by grok from its account's model endpoint):
+ * `models` keyed by id, each with `info.reasoning_efforts` and the default `info.reasoning_effort`.
+ */
+export function parseGrokCache(text) {
+    let models;
+    try {
+        models = text === undefined ? undefined : JSON.parse(text)?.models;
+    }
+    catch {
+        return [];
+    }
+    if (typeof models !== 'object' || models === null)
+        return [];
+    const out = [];
+    for (const [key, entry] of Object.entries(models)) {
+        const info = entry?.info ?? {};
+        if (info.hidden === true)
+            continue;
+        const id = typeof info.id === 'string' ? info.id : key;
+        // On xAI's multi-agent models effort sets how many agents run, not how long one thinks: never pass it.
+        const multiAgent = /multi-?agent/i.test(id);
+        const levels = multiAgent || info.supports_reasoning_effort === false || !Array.isArray(info.reasoning_efforts) ? [] : info.reasoning_efforts;
+        const supported = new Set(levels.map((l) => parseEffort(String(l?.value ?? l?.id ?? ''))).filter((e) => e !== undefined));
+        const native = typeof info.reasoning_effort === 'string' ? parseEffort(info.reasoning_effort) : undefined;
+        out.push({ id, efforts: EFFORT_LADDER.filter((e) => supported.has(e)), ...(native ? { defaultEffort: native } : {}) });
+    }
+    return out;
+}
+/** `grok models` is text only: bulleted ids (`*` marks the default) under "Available models:", up to a blank line. */
+export function parseGrokModels(text) {
+    const lines = text.split(/\r?\n/);
+    const header = lines.findIndex((l) => l.trim() === 'Available models:');
+    if (header < 0)
+        return [];
+    const ids = [];
+    for (const line of lines.slice(header + 1)) {
+        if (line.trim() === '' && ids.length > 0)
+            break;
+        const m = /^\s*[*-]\s+([^\s(]+)/.exec(line);
+        if (m && !ids.includes(m[1]))
+            ids.push(m[1]);
+    }
+    return ids;
+}
+const effortsOf = (id) => (CEILINGS[id] ? EFFORTS.slice(0, EFFORTS.indexOf(CEILINGS[id]) + 1) : EFFORTS);
+function toLaunchModel(m, source, deps) {
+    return {
+        agent: 'grok',
+        modelId: m.id,
+        ...(deps.index[m.id] ? { meta: deps.index[m.id] } : {}),
+        efforts: m.efforts,
+        effortSource: source,
+        ...(m.defaultEffort ? { defaultEffort: m.defaultEffort } : {}),
+        launch: { kind: 'flag', model: m.id },
+        // xAI billing: a weekly credit window or a monthly budget, never a session window.
+        poolNames: ['weekly', 'monthly'],
+    };
+}
+// Orca looks in $GROK_HOME/bin and adds ~/.grok/bin to its PATH; the installer leaves ~/.grok/bin off the
+// PATH of processes started before it ran.
+export function locateGrok(deps) {
+    const dirs = [...(deps.env.GROK_HOME ? [join(deps.env.GROK_HOME, 'bin')] : []), join(homeDir(deps.env), '.grok', 'bin')];
+    return deps.find('grok', dirs);
+}
+export async function discoverGrok(deps) {
+    const grokHome = deps.env.GROK_HOME || join(homeDir(deps.env), '.grok');
+    const exe = locateGrok(deps);
+    if (!exe)
+        return { agent: 'grok', installed: false, models: [], note: 'grok not found' };
+    const cachePath = join(grokHome, 'models_cache.json');
+    const cached = parseGrokCache(deps.readFile(cachePath));
+    if (cached.length > 0) {
+        return { agent: 'grok', installed: true, models: cached.map((m) => toLaunchModel(m, 'provider', deps)), note: `models from ${cachePath}` };
+    }
+    const listing = await listModels(deps, exe, ['models'], 'grok', (text) => parseGrokModels(text).map((id) => ({ id })));
+    if (!listing.items) {
+        const note = listing.signedOut ? `not signed in: ${listing.error}` : `grok models failed: ${listing.error}`;
+        return { agent: 'grok', installed: true, models: [], note, ...(listing.signedOut ? { signedOut: true } : {}) };
+    }
+    const note = savedNote('grok models', listing, deps.now);
+    const models = listing.items.map(({ id }) => toLaunchModel({ id, efforts: effortsOf(id) }, 'orca', deps));
+    return { agent: 'grok', installed: true, models, ...(note ? { note } : {}) };
+}

package/dist/placements/agents/list-cache.js

@@ -0,0 +1,85 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** Output of a listing command that asks the user to sign in, e.g. "Please run grok login". */
+const SIGNED_OUT = /not (logged|signed) in|(log|sign) ?in (is )?required|please (log|sign) ?in|run [\w-]+ login|\blogin\b.*\bfirst\b|unauthori[sz]ed|unauthenticated/i;
+function readSaved(deps, agent) {
+    try {
+        const saved = JSON.parse(deps.readFile(join(deps.cacheDir, `${agent}-models.json`)) ?? 'null');
+        if (!saved || saved.schemaVersion !== 1 || saved.agent !== agent ||
+            !Number.isSafeInteger(saved.fetchedAt) || saved.fetchedAt < 0 ||
+            !Array.isArray(saved.models) || saved.models.length === 0 ||
+            !saved.models.every((m) => {
+                if (!m || typeof m !== 'object')
+                    return false;
+                const entry = m;
+                return typeof entry.id === 'string' && /^\S+$/.test(entry.id) &&
+                    (entry.label === undefined || typeof entry.label === 'string');
+            }))
+            return undefined;
+        return { fetchedAt: saved.fetchedAt, models: saved.models.map((m) => ({
+                id: m.id, ...(m.label !== undefined ? { label: m.label } : {}),
+            })) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function save(deps, agent, models, fetchedAt = deps.now) {
+    const file = join(deps.cacheDir, `${agent}-models.json`);
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        mkdirSync(deps.cacheDir, { recursive: true });
+        writeFileSync(temporary, JSON.stringify({ schemaVersion: 1, agent, fetchedAt, models }, null, 2) + '\n');
+        renameSync(temporary, file);
+    }
+    catch {
+        // The saved copy is only a fallback for a failed listing.
+    }
+    finally {
+        try {
+            unlinkSync(temporary);
+        }
+        catch { /* renamed or unavailable */ }
+    }
+}
+const firstLine = (s) => s?.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+/**
+ * Runs an agent's model-listing command on every call, so the route sees what the provider offers now.
+ * A good listing is saved; when the command fails for any reason but a sign-in prompt, the saved listing
+ * is used instead, with its age. A sign-in prompt is reported as `signedOut` and never falls back.
+ */
+export async function listModels(deps, exe, args, agent, parse, env) {
+    const r = await deps.run(exe, args, { timeoutMs: 30_000, env });
+    const items = r.code === 0 ? parse(r.stdout) : [];
+    if (items.length > 0) {
+        save(deps, agent, items);
+        return { items };
+    }
+    const error = firstLine(r.stderr) ?? r.error ?? firstLine(r.stdout) ?? `exit code ${r.code}`;
+    if (SIGNED_OUT.test(`${r.stdout}\n${r.stderr}`))
+        return { error, signedOut: true };
+    const saved = readSaved(deps, agent);
+    if (saved)
+        return { items: saved.models, savedAt: saved.fetchedAt, error };
+    // Migrate old stdout caches only when needed, retaining the original observation time.
+    const legacy = deps.readFile(join(deps.cacheDir, `${agent}-models.txt`));
+    const header = legacy && /^fetchedAt (\d+)\r?\n/.exec(legacy);
+    if (legacy && header && Number.isSafeInteger(Number(header[1]))) {
+        const models = parse(legacy.slice(header[0].length));
+        if (models.length > 0) {
+            const fetchedAt = Number(header[1]);
+            save(deps, agent, models, fetchedAt);
+            return { items: models, savedAt: fetchedAt, error };
+        }
+    }
+    return { error, signedOut: false };
+}
+/** The discovery note for a listing that fell back to its saved copy, e.g. "agy models failed (timed out); using the list from 3h ago". */
+export function savedNote(command, listing, now) {
+    if (listing.savedAt === undefined)
+        return undefined;
+    const hours = Math.floor((now - listing.savedAt) / 3_600_000);
+    const age = hours >= 48 ? `${Math.floor(hours / 24)}d` : hours >= 1 ? `${hours}h` : `${Math.max(0, Math.floor((now - listing.savedAt) / 60_000))}m`;
+    return `${command} failed (${listing.error}); using the list from ${age} ago`;
+}

package/dist/placements/agents/muse.js

@@ -0,0 +1,7 @@
+/** Orca launches Muse with any --model but has no Muse model list (account-scoped ids), so Muse is detected, never routed. */
+export const locateMuse = (deps) => deps.find('muse');
+export async function discoverMuse(deps) {
+    if (!locateMuse(deps))
+        return { agent: 'muse', installed: false, models: [], note: 'muse not found on PATH' };
+    return { agent: 'muse', installed: true, models: [], note: 'no model list available from Orca; not routed' };
+}

package/dist/placements/agents/opencode.js

@@ -0,0 +1,77 @@
+import { join } from 'node:path';
+import { homeDir } from '../../paths.js';
+import { normalizeModelId } from '../score.js';
+import { listModels, savedNote } from './list-cache.js';
+// Providers that serve models from this machine.
+const LOCAL = new Set(['ollama', 'lmstudio', 'llamacpp', 'llama.cpp', 'localai', 'vllm']);
+/**
+ * `opencode models`: one `provider/model` id per line, for every provider OpenCode can reach (an API key, a
+ * subscription or a local server). OpenRouter's `~vendor/x-latest` ids are moving aliases of models it also
+ * lists by their own id, so they are skipped.
+ */
+export function parseOpencodeModels(text) {
+    const ids = [];
+    for (const line of text.split(/\r?\n/)) {
+        const id = line.trim();
+        if (/^[\w.-]+\/\S+$/.test(id) && !id.includes('/~') && !ids.includes(id))
+            ids.push(id);
+    }
+    return ids;
+}
+/** How a model is paid for: on this machine, free, or per token. */
+export function billingOf(provider, model) {
+    if (LOCAL.has(provider))
+        return { text: `runs on this machine (${provider})`, rank: 0 };
+    if (/[-:]free$/.test(model))
+        return { text: `free model through ${provider}`, rank: 1 };
+    return { text: `pay per use through ${provider}`, rank: 2 };
+}
+/**
+ * OpenCode reaches many providers, so one model can be listed more than once (Zen and OpenRouter): each model
+ * is kept once, from the cheapest way to run it. Effort is not passed: Orca does not support it for OpenCode.
+ */
+export function toOpencodeModels(ids, deps) {
+    const byNorm = new Map();
+    for (const m of Object.values(deps.index))
+        if (!byNorm.has(normalizeModelId(m.id)))
+            byNorm.set(normalizeModelId(m.id), m);
+    const best = new Map();
+    for (const id of ids) {
+        const provider = id.slice(0, id.indexOf('/'));
+        const sub = id.slice(provider.length + 1);
+        const billing = billingOf(provider, sub);
+        // A free copy (glm-5.3-flash-free, cohere/north-mini-code:free) is the same model: rate and keep it as one.
+        const base = sub.replace(/[-:]free$/, '');
+        const meta = deps.index[base] ?? byNorm.get(normalizeModelId(base));
+        const model = {
+            agent: 'opencode',
+            modelId: meta?.id ?? base,
+            ...(meta ? { meta } : {}),
+            efforts: [],
+            effortSource: 'orca',
+            launch: { kind: 'flag', model: id },
+            // No usage window: Orca tracks no OpenCode limits, and these models cost per token or local resources.
+            poolNames: [],
+            billing: billing.text,
+        };
+        const cur = best.get(model.modelId);
+        if (!cur || billing.rank < cur.rank)
+            best.set(model.modelId, { model, rank: billing.rank });
+    }
+    return [...best.values()].map((b) => b.model);
+}
+export function locateOpencode(deps) {
+    return deps.find('opencode', [join(homeDir(deps.env), '.opencode', 'bin')]);
+}
+export async function discoverOpencode(deps) {
+    const exe = locateOpencode(deps);
+    if (!exe)
+        return { agent: 'opencode', installed: false, models: [], note: 'opencode not found' };
+    const listing = await listModels(deps, exe, ['models'], 'opencode', (text) => parseOpencodeModels(text).map((id) => ({ id })));
+    if (!listing.items) {
+        const note = listing.signedOut ? `not signed in: ${listing.error}` : `opencode models failed: ${listing.error}`;
+        return { agent: 'opencode', installed: true, models: [], note, ...(listing.signedOut ? { signedOut: true } : {}) };
+    }
+    const note = savedNote('opencode models', listing, deps.now);
+    return { agent: 'opencode', installed: true, models: toOpencodeModels(listing.items.map((m) => m.id), deps), ...(note ? { note } : {}) };
+}

package/dist/placements/agents/orca-catalog.js

@@ -0,0 +1,34 @@
+import { join } from 'node:path';
+import { homeDir } from '../../paths.js';
+import { orcaUserDataPath } from '../../routing/orca-settings.js';
+export const description = (v) => typeof v === 'string' && v.trim() !== '' ? { description: v.trim() } : {};
+export const parseJson = (text) => {
+    if (text === undefined)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Orca's internal (undocumented) catalog; the agent's last entry is the newest probe. */
+export function fromOrcaCatalog(text, agent) {
+    const entries = parseJson(text)?.entries;
+    if (!Array.isArray(entries))
+        return [];
+    const models = entries.filter((e) => e?.agent === agent).at(-1)?.discovered?.models;
+    if (!Array.isArray(models))
+        return [];
+    return models
+        .filter((m) => typeof m?.id === 'string')
+        .map((m) => ({
+        id: typeof m.resolvedModel === 'string' ? m.resolvedModel : m.id,
+        efforts: (m.efforts ?? []).map((e) => String(e?.value)),
+    }));
+}
+/** The catalog sits in Orca's userData folder; a Windows machine without APPDATA gets the usual location. */
+export function orcaCatalogPath(env) {
+    const home = homeDir(env);
+    return join(orcaUserDataPath(env, process.platform, home) ?? join(home, 'AppData', 'Roaming', 'orca'), 'agent-model-catalog.json');
+}

package/dist/placements/benchmark.js

@@ -0,0 +1,70 @@
+import { compact, normalizeModelId, stripVersion } from './score.js';
+import { TIERS } from '../types.js';
+// Benchmark placement: a model's Artificial Analysis capability relative to the best model measured,
+// nudged by its intelligence per token cost, and cut into tiers at fixed fractions of the top.
+/** BENCHMARK_CUTS[i] separates TIERS[i] from TIERS[i + 1], as a fraction of the top capability. */
+export const BENCHMARK_CUTS = [0.55, 0.78, 0.93];
+/** Placement shift per tenfold difference from the median points per dollar: dear models up, cheap ones down. */
+export const VALUE_WEIGHT = 0.05;
+/** Intelligence and engineering index averaged, or intelligence alone. */
+export const capability = (b) => (b.engineering === undefined ? b.intelligence : (b.intelligence + b.engineering) / 2);
+/** USD per million tokens blended 3:1 input to output, Artificial Analysis's own convention. */
+export function blendedPrice(b) {
+    return b.in !== undefined && b.out !== undefined ? (3 * b.in + b.out) / 4 : undefined;
+}
+/** Capability points per blended dollar: intelligence per token cost. */
+export function pointsPerDollar(b) {
+    const price = blendedPrice(b);
+    return price === undefined ? undefined : capability(b) / price;
+}
+function median(values) {
+    if (values.length === 0)
+        return undefined;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = sorted.length / 2;
+    return sorted.length % 2 ? sorted[Math.floor(mid)] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+export function benchmarkScale(benchmarks) {
+    if (benchmarks.length === 0)
+        return undefined;
+    const values = benchmarks.map(pointsPerDollar).filter((v) => v !== undefined);
+    return { top: Math.max(...benchmarks.map(capability)), medianValue: median(values), benchmarks };
+}
+const EFFORT_SUFFIX = /-(none|minimal|low|medium|high|xhigh|max|non-reasoning|thinking)$/;
+const DATE_SUFFIX = /-\d{8}$/;
+function lookup(id, benchmarks) {
+    return (benchmarks.find((b) => b.slugs.some((s) => normalizeModelId(s) === id)) ??
+        benchmarks.find((b) => b.slugs.some((s) => compact(normalizeModelId(s)) === compact(id))));
+}
+/** The benchmark of a routed model id: the effort variant's slug counts as the model's. */
+export function matchBenchmark(modelId, benchmarks) {
+    const id = normalizeModelId(modelId);
+    const candidates = [id, id.replace(DATE_SUFFIX, ''), id.replace(EFFORT_SUFFIX, ''), stripVersion(id)];
+    for (const c of new Set(candidates)) {
+        const hit = lookup(c, benchmarks);
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+/** capability / top + VALUE_WEIGHT × log10(median value / value); no value term without a price. */
+export function placement(scale, b) {
+    const relative = capability(b) / scale.top;
+    const value = pointsPerDollar(b);
+    if (value === undefined || scale.medianValue === undefined)
+        return relative;
+    return relative + VALUE_WEIGHT * Math.log10(scale.medianValue / value);
+}
+const fixed = (n, digits = 2) => n.toFixed(digits);
+/** The tier a placement lands in, with the numbers behind it in one line. */
+export function benchmarkTier(scale, b) {
+    const p = placement(scale, b);
+    const tier = TIERS[BENCHMARK_CUTS.filter((cut) => cut <= p).length];
+    const indices = b.engineering === undefined ? `${b.intelligence}` : `${b.intelligence}/${b.engineering}`;
+    const value = pointsPerDollar(b);
+    const priced = value === undefined || scale.medianValue === undefined
+        ? 'no price'
+        : `${fixed(value, 1)} points per dollar vs median ${fixed(scale.medianValue, 1)}`;
+    const detail = `benchmarks (Artificial Analysis ${indices} = ${fixed(capability(b) / scale.top)} of top, ${priced} → ${fixed(p)}; cuts ${BENCHMARK_CUTS.map((c) => fixed(c)).join('/')})`;
+    return { tier, placement: p, detail };
+}

package/dist/placements/build.js

@@ -0,0 +1,94 @@
+import { cacheDir } from '../paths.js';
+import { findExecutable, runCommand } from '../system/run.js';
+import { AGENT_IDS } from '../types.js';
+import { VERSION } from '../version.js';
+import { discoverAntigravity, locateAntigravity } from './agents/antigravity.js';
+import { discoverClaude, locateClaude } from './agents/claude.js';
+import { discoverCodex, locateCodex } from './agents/codex.js';
+import { discoverCursor, locateCursor } from './agents/cursor.js';
+import { listDirectory, readTextFile } from './agents/deps.js';
+import { discoverGrok, locateGrok } from './agents/grok.js';
+import { discoverMuse, locateMuse } from './agents/muse.js';
+import { discoverOpencode, locateOpencode } from './agents/opencode.js';
+import { benchmarkScale } from './benchmark.js';
+import { AA_KEY_ENV, loadBenchmarks } from './sources/artificialanalysis.js';
+import { loadRatings } from './sources/modelindex.js';
+import { loadCatalog } from './sources/modelsdev.js';
+import { builtWith, writeTable } from './table.js';
+import { classifyLaunch, scoreScale } from './tiers.js';
+// Part 1 of OrcaCompass: every source at once, every model placed, one table written.
+/** Each agent's executable lookup and discovery; the freshness check and the build use the same lookup. */
+export const AGENTS = {
+    claude: { locate: locateClaude, discover: discoverClaude },
+    codex: { locate: locateCodex, discover: discoverCodex },
+    cursor: { locate: locateCursor, discover: discoverCursor },
+    grok: { locate: locateGrok, discover: discoverGrok },
+    antigravity: { locate: locateAntigravity, discover: discoverAntigravity },
+    opencode: { locate: locateOpencode, discover: discoverOpencode },
+    muse: { locate: locateMuse, discover: discoverMuse },
+};
+/** The agents whose executable is found right now, looked up exactly as discovery does. */
+export const installedAgents = (deps) => AGENT_IDS.filter((a) => AGENTS[a].locate(deps) !== undefined);
+/** The scales the placements draw on, computed once over the whole datasets. */
+export function placementScales(ratings, benchmarks, config) {
+    const score = scoreScale(ratings, config.scoreWeight);
+    const benchmark = benchmarks && benchmarkScale(benchmarks);
+    return { ...(score ? { score } : {}), ...(benchmark ? { benchmark } : {}) };
+}
+/** Pure: every discovered model with its placements, in the input order. */
+export function placeModels(discoveries, config, scales) {
+    return discoveries.map((d) => ({
+        agent: d.agent,
+        installed: d.installed,
+        models: d.models.map((model) => {
+            const placements = classifyLaunch(model, config, scales);
+            return { ...model, placements, tiers: placements.map((p) => p.tier) };
+        }),
+        ...(d.note !== undefined ? { note: d.note } : {}),
+        ...(d.signedOut !== undefined ? { signedOut: d.signedOut } : {}),
+    }));
+}
+/** Loads the three sources, discovers every agent, places every model and writes the table. */
+export async function buildPlacements(config, deps = {}) {
+    const now = deps.now ?? Date.now();
+    const env = deps.env ?? process.env;
+    const opts = { ttlHours: config.modelsDevTtlHours, now, fetchImpl: deps.fetchImpl, refresh: deps.refresh };
+    const catalogP = loadCatalog(opts);
+    // Scores only add tiers for models outside the family table, so a failure must not stop the build.
+    const ratingsP = loadRatings(opts).catch(() => undefined);
+    // Benchmarks need the user's own Artificial Analysis key; without one, the cache from an earlier refresh still serves.
+    const benchmarksP = loadBenchmarks({ ...opts, key: env[AA_KEY_ENV] }).catch(() => undefined);
+    const catalog = await catalogP;
+    const agentDeps = {
+        index: catalog.index,
+        run: deps.run ?? runCommand,
+        find: deps.find ?? findExecutable,
+        readFile: deps.readFile ?? readTextFile,
+        listDir: deps.listDir ?? listDirectory,
+        env,
+        cacheDir: deps.cacheDir ?? cacheDir(),
+        now,
+    };
+    const [discoveries, ratings, benchmarks] = await Promise.all([
+        Promise.all(AGENT_IDS.map((a) => AGENTS[a].discover(agentDeps))),
+        ratingsP,
+        benchmarksP,
+    ]);
+    const scales = placementScales(ratings?.ratings, benchmarks?.benchmarks, config);
+    const table = {
+        schemaVersion: 1,
+        version: deps.version ?? VERSION,
+        builtAt: now,
+        builtWith: builtWith(config),
+        sources: {
+            catalog: { source: catalog.source, fetchedAt: catalog.fetchedAt, models: Object.keys(catalog.index).length },
+            scores: ratings ? { source: ratings.source, fetchedAt: ratings.fetchedAt, models: ratings.ratings.length } : null,
+            benchmarks: benchmarks ? { source: benchmarks.source, fetchedAt: benchmarks.fetchedAt, models: benchmarks.benchmarks.length } : null,
+            benchmarkScale: scales.benchmark ? { top: scales.benchmark.top, medianValue: scales.benchmark.medianValue ?? null } : null,
+            scoreScale: scales.score ? { cuts: scales.score.cuts } : null,
+        },
+        agents: placeModels(discoveries, config, scales),
+    };
+    const saveError = writeTable(table, agentDeps.cacheDir);
+    return { table, ...(saveError !== undefined ? { saveError } : {}) };
+}

package/dist/placements/score.js

@@ -0,0 +1,70 @@
+import { TIERS } from '../types.js';
+/** Lowercase, no provider prefix, dashes only: anthropic/claude-opus-5.5 → claude-opus-5-5. */
+export function normalizeModelId(id) {
+    return id
+        .toLowerCase()
+        .replace(/^[^/]*\//, '')
+        .replace(/[._\s]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export const compact = (id) => id.replace(/-/g, '');
+/** Drops a trailing ".0" version (and a "1.0" after a name): muse-wonder-1-0 → muse-wonder, grok-4-6-0 → grok-4-6. */
+export function stripVersion(id) {
+    const parts = id.split('-');
+    const n = parts.length;
+    while (parts.length > 1 && parts.at(-1) === '0')
+        parts.pop();
+    if (parts.length < n && parts.length > 2 && parts.at(-1) === '1' && !/^\d+$/.test(parts.at(-2)))
+        parts.pop();
+    return parts.join('-');
+}
+function keysOf(r) {
+    const keys = [normalizeModelId(r.id)];
+    if (r.orId) {
+        const or = normalizeModelId(r.orId);
+        keys.push(or, or.replace(/-preview$/, ''));
+    }
+    return keys;
+}
+function lookup(id, ratings) {
+    // Exact keys first (entry id before OpenRouter id), then Cursor's dashless spelling (deepseek-v41-flash).
+    return (ratings.find((r) => normalizeModelId(r.id) === id) ??
+        ratings.find((r) => keysOf(r).includes(id)) ??
+        ratings.find((r) => keysOf(r).some((k) => compact(k) === compact(id))));
+}
+/** The Model Index entry for a routed model id, or undefined. */
+export function matchRating(modelId, ratings) {
+    const id = normalizeModelId(modelId);
+    const hit = lookup(id, ratings);
+    if (hit)
+        return hit;
+    const stripped = stripVersion(id);
+    return stripped !== id ? lookup(stripped, ratings) : undefined;
+}
+const unit = (v, range) => (v - range.min) / (range.max - range.min);
+/** c = w·score + (1 − w)·ln(price), both min-max normalized over the anchors. */
+export function combinedScore(scale, r) {
+    return scale.weight * unit(r.score, scale.score) + (1 - scale.weight) * unit(Math.log(r.out), scale.lnPrice);
+}
+const span = (values) => ({ min: Math.min(...values), max: Math.max(...values) });
+/** Undefined unless every tier has an anchor and anchors differ in score and price. */
+export function buildScale(anchors, weight, ratings) {
+    if (!TIERS.every((t) => anchors.some((a) => a.tier === t)))
+        return undefined;
+    const score = span(anchors.map((a) => a.rating.score));
+    const lnPrice = span(anchors.map((a) => Math.log(a.rating.out)));
+    if (score.max === score.min || lnPrice.max === lnPrice.min)
+        return undefined;
+    const scale = { weight, score, lnPrice, cuts: [], ratings };
+    const cs = (t) => anchors.filter((a) => a.tier === t).map((a) => combinedScore(scale, a.rating));
+    for (let i = 1; i < TIERS.length; i++) {
+        scale.cuts.push((Math.max(...cs(TIERS[i - 1])) + Math.min(...cs(TIERS[i]))) / 2);
+    }
+    return scale;
+}
+/** Tier = number of cuts at or below c, capped at Advanced: a score never makes a model Frontier. */
+export function scoreTier(scale, c) {
+    const above = scale.cuts.filter((cut) => cut <= c).length;
+    return TIERS[Math.min(above, TIERS.indexOf('advanced'))];
+}