@phnx-labs/agents-cli 1.21.2 → 1.22.0

package/dist/lib/hosts/reconnect.js

@@ -28,12 +28,50 @@
  * The retry policy is a pure state machine (`reconnectStep`) so it is unit-tested
  * without touching SSH; the loop (`reconnectInteractiveSession`) only adds the real
  * preflight + `sshStream` re-attach and the wait.
+ *
+ * **255 from the REMOTE side should never be trusted as "the link dropped."**
+ * `reattachRemoteSession`'s `connected` flag is set as soon as the fast preflight
+ * probe succeeds — it says nothing about whether the interactive attach that
+ * follows actually reattached a live pane. If the REMOTE command (`agents
+ * sessions focus <id> --local --attach-only`) itself ever happened to exit 255
+ * for a reason that has nothing to do with the ssh transport, `sshStream` would
+ * return that same 255, `reconnectStep` couldn't tell it apart from a genuine
+ * drop, and `connected: true` would refill the retry budget forever — "attempt
+ * 1/N" printed on every single cycle, the terminal filling with aborted-TTY
+ * escape-code garbage, `MAX_ATTEMPTS` never actually bounding anything.
+ *
+ * Two candidate producers of that scenario were investigated —
+ * `refuseFallback`'s login-shell fallback (commands/go.ts) and `jumpTo`'s
+ * nested remote-tmux hop — and both turned out to be UNREACHABLE through this
+ * exact remote command: under `--local`, `gatherLiveTargets` never sets a
+ * foreign `.machine` (go.ts:61), so `remote` is always `undefined` in both,
+ * and neither branch can fire (the same reasoning that made an earlier,
+ * narrower fix here dead code — see git history). So this fix does not close
+ * a confirmed incident cause; what it closes is the underlying channel-level
+ * flaw that would make *any* future remote-side 255 producer — reachable today
+ * or not — indistinguishable from a real drop. {@link wrapRemoteExitCode} wraps
+ * the entire remote command so that whatever exit code it decides on, a 255 is
+ * remapped to {@link REMOTE_EXIT_255_REMAPPED} before `sshStream` ever sees it,
+ * regardless of which internal branch produced it and regardless of the peer's
+ * `agents` version (the remap happens in the shell wrapper THIS process sends).
+ *
+ * This does NOT close every way `reconnectStep` can loop on a real transport
+ * 255: a genuinely recurring LOCAL ssh failure (a fast-flapping link, an
+ * attach that dies at the TTY stage on every reconnect) still refills the
+ * budget every time by design (see "Why the budget refills on `connected`"
+ * above) and can still print "attempt 1/N" indefinitely. That's an accepted,
+ * pre-existing tradeoff of the original feature, not something this fix
+ * changes either way — tracked separately (agents-cli#1884), not fixed here.
  */
 import { sshExec, sshStream, shellQuote } from '../ssh-exec.js';
 import { sshTargetFor } from './types.js';
 /** ssh's connection-layer failure code — the signal that the link dropped rather
  *  than the remote command exiting on its own. Mirrors ssh-exec.ts `sshStream`. */
 export const SSH_CONN_FAILURE = 255;
+/** What a would-be-255 remote-origin exit code is remapped to by
+ *  {@link wrapRemoteExitCode} — see the file header. Never produced by the ssh
+ *  transport itself, so it can never be confused with {@link SSH_CONN_FAILURE}. */
+export const REMOTE_EXIT_255_REMAPPED = 254;
 /** Consecutive failed-to-connect reattaches before giving up. Backoff is capped at
  *  {@link MAX_BACKOFF_MS}. A reattach that actually reconnected (then dropped again)
  *  refills the budget, so a long session that blinks all day reconnects every time
@@ -77,6 +115,50 @@ export function reconnectNotice(sessionId, host, attempt, waitMs) {
 export function exhaustedNotice(sessionId, host) {
     return `\nCouldn't reconnect to ${host} after ${MAX_ATTEMPTS} attempts. The agent may still be running — reattach when the network is back:\n  agents sessions focus ${sessionId.slice(0, 8)}\n`;
 }
+/** Notice shown when a reattach stops on a remapped remote-side exit
+ *  ({@link REMOTE_EXIT_255_REMAPPED} — a would-be-255 the remote command decided
+ *  on for its own reasons, not the ssh transport dropping; see
+ *  {@link wrapRemoteExitCode}). Distinct from {@link exhaustedNotice}, which is
+ *  only for a genuinely spent retry budget. */
+export function remoteExitNotice(sessionId, host) {
+    return `\nReattach to ${sessionId.slice(0, 8)} on ${host} ended (not a network drop) — check whether it's still live:\n  agents sessions ${sessionId.slice(0, 8)}\n`;
+}
+/**
+ * Wrap `cmd` in `bash -lc` (the login-shell pattern `buildRemoteAgentsInvocation`
+ * in remote-cmd.ts uses for its own POSIX callers — see its doc comment for why
+ * a login shell at all; the sibling interactive dispatch in dispatch.ts sends a
+ * bare `agents …` with no shell wrapper, so this is a NEW login-shell hop on the
+ * reattach path specifically, not something already universal here) with a
+ * trailing exit-code remap: whatever `cmd` itself exits with, a 255 becomes
+ * {@link REMOTE_EXIT_255_REMAPPED} before the wrapper exits — see the file
+ * header for why. Every other code (0, 1, …) passes through unchanged. This
+ * carries no PATH bootstrap of its own — `ensureHostReady`/`readyProbe` already
+ * gates every `--host` dispatch on `bash -lc 'agents --version'` succeeding
+ * before a run is attempted at all, so the peer's login shell resolving `agents`
+ * is an established precondition here too. Pure string-building, so it is
+ * unit-tested without SSH (and, since the constructed script is ordinary POSIX,
+ * also exercised by actually running it through a real shell in the test — no
+ * mock needed).
+ */
+export function wrapRemoteExitCode(cmd) {
+    const guarded = `${cmd}; rc=$?; [ "$rc" = "${SSH_CONN_FAILURE}" ] && rc=${REMOTE_EXIT_255_REMAPPED}; exit "$rc"`;
+    return `bash -lc ${shellQuote(guarded)}`;
+}
+/**
+ * The remote command a reattach runs — the peer's own reconnect verb
+ * (`agents sessions focus <id> --local --attach-only`), wrapped by
+ * {@link wrapRemoteExitCode} so a stray remote-origin 255 (from this command,
+ * whatever produces it — see the file header) can never masquerade as a
+ * network drop. Split out from {@link reattachRemoteSession} so it is
+ * unit-tested without SSH — mirrors `remoteAgentsJsonCommand` in
+ * lib/remote-agents-json.ts.
+ */
+export function reattachRemoteCommand(sessionId) {
+    const inner = ['agents', 'sessions', 'focus', sessionId, '--local', '--attach-only']
+        .map(shellQuote)
+        .join(' ');
+    return wrapRemoteExitCode(inner);
+}
 /**
  * Re-attach the live remote tmux pane for `sessionId` by driving the peer's own
  * `agents sessions focus`. A fast, un-multiplexed preflight probe (`ssh … true`)
@@ -94,10 +176,7 @@ export function reattachRemoteSession(host, sessionId) {
     const probe = sshExec(target, 'true', { multiplex: false });
     if (probe.code !== 0)
         return { code: SSH_CONN_FAILURE, connected: false };
-    const remoteCmd = ['agents', 'sessions', 'focus', sessionId, '--local', '--attach-only']
-        .map(shellQuote)
-        .join(' ');
-    return { code: sshStream(target, remoteCmd, { tty: true }), connected: true };
+    return { code: sshStream(target, reattachRemoteCommand(sessionId), { tty: true }), connected: true };
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
@@ -117,6 +196,8 @@ export async function reconnectInteractiveSession(opts) {
         if (decision.action === 'stop') {
             if (decision.code === SSH_CONN_FAILURE)
                 write(exhaustedNotice(opts.sessionId, opts.host.name));
+            else if (decision.code === REMOTE_EXIT_255_REMAPPED)
+                write(remoteExitNotice(opts.sessionId, opts.host.name));
             return decision.code;
         }
         write(reconnectNotice(opts.sessionId, opts.host.name, decision.state.attempt, decision.waitMs));

package/dist/lib/hosts/run-target.js

@@ -55,7 +55,16 @@ export async function resolveHostRunTarget(name, opts = {}) {
 }
 /** Resolve the id the remote host will adopt for a fresh Claude session. */
 export function resolveHostSessionId(agent, resume, sessionId) {
-    return agent === 'claude' && !resume ? sessionId ?? randomUUID() : undefined;
+    if (resume)
+        return undefined;
+    if (agent === 'claude')
+        return sessionId ?? randomUUID();
+    // `run auto`: the harness is picked on the REMOTE. Forward an explicit id so
+    // a claude pick adopts it — but never mint one: minting would suppress the
+    // --emit-session-id marker a non-claude pick needs to register its session.
+    if (agent === 'auto')
+        return sessionId;
+    return undefined;
 }
 /**
  * Dispatch a headless prompt run onto a resolved host, then relate the run's
@@ -77,7 +86,10 @@ export async function dispatchPromptToHost(host, opts) {
     // Ask the remote to print its resolved id whenever we did NOT force one (every
     // non-Claude agent, and Claude-on-resume where the id is already known). No-op
     // when the run isn't followed — nothing tails the log to catch the marker.
-    const emitSessionId = !forcedSessionId && !opts.resume && opts.follow !== false;
+    // `run auto` with an explicit --session-id is the exception: the id is only
+    // ADOPTED when the remote picks claude, so a non-claude pick must still emit
+    // the marker for its own coined id.
+    const emitSessionId = (!forcedSessionId || opts.agent === 'auto') && !opts.resume && opts.follow !== false;
     const result = await dispatchToHost(host, {
         agent: opts.agent,
         prompt: opts.prompt,

package/dist/lib/model-tiers.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Cost tiers for model selection: cheap / default / best / ultra.
+ *
+ * An orchestrating agent picks a teammate's model by a stable, cost-first tier
+ * instead of a concrete id that churns per release and varies per harness. A
+ * tier resolves, per (harness, installed version), to a model that version
+ * actually ships — so `--model cheap|default|best|ultra` works on `agents run`
+ * and `agents teams add` alike, funnelling through `resolveModel()`.
+ *
+ * Ranking signal, in priority (see apps/cli/docs — model ranking mechanisms):
+ *   1. Provider-declared lineup — the catalog's own family names / descriptions
+ *      (opus/sonnet/haiku/fable; Codex "frontier / balanced / fast"). Most
+ *      drift-proof: the provider tells us its own ranking.
+ *   2. Per-token price (prices.json) — cross-check + the $/Mtok display + budget.
+ *   3. Size-token heuristic (nano|mini|lite|flash cheaper; pro|max|opus dearer).
+ *   4. Reasoning effort for single-model harnesses (Grok) — tiers steer --effort.
+ *
+ * The mechanism differs per provider and drifts across versions, so tiers always
+ * resolve against the installed version's own catalog.
+ */
+import type { AgentId } from './types.js';
+import { type ModelInfo } from './models.js';
+/** The four cross-harness cost tiers, cheapest -> most capable. */
+export declare const MODEL_TIERS: readonly ["cheap", "default", "best", "ultra"];
+export type ModelTier = (typeof MODEL_TIERS)[number];
+/** True if `s` is one of the four tier tokens (not a concrete model id). */
+export declare function isTierToken(s: string | undefined | null): s is ModelTier;
+/** How a single tier resolved for a given (agent, version). */
+export interface TierResolution {
+    tier: ModelTier;
+    /** Concrete model id to forward, or null when nothing resolves (fail-safe). */
+    model: string | null;
+    /** Reasoning effort to forward, for single-model harnesses where the tier is effort, not model. */
+    effort?: string;
+    /** Set when this tier has no rung of its own: the lower tier whose model it borrowed. */
+    clampedFrom?: ModelTier;
+    /** Human note (e.g. why it clamped, or that it is a curated/subscription mapping). */
+    note?: string;
+}
+/**
+ * Resolve all four tiers for an (agent, version). The map is what `agents models`
+ * prints and what `resolveTier` indexes into.
+ */
+export declare function resolveTierMap(agent: AgentId, version: string): Record<ModelTier, TierResolution>;
+/**
+ * Map a harness's catalog models onto the four tiers. Pure (no catalog lookup)
+ * so it is directly testable with synthetic inputs. Ranks the models, collapses
+ * variants, buckets onto cheap/default/best/ultra, and clamps absent tiers down
+ * to the nearest lower one. A single-model harness maps the tiers to reasoning
+ * effort instead of models.
+ */
+export declare function tierizeModels(agent: AgentId, models: ModelInfo[]): Record<ModelTier, TierResolution>;
+/** Resolve one tier for an (agent, version). Null model => caller drops the flag. */
+export declare function resolveTier(agent: AgentId, version: string, tier: ModelTier): TierResolution;

package/dist/lib/model-tiers.js

@@ -0,0 +1,229 @@
+import { getModelCatalog } from './models.js';
+import { getModelPricing } from './pricing/index.js';
+/** The four cross-harness cost tiers, cheapest -> most capable. */
+export const MODEL_TIERS = ['cheap', 'default', 'best', 'ultra'];
+/** True if `s` is one of the four tier tokens (not a concrete model id). */
+export function isTierToken(s) {
+    return !!s && MODEL_TIERS.includes(s);
+}
+// --- single-model harnesses: the tier is reasoning effort, not a model ---------
+const TIER_EFFORT = {
+    cheap: 'low',
+    default: 'medium',
+    best: 'high',
+    ultra: 'xhigh',
+};
+// --- Droid: no live catalog; prices in credit multipliers. Curated map, capped
+//     at 2x (no 4x models like Fable 5 / Fast modes). Ids are Factory -m values.
+const DROID_TIERS = {
+    cheap: 'glm-5.2', // 0.55x (Droid Core)
+    default: 'kimi-k3', // 0.6x (Droid Core)
+    best: 'claude-opus-5', // 2x
+    ultra: 'claude-opus-5', // clamp to best; avoid 4x
+};
+/** Router / pseudo models that are not a concrete choice and never a tier target. */
+const PSEUDO = /(^|[-/])(auto|auto-review|router|dynamic)([-/]|$)/i;
+/** Effort / speed suffixes aggregator harnesses (Cursor) bake into ids. */
+const AGGREGATOR_SUFFIX = /-(low|medium|high|xhigh|thinking|fast|reasoning)\b/gi;
+/** Anthropic capability family -> rank (cheapest 0 -> dearest 3). */
+function anthropicFamilyRank(id) {
+    if (/(^|[-/])claude-haiku|(^|[-/])haiku/.test(id))
+        return 0;
+    if (/claude-sonnet|(^|[-/])sonnet/.test(id))
+        return 1;
+    if (/claude-opus|(^|[-/])opus/.test(id))
+        return 2;
+    if (/claude-(fable|mythos)|(^|[-/])(fable|mythos)/.test(id))
+        return 3;
+    return null;
+}
+/** Rank from the provider's own description keywords (e.g. Codex Sol/Terra/Luna). */
+function descriptionRank(desc) {
+    if (!desc)
+        return null;
+    const d = desc.toLowerCase();
+    if (/(fast|affordable|cost-efficient|small|cheap|mini|nano|lightweight|spark)/.test(d))
+        return 0;
+    if (/(balanced|everyday|strong|general)/.test(d))
+        return 1;
+    if (/(frontier|latest|flagship|most capable|complex|advanced|professional)/.test(d))
+        return 2;
+    return null;
+}
+/** Last-resort ordering from size tokens embedded in the id. */
+function sizeTokenRank(id) {
+    if (/(nano|mini|lite|flash|highspeed|small|air|spark)/.test(id))
+        return 0;
+    if (/(pro|max|ultra|opus|sol|large|frontier|heavy|thinking)/.test(id))
+        return 2;
+    return 1;
+}
+const blended = (id) => {
+    const p = getModelPricing(id);
+    return p ? p.inputPerToken + p.outputPerToken : null;
+};
+/** Strip an aggregator's effort/speed suffixes down to a base provider id. */
+function normalizeAggregatorId(id) {
+    return id.replace(AGGREGATOR_SUFFIX, '').replace(/-+$/, '');
+}
+/**
+ * Compare two concrete ids so the newest wins within a family. Strips a trailing
+ * date stamp (`-20251101`), rebuild marker (`-v1`), and `-fast` first, so a dated
+ * `opus-4-5-20251101` doesn't out-rank the genuinely newer `opus-4-8` (a bare
+ * `compareVersions` reads the date as a huge version component).
+ */
+function cleanForCompare(id) {
+    return id
+        .replace(/-\d{8}(?=($|-))/, '')
+        .replace(/-v\d+$/, '')
+        .replace(/-fast$/, '');
+}
+/** Numeric segments of a (cleaned) id, splitting on BOTH dashes and dots. */
+function versionSegments(id) {
+    const m = cleanForCompare(id).match(/\d+/g);
+    return m ? m.map((n) => parseInt(n, 10)) : [];
+}
+/**
+ * Newest concrete id within a family wins. `compareVersions` only splits on `.`,
+ * so it degenerates to a single `[0]` segment for a dash-separated model id and
+ * mis-ranks e.g. `claude-sonnet-5` below `claude-sonnet-4-6`. Compare the numeric
+ * segments directly instead.
+ */
+function newer(a, b) {
+    const A = versionSegments(a);
+    const B = versionSegments(b);
+    for (let i = 0; i < Math.max(A.length, B.length); i++) {
+        const d = (A[i] ?? 0) - (B[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/**
+ * Rank a harness's catalog models cheapest -> dearest and collapse variants of
+ * one model to a single rung (keeping the newest concrete id). Strategy depends
+ * on the harness class: aggregator (Cursor) ranks by price of the normalized
+ * base id; single-provider harnesses rank by the provider lineup with price and
+ * size tokens as fallbacks.
+ */
+function rankCatalog(agent, models) {
+    const usable = models.filter((m) => !PSEUDO.test(m.id));
+    const aggregator = agent === 'cursor';
+    const scored = usable.map((m) => {
+        const rawId = m.id;
+        const baseId = aggregator ? normalizeAggregatorId(rawId) : rawId;
+        const lc = baseId.toLowerCase();
+        const price = blended(baseId) ?? blended(rawId);
+        let rank;
+        let family;
+        if (aggregator) {
+            // cross-provider: price is the unifying signal; family = base id
+            rank = price != null ? price * 1e6 : 100 + sizeTokenRank(lc);
+            family = baseId;
+        }
+        else {
+            const fam = anthropicFamilyRank(lc);
+            const desc = descriptionRank(m.description);
+            if (fam != null) {
+                rank = fam;
+                family = `anthropic-${fam}`;
+            }
+            else if (desc != null) {
+                rank = desc;
+                family = `desc-${desc}-${baseId.replace(/[0-9].*$/, '')}`;
+            }
+            else if (price != null) {
+                rank = 10 + price * 1e6;
+                // Collapse only true re-releases of ONE model (same base id, differing
+                // date/rebuild suffix). Keying on price would merge two DIFFERENT models
+                // that happen to cost the same (e.g. gpt-5.5 and gpt-5.6-sol), dropping
+                // one from every tier.
+                family = cleanForCompare(baseId);
+            }
+            else {
+                rank = 20 + sizeTokenRank(lc);
+                family = cleanForCompare(baseId);
+            }
+        }
+        return { id: rawId, baseId, rank, family, price };
+    });
+    // collapse by family: keep the newest concrete id, lowest (cheapest) rank
+    const byFamily = new Map();
+    for (const s of scored) {
+        const prev = byFamily.get(s.family);
+        if (!prev) {
+            byFamily.set(s.family, s);
+            continue;
+        }
+        // keep the newer id; keep the cheaper rank
+        if (newer(s.id, prev.id) > 0)
+            prev.id = s.id;
+        if (s.rank < prev.rank)
+            prev.rank = s.rank;
+        if (prev.price == null && s.price != null)
+            prev.price = s.price;
+    }
+    return [...byFamily.values()].sort((a, b) => a.rank - b.rank || newer(b.id, a.id));
+}
+/** Which ranked rung each tier index maps to, collapsing when there are < 4 rungs. */
+function rungIndexFor(tierIndex, n) {
+    return n >= 4 ? Math.round((tierIndex / 3) * (n - 1)) : Math.min(tierIndex, n - 1);
+}
+/**
+ * Resolve all four tiers for an (agent, version). The map is what `agents models`
+ * prints and what `resolveTier` indexes into.
+ */
+export function resolveTierMap(agent, version) {
+    // Droid: curated credit-multiplier map (no live catalog).
+    if (agent === 'droid') {
+        return {
+            cheap: { tier: 'cheap', model: DROID_TIERS.cheap, note: 'Droid Core 0.55x' },
+            default: { tier: 'default', model: DROID_TIERS.default, note: 'Droid Core 0.6x' },
+            best: { tier: 'best', model: DROID_TIERS.best, note: '2x' },
+            ultra: { tier: 'ultra', model: DROID_TIERS.ultra, clampedFrom: 'best', note: 'capped at 2x (4x models excluded)' },
+        };
+    }
+    const catalog = getModelCatalog(agent, version);
+    return tierizeModels(agent, catalog?.models ?? []);
+}
+/**
+ * Map a harness's catalog models onto the four tiers. Pure (no catalog lookup)
+ * so it is directly testable with synthetic inputs. Ranks the models, collapses
+ * variants, buckets onto cheap/default/best/ultra, and clamps absent tiers down
+ * to the nearest lower one. A single-model harness maps the tiers to reasoning
+ * effort instead of models.
+ */
+export function tierizeModels(agent, models) {
+    const rungs = rankCatalog(agent, models);
+    // Single-model harness (e.g. Grok): the tier is reasoning effort, not a model.
+    if (rungs.length === 1) {
+        const only = rungs[0].id;
+        const map = {};
+        for (const t of MODEL_TIERS)
+            map[t] = { tier: t, model: only, effort: TIER_EFFORT[t], note: 'single model — tier maps to reasoning effort' };
+        return map;
+    }
+    const n = rungs.length;
+    const map = {};
+    if (n === 0) {
+        // Fail-safe: no catalog -> every tier null, caller drops the --model flag.
+        for (const t of MODEL_TIERS)
+            map[t] = { tier: t, model: null };
+        return map;
+    }
+    // Map each tier onto a rung; a tier that shares the rung of the tier below it
+    // has no distinct rung of its own, so mark it clamped for an honest display.
+    for (let i = 0; i < MODEL_TIERS.length; i++) {
+        const t = MODEL_TIERS[i];
+        const idx = rungIndexFor(i, n);
+        const shared = i > 0 && rungIndexFor(i - 1, n) === idx;
+        map[t] = shared
+            ? { tier: t, model: rungs[idx].id, clampedFrom: MODEL_TIERS[i - 1], note: `no distinct ${t} rung; using ${MODEL_TIERS[i - 1]}` }
+            : { tier: t, model: rungs[idx].id };
+    }
+    return map;
+}
+/** Resolve one tier for an (agent, version). Null model => caller drops the flag. */
+export function resolveTier(agent, version, tier) {
+    return resolveTierMap(agent, version)[tier];
+}

package/dist/lib/models.d.ts

@@ -1,4 +1,5 @@
 import type { AgentId } from './types.js';
+import { type ModelPricing } from './pricing/index.js';
 /** Model identifiers per cloud provider (used by Claude's multi-cloud routing). */
 export interface ModelPerCloud {
     firstParty: string;
@@ -28,6 +29,8 @@ export interface ModelInfo {
     reasoningLevels?: ReasoningLevel[];
     /** Default reasoning level if applicable */
     defaultReasoningLevel?: string;
+    /** Per-token USD pricing when known (from prices.json); absent for subscription/unpriced models. */
+    pricing?: ModelPricing;
 }
 /** The complete model catalog for a specific (agent, version) pair. */
 export interface ModelCatalog {

package/dist/lib/models.js

@@ -15,6 +15,7 @@ import { getVersionDir, getVersionHomePath, getBinaryPath } from './versions.js'
 import { getModelsCachePath } from './state.js';
 import { agentConfigDirName } from './agents.js';
 import { resolveRunDefaults } from './run-defaults.js';
+import { getModelPricing } from './pricing/index.js';
 const CACHE_PATH = getModelsCachePath();
 /**
  * Bump when the extractor logic changes shape in an incompatible way so cached
@@ -342,17 +343,12 @@ function extractClaudeCatalog(text) {
             mantle: m[6] ?? null,
         };
     }
-    const allIds = new Set([
-        ...Object.values(aliases),
-        ...Object.keys(displayNames),
-        ...Object.keys(perCloud),
-    ]);
     const aliasReverse = {};
     for (const [a, id] of Object.entries(aliases))
         aliasReverse[id] = a;
     const defaults = new Set(Object.values(aliases));
-    const models = Array.from(allIds)
-        .filter((id) => /^claude-(opus|sonnet|haiku)-/.test(id))
+    const build = (ids) => Array.from(new Set(ids))
+        .filter((id) => /^claude-(opus|sonnet|haiku|fable|mythos)-/.test(id))
         .sort()
         .map((id) => ({
         id,
@@ -361,6 +357,32 @@ function extractClaudeCatalog(text) {
         isDefault: defaults.has(id),
         perCloud: perCloud[id],
     }));
+    // The structured maps (alias/perCloud/const) are the curated, accurate
+    // supported set. Prefer them.
+    let models = build([
+        ...Object.values(aliases),
+        ...Object.keys(displayNames),
+        ...Object.keys(perCloud),
+    ]);
+    // Fallback id scan. The structured maps fail on the newest native-binary
+    // format (verified: claude@2.1.219 leaks only a stray id, so the curated set
+    // is effectively empty). Only when the curated catalog is that thin do we scan
+    // the raw strings for canonical ids -- so an older version keeps its precise
+    // catalog while a newer one still gets a real catalog (incl. fable/mythos and
+    // the opus-5/sonnet-5 line) rather than an empty or single-model one.
+    if (models.length < 2) {
+        const scanned = new Set();
+        // Dash-separated segments only. Real ids are `claude-sonnet-4-6`; the dotted
+        // form `claude-sonnet-4.6` appears only inside the binary's own "Typo in
+        // model ID" troubleshooting text, so a `.`-permitting pattern would scrape a
+        // non-model string as if it were real.
+        const idRe = /claude-(?:opus|sonnet|haiku|fable|mythos)-\d+(?:-\d+)*(?:-(?:fast|v\d+))?/g;
+        let sm;
+        while ((sm = idRe.exec(text)) !== null)
+            scanned.add(sm[0]);
+        if (scanned.size >= 2)
+            models = build(scanned);
+    }
     return { models, aliases };
 }
 /**
@@ -929,6 +951,14 @@ export function getModelCatalog(agent, version) {
         else if (agent === 'grok')
             ({ models, aliases } = extractGrokCatalog(src.path));
     }
+    // Attach per-token pricing where the offline table knows the model, so the
+    // catalog carries $/token for the tier display and budgeting. Subscription /
+    // unknown models keep `pricing` undefined (surfaced as "--", never faked).
+    for (const m of models) {
+        const p = getModelPricing(m.id);
+        if (p)
+            m.pricing = p;
+    }
     const catalog = {
         agent,
         version,
@@ -1123,5 +1153,12 @@ export function buildReasoningFlags(agent, level) {
         const droidLevel = (normalized === 'xhigh' || normalized === 'max') ? 'high' : normalized;
         return ['-r', droidLevel];
     }
+    if (agent === 'grok') {
+        // Grok: `--reasoning-effort <low|medium|high>` (alias --effort). xhigh/max
+        // clamp to high. This is the effort dial cost tiers steer for Grok, whose
+        // catalog exposes a single model.
+        const grokLevel = (normalized === 'xhigh' || normalized === 'max') ? 'high' : normalized;
+        return ['--reasoning-effort', grokLevel];
+    }
     return [];
 }

package/dist/lib/percentile.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Percentile of a sorted-ascending array, linear interpolation. p in [0,100].
+ *
+ * Deliberately its own file with zero imports: `perf/db.ts` (the SQLite
+ * warehouse), `hooks/profile.ts` (the legacy JSONL hook profile), and
+ * `routines.ts` (routineStats) all need this exact formula, but `routines.ts`
+ * and `hooks/profile.ts` must NOT pull in `perf/db.ts`'s `../sqlite.js`
+ * dependency just to round a percentile — sqlite is a heavier, perf-warehouse-
+ * specific dependency that has no business loading into every routines- or
+ * hooks-touching code path.
+ */
+export declare function percentile(sorted: number[], p: number): number;

package/dist/lib/percentile.js

@@ -0,0 +1,24 @@
+/**
+ * Percentile of a sorted-ascending array, linear interpolation. p in [0,100].
+ *
+ * Deliberately its own file with zero imports: `perf/db.ts` (the SQLite
+ * warehouse), `hooks/profile.ts` (the legacy JSONL hook profile), and
+ * `routines.ts` (routineStats) all need this exact formula, but `routines.ts`
+ * and `hooks/profile.ts` must NOT pull in `perf/db.ts`'s `../sqlite.js`
+ * dependency just to round a percentile — sqlite is a heavier, perf-warehouse-
+ * specific dependency that has no business loading into every routines- or
+ * hooks-touching code path.
+ */
+export function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    if (sorted.length === 1)
+        return sorted[0];
+    const rank = (p / 100) * (sorted.length - 1);
+    const lo = Math.floor(rank);
+    const hi = Math.ceil(rank);
+    if (lo === hi)
+        return sorted[lo];
+    const frac = rank - lo;
+    return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}

package/dist/lib/perf/db.d.ts

@@ -8,14 +8,13 @@ import Database from '../sqlite.js';
 import type { AggregateOptions, PerfAggregateRow } from './types.js';
 export type { AggregateOptions, PerfAggregateRow, PerfSample } from './types.js';
 export { recordSample, shortSessionId, resolveSpoolPath } from './spool.js';
+export { percentile } from '../percentile.js';
 export declare const PERF_SCHEMA_VERSION = 1;
 export declare const DEFAULT_RETENTION_DAYS = 30;
 /** Test seam — redirect the warehouse path (like AGENTS_EVENTS_PATH). */
 export declare function _resetPerfDbForTest(overridePath?: string | null): void;
 /** Drain the NDJSON spool into samples. Idempotent; truncates on success. */
 export declare function drainSpool(db?: Database.Database): number;
-/** Percentile of a sorted-ascending array. p in [0,100]. */
-export declare function percentile(sorted: number[], p: number): number;
 /**
  * Aggregate samples by (kind, label) with p50/p95/p99. Drains the spool first.
  *

package/dist/lib/perf/db.js

@@ -10,8 +10,10 @@ import Database from '../sqlite.js';
 import { getPerfDbPath, getPerfDir } from '../state.js';
 import { localMachineId } from '../session/origin-machine.js';
 import { resolveProjectKey } from '../project-key.js';
+import { percentile } from '../percentile.js';
 import { resolveSpoolPath, shortSessionId, _resetPerfSpoolForTest } from './spool.js';
 export { recordSample, shortSessionId, resolveSpoolPath } from './spool.js';
+export { percentile } from '../percentile.js';
 export const PERF_SCHEMA_VERSION = 1;
 export const DEFAULT_RETENTION_DAYS = 30;
 const SCHEMA = `
@@ -186,20 +188,6 @@ function maybeRetain(db) {
         // ignore
     }
 }
-/** Percentile of a sorted-ascending array. p in [0,100]. */
-export function percentile(sorted, p) {
-    if (sorted.length === 0)
-        return 0;
-    if (sorted.length === 1)
-        return sorted[0];
-    const rank = (p / 100) * (sorted.length - 1);
-    const lo = Math.floor(rank);
-    const hi = Math.ceil(rank);
-    if (lo === hi)
-        return sorted[lo];
-    const frac = rank - lo;
-    return sorted[lo] * (1 - frac) + sorted[hi] * frac;
-}
 /**
  * Aggregate samples by (kind, label) with p50/p95/p99. Drains the spool first.
  *