amicus 3.1.0 → 3.2.0

package/src/sidecar/setup.js

@@ -187,8 +187,12 @@ async function seedCatalog(print) {
  * (Enter = the vendor-diverse default), seeds aliases + councils.free, and
  * never touches config.default.
  * @param {readline.Interface} rl
+ * @param {Array<object>} [catalogArg] pre-fetched catalog from the caller
+ *   (`runReadlineSetup` already fetches one for the per-provider phase) --
+ *   reused as-is to avoid a second `getCatalog()` round trip. Falls back to
+ *   fetching its own when omitted (e.g. direct unit-test callers).
  */
-async function runFreeCouncilBranch(rl) {
+async function runFreeCouncilBranch(rl, catalogArg) {
   const keys = detectApiKeys();
   if (!keys.openrouter) {
     console.log('');
@@ -196,10 +200,14 @@ async function runFreeCouncilBranch(rl) {
     console.log('Set OPENROUTER_API_KEY and re-run: amicus setup. No changes made.');
     return;
   }
-  const { getCatalog } = require('../utils/model-catalog');
   const { listFreeModels, suggestFreeCouncil, PINNED_FREE_MODELS } = require('../utils/free-models');
   let catalog = [];
-  try { catalog = await getCatalog(); } catch (_e) { /* offline */ }
+  if (Array.isArray(catalogArg)) {
+    catalog = catalogArg;
+  } else {
+    const { getCatalog } = require('../utils/model-catalog');
+    try { catalog = await getCatalog(); } catch (_e) { /* offline */ }
+  }
   let free = listFreeModels(catalog);
   if (free.length === 0) {
     console.log('Live free-model list unavailable (offline?) — using a small pinned set.');
@@ -237,14 +245,63 @@ async function runFreeCouncilBranch(rl) {
   console.log('unless you enable data-sharing at openrouter.ai/settings/privacy.');
 }
 
+/**
+ * Run the shared per-provider default-model picker (Task 6, `runProviderDefaultFlow`)
+ * once for each keyed provider, in `foundKeys` detection order -- whichever
+ * comes first seeds `config.default` (`applyProviderDefault`'s
+ * seed-only-when-absent rule; see `provider-default-picker.js`). Each provider
+ * is its own read-modify-write against the real config file, so an alias
+ * written here is on disk before the standard model step's own `loadConfig()`
+ * runs -- no clobber, no shared in-memory object to race.
+ *
+ * Skippable and crash-proof: `runProviderDefaultFlow` already degrades to a
+ * graceful summary line on an empty/offline catalog (never calls `ask`), and
+ * a per-provider try/catch means one provider's failure can't block the rest
+ * of setup (mirrors `cli-handlers.js`'s `offerProviderDefault`). It's also a
+ * graceful no-op for a gateway provider (`openrouter`) -- see
+ * `runProviderDefaultFlow`'s `isDirectProvider` gate.
+ * @param {readline.Interface} rl
+ * @param {string[]} foundKeys keyed providers, in detection order
+ * @param {Array<object>} catalog
+ * @returns {Promise<Set<string>>} vendor alias NAMES actually written this run
+ *   (i.e. `runProviderDefaultFlow` returned a non-null `chosenId`) -- the
+ *   standard model step must not clobber these when a quick-pick family
+ *   alias collides with one (see the standard-model-step alias-upgrade guard).
+ */
+async function runProviderDefaultPickers(rl, foundKeys, catalog) {
+  const written = new Set();
+  if (foundKeys.length === 0) { return written; }
+  const { runProviderDefaultFlow } = require('../utils/provider-default-prompt');
+  for (const provider of foundKeys) {
+    try {
+      const { chosenId, summaryLine } = await runProviderDefaultFlow(provider, {
+        interactive: true,
+        ask: (q) => askQuestion(rl, q),
+        catalog,
+        print: console.log,
+      });
+      if (chosenId) { written.add(provider); }
+      console.log(summaryLine);
+    } catch (err) {
+      console.log(
+        `Note: couldn't set a default for ${provider} (${err.message}). ` +
+        `Run \`amicus key ${provider}\` again later.`
+      );
+    }
+  }
+  console.log('');
+  return written;
+}
+
 /**
  * Run the readline-based setup wizard (headless fallback)
  *
  * Guides the user through:
  * 1. API key detection
- * 2. Mode selection (standard or free council)
- * 3. Default model selection from live quick-picks (read-modify-write, no clobber)
- * 4. Config file save
+ * 2. Per-provider default-model picker (Task 7) -- once per keyed provider
+ * 3. Mode selection (standard or free council)
+ * 4. Default model selection from live quick-picks (read-modify-write, no clobber)
+ * 5. Config file save
  */
 async function runReadlineSetup() {
   const rl = readline.createInterface({
@@ -279,18 +336,25 @@ async function runReadlineSetup() {
       await warnOnLowOpenRouterCredit();
     }
 
+    const { getCatalog } = require('../utils/model-catalog');
+    let catalog = [];
+    try { catalog = await getCatalog(); } catch (_err) { /* offline: pinned */ }
+
+    // Task 7 (cost-aware defaults P2): per-provider picker, once per keyed
+    // provider, BEFORE the mode prompt -- orthogonal to standard-vs-free-council.
+    // `vendorAliasesWritten` is consulted by the standard model step below so
+    // it never clobbers a vendor alias this phase just wrote (Fix 2).
+    const vendorAliasesWritten = await runProviderDefaultPickers(rl, foundKeys, catalog);
+
     const mode = await askQuestion(rl,
       'Setup mode — 1) Standard (pick a default model)  2) Free OpenRouter council: ');
     if (mode === '2') {
-      await runFreeCouncilBranch(rl);
+      await runFreeCouncilBranch(rl, catalog);
       return;
     }
 
-    const { getCatalog } = require('../utils/model-catalog');
     const { resolveQuickPicks, toLiveSeedAliases } = require('../utils/quick-picks');
     const { toCanonicalDefault } = require('../utils/curated-models');
-    let catalog = [];
-    try { catalog = await getCatalog(); } catch (_err) { /* offline: pinned */ }
     const picks = resolveQuickPicks(catalog);
 
     console.log('Choose your default model:');
@@ -316,7 +380,12 @@ async function runReadlineSetup() {
     if (chosen.alias) {
       cfg.default = chosen.alias;
       const pick = picks.find(p => p.alias === chosen.alias);
-      if (pick && !chosen.noUpgrade) {
+      // Fix 2: a quick-pick family alias (e.g. 'deepseek') can collide with a
+      // vendor alias the per-provider phase just wrote this run. `config.default`
+      // pointing at that alias name is fine (the user's explicit overall-default
+      // choice), but the alias's VALUE must stay the vendor phase's tier choice --
+      // skip the curated-flagship upgrade so it isn't discarded.
+      if (pick && !chosen.noUpgrade && !vendorAliasesWritten.has(chosen.alias)) {
         cfg.aliases[chosen.alias] = toCanonicalDefault(pick.routes.openrouter || Object.values(pick.routes)[0]);
       } else if (cfg.aliases[chosen.alias] === undefined) {
         const fallback = getDefaultAliases()[chosen.alias];

package/src/utils/config.js

@@ -419,6 +419,60 @@ function markMigrationNotified(vendor) {
   }
 }
 
+/**
+ * Existing-user one-time onboarding offer (Part 2, Task 9). Mirrors
+ * markMigrationNotified's flag pattern: a single boolean persisted at
+ * config.routing.tier_onboarded once the notice has fired, so it never
+ * repeats.
+ * @returns {boolean} true once the notice has fired
+ */
+function hasTierOnboarded() {
+  const config = loadConfig() || {};
+  return !!(config.routing && config.routing.tier_onboarded === true);
+}
+
+/**
+ * Persist the one-time onboarding-notice flag, preserving any other routing
+ * keys (prefer, tier, migration_notified). Best-effort: swallows any
+ * saveConfig failure so a persistence hiccup never breaks the command that
+ * triggered it (mirrors markMigrationNotified).
+ */
+function markTierOnboarded() {
+  try {
+    const config = loadConfig() || {};
+    if (!config.routing || typeof config.routing !== 'object') { config.routing = {}; }
+    config.routing.tier_onboarded = true;
+    saveConfig(config);
+  } catch (_err) {
+    // best-effort: never fail the command over a persistence error
+  }
+}
+
+/** Global cost-tier preference (Part 2, Task 1) — priciest-to-cheapest. */
+const COST_TIERS = ['frontier', 'balanced', 'economy'];
+
+/** @returns {'frontier'|'balanced'|'economy'} config.routing.tier, defaulting/coercing to 'balanced' */
+function getCostTier() {
+  const config = loadConfig() || {};
+  const tier = config.routing && config.routing.tier;
+  return COST_TIERS.includes(tier) ? tier : 'balanced';
+}
+
+/**
+ * Persist the global cost-tier preference under routing.tier, preserving any
+ * other routing keys (prefer, migration_notified).
+ * @param {string} tier one of COST_TIERS
+ * @throws {Error} when tier is not a recognized cost tier
+ */
+function setCostTier(tier) {
+  if (!COST_TIERS.includes(tier)) {
+    throw new Error(`Invalid cost tier '${tier}'. Must be one of: ${COST_TIERS.join(', ')}`);
+  }
+  const config = loadConfig() || {};
+  config.routing = { ...(config.routing || {}), tier };
+  saveConfig(config);
+}
+
 module.exports = {
   getConfigDir,
   getConfigPath,
@@ -440,4 +494,9 @@ module.exports = {
   getRoutingConfig,
   resolveGatewayMode,
   markMigrationNotified,
+  COST_TIERS,
+  getCostTier,
+  setCostTier,
+  hasTierOnboarded,
+  markTierOnboarded,
 };

package/src/utils/curated-models.js

@@ -47,7 +47,7 @@ const FAMILIES = [
     idPattern: /^claude-opus-[\d.-]+$/,
     directProviders: ['anthropic'],
     fallback: { openrouter: 'openrouter/anthropic/claude-opus-4.8',
-                anthropic: 'anthropic/claude-opus-4-6' } },
+                anthropic: 'anthropic/claude-opus-4-8' } },
   { alias: 'deepseek', label: 'DeepSeek flagship', blurb: 'open-source',
     vendorPath: 'deepseek',
     idPattern: /^deepseek-v[\d.]+(-pro)?$/,
@@ -64,9 +64,13 @@ const CARDLESS = [
   { alias: 'gpt-pro', routes: { openrouter: 'openrouter/openai/gpt-5.5-pro' } },
   // codex: newest codex-specific model on OpenRouter (verified 2026-06-09).
   { alias: 'codex', routes: { openrouter: 'openrouter/openai/gpt-5.3-codex' } },
-  { alias: 'claude', routes: { openrouter: 'openrouter/anthropic/claude-sonnet-4.6' } },
-  { alias: 'sonnet', routes: { openrouter: 'openrouter/anthropic/claude-sonnet-4.6' } },
-  { alias: 'haiku', routes: { openrouter: 'openrouter/anthropic/claude-haiku-4.5' } },
+  { alias: 'claude', routes: { openrouter: 'openrouter/anthropic/claude-sonnet-5',
+                                anthropic: 'anthropic/claude-sonnet-5' } },
+  { alias: 'sonnet', routes: { openrouter: 'openrouter/anthropic/claude-sonnet-5',
+                                anthropic: 'anthropic/claude-sonnet-5' } },
+  { alias: 'haiku', routes: { openrouter: 'openrouter/anthropic/claude-haiku-4.5',
+                              anthropic: 'anthropic/claude-haiku-4-5-20251001' } },
+  { alias: 'fable', routes: { openrouter: 'openrouter/anthropic/claude-fable-5' } },
   { alias: 'qwen', routes: { openrouter: 'openrouter/qwen/qwen3.7-max' } },
   { alias: 'qwen-coder', routes: { openrouter: 'openrouter/qwen/qwen3-coder-next' } },
   { alias: 'qwen-flash', routes: { openrouter: 'openrouter/qwen/qwen3.6-flash' } },
@@ -151,4 +155,64 @@ function listCuratedRoutes() {
   return out;
 }
 
-module.exports = { getFamilies, toDefaultAliases, toCanonicalDefault, listCuratedRoutes };
+/**
+ * Vendors whose direct-API ids differ from OpenRouter's (dot vs. dash
+ * versioning, distinct model names, etc.). NEVER derive a direct form for
+ * these — derivation would emit the wrong (dot) id, or invent a direct id
+ * for a model that is OpenRouter-only today (e.g. fable).
+ * Frozen so consumers can only read it (`.has()`) — a frozen Set still
+ * supports lookups, it just can't be `.add()`/`.delete()`/`.clear()`-ed.
+ */
+const DIVERGENT_VENDORS = Object.freeze(new Set(['anthropic']));
+
+/**
+ * @param {string} orRoute e.g. 'openrouter/anthropic/claude-sonnet-5'
+ * @returns {string} the vendor segment, e.g. 'anthropic'
+ */
+function vendorOf(orRoute) {
+  const rest = orRoute.slice('openrouter/'.length);
+  return rest.slice(0, rest.indexOf('/'));
+}
+
+/**
+ * @param {string} vendorPath
+ * @param {Object<string,string>} obj a family.fallback or cardless.routes map
+ * @returns {string|undefined} the direct-API executable id, or undefined
+ * when no direct form is available for this alias.
+ */
+function directFormFor(vendorPath, obj) {
+  if (obj[vendorPath]) { return obj[vendorPath]; } // explicit, authored, current direct id
+  if (DIVERGENT_VENDORS.has(vendorPath)) { return undefined; } // no explicit form + divergent → omit
+  const bare = toCanonicalDefault(obj.openrouter); // safe only when ids are identical across gateways
+  return bare !== obj.openrouter ? bare : undefined; // gateway-only vendor → undefined
+}
+
+/**
+ * @param {string} vendorPath
+ * @param {Object<string,string>} obj a family.fallback or cardless.routes map
+ * @returns {{direct?: string, openrouter: string}}
+ */
+function gatewayRoutesFor(vendorPath, obj) {
+  const routes = { openrouter: obj.openrouter };
+  const direct = directFormFor(vendorPath, obj);
+  if (direct) { routes.direct = direct; }
+  return routes;
+}
+
+/**
+ * @returns {Object<string,{direct?: string, openrouter: string}>} alias →
+ * per-gateway executable ids. Unlike `toDefaultAliases` (a single pinned
+ * string per alias, used for display/`config.default`), this carries BOTH
+ * gateway-native forms so the router (Task 3) can route direct-first
+ * without corrupting divergent-vendor ids (e.g. Anthropic's dash format).
+ */
+function toGatewayRoutes() {
+  const out = {};
+  for (const f of FAMILIES) { out[f.alias] = gatewayRoutesFor(f.vendorPath, f.fallback); }
+  for (const e of CARDLESS) { out[e.alias] = gatewayRoutesFor(vendorOf(e.routes.openrouter), e.routes); }
+  return out;
+}
+
+module.exports = {
+  getFamilies, toDefaultAliases, toCanonicalDefault, listCuratedRoutes, toGatewayRoutes, DIVERGENT_VENDORS
+};

package/src/utils/gateway-route-audit.js

@@ -0,0 +1,103 @@
+/**
+ * Per-gateway-form audit for curated DEFAULT aliases (Task 6, #gwid).
+ *
+ * Complements the flat alias-audit.js (which audits the single pinned string
+ * per alias from `toDefaultAliases()`/`listCuratedRoutes()`): this audits
+ * BOTH gateway-native forms from `curated-models.toGatewayRoutes()` against
+ * the live catalog.
+ *
+ *   - STALE      a stored form's id is absent from its namespace.
+ *   - DIVERGENT  a direct-capable vendor's alias is missing a `direct` form
+ *                the catalog can now confirm ('divergent-missing'), or its
+ *                stored `direct` form no longer matches what the catalog
+ *                pairs ('divergent-mismatch').
+ *
+ * Never reports against data it cannot trust: a direct namespace the process
+ * has no key for is skipped, not flagged --
+ *   - STALE relies on classifyModel(), whose 'unknown' already covers this
+ *     (empty namespace, or every row a non-authoritative floor-fallback).
+ *   - DIVERGENT additionally re-checks `authoritative` itself, because
+ *     pairAcrossGateways() (Task 5) is a pure string matcher that has no
+ *     concept of authoritative vs. floor-fallback rows -- left unguarded, it
+ *     would happily "confirm" a direct pairing against the hardcoded
+ *     Anthropic offline floor (e.g. matching a dated id like
+ *     claude-haiku-4-5-20251001 to the floor's undated claude-haiku-4-5) and
+ *     report a false mismatch with no key present at all.
+ *
+ * Consumed by `amicus models --check` (Task 6); `--strict` gates the exit
+ * code on these findings.
+ */
+
+'use strict';
+
+const { toGatewayRoutes } = require('./curated-models');
+const { classifyModel } = require('./model-classification');
+const { pairAcrossGateways } = require('./gateway-route-catalog');
+const { isDirectProvider } = require('./provider-registry');
+
+const OR_PREFIX = 'openrouter/';
+
+/** @param {string} orId e.g. 'openrouter/anthropic/claude-sonnet-5' @returns {string|null} vendor segment */
+function vendorOf(orId) {
+  if (typeof orId !== 'string' || !orId.startsWith(OR_PREFIX)) { return null; }
+  const rest = orId.slice(OR_PREFIX.length);
+  const i = rest.indexOf('/');
+  return i > 0 ? rest.slice(0, i) : null;
+}
+
+/**
+ * Bare model segment for pairAcrossGateways' versionToken -- Task-5's locked
+ * calling convention: strip BOTH the `openrouter/` and `<vendor>/` prefixes
+ * before calling, never pass the route string verbatim.
+ * @param {string} orId @param {string} vendor @returns {string|null}
+ */
+function bareSegment(orId, vendor) {
+  const prefix = `${OR_PREFIX}${vendor}/`;
+  return typeof orId === 'string' && orId.startsWith(prefix) ? orId.slice(prefix.length) : null;
+}
+
+/** @returns {boolean} true only when `id` names a live-fetched (not floor-fallback) catalog row */
+function isAuthoritative(catalogInfo, id) {
+  const models = (catalogInfo && Array.isArray(catalogInfo.models)) ? catalogInfo.models : [];
+  const row = models.find(m => m && m.id === id);
+  return !!row && row.authoritative !== false;
+}
+
+/**
+ * @param {{models: Array<{id:string, authoritative?: boolean}>, lastRefreshError?: string|null}} catalogInfo
+ * @returns {Array<{alias:string, gateway:'direct'|'openrouter',
+ *   kind:'stale'|'divergent-missing'|'divergent-mismatch', model:string, expected?:string}>}
+ */
+function auditGatewayRoutes(catalogInfo) {
+  const routes = toGatewayRoutes();
+  const findings = [];
+
+  for (const [alias, forms] of Object.entries(routes)) {
+    for (const gateway of ['direct', 'openrouter']) {
+      const id = forms[gateway];
+      if (!id) { continue; }
+      if (classifyModel(id, gateway, catalogInfo) === 'invalid') {
+        findings.push({ alias, gateway, kind: 'stale', model: id });
+      }
+    }
+
+    const vendor = vendorOf(forms.openrouter);
+    if (!vendor || !isDirectProvider(vendor)) { continue; } // gateway-only vendor: no direct route ever possible
+    const token = bareSegment(forms.openrouter, vendor);
+    if (!token) { continue; }
+    const paired = pairAcrossGateways(vendor, token, catalogInfo); // Task-5 contract: bare segment only
+    if (!paired.direct || !isAuthoritative(catalogInfo, paired.direct)) { continue; } // unconfirmed -- never guess
+
+    if (!forms.direct) {
+      findings.push({ alias, gateway: 'direct', kind: 'divergent-missing', model: paired.direct });
+    } else if (forms.direct !== paired.direct) {
+      findings.push({
+        alias, gateway: 'direct', kind: 'divergent-mismatch', model: forms.direct, expected: paired.direct
+      });
+    }
+  }
+
+  return findings;
+}
+
+module.exports = { auditGatewayRoutes };

package/src/utils/gateway-route-catalog.js

@@ -0,0 +1,92 @@
+/**
+ * Conservative cross-gateway catalog pairing helper (Task 5, #gwid).
+ *
+ * The same model has a different id per gateway namespace: direct
+ * `anthropic/claude-opus-4-8` (dashes, sometimes a trailing date suffix)
+ * vs. OpenRouter `openrouter/anthropic/claude-opus-4.8` (dots). This module
+ * pairs the two rows for a given vendor + version token, using a normalized
+ * comparison key ONLY to decide whether two catalog rows refer to the same
+ * model -- it never derives, transforms, or invents an id. Every id this
+ * module returns is copied verbatim from `catalogInfo.models[].id`.
+ *
+ * Used ONLY by `amicus models --check` (Task 6) to audit/refresh the curated
+ * per-gateway route map -- NOT on any launch hot path. Correctness-when-
+ * uncertain matters more than cleverness here: when a namespace has zero or
+ * more than one plausible match, that side is OMITTED rather than guessed.
+ *
+ * Pure function: no I/O, no network, no catalog fetch.
+ */
+
+'use strict';
+
+const OPENROUTER_PREFIX = 'openrouter/';
+/** Trailing 8-digit date suffix (e.g. '-20251001'), comparison-only. */
+const TRAILING_DATE_RE = /-\d{8}$/;
+
+/**
+ * Normalize a catalog id or a caller-supplied version token into a
+ * comparison-only key: strip a leading `openrouter/`, strip a leading
+ * `<vendor>/`, lowercase, unify '.'/'-' separators (dots become dashes), and
+ * drop a trailing 8-digit date suffix. The result is NEVER returned to
+ * callers -- it exists solely to decide whether two strings name the same
+ * model.
+ * @param {string} raw
+ * @param {string} vendor
+ * @returns {string|null} normalized key, or null when `raw` isn't a string
+ */
+function normalizeKey(raw, vendor) {
+  if (typeof raw !== 'string' || raw.length === 0) { return null; }
+  let s = raw;
+  if (s.startsWith(OPENROUTER_PREFIX)) { s = s.slice(OPENROUTER_PREFIX.length); }
+  const vendorPrefix = `${vendor}/`;
+  if (s.startsWith(vendorPrefix)) { s = s.slice(vendorPrefix.length); }
+  s = s.toLowerCase().replace(/\./g, '-');
+  s = s.replace(TRAILING_DATE_RE, '');
+  return s;
+}
+
+/**
+ * Find, in `catalogInfo.models`, the direct-namespace id and the
+ * OpenRouter-namespace id that both correspond to the model named by
+ * `versionToken` for `vendor`.
+ *
+ * Matching is conservative: a side is only included when EXACTLY ONE row in
+ * that namespace normalizes to the same key as `versionToken`. Zero matches
+ * or more than one plausible match (ambiguous) both result in that side
+ * being omitted -- never a guessed/fuzzy pick.
+ *
+ * @param {string} vendor e.g. 'anthropic'
+ * @param {string} versionToken e.g. 'claude-opus-4-8' or 'claude-opus-4.8'
+ * @param {{models: Array<{id: string}>}} catalogInfo
+ * @returns {{direct?: string, openrouter?: string}} verbatim catalog ids only
+ */
+function pairAcrossGateways(vendor, versionToken, catalogInfo) {
+  const models = (catalogInfo && Array.isArray(catalogInfo.models)) ? catalogInfo.models : [];
+  const targetKey = normalizeKey(versionToken, vendor);
+  const result = {};
+  if (targetKey === null) { return result; }
+
+  const directPrefix = `${vendor}/`;
+  const openrouterPrefix = `${OPENROUTER_PREFIX}${vendor}/`;
+
+  const directMatches = [];
+  const openrouterMatches = [];
+
+  for (const row of models) {
+    if (!row || typeof row.id !== 'string') { continue; }
+    const id = row.id;
+    if (id.startsWith(openrouterPrefix)) {
+      if (normalizeKey(id, vendor) === targetKey) { openrouterMatches.push(id); }
+    } else if (id.startsWith(directPrefix)) {
+      if (normalizeKey(id, vendor) === targetKey) { directMatches.push(id); }
+    }
+  }
+
+  // Exactly one candidate required per side -- ambiguity (>1) is treated the
+  // same as absence (0): omit rather than guess.
+  if (directMatches.length === 1) { result.direct = directMatches[0]; }
+  if (openrouterMatches.length === 1) { result.openrouter = openrouterMatches[0]; }
+  return result;
+}
+
+module.exports = { pairAcrossGateways };

package/src/utils/gateway-router.js

@@ -1,8 +1,9 @@
 /**
  * Pure gateway router (#61). Decides direct vs OpenRouter for a request using
  * only injected state (keys, catalogInfo, gatewayMode) — no I/O. Returns a
- * RouteResult (resolved | selection_required | error). Wiring into launch paths
- * is Plan 2; this module is behavior-neutral until then.
+ * RouteResult (resolved | selection_required | error). Wired into live launch
+ * paths via route-launch.js's resolveRouteForLaunch (start-helpers.js,
+ * mcp-server.js, sidecar/fanout-validate.js).
  */
 'use strict';
 
@@ -36,9 +37,18 @@ function catalogGate({ id, gateway, req }) {
     preferredGateway: gateway, suggestions: [] }) };
 }
 
+/**
+ * True when the given gateway is usable for this request: either the caller
+ * didn't supply per-gateway ids at all (back-compat: nothing to check), or it
+ * did and this specific gateway has a form in it.
+ */
+function hasForm(req, gateway) {
+  return !req.gatewayIds || req.gatewayIds[gateway] !== undefined;
+}
+
 /** Resolve to a concrete gateway after the catalog gate passes. */
 function finish(gateway, vendor, model, req) {
-  const id = executableFor(gateway, vendor, model);
+  const id = (req.gatewayIds && req.gatewayIds[gateway]) || executableFor(gateway, vendor, model);
   const gate = catalogGate({ id, gateway, req });
   if (!gate.ok) { return gate.result; }
   return resolved({ model: id, gateway, executableId: id,
@@ -93,6 +103,9 @@ function resolveRoute(req) {
     if (!rq.keys.openrouter) {
       return routeError({ requested: d.raw, reason: 'no_openrouter_key', preferredGateway: 'openrouter', suggestions: [] });
     }
+    if (!hasForm(rq, 'openrouter')) {
+      return routeError({ requested: d.raw, reason: 'openrouter_unavailable', preferredGateway: 'openrouter', suggestions: [] });
+    }
     return finish('openrouter', vendor, model, rq);
   }
   // 6. Explicit --gateway direct
@@ -100,13 +113,16 @@ function resolveRoute(req) {
     if (!rq.keys[vendor]) {
       return routeError({ requested: d.raw, reason: 'no_direct_key', preferredGateway: 'direct', suggestions: [] });
     }
+    if (!hasForm(rq, 'direct')) {
+      return routeError({ requested: d.raw, reason: 'direct_unavailable', preferredGateway: 'direct', suggestions: [] });
+    }
     return finish('direct', vendor, model, rq);
   }
   // 7. auto (direct-first)
-  if (rq.keys[vendor]) {
+  if (rq.keys[vendor] && hasForm(rq, 'direct')) {
     return finish('direct', vendor, model, rq);
   }
-  if (rq.keys.openrouter) {
+  if (rq.keys.openrouter && hasForm(rq, 'openrouter')) {
     return finish('openrouter', vendor, model, rq);
   }
   return routeError({ requested: d.raw, reason: 'no_key_for_vendor', preferredGateway: 'direct', suggestions: [] });

package/src/utils/model-fetcher.js

@@ -7,13 +7,19 @@
 
 const https = require('https');
 
-/** Hardcoded Anthropic models (no public listing endpoint) */
+/**
+ * Hardcoded Anthropic models (no public listing endpoint). This is the
+ * DIRECT-API floor only — Fable is OpenRouter-only (see curated-models.js
+ * DIVERGENT_VENDORS / CARDLESS 'fable' entry, which has no `anthropic` route)
+ * and must never appear here: classifyModel() returns 'valid' on a floor HIT
+ * before it ever checks `authoritative`, so listing an OR-only model here
+ * would mislabel a direct-API request for it as valid.
+ */
 const ANTHROPIC_MODELS = [
-  { id: 'anthropic/claude-opus-4-6', name: 'Claude Opus 4.6', contextLength: null, pricing: null },
-  { id: 'anthropic/claude-sonnet-4-6', name: 'Claude Sonnet 4.6', contextLength: null, pricing: null },
+  { id: 'anthropic/claude-opus-4-8', name: 'Claude Opus 4.8', contextLength: null, pricing: null },
+  { id: 'anthropic/claude-sonnet-5', name: 'Claude Sonnet 5', contextLength: null, pricing: null },
   { id: 'anthropic/claude-haiku-4-5', name: 'Claude Haiku 4.5', contextLength: null, pricing: null },
-  { id: 'anthropic/claude-sonnet-4-5', name: 'Claude Sonnet 4.5', contextLength: null, pricing: null },
-  { id: 'anthropic/claude-3-5-haiku', name: 'Claude 3.5 Haiku', contextLength: null, pricing: null }
+  { id: 'anthropic/claude-sonnet-4-6', name: 'Claude Sonnet 4.6', contextLength: null, pricing: null }
 ];
 
 const { PROVIDER_FAMILY_NAMES } = require('./provider-registry');