orcacompass 0.0.0-stage → 0.1.0

package/dist/config.js

@@ -0,0 +1,272 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { EFFORT_LADDER } from './routing/effort.js';
+import { EFFORT_POLICIES, TIERS } from './types.js';
+import { configPath } from './paths.js';
+export const DEFAULT_CONFIG = {
+    denyAgents: [],
+    pins: {},
+    tierOverrides: {},
+    thresholds: { longPercent: 95, sessionPercent: 90 },
+    defaultEffort: { light: 'low', daily: 'medium', advanced: 'medium', frontier: 'high' },
+    effortPolicy: 'balanced',
+    scoreWeight: 0.4,
+    modelsDevTtlHours: 24,
+    placementsTtlHours: 5,
+    usageStaleMinutes: 30,
+    rejectionTtlHours: 168,
+    excludeNoZdr: false,
+    cursorAuto: true,
+    preferRiskLimit: 100,
+    banModels: [],
+    lastResortAgents: ['opencode'],
+};
+/** Message always starts with the config file path. */
+export class ConfigError extends Error {
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+        this.name = 'ConfigError';
+    }
+}
+/** Missing file → defaults. Otherwise the file is deep-merged over the defaults; unknown keys are ignored. */
+export function loadConfig(path = configPath()) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return structuredClone(DEFAULT_CONFIG);
+        throw new ConfigError(path, `cannot read: ${e.message}`);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (e) {
+        throw new ConfigError(path, `invalid JSON: ${e.message}`);
+    }
+    try {
+        return merge(raw);
+    }
+    catch (e) {
+        if (e instanceof Invalid)
+            throw new ConfigError(path, e.message);
+        throw e;
+    }
+}
+class Invalid extends Error {
+}
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function obj(v, key) {
+    if (!isObj(v))
+        throw new Invalid(`${key} must be an object`);
+    return v;
+}
+function strings(v, key) {
+    if (!Array.isArray(v) || !v.every((s) => typeof s === 'string'))
+        throw new Invalid(`${key} must be an array of strings`);
+    return [...v];
+}
+function num(v, key) {
+    if (typeof v !== 'number' || !Number.isFinite(v) || v < 0)
+        throw new Invalid(`${key} must be a non-negative number`);
+    return v;
+}
+function fraction(v, key) {
+    if (typeof v !== 'number' || !Number.isFinite(v) || v < 0 || v > 1)
+        throw new Invalid(`${key} must be a number from 0 to 1`);
+    return v;
+}
+function tier(v, key) {
+    if (!TIERS.includes(v))
+        throw new Invalid(`${key} must be one of ${TIERS.join(', ')} (got ${JSON.stringify(v)})`);
+    return v;
+}
+function effort(v, key) {
+    if (!EFFORT_LADDER.includes(v)) {
+        throw new Invalid(`${key} must be one of ${EFFORT_LADDER.join(', ')} (got ${JSON.stringify(v)})`);
+    }
+    return v;
+}
+function tierKey(k, key) {
+    return tier(k, `${key} key`);
+}
+function merge(raw) {
+    const r = obj(raw, 'config');
+    const c = structuredClone(DEFAULT_CONFIG);
+    if (r.allowAgents !== undefined)
+        c.allowAgents = strings(r.allowAgents, 'allowAgents');
+    if (r.denyAgents !== undefined)
+        c.denyAgents = strings(r.denyAgents, 'denyAgents');
+    if (r.pins !== undefined) {
+        for (const [k, v] of Object.entries(obj(r.pins, 'pins'))) {
+            const pin = obj(v, `pins.${k}`);
+            if (typeof pin.agent !== 'string' || (pin.model !== undefined && typeof pin.model !== 'string')) {
+                throw new Invalid(`pins.${k} must have a string "agent" and an optional string "model"`);
+            }
+            c.pins[tierKey(k, 'pins')] = { agent: pin.agent, ...(pin.model !== undefined ? { model: pin.model } : {}) };
+        }
+    }
+    if (r.tierOverrides !== undefined) {
+        for (const [k, v] of Object.entries(obj(r.tierOverrides, 'tierOverrides')))
+            c.tierOverrides[k] = tier(v, `tierOverrides.${k}`);
+    }
+    if (r.thresholds !== undefined) {
+        const t = obj(r.thresholds, 'thresholds');
+        for (const k of ['longPercent', 'sessionPercent']) {
+            if (t[k] !== undefined)
+                c.thresholds[k] = num(t[k], `thresholds.${k}`);
+        }
+    }
+    if (r.defaultEffort !== undefined) {
+        for (const [k, v] of Object.entries(obj(r.defaultEffort, 'defaultEffort'))) {
+            c.defaultEffort[tierKey(k, 'defaultEffort')] = effort(v, `defaultEffort.${k}`);
+        }
+    }
+    if (r.effortPolicy !== undefined) {
+        if (!EFFORT_POLICIES.includes(r.effortPolicy))
+            throw new Invalid(`effortPolicy must be one of ${EFFORT_POLICIES.join(', ')}`);
+        c.effortPolicy = r.effortPolicy;
+    }
+    if (r.scoreWeight !== undefined)
+        c.scoreWeight = fraction(r.scoreWeight, 'scoreWeight');
+    if (r.modelsDevTtlHours !== undefined)
+        c.modelsDevTtlHours = num(r.modelsDevTtlHours, 'modelsDevTtlHours');
+    if (r.placementsTtlHours !== undefined)
+        c.placementsTtlHours = num(r.placementsTtlHours, 'placementsTtlHours');
+    if (r.usageStaleMinutes !== undefined)
+        c.usageStaleMinutes = num(r.usageStaleMinutes, 'usageStaleMinutes');
+    if (r.rejectionTtlHours !== undefined)
+        c.rejectionTtlHours = num(r.rejectionTtlHours, 'rejectionTtlHours');
+    if (r.excludeNoZdr !== undefined) {
+        if (typeof r.excludeNoZdr !== 'boolean')
+            throw new Invalid('excludeNoZdr must be a boolean');
+        c.excludeNoZdr = r.excludeNoZdr;
+    }
+    if (r.cursorAuto !== undefined) {
+        if (typeof r.cursorAuto !== 'boolean')
+            throw new Invalid('cursorAuto must be a boolean');
+        c.cursorAuto = r.cursorAuto;
+    }
+    if (r.preferRiskLimit !== undefined)
+        c.preferRiskLimit = num(r.preferRiskLimit, 'preferRiskLimit');
+    if (r.banModels !== undefined)
+        c.banModels = strings(r.banModels, 'banModels');
+    if (r.lastResortAgents !== undefined)
+        c.lastResortAgents = strings(r.lastResortAgents, 'lastResortAgents');
+    return c;
+}
+const unique = (ids) => [...new Set(ids)];
+/** The allow/deny lists after `orcacompass agents <action> <ids>`. */
+export function applyAgentChoice(choice, action, ids) {
+    const deny = choice.denyAgents.filter((a) => !ids.includes(a));
+    switch (action) {
+        case 'disable':
+            return {
+                ...(choice.allowAgents ? { allowAgents: choice.allowAgents.filter((a) => !ids.includes(a)) } : {}),
+                denyAgents: unique([...choice.denyAgents, ...ids]),
+            };
+        case 'enable':
+            return { ...(choice.allowAgents ? { allowAgents: unique([...choice.allowAgents, ...ids]) } : {}), denyAgents: deny };
+        case 'only':
+            return { allowAgents: unique(ids), denyAgents: deny };
+        case 'reset':
+            return { denyAgents: [] };
+    }
+}
+/** Whether the user's choice lets OrcaCompass use the agent. */
+export const isChosen = (agent, choice) => !choice.denyAgents.includes(agent) && (!choice.allowAgents || choice.allowAgents.includes(agent));
+/** Writes allowAgents/denyAgents; an empty denyAgents or an absent allowAgents removes the key. */
+export function writeAgentChoice(choice, path = configPath()) {
+    updateConfigFile((raw) => setAgentChoice(raw, choice), path);
+}
+// Edits of the raw config JSON, shared by the commands and `setup` so both write the same keys the same way.
+export function setAgentChoice(raw, choice) {
+    if (choice.allowAgents)
+        raw.allowAgents = choice.allowAgents;
+    else
+        delete raw.allowAgents;
+    if (choice.denyAgents.length > 0)
+        raw.denyAgents = choice.denyAgents;
+    else
+        delete raw.denyAgents;
+}
+/** Sets the preferred route of one tier, or removes it without a preference; no preferences removes `pins`. */
+export function setPin(raw, tier, pin) {
+    const pins = isObj(raw.pins) ? { ...raw.pins } : {};
+    if (pin)
+        pins[tier] = pin;
+    else
+        delete pins[tier];
+    if (Object.keys(pins).length > 0)
+        raw.pins = pins;
+    else
+        delete raw.pins;
+}
+export function setBans(raw, banModels) {
+    if (banModels.length > 0)
+        raw.banModels = banModels;
+    else
+        delete raw.banModels;
+}
+/** A percent such as "120" or "120%" for `preferRiskLimit`, or undefined when it is not a non-negative number. */
+export function parsePercent(text) {
+    const t = text.trim().replace(/%$/, '');
+    const n = Number(t);
+    return t !== '' && Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+/** The default limit removes the key. */
+export function setPreferRiskLimit(raw, percent) {
+    if (percent === DEFAULT_CONFIG.preferRiskLimit)
+        delete raw.preferRiskLimit;
+    else
+        raw.preferRiskLimit = percent;
+}
+/**
+ * Applies `change` to the config file's JSON, creating the file if needed. Every other key keeps its
+ * value and position, and the file keeps its indentation and line endings. A file that is not a valid
+ * config, or a change that would make it invalid, leaves the file untouched.
+ */
+export function updateConfigFile(change, path = configPath()) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw new ConfigError(path, `cannot read: ${e.message}`);
+    }
+    let raw = {};
+    if (text !== undefined) {
+        try {
+            raw = obj(JSON.parse(text), 'config');
+            merge(raw);
+        }
+        catch (e) {
+            if (e instanceof SyntaxError)
+                throw new ConfigError(path, `invalid JSON: ${e.message}`);
+            if (e instanceof Invalid)
+                throw new ConfigError(path, e.message);
+            throw e;
+        }
+    }
+    change(raw);
+    try {
+        merge(raw);
+    }
+    catch (e) {
+        if (e instanceof Invalid)
+            throw new ConfigError(path, e.message);
+        throw e;
+    }
+    const indent = (text && /^[ \t]+(?=")/m.exec(text)?.[0]) || '  ';
+    const eol = text?.includes('\r\n') ? '\r\n' : '\n';
+    const trailing = text === undefined || /\n$/.test(text) ? eol : '';
+    const out = JSON.stringify(raw, null, indent).replace(/\n/g, eol) + trailing;
+    mkdirSync(dirname(path), { recursive: true });
+    // Replace in one step so a crash never leaves half a config.
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, out);
+    renameSync(tmp, path);
+}

