amicus 3.1.0 → 3.1.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "amicus",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Multi-model LLM Council + parallel AI window for Claude Code. Run structured council reviews across Gemini, GPT, DeepSeek and more — or fork a conversation to any model and fold the results back.",
   "author": {
     "name": "Christian Wagner"

package/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to Amicus are documented here. Format follows
 
 ## [Unreleased]
 
+## [3.1.1] - 2026-07-16
+
+### Fixed
+
+- **Anthropic model aliases now route correctly for direct-Anthropic-key users.** `--model opus` /
+  `haiku` / `claude` / `sonnet` previously resolved to OpenRouter's dot-form id (e.g.
+  `anthropic/claude-opus-4.8`), which the direct Anthropic API rejects with `model_not_found` (it uses
+  dashes/date suffixes: `claude-opus-4-8`, `claude-haiku-4-5-20251001`). Aliases now carry per-gateway
+  executable ids and the router emits the selected gateway's native id. OpenRouter-only users were
+  unaffected.
+
+### Changed
+
+- `--model claude` / `--model sonnet` default target moves from Claude Sonnet 4.6 to **Claude Sonnet
+  5**; the offline model floor was refreshed to the current Anthropic family.
+- Availability-aware routing: a model not served on the selected gateway (e.g. Fable, which is
+  OpenRouter-only) routes to the gateway that has it, or errors clearly under an explicit `--gateway`.
+
+### Added
+
+- `amicus models --check --strict` exits non-zero on curated default-alias drift; a scheduled
+  `model-drift` CI workflow audits the per-gateway ids against the live (keyless) OpenRouter catalog.
+
 ## [3.1.0] - 2026-07-15
 
 ### Added

package/README.md

@@ -4,7 +4,7 @@
 
 **A multi-model LLM Council for Claude — with a parallel AI window underneath.**
 
-![The Amicus council mid-ritual: five models — Gemini 3 Pro, Llama 4, Grok 4, Claude Opus — reading the same material independently, chaired by GPT-5](./docs/council.png)
+![The Amicus council mid-ritual: five models — Gemini, Llama, Grok, Claude Opus — reading the same material independently, chaired by GPT](./docs/council.png)
 
 Hand Claude a plan, a design, a diff, an architecture decision, a manuscript — anything — and say *council review this*: Amicus routes it through several models from different families, has them anonymously cross-review each other, and a non-Claude chair synthesizes a verdict you turn into accept/deny edits. Or skip the ceremony and **fork** a single conversation to Gemini, GPT, DeepSeek, or any other model — it works in parallel with full context, and you **fold** the result back when you're ready. Claude orchestrates throughout; you stay in your editor.
 
@@ -319,7 +319,7 @@ $ amicus status demo123 --json
   "taskId": "demo123",
   "status": "complete",
   "elapsed": "5m 0s",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "model": "google/gemini-2.5-flash",
   "phase": "terminal"
 }

package/electron/setup-ui-aliases.js