package/dist/install.js

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs';
+import { delimiter, join, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findExecutable, runInteractive } from './system/run.js';
+/** The `skills` installer (vercel-labs/skills) knows each agent's skills folder; the major version is pinned. */
+export const SKILLS_CLI = 'skills@1';
+// A folder URL converts to a path ending in a separator; drop it so the path is a plain argument.
+const PACKAGE_ROOT = fileURLToPath(new URL('..', import.meta.url)).replace(/[\\/]+$/, '');
+// npx runs this package from its cache and puts that cache on PATH, so a copy found there
+// disappears after the run and does not count as installed.
+function findInstalledCli() {
+    const marker = `${sep}_npx${sep}`;
+    const path = (process.env.PATH ?? '').split(delimiter).filter((d) => !d.includes(marker)).join(delimiter);
+    return findExecutable('orcacompass', [], path);
+}
+/**
+ * Installs the Skill through the `skills` installer, pointed at this package's own copy, so the
+ * Skill always matches this CLI version. Then installs the CLI globally if it is not on PATH yet.
+ * Returns the exit code.
+ */
+export async function install(opts, deps = {}) {
+    const interactive = deps.interactive ?? runInteractive;
+    const root = deps.packageRoot ?? PACKAGE_ROOT;
+    const log = deps.log ?? (() => { });
+    const { version } = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+    const skillArgs = ['-y', SKILLS_CLI, 'add', root];
+    if (opts.global)
+        skillArgs.push('--global');
+    if (opts.yes)
+        skillArgs.push('--yes');
+    for (const agent of opts.agents ?? [])
+        skillArgs.push('--agent', agent);
+    log(`Installing the OrcaCompass Skill ${version} with npx ${SKILLS_CLI}...`);
+    const skillCode = await interactive('npx', skillArgs);
+    if (skillCode !== 0) {
+        log(`The Skill was not installed (npx ${SKILLS_CLI} exited with ${skillCode ?? 'no code'}).`);
+        return 1;
+    }
+    if (opts.skillOnly) {
+        log('Skill installed. The CLI was left alone (--skill-only).');
+        return 0;
+    }
+    const existing = (deps.findCli ?? findInstalledCli)();
+    if (existing) {
+        log(`Skill installed. The CLI is already installed: ${existing}`);
+        return 0;
+    }
+    log(`Installing the CLI: npm install -g orcacompass@${version}`);
+    const cliCode = await interactive('npm', ['install', '-g', `orcacompass@${version}`]);
+    if (cliCode !== 0) {
+        log(`The Skill is installed, but the CLI is not (npm exited with ${cliCode ?? 'no code'}). Run: npm install -g orcacompass`);
+        return 1;
+    }
+    log('Skill and CLI installed. Ask your orchestrator to set up OrcaCompass, or run: orcacompass setup');
+    return 0;
+}

package/dist/paths.js

@@ -0,0 +1,30 @@
+import { homedir, userInfo } from 'node:os';
+import { join } from 'node:path';
+// An empty location variable counts as unset throughout: joining onto "" gives a path relative to the
+// working directory, so the config would change with the folder a command runs in.
+/**
+ * The user's home folder, where agents keep their files. On Windows they follow USERPROFILE, not a HOME
+ * set by Git Bash or other tools. os.homedir() returns an empty HOME as is, hence the account's own record.
+ */
+export function homeDir(env = process.env, platform = process.platform) {
+    return (platform === 'win32' ? env.USERPROFILE || env.HOME : env.HOME) || homedir() || userInfo().homedir;
+}
+// ORCACOMPASS_HOME holds both config and cache when set (used by tests).
+export function configPath() {
+    const home = process.env.ORCACOMPASS_HOME;
+    if (home)
+        return join(home, 'config.json');
+    if (process.platform === 'win32') {
+        return join(process.env.APPDATA || join(homeDir(), 'AppData', 'Roaming'), 'orcacompass', 'config.json');
+    }
+    return join(process.env.XDG_CONFIG_HOME || join(homeDir(), '.config'), 'orcacompass', 'config.json');
+}
+export function cacheDir() {
+    const home = process.env.ORCACOMPASS_HOME;
+    if (home)
+        return join(home, 'cache');
+    if (process.platform === 'win32') {
+        return join(process.env.LOCALAPPDATA || join(homeDir(), 'AppData', 'Local'), 'orcacompass', 'cache');
+    }
+    return join(process.env.XDG_CACHE_HOME || join(homeDir(), '.cache'), 'orcacompass');
+}

package/dist/placements/agents/antigravity.js

@@ -0,0 +1,87 @@
+import { join } from 'node:path';
+import { homeDir } from '../../paths.js';
+import { EFFORT_LADDER } from '../../routing/effort.js';
+import { listModels, savedNote } from './list-cache.js';
+// Orca's effort choices for every Antigravity model (it passes them on as agy --effort).
+const EFFORTS = ['low', 'medium', 'high'];
+const EFFORT_SUFFIX = /-(low|medium|high)$/;
+// agy bills each quota group separately (Orca's bucket groups); these are the labels agy 1.4 reports.
+const GEMINI_GROUP = 'Gemini Models';
+const OTHER_GROUP = 'Claude and GPT models';
+/** A group's own pools, then Orca's overall windows, which it reports only when there are no groups. */
+const poolsOf = (id) => {
+    const group = id.startsWith('gemini') ? GEMINI_GROUP : OTHER_GROUP;
+    return [`bucket:${group} 5h`, `bucket:${group}`, 'session', 'weekly'];
+};
+/** `agy models` prints `id<TAB>label` rows; older agy versions print display names only, which are not launch ids. */
+export function parseAgyModels(text) {
+    const ids = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        const tab = line.indexOf('\t');
+        if (tab < 0)
+            continue;
+        const id = line.slice(0, tab).trim();
+        if (!id || /\s/.test(id) || /^(id|model)$/i.test(id) || !line.slice(tab + 1).trim() || ids.includes(id))
+            continue;
+        ids.push(id);
+    }
+    return ids;
+}
+/** agy bakes effort into Gemini ids (gemini-3.8-flash-high); other ids take Orca's --effort. */
+function toLaunchModels(ids, deps) {
+    const groups = new Map();
+    for (const id of ids) {
+        const m = EFFORT_SUFFIX.exec(id);
+        const base = m ? id.slice(0, m.index) : id;
+        const g = groups.get(base) ?? { ids: {} };
+        groups.set(base, g);
+        if (m)
+            g.ids[m[1]] = id;
+        else
+            g.plain = id;
+    }
+    return [...groups].map(([base, g]) => {
+        // agy lists some Claude models as claude-opus-4-6-thinking; the catalog knows them without the suffix.
+        const plain = base.replace(/-thinking$/, '');
+        const modelId = deps.index[base] || !deps.index[plain] ? base : plain;
+        const common = {
+            agent: 'antigravity',
+            modelId,
+            ...(deps.index[modelId] ? { meta: deps.index[modelId] } : {}),
+            poolNames: poolsOf(base),
+        };
+        // A plain id takes Orca's effort menu; agy does not say which efforts it honors.
+        if (Object.keys(g.ids).length === 0)
+            return { ...common, efforts: EFFORTS, effortSource: 'orca', launch: { kind: 'flag', model: g.plain } };
+        // An unsuffixed sibling is agy's default, so it stands in for a missing medium.
+        if (g.plain && !g.ids.medium)
+            g.ids.medium = g.plain;
+        return {
+            ...common,
+            efforts: EFFORT_LADDER.filter((e) => g.ids[e]),
+            effortSource: 'provider',
+            launch: { kind: 'variant', ids: g.ids, ...(g.plain ? { defaultId: g.plain } : {}) },
+        };
+    });
+}
+// agy otherwise forks a detached updater every 15 minutes, and on Windows its console-less child opens a visible terminal. agy accepts only the exact value "true".
+const NO_AUTO_UPDATE = { AGY_CLI_DISABLE_AUTO_UPDATE: 'true' };
+// The agy installer's default locations; a process started before the install misses them on PATH.
+export function locateAntigravity(deps) {
+    const home = homeDir(deps.env);
+    const localAppData = deps.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+    return deps.find('agy', [join(localAppData, 'agy', 'bin'), join(home, '.local', 'bin')]);
+}
+export async function discoverAntigravity(deps) {
+    const exe = locateAntigravity(deps);
+    if (!exe)
+        return { agent: 'antigravity', installed: false, models: [], note: 'agy not found' };
+    const listing = await listModels(deps, exe, ['models'], 'antigravity', (text) => parseAgyModels(text).map((id) => ({ id })), NO_AUTO_UPDATE);
+    if (!listing.items) {
+        const note = listing.signedOut ? `not signed in: ${listing.error}` : `agy models gave no model ids: ${listing.error}`;
+        return { agent: 'antigravity', installed: true, models: [], note, ...(listing.signedOut ? { signedOut: true } : {}) };
+    }
+    const note = savedNote('agy models', listing, deps.now);
+    return { agent: 'antigravity', installed: true, models: toLaunchModels(listing.items.map((m) => m.id), deps), ...(note ? { note } : {}) };
+}