@@ -9,7 +9,7 @@
 const ALIAS_GROUPS = [
   { name: 'Gemini', keys: ['gemini', 'gemini-pro'] },
   { name: 'GPT', keys: ['gpt', 'gpt-pro', 'codex'] },
-  { name: 'Claude', keys: ['claude', 'sonnet', 'opus', 'haiku'] },
+  { name: 'Claude', keys: ['claude', 'sonnet', 'opus', 'haiku', 'fable'] },
   { name: 'DeepSeek', keys: ['deepseek'] },
   { name: 'Qwen', keys: ['qwen', 'qwen-coder', 'qwen-flash'] },
   { name: 'Mistral', keys: ['mistral', 'devstral'] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amicus",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "mcpName": "io.github.BourbonDog/amicus",
   "description": "Multi-model LLM Council + parallel AI window for Claude Code. Run structured council reviews across Gemini, GPT, DeepSeek and more — or fork a conversation to any model and fold the results back.",
   "keywords": [
@@ -59,6 +59,7 @@
     "refresh-models": "node bin/amicus.js models --refresh",
     "models:info": "node bin/amicus.js models",
     "models:check": "node bin/amicus.js models --check",
+    "models:check:strict": "node bin/amicus.js models --check --strict",
     "generate-icon": "node scripts/generate-icon.js",
     "generate-docs": "node scripts/generate-docs.js",
     "generate-docs:check": "node scripts/generate-docs.js --check",

package/src/cli.js

@@ -138,6 +138,7 @@ function isBooleanFlag(key) {
      'html',                 // council report: emit a self-contained HTML page
      'md',                   // council report: emit Markdown (default)
      'fix',                  // doctor: self-heal fixable checks in place (#56)
+     'strict',               // models --check: exit non-zero on curated per-gateway drift (#gwid Task 6)
    ];
   return booleanFlags.includes(key);
 }
@@ -436,6 +437,9 @@ Options for 'models':
   --search <q>                 Filter by substring over model id and name
   --refresh                    Force-refresh the catalog from provider APIs
   --check                      Audit aliases against the catalog (exit = stale count)
+  --strict                     With --check: also exit non-zero on curated
+                               per-gateway drift (stale/divergent direct or
+                               openrouter forms). Informational without it.
   --json                       Machine-readable output
 `,
   list: `

package/src/sidecar/models.js

@@ -14,6 +14,7 @@
 
 const { getCatalogInfo, refreshCatalog, catalogPath } = require('../utils/model-catalog');
 const { collectAliasSources, findStaleAliases, suggestReplacements } = require('../utils/alias-audit');
+const { auditGatewayRoutes } = require('../utils/gateway-route-audit');
 const { buildCatalogDoc, buildAuditDoc } = require('../utils/result-schema');
 const { getFamilies } = require('../utils/curated-models');
 const { pickCurrent } = require('../utils/quick-picks');
@@ -116,8 +117,20 @@ async function runRefresh(args) {
   return 0;
 }
 
+/** One readable line per gateway-route finding (Task 6, #gwid). @param {object} f @returns {string} */
+function fmtGatewayFinding(f) {
+  if (f.kind === 'stale') {
+    return `  GATEWAY STALE (${f.gateway}): ${f.alias} -> ${f.model}`;
+  }
+  if (f.kind === 'divergent-missing') {
+    return `  GATEWAY DIVERGENT: ${f.alias} has no direct form; catalog confirms ${f.model}`;
+  }
+  return `  GATEWAY DIVERGENT: ${f.alias} direct form ${f.model} no longer matches catalog (now ${f.expected})`;
+}
+
 async function runCheck(args) {
-  const { models: catalog } = await getCatalogInfo();
+  const catalogInfo = await getCatalogInfo();
+  const catalog = catalogInfo.models;
   if (!catalog || catalog.length === 0) {
     if (args.json) {
       process.stdout.write(JSON.stringify(buildAuditDoc({
@@ -131,35 +144,44 @@ async function runCheck(args) {
   const sources = collectAliasSources();
   const stale = findStaleAliases(sources, catalog)
     .map(s => ({ ...s, suggestions: suggestReplacements(s.model, catalog) }));
+  // Task 6 (#gwid): per-gateway-form audit of the curated DEFAULTS
+  // (toGatewayRoutes()) — additive to the flat audit above. Informational by
+  // default; --strict promotes it to a build-breaking exit code (CI gate).
+  const gatewayFindings = auditGatewayRoutes(catalogInfo);
+  const legacyExitCode = Math.min(stale.length, CHECK_EXIT_CAP);
+  const exitCode = args.strict
+    ? Math.max(legacyExitCode, Math.min(gatewayFindings.length, CHECK_EXIT_CAP))
+    : legacyExitCode;
+
   if (args.json) {
     process.stdout.write(JSON.stringify(buildAuditDoc({
-      stale, catalogAvailable: true
+      stale, catalogAvailable: true, gatewayFindings
     }), null, 2) + '\n');
-    return Math.min(stale.length, CHECK_EXIT_CAP);
+    return exitCode;
   }
   const driftLines = buildFallbackDriftReport(catalog);
   if (stale.length === 0) {
     process.stdout.write(`All aliases resolve to catalog models (${sources.length} checked).\n`);
-    if (driftLines.length > 0) {
-      process.stdout.write('Pinned fallback drift:\n');
-      for (const l of driftLines) { process.stdout.write(l + '\n'); }
-    }
-    return 0;
-  }
-  for (const s of stale) {
-    process.stdout.write(`STALE: ${s.alias} -> ${s.model} (${s.source})\n`);
-    if (s.suggestions.length > 0) {
-      process.stdout.write(`  candidates: ${s.suggestions.join(', ')}\n`);
-      process.stdout.write(`  fix: amicus setup --add-alias ${s.alias}=${s.suggestions[0]}\n`);
-    } else {
-      process.stdout.write('  no same-vendor candidates in catalog\n');
+  } else {
+    for (const s of stale) {
+      process.stdout.write(`STALE: ${s.alias} -> ${s.model} (${s.source})\n`);
+      if (s.suggestions.length > 0) {
+        process.stdout.write(`  candidates: ${s.suggestions.join(', ')}\n`);
+        process.stdout.write(`  fix: amicus setup --add-alias ${s.alias}=${s.suggestions[0]}\n`);
+      } else {
+        process.stdout.write('  no same-vendor candidates in catalog\n');
+      }
     }
   }
   if (driftLines.length > 0) {
     process.stdout.write('Pinned fallback drift:\n');
     for (const l of driftLines) { process.stdout.write(l + '\n'); }
   }
-  return Math.min(stale.length, CHECK_EXIT_CAP);
+  if (gatewayFindings.length > 0) {
+    process.stdout.write('Per-gateway route audit (curated defaults):\n');
+    for (const f of gatewayFindings) { process.stdout.write(fmtGatewayFinding(f) + '\n'); }
+  }
+  return exitCode;
 }
 
 /**

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,62 @@ 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).
+ */
+const DIVERGENT_VENDORS = 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
+};

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');

package/src/utils/result-schema.js

@@ -182,15 +182,22 @@ function buildCatalogDoc({ models, fetchedAt, refreshed = false, search = null,
 
 /**
  * Build an alias-audit document (`models --check --json`).
- * @param {{stale: Array<{alias,model,source,suggestions}>, catalogAvailable: boolean}} opts
+ * `gatewayFindings` (Task 6, #gwid) is additive: the per-gateway-form audit
+ * of curated DEFAULT aliases (toGatewayRoutes() vs. the live catalog),
+ * distinct from the flat `stale` audit above. Defaults to [] so existing
+ * callers that omit it are unaffected.
+ * @param {{stale: Array<{alias,model,source,suggestions}>, catalogAvailable: boolean,
+ *   gatewayFindings?: Array<{alias,gateway,kind,model,expected?}>}} opts
  */
-function buildAuditDoc({ stale, catalogAvailable }) {
+function buildAuditDoc({ stale, catalogAvailable, gatewayFindings = [] }) {
   return {
     schemaVersion: SCHEMA_VERSION,
     type: 'alias-audit',
     catalogAvailable,
     staleCount: stale.length,
     stale,
+    gatewayFindingsCount: gatewayFindings.length,
+    gatewayFindings,
   };
 }
 

package/src/utils/route-error.js

@@ -6,8 +6,9 @@
  *   - `toCliMessage`      -> a human stderr string for the CLI
  *
  * Pure module: no I/O, no requires of launch modules (cli.js/headless.js/
- * mcp-server.js/etc). Additive only — not imported by any launch path yet;
- * wiring is a later task in the #61 Integration plan.
+ * mcp-server.js/etc). Wired into live launch paths — start-helpers.js,
+ * sidecar/fanout-leg.js, and mcp-server.js all render RouteResults through
+ * toStructuredError/toCliMessage.
  *
  * Router error shape (src/utils/model-descriptor.js `routeError()`):
  *   {kind:'error', type:'model_route_error', field, requested, reason,
@@ -15,16 +16,28 @@
  * Selection shape (`selectionRequired()`):
  *   {kind:'selection_required', requested, suggestions}
  *
- * The router's error `reason` is a closed set of 7 values (ROUTE_ERROR_REASONS
- * below). A `selection_required` result has no `reason` of its own — it is
- * synthesized here as SELECTION_REQUIRED_REASON, kept in the same documented
- * REASON_TEXT map rather than invented ad hoc, so callers can treat every
- * rendered structured error the same way regardless of which RouteResult
- * produced it.
+ * The router's error `reason` is NOT limited to the 7 values in
+ * ROUTE_ERROR_REASONS below — that array is just the original/base set,
+ * intentionally pinned as-is (see its own doc comment). The router can also
+ * emit availability reasons (`direct_unavailable`, `openrouter_unavailable`),
+ * which have REASON_TEXT/FIX_HINTS entries but are deliberately excluded from
+ * ROUTE_ERROR_REASONS. A `selection_required` result has no `reason` of its
+ * own — it is synthesized here as SELECTION_REQUIRED_REASON, kept in the same
+ * documented REASON_TEXT map rather than invented ad hoc, so callers can
+ * treat every rendered structured error the same way regardless of which
+ * RouteResult produced it.
  */
 'use strict';
 
-/** The closed set of reasons a router `error` result can carry. */
+/**
+ * The original/base set of router error reasons — NOT an exhaustive list of
+ * every reason a router error can carry. Pinned to exactly these 7 values by
+ * a back-compat test (route-error.test.js:14-24), so this array must not be
+ * extended when new reasons are added. The router also emits
+ * `direct_unavailable` and `openrouter_unavailable` (REASON_TEXT/FIX_HINTS
+ * below have entries for both); those are intentionally left out of this
+ * array. Do not use ROUTE_ERROR_REASONS as an exhaustive switch/allow-list.
+ */
 const ROUTE_ERROR_REASONS = Object.freeze([
   'gateway_conflict',
   'no_openrouter_key',
@@ -51,6 +64,8 @@ const REASON_TEXT = Object.freeze({
   no_key_for_vendor: 'No API key was found for this vendor via any gateway.',
   model_not_found: 'The requested model was not found in the catalog.',
   invalid_descriptor: 'The model identifier could not be parsed.',
+  direct_unavailable: "This model isn't available on the vendor's direct API; use OpenRouter or a different model.",
+  openrouter_unavailable: "This model isn't on OpenRouter; use --gateway direct or a different model.",
   [SELECTION_REQUIRED_REASON]: 'Multiple models match your request; a specific one must be selected.',
 });
 
@@ -63,6 +78,8 @@ const FIX_HINTS = Object.freeze({
   no_key_for_vendor: 'Add a provider key or an OpenRouter key.',
   model_not_found: 'Run `amicus models --refresh`, or pass --no-validate-model.',
   invalid_descriptor: 'Use a vendor/model id or a configured alias.',
+  direct_unavailable: 'Drop --gateway direct (use auto or --gateway openrouter), or pick a different model.',
+  openrouter_unavailable: 'Use --gateway direct, or pick a different model.',
   [SELECTION_REQUIRED_REASON]: 'Pick one of the suggestions below, or narrow the model id.',
 });
 

package/src/utils/route-launch.js

@@ -1,9 +1,10 @@
 /**
  * Route-launch views (#61 gateway routing integration, Task 4.2).
  *
- * Additive, read-only helpers consumed by Task 4.4's resolveRouteForLaunch
- * (not wired into any launch path yet). Pure-ish: all I/O goes through the
- * stubbable api-key-store / auth-json / model-catalog modules.
+ * Read-only helpers consumed by resolveRouteForLaunch, which IS wired into
+ * live launch paths (start-helpers.js, mcp-server.js, sidecar/fanout-validate.js).
+ * Pure-ish: all I/O goes through the stubbable api-key-store / auth-json /
+ * model-catalog modules.
  */
 'use strict';
 
@@ -52,12 +53,20 @@ const ROUTE_VERSION = 1;
 /**
  * Build up to ~6 labeled alternatives for a `selection_required` RouteResult
  * (#61 Task 6.3, spec Decision 10). Pure: reads only the already-parsed
- * descriptor plus the live keys/catalogInfo the caller already assembled.
+ * descriptor plus the live keys/catalogInfo/gatewayIds the caller already
+ * assembled.
  *
  * Two categories, in order:
  *  1. The SAME model via OpenRouter — only when an OpenRouter key is present
- *     AND the OR-namespaced id (`openrouter/<vendor>/<model>`) is actually
- *     present in the catalog (never suggest an id we can't confirm exists).
+ *     AND the OR-namespaced id is actually present in the catalog (never
+ *     suggest an id we can't confirm exists). For divergent vendors (e.g.
+ *     Anthropic) `descriptor.model` may be the DASH-form direct id, so a
+ *     reconstructed `openrouter/<vendor>/<model>` would never match the
+ *     catalog's dot-form OR id -- when the caller's `gatewayIds.openrouter`
+ *     is available (the catalog-correct form), it is used instead of
+ *     reconstructing. Falls back to reconstruction when `gatewayIds` is
+ *     absent (non-alias / full-id / non-divergent requests), so behavior
+ *     there is unchanged.
  *  2. Up to 5 OTHER models in the same direct vendor namespace (ids starting
  *     `<vendor>/`, excluding the requested id itself and excluding any
  *     `openrouter/`-prefixed rows, which share the `<vendor>/` prefix check
@@ -68,9 +77,13 @@ const ROUTE_VERSION = 1;
  *   openrouter-literal — both carry vendor/model)
  * @param {Object<string,boolean>} keys per-provider key-presence map (buildLaunchKeys() shape)
  * @param {{models: Array<{id:string}>}} catalogInfo
+ * @param {{direct?: string, openrouter?: string}} [gatewayIds] the same
+ *   per-gateway id map resolveRouteForLaunch threads through resolveRoute
+ *   (Task 3's bridge for divergent curated aliases); absent for non-alias /
+ *   full-id / non-divergent requests
  * @returns {Array<{model:string, gateway:string, note:string}>}
  */
-function buildSuggestions(descriptor, keys, catalogInfo) {
+function buildSuggestions(descriptor, keys, catalogInfo, gatewayIds) {
   const suggestions = [];
   const vendor = descriptor && descriptor.vendor;
   const model = descriptor && descriptor.model;
@@ -80,7 +93,7 @@ function buildSuggestions(descriptor, keys, catalogInfo) {
   const requestedDirectId = `${vendor}/${model}`;
 
   if (keys && keys.openrouter) {
-    const orId = `openrouter/${vendor}/${model}`;
+    const orId = (gatewayIds && gatewayIds.openrouter) || `openrouter/${vendor}/${model}`;
     if (models.some(m => m && m.id === orId)) {
       suggestions.push({ model: orId, gateway: 'openrouter', note: 'same model via OpenRouter' });
     }
@@ -137,25 +150,52 @@ function maybeMigrationNotice({ result, descriptor, gatewayMode, keys }) {
 }
 
 /**
- * Bridge: alias -> descriptor -> resolveRoute (Task 4.4).
+ * Bridge: alias -> descriptor -> resolveRoute (Task 4.4; gatewayIds bridging
+ * Task 3 of #61's gateway-correct-model-ids fix).
  * Resolves a raw model string to a Descriptor — if it is a known no-slash
  * alias (per getEffectiveAliases()), its concrete id is parsed instead, so an
  * alias pointing at an `openrouter/...` value is treated as an explicit,
  * force-OR literal while an alias pointing at a bare `vendor/model` is
- * policy-routed like any other canonical id. Assembles live key/catalog state
- * and delegates the actual decision to the pure gateway-router. Additive:
- * not wired into any launch path yet.
+ * policy-routed like any other canonical id.
+ *
+ * When the alias is UNMODIFIED from its curated default (effective value ===
+ * getDefaultAliases()[alias]), this also looks up curated-models'
+ * toGatewayRoutes()[alias] and threads it through as `gatewayIds`, and parses
+ * the descriptor from the gateway-native direct form (falling back to the
+ * openrouter form) rather than the single pinned alias string — the pinned
+ * string can be the wrong per-gateway form for divergent vendors (e.g.
+ * Anthropic's dash ids vs. OpenRouter's dot ids), so `toGatewayRoutes()` is
+ * the source of truth for actually-correct ids. A USER OVERRIDE (the
+ * effective alias differs from the curated default) or an alias with no
+ * curated route map intentionally skips all of this: no gatewayIds, and the
+ * user's own alias string is parsed as before — we must never impose curated
+ * Anthropic-style ids onto a target the user chose themselves. Full-id /
+ * non-alias inputs are likewise unaffected (no gatewayIds).
+ *
+ * Assembles live key/catalog state and delegates the actual decision to the
+ * pure gateway-router. Wired into start-helpers.js, mcp-server.js, and
+ * sidecar/fanout-validate.js.
  * @param {{model:string, gatewayMode:string, source:string, allowSelection?:boolean, validateModel?:boolean}} opts
  * @returns {Promise<object>} RouteResult (resolved | selection_required | error)
  */
 async function resolveRouteForLaunch({ model, gatewayMode, source, allowSelection, validateModel }) {
-  // Lazy-required so jest.doMock('./config' | './model-descriptor' | './gateway-router', ...)
+  // Lazy-required so jest.doMock('./config' | './model-descriptor' | './gateway-router' | './curated-models', ...)
   // can intercept them per-test, matching the pattern already used above for model-catalog.
-  const { getEffectiveAliases } = require('./config');
+  const { getEffectiveAliases, getDefaultAliases } = require('./config');
   const { parseDescriptor } = require('./model-descriptor');
   const { resolveRoute } = require('./gateway-router');
+  const { toGatewayRoutes } = require('./curated-models');
   const aliases = getEffectiveAliases();
-  const concrete = (typeof model === 'string' && !model.includes('/') && aliases[model]) ? aliases[model] : model;
+  const isAlias = typeof model === 'string' && !model.includes('/') && !!aliases[model];
+  let concrete = isAlias ? aliases[model] : model;
+  let gatewayIds;
+  if (isAlias && aliases[model] === getDefaultAliases()[model]) {
+    const routes = toGatewayRoutes()[model];
+    if (routes) {
+      gatewayIds = routes;
+      concrete = routes.direct || routes.openrouter;
+    }
+  }
   const descriptor = parseDescriptor(concrete, { aliases });
   const keys = buildLaunchKeys();
   // Skip the catalog fetch entirely under --no-validate-model: gateway-router's
@@ -166,12 +206,12 @@ async function resolveRouteForLaunch({ model, gatewayMode, source, allowSelectio
   // own `=== false` guard: any other value (incl. an omitted flag) still fetches,
   // so a caller can never skip the fetch while the gate still classifies against it.
   const catalogInfo = validateModel === false ? { models: [], lastRefreshError: null } : await getRouteCatalogInfo();
-  let result = resolveRoute({ descriptor, source, gatewayMode, allowSelection, validateModel, keys, catalogInfo });
+  let result = resolveRoute({ descriptor, source, gatewayMode, allowSelection, validateModel, keys, catalogInfo, gatewayIds });
   if (result.kind === 'resolved') {
     result.provenance = { ...result.provenance, resolutionVersion: ROUTE_VERSION };
     result = maybeMigrationNotice({ result, descriptor, gatewayMode, keys });
   } else if (result.kind === 'selection_required') {
-    result.suggestions = buildSuggestions(descriptor, keys, catalogInfo);
+    result.suggestions = buildSuggestions(descriptor, keys, catalogInfo, gatewayIds);
   }
   return result;
 }