package/dist/placements/agents/claude.js

@@ -0,0 +1,72 @@
+import { join } from 'node:path';
+import { parseEffort } from '../../routing/effort.js';
+import { homeDir } from '../../paths.js';
+import { description, fromOrcaCatalog, orcaCatalogPath, parseJson } from './orca-catalog.js';
+const DEFAULT_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const isClaude = (id) => id.startsWith('claude-');
+const poolNames = (id) => (id.startsWith('claude-fable') ? ['session', 'weekly', 'fableWeekly'] : ['session', 'weekly']);
+/** Claude Code's cached account catalog, <account>-<hash>-cc.json; several files can exist after an account change. */
+function fromClaudeCache(deps, dir) {
+    const newest = deps.listDir(dir)
+        .filter((name) => name.endsWith('-cc.json'))
+        .map((name) => {
+        const path = join(dir, name);
+        const doc = parseJson(deps.readFile(path));
+        return { path, fetchedAt: Number(doc?.fetchedAt) || 0, models: doc?.catalog?.config?.models };
+    })
+        .filter((c) => Array.isArray(c.models))
+        .sort((a, b) => b.fetchedAt - a.fetchedAt)[0];
+    if (!newest)
+        return undefined;
+    const models = newest.models
+        .filter((m) => typeof m?.id === 'string')
+        .map((m) => ({
+        id: m.id,
+        efforts: (m.thinking?.effort_options ?? []).map((o) => String(o?.id)),
+        ...description(m.description),
+    }));
+    return { path: newest.path, models };
+}
+function toLaunch({ id, efforts, description: lineup }, deps, effortSource) {
+    return {
+        agent: 'claude',
+        modelId: id,
+        ...(deps.index[id] ? { meta: deps.index[id] } : {}),
+        efforts: [...new Set(efforts.map(parseEffort).filter((e) => e !== undefined))],
+        effortSource,
+        launch: { kind: 'flag', model: id },
+        poolNames: poolNames(id),
+        ...(lineup ? { lineup } : {}),
+    };
+}
+/** Claude Code has no model list command: its account catalog, then Orca's probe, then the Models.dev catalog. */
+export const locateClaude = (deps) => deps.find('claude');
+export async function discoverClaude(deps) {
+    if (!locateClaude(deps))
+        return { agent: 'claude', installed: false, models: [], note: 'claude not found on PATH' };
+    const configDir = deps.env.CLAUDE_CONFIG_DIR || join(homeDir(deps.env), '.claude');
+    const cache = fromClaudeCache(deps, join(configDir, 'cache', 'model-catalog'));
+    const orcaPath = orcaCatalogPath(deps.env);
+    const sources = [
+        ...(cache ? [[cache.path, cache.models, 'provider']] : []),
+        [orcaPath, fromOrcaCatalog(deps.readFile(orcaPath), 'claude'), 'orca'],
+    ];
+    for (const [path, raw, effortSource] of sources) {
+        const unique = new Map(raw.filter((m) => isClaude(m.id)).map((m) => [m.id, m]));
+        if (unique.size === 0)
+            continue;
+        return { agent: 'claude', installed: true, models: [...unique.values()].map((m) => toLaunch(m, deps, effortSource)), note: `models from ${path}` };
+    }
+    const models = Object.values(deps.index)
+        .filter((m) => m.provider === 'anthropic' && m.family?.startsWith('claude-'))
+        .map((meta) => ({
+        agent: 'claude',
+        modelId: meta.id,
+        meta,
+        efforts: meta.efforts?.length ? meta.efforts : DEFAULT_EFFORTS,
+        effortSource: meta.efforts?.length ? 'catalog' : 'assumed',
+        launch: { kind: 'flag', model: meta.id },
+        poolNames: poolNames(meta.id),
+    }));
+    return { agent: 'claude', installed: true, models };
+}

package/dist/placements/agents/codex.js

@@ -0,0 +1,66 @@
+import { join } from 'node:path';
+import { parseEffort } from '../../routing/effort.js';
+import { FAMILY_TIERS } from '../tiers.js';
+const DEFAULT_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+import { homeDir } from '../../paths.js';
+import { description, fromOrcaCatalog, orcaCatalogPath, parseJson } from './orca-catalog.js';
+/** Codex CLI's own cache: models[] with visibility and supported_reasoning_levels. */
+function fromCodexCache(text) {
+    const models = parseJson(text)?.models;
+    if (!Array.isArray(models))
+        return [];
+    return models
+        .filter((m) => m?.visibility === 'list' && typeof m.slug === 'string')
+        .map((m) => ({
+        id: m.slug,
+        efforts: (m.supported_reasoning_levels ?? []).map((l) => String(l?.effort)),
+        ...(typeof m.default_reasoning_level === 'string' ? { defaultEffort: m.default_reasoning_level } : {}),
+        ...description(m.description),
+    }));
+}
+export const locateCodex = (deps) => deps.find('codex');
+export async function discoverCodex(deps) {
+    if (!locateCodex(deps))
+        return { agent: 'codex', installed: false, models: [], note: 'codex not found on PATH' };
+    const sources = [
+        [join(deps.env.CODEX_HOME || join(homeDir(deps.env), '.codex'), 'models_cache.json'), fromCodexCache, 'provider'],
+        [orcaCatalogPath(deps.env), (text) => fromOrcaCatalog(text, 'codex'), 'orca'],
+    ];
+    for (const [path, parse, effortSource] of sources) {
+        const raw = parse(deps.readFile(path));
+        if (raw.length === 0)
+            continue;
+        const models = raw.map(({ id, efforts, defaultEffort, description: lineup }) => {
+            const native = defaultEffort === undefined ? undefined : parseEffort(defaultEffort);
+            return {
+                agent: 'codex',
+                modelId: id,
+                ...(deps.index[id] ? { meta: deps.index[id] } : {}),
+                efforts: [...new Set(efforts.map(parseEffort).filter((e) => e !== undefined))],
+                effortSource,
+                ...(native ? { defaultEffort: native } : {}),
+                launch: { kind: 'flag', model: id },
+                poolNames: ['session', 'weekly'],
+                ...(lineup ? { lineup } : {}),
+            };
+        });
+        return { agent: 'codex', installed: true, models, note: `models from ${path}` };
+    }
+    // Models.dev lists every OpenAI model; only the Codex lineup families are launchable here, and
+    // "-latest" ids are moving aliases.
+    const families = Object.keys(FAMILY_TIERS).filter((f) => f.startsWith('gpt-'));
+    const models = Object.values(deps.index)
+        .filter((m) => m.provider === 'openai' && m.family !== undefined && families.includes(m.family) && !m.id.endsWith('-latest'))
+        .map((meta) => ({
+        agent: 'codex',
+        modelId: meta.id,
+        meta,
+        efforts: meta.efforts?.length ? meta.efforts : DEFAULT_EFFORTS,
+        effortSource: meta.efforts?.length ? 'catalog' : 'assumed',
+        launch: { kind: 'flag', model: meta.id },
+        poolNames: ['session', 'weekly'],
+    }));
+    if (models.length > 0)
+        return { agent: 'codex', installed: true, models, note: 'models from Models.dev (Codex has not cached its model list yet)' };
+    return { agent: 'codex', installed: true, models: [], note: 'no Codex model list found' };
+}