amicus 4.1.0 → 4.1.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "amicus",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "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,119 @@ All notable changes to Amicus are documented here. Format follows
 
 ## [Unreleased]
 
+## [4.1.2] - 2026-07-22
+
+### Fixed
+
+- **Claude model aliases no longer drift between the direct API and OpenRouter.** The two
+  gateways spell the same model differently — OpenRouter serves `anthropic/claude-opus-4.8`,
+  the direct Anthropic API serves `anthropic/claude-opus-4-8` — and three places converted
+  between the two by adding or removing the `openrouter/` prefix. That is only sound when the
+  rest of the id is identical, which for Claude it is not. Two user-visible consequences: a fresh
+  `amicus setup` wrote an `opus` alias that `amicus doctor` then reported as stale (the exact
+  warning 4.1.1 shipped to remove — and it fired even with an Anthropic-only catalog, not just
+  for OpenRouter users), and the pre-registered fallback catalog handed to a long-lived shared
+  server carried two ids OpenRouter does not serve while omitting the two it does. All three
+  sites now read each gateway's authored route instead of deriving one from the other, and an
+  alias you have overridden yourself is left alone rather than inheriting a curated route.
+  Affects `opus` and `haiku`; every other alias is spelled identically on both gateways or is
+  OpenRouter-only. Default routing is direct-first and was never affected — no run selected a
+  wrong model.
+
+## [4.1.1] - 2026-07-21
+
+### Fixed
+
+- **The integration tier is tested again, and now something actually watches it.** All 14
+  `tests/**/*.integration.test.js` files were unreachable from every gate — `jest.config.js` excludes
+  them from `npm test`, no workflow ran `npm run test:integration`, and the pre-push hook ran only the
+  unit suite. Six tests had been failing unnoticed behind a single dead model alias: three E2E suites
+  passed `--model gemini-flash`, which is not a live alias (`tryResolveModel('gemini-flash')` returns
+  `Unknown model alias`). They now pass `gemini`.
+- **`--claude-review` reports no longer grow a blank `claude` judge column, or a false self-vote `*`.**
+  `report.js`'s `toModel()` reused `verdict.council` (the street-cred universe, which legitimately
+  includes `claude` on a `--claude-review` run) as the adjudication-matrix judge roster too. Claude is
+  judged but never judges, so the matrix grew an extra column that always rendered blank, or a bare
+  `*` on a row Claude itself raised — asserting Claude voted for its own finding, the opposite of the
+  documented guarantee. `judges` is now filtered out of `council` independently (gated on the
+  `claudeInCouncil` flag plus the `claude` name, never on whether a model cast any adjudications, so a
+  genuinely dead/unstructured bench judge with zero votes still keeps its blank column).
+- **`debate-revote` now checkpoints `skipped`, not a false `complete`, when the re-vote wave never
+  launches** (nothing was defended/amended, or the cost ceiling skipped it). **This is a
+  consumer-visible `run.json` value change**: anything parsing `stages[].status` for this stage — the
+  Council Review Action's stage-ladder footer, `amicus status`, or a user script — now sees `skipped`
+  instead of `complete` on a run that hits this path. Neither the Action's footer nor `amicus
+  status`'s human/JSON renderers special-case `complete`, so both already print whatever value is
+  there correctly; a script that hard-coded an expectation of `complete` for this stage should treat
+  `skipped` as the equivalent no-op, the same way `run-chair.js`'s existing chair-skipped-over-budget
+  convention already works.
+- **`amicus council verdict --render` now writes `report.html` at `0o600`**, matching every sibling
+  writer (`run-assemble.js`, `mcp-server.js`'s `amicus_verdict` `render:true` path, `run-launch.js`).
+  It previously wrote with no explicit mode, which falls back to the process umask (typically `0o644`
+  on POSIX — group/world-readable) whenever the target directory had no pre-existing `report.html`,
+  i.e. exactly the fresh-`--out-dir` case, for a file that holds model output.
+- **Dropped the false `amicus wait` CLI claim.** `docs/usage.md` and `docs/council.md` both documented
+  `amicus status|wait|abort <councilRunId>` as working CLI commands. There is no CLI `wait` (verified
+  against `bin/amicus.js`'s command dispatch) — only `status` and `abort` genuinely resolve council
+  runs via the sessions-dir pointer file. Both docs now point readers at the MCP `amicus_wait` tool
+  instead.
+
+### Added
+
+- **Keyless integration job in CI.** `.github/workflows/ci.yml` gained an `integration` job that runs
+  `npm run test:integration` with no secrets on every push and PR, so the tier is permanently watched
+  for free (~51 assertions, ~10s). `npm run test:integration` now goes through
+  `scripts/run-integration-keyless.js`, which strips every provider credential and sandboxes
+  `HOME`/`USERPROFILE` before spawning jest — the money-spending suites self-skip and the script cannot
+  bill even on a machine with keys on disk. The scrub derives its key names from the engine's own
+  `PROVIDER_ENV_MAP`, so it covers providers and paid suites added later without maintenance.
+- **`npm run test:integration:live`** — the paid rail, split out so the CI job cannot silently start
+  billing if secrets are ever added to it. Run by the new `.github/workflows/integration-live.yml`
+  (`workflow_dispatch` only, carries `secrets.OPENROUTER_API_KEY`) and by the release checklist in
+  `docs/publishing.md`.
+
+### Fixed (docs)
+
+- `docs/testing.md` and `CLAUDE.md` both claimed a pre-push integration gate that has never existed;
+  the pre-push hook runs the unit suite only, deliberately, so a local push never spends money. Both
+  now describe the real rails, and `.husky/pre-push`'s stale "until the 'Fix integration tests' task
+  lands" comment is replaced with the reason the hook stays unit-only.
+- **`amicus doctor` no longer warns about Amicus's own shipped defaults — on a fresh install, and in
+  the keyless `model-drift.yml` CI check.** Both previously reported `⚠ Model aliases: 2 stale: opus,
+  haiku` (and the scheduled Model Drift Check ran red) with no user config involved.
+  `toDefaultAliases()` built each alias's pinned id by string-stripping the `openrouter/` prefix
+  instead of routing through the module's own `directFormFor()`, so it emitted OpenRouter's dot ids
+  for Anthropic — `anthropic/claude-opus-4.8`, `anthropic/claude-haiku-4.5` — which the direct API
+  rejects, and invented a bare `anthropic/claude-fable-5` for a model OpenRouter serves exclusively.
+  Defaults now come from `toGatewayRoutes()`, so an alias resolves to its authored direct form when
+  one exists (`anthropic/claude-opus-4-8`, `anthropic/claude-haiku-4-5-20251001`) and to its
+  OpenRouter route when none does (`openrouter/anthropic/claude-fable-5`). `fable`'s *recorded* form
+  changes, but this is **not a routing change** — OpenRouter was already the only gateway that serves
+  it, so a `fable` run resolves and routes identically before and after; only the id `doctor`/`amicus
+  models` display and compare against is different. Council artifacts are unaffected either way — they
+  record alias strings, not resolved ids.
+  - **This fix does not reach everyone who already ran `amicus setup`.** `createDefaultConfig()`
+    (`src/sidecar/setup.js`) persists the *entire* default alias map into `config.json` at setup time,
+    and `getEffectiveAliases()` lets that persisted user config win over the shipped defaults — so
+    anyone who ran `amicus setup` on Amicus ≤4.1.0 has the old, broken ids frozen on disk
+    (`source: user-config`), which `findStaleAliases()` never suppresses. Measured: such a user sees
+    **4 stale** aliases after upgrading to 4.1.1 — `opus`, `haiku`, `fable` (the pre-fix ids) plus
+    `gemini` (this release's own pin move, see Changed below) — not zero, and `amicus doctor` /
+    the Model Drift Check will keep warning for them. **There is no code fix for this in 4.1.1**; a
+    self-healing config migration is a 4.2 candidate. If `amicus doctor` still warns after upgrading,
+    re-run `amicus setup`, or fix individual aliases by hand, e.g.
+    `amicus setup --add-alias opus=anthropic/claude-opus-4-8`.
+- The offline Anthropic model floor now also lists `anthropic/claude-haiku-4-5-20251001`, the dated id
+  Anthropic's own listing returns. Without it, keyless and OpenRouter-only users saw the shipped
+  `haiku` default reported stale against the shipped floor.
+
+### Changed
+
+- **Curated `gemini` pin moves from Gemini 3.5 Flash to Gemini 3.6 Flash on both gateways.** This is a
+  **silent model change, not merely a drift-notice cleanup**: a user with no `gemini` alias override of
+  their own starts talking to a different underlying model the next time they use the `gemini` alias
+  after upgrading. It also clears the pinned-fallback drift notice from `amicus models --check`.
+
 ## [4.1.0] - 2026-07-21
 
 The `second-opinion` skill stops hand-driving councils. Stages 1–3 and the Stage-5 artifacts

package/README.md

@@ -329,7 +329,7 @@ $ amicus status demo123 --json
   "taskId": "demo123",
   "status": "complete",
   "elapsed": "5m 0s",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "model": "google/gemini-2.5-flash",
   "phase": "terminal"
 }
@@ -352,7 +352,7 @@ amicus models --search gemini # filter by substring
 
 ### Routing
 
-- **Bare `provider/model`** (e.g. `openai/gpt-5.5`, `anthropic/claude-opus-4.8`, `google/gemini-3.5-flash`) is the canonical, policy-routed form — Amicus routes it **direct-first**: your direct provider key when one is configured, falling back to OpenRouter automatically when only an OpenRouter key exists.
+- **Bare `provider/model`** (e.g. `openai/gpt-5.5`, `anthropic/claude-opus-4-8`, `google/gemini-3.6-flash`) is the canonical, policy-routed form — Amicus routes it **direct-first**: your direct provider key when one is configured, falling back to OpenRouter automatically when only an OpenRouter key exists.
 - **`openrouter/provider/model`** is an explicit override that always forces OpenRouter, even when a direct key is present — reach for it deliberately, or for gateway-only vendors with no direct integration (Qwen, Grok, Mistral, GLM, …).
 - **`--gateway auto|direct|openrouter`** (CLI, also on the MCP tools) overrides routing for one call; `auto` is the direct-first default. `routing.prefer` in `config.json` (`"direct"` by default, or `"openrouter"`) sets the global default.
 - **One-time migration notice:** if you hold both an OpenRouter key and a direct key for a vendor, the first launch that resolves to that vendor under **`auto`** routing (the default) prints a one-time notice that routing moved to direct API; set `routing.prefer: "openrouter"` to restore the old all-OpenRouter behavior. The notice never fires when you explicitly pass `--gateway direct` — that's your own choice, not a migration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amicus",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "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": [
@@ -49,7 +49,8 @@
   "scripts": {
     "start": "node --experimental-top-level-await --experimental-vm-modules bin/amicus.js",
     "test": "jest",
-    "test:integration": "jest --testPathIgnorePatterns='worktrees' --testMatch='**/tests/**/*.integration.test.js'",
+    "test:integration": "node scripts/run-integration-keyless.js",
+    "test:integration:live": "jest --testPathIgnorePatterns='worktrees' --testMatch='**/tests/**/*.integration.test.js'",
     "test:all": "jest --testPathIgnorePatterns='/node_modules/' --testPathIgnorePatterns='worktrees' && node scripts/mark-test-passed.js",
     "test:e2e:mcp": "jest tests/mcp-repomix-e2e.integration.test.js --testTimeout=180000 --forceExit",
     "posttest": "node scripts/mark-test-passed.js",

package/skills/second-opinion/SKILL.md

@@ -513,7 +513,7 @@ Use these together with `amicus council stats` (the ledger — authoritative qua
 
 Always **rank recommendations by fit**, state the trade-off for each option, and surface the estimated cost (an estimate, not a guarantee; unpriced legs disclosed as "cost unknown"). Never present a single option without explanation.
 
-**Model naming for council members.** Name bench members by alias (`gemini`, `gpt`, `deepseek`, `opus`, …) or by full `provider/model` id — both work with `--models`. A bare canonical id (e.g. `anthropic/claude-opus-4.8`) is policy-routed **direct-first**: Amicus uses the user's direct provider key when one is configured, falling back to OpenRouter automatically. `openrouter/provider/model` is an explicit force-OpenRouter override — reach for it only when the user deliberately wants a specific member to run through OpenRouter (e.g. to use a free-tier variant), or for gateway-only vendors with no direct integration. A per-run `--gateway auto|direct|openrouter` overrides routing for the whole run if the user asks for it; leave it unset (`auto`) by default.
+**Model naming for council members.** Name bench members by alias (`gemini`, `gpt`, `deepseek`, `opus`, …) or by full `provider/model` id — both work with `--models`. A bare canonical id (e.g. `anthropic/claude-opus-4-8`) is policy-routed **direct-first**: Amicus uses the user's direct provider key when one is configured, falling back to OpenRouter automatically. `openrouter/provider/model` is an explicit force-OpenRouter override — reach for it only when the user deliberately wants a specific member to run through OpenRouter (e.g. to use a free-tier variant), or for gateway-only vendors with no direct integration. A per-run `--gateway auto|direct|openrouter` overrides routing for the whole run if the user asks for it; leave it unset (`auto`) by default.
 
 ---
 

package/skills/sidecar/SKILL.md

@@ -79,8 +79,8 @@ Amicus uses the OpenCode SDK to communicate with LLM providers. You need to conf
 
 Read this before picking a model string — it decides both routing and which credentials get used:
 
-- **Bare `provider/model`** (e.g. `openai/gpt-5.5`, `anthropic/claude-opus-4.8`, `google/gemini-3.5-flash`) is the **canonical, policy-routed** form — use it by default. Amicus routes it **direct-first**: your direct provider key when one is configured, falling back to OpenRouter automatically when only `OPENROUTER_API_KEY` exists. You never pick the gateway by hand.
-- **`openrouter/provider/model`** (e.g. `openrouter/google/gemini-3.5-flash`) is an **explicit force-OpenRouter override** — it always routes through OpenRouter even when a direct key is present. Reach for it deliberately, or for gateway-only vendors with no direct integration at all (Qwen, Grok, Mistral, GLM, MiniMax, Kimi, Seed, …) — those *require* the `openrouter/` prefix.
+- **Bare `provider/model`** (e.g. `openai/gpt-5.5`, `anthropic/claude-opus-4-8`, `google/gemini-3.6-flash`) is the **canonical, policy-routed** form — use it by default. Amicus routes it **direct-first**: your direct provider key when one is configured, falling back to OpenRouter automatically when only `OPENROUTER_API_KEY` exists. You never pick the gateway by hand.
+- **`openrouter/provider/model`** (e.g. `openrouter/google/gemini-3.6-flash`) is an **explicit force-OpenRouter override** — it always routes through OpenRouter even when a direct key is present. Reach for it deliberately, or for gateway-only vendors with no direct integration at all (Qwen, Grok, Mistral, GLM, MiniMax, Kimi, Seed, …) — those *require* the `openrouter/` prefix.
 - Short aliases (`gemini`, `gpt`, `opus`, `claude`, `deepseek`, …) resolve to one of the two forms above via your config; `amicus setup` seeds direct-capable vendors to the bare canonical form automatically.
 - **Routing controls:** `routing.prefer` in `~/.config/amicus/config.json` sets the global default — `"direct"` (the default) or `"openrouter"` to always prefer OpenRouter. Per call, `--gateway auto|direct|openrouter` overrides it (`auto` = direct-first, same as the default).
 - **One-time migration notice:** if you hold both an OpenRouter key and a direct key for a vendor, the first launch that resolves to that vendor prints a one-time notice that routing moved to direct API (previously OpenRouter); set `routing.prefer: "openrouter"` (or pass `--gateway openrouter`) to restore the old all-OpenRouter behavior.
@@ -116,8 +116,8 @@ amicus start --model gemini --prompt "Say hello" --no-ui
 **With OpenRouter as your only key**, aliases and bare canonical ids both work — the router falls back to OpenRouter automatically since no direct key exists for the vendor:
 ```bash
 amicus start --model gemini --prompt "..."                              # alias
-amicus start --model google/gemini-3.5-flash --prompt "..."             # bare canonical, falls back to OpenRouter
-amicus start --model openrouter/google/gemini-3.5-flash --prompt "..."  # explicit override — same result here
+amicus start --model google/gemini-3.6-flash --prompt "..."             # bare canonical, falls back to OpenRouter
+amicus start --model openrouter/google/gemini-3.6-flash --prompt "..."  # explicit override — same result here
 ```
 
 ### Option B: Direct API Keys (Provider-Specific)
@@ -451,7 +451,7 @@ Use short aliases (run `amicus models` to see the live catalog, and `amicus mode
 - Omit `--model` entirely to use your configured default
 
 Full model strings also work: `--model provider/model-id` (bare canonical, direct-first — e.g.
-`--model anthropic/claude-opus-4.8`) or `--model openrouter/provider/model-id` (explicit
+`--model anthropic/claude-opus-4-8`) or `--model openrouter/provider/model-id` (explicit
 force-OpenRouter override).
 
 ### Verifying Model Names

package/src/cli-handlers-council.js

@@ -181,7 +181,7 @@ function runVerdict(args, useJson) {
     // v4.1 §4.5c: refresh report.html next to the decided verdict.
     try {
       const html = buildReport({ verdict }, { format: 'html' });
-      fs.writeFileSync(path.join(path.dirname(outPath), 'report.html'), html);
+      fs.writeFileSync(path.join(path.dirname(outPath), 'report.html'), html, { mode: 0o600 });
     } catch (e) {
       return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `verdict written but render failed: ${e.message}`,
         hint: 'the verdict.json is valid; re-run `amicus council report <verdict.json> --html` manually' });

package/src/council/report.js

@@ -20,7 +20,19 @@ function toModel(verdict, wave) {
   if (!verdict || !Array.isArray(verdict.findings)) {
     throw new Error('verdict.json must have a findings[] array');
   }
-  const judges = verdict.council || [];
+  const council = verdict.council || [];
+  // 'council' (verdict.council / meta.models) is the street-cred universe and
+  // legitimately includes 'claude' on a --claude-review run (run-assemble.js:
+  // 123-125, docs/council.md:326). 'judges' is the adjudication-matrix column
+  // set: SKILL.md:482 / run-stages.js:162-163 guarantee Claude is judged but
+  // never judges, so its reserved seat must never grow a matrix column — filter
+  // it out ONLY when claudeInCouncil is true. This is name+flag gated, not
+  // vote-derived: a bench judge that cast zero adjudications (dead/unstructured
+  // leg, run-stages.js:204-207) is still in council/judges and must still get
+  // its (blank) column — deriving the roster from "who actually voted" would
+  // silently delete that column too and break the byte-unchanged-artifact
+  // contract for degraded v4.0.1-shaped runs.
+  const judges = verdict.claudeInCouncil === true ? council.filter(j => j !== 'claude') : council;
   const findings = verdict.findings.map((f) => {
     const byJudge = {};
     for (const j of judges) { byJudge[j] = null; }
@@ -61,7 +73,7 @@ function toModel(verdict, wave) {
   return {
     header: {
       runType: verdict.runType || 'review', runId: verdict.runId, date: verdict.date,
-      chair: verdict.chair, council: judges, claudeInCouncil: verdict.claudeInCouncil === true,
+      chair: verdict.chair, council, claudeInCouncil: verdict.claudeInCouncil === true,
     },
     tierCounts: verdict.tierCounts || { Confirmed: 0, Contested: 0, Singleton: 0, Disputed: 0 },
     judges, findings, debate,

package/src/council/run-debate.js

@@ -223,7 +223,11 @@ async function runDebate(ctx, { provisionalRecord, tallyInput }) {
   // degradation branch (spec §5.7); skipping because there is simply nothing to re-vote is NOT.
   const wouldRevote = defendedOrAmended.length > 0 && judges.length > 0;
   const costCeiling = ctx.overBudget() && wouldRevote;
-  if (wouldRevote && !costCeiling) {
+  // run.js needs to know whether the wave actually launched so it can
+  // checkpoint debate-revote 'skipped' (not a false 'complete') when nothing
+  // was defended/amended, or the cost ceiling skipped it (spec §5.7).
+  const revoteLaunched = wouldRevote && !costCeiling;
+  if (revoteLaunched) {
     const rv = await runRevoteWave(ctx, judges, defendedOrAmended);
     if (rv.aborted) { return { aborted: rv.aborted, contested, disputed }; }
     revoteByJudge = rv.byJudge;
@@ -283,7 +287,7 @@ async function runDebate(ctx, { provisionalRecord, tallyInput }) {
 
   return { debatedInput, debateFindings, debateSummary, addendumOutcomes,
     defenseLegs: defenseResults.map(d => d.leg), revoteLegs, verdictChanges,
-    degraded, aborted: null };
+    degraded, aborted: null, revoteLaunched };
 }
 
 module.exports = { runDebate, nothingToDebate, disputingJudges, debateTargets };

package/src/council/run.js

@@ -198,7 +198,11 @@ async function runCouncil(options, deps = {}) {
         // run-debate owns debate-revote's running/waveId/waveIds checkpoint — only it
         // knows whether the wave launched. Never advertise a `-rv` id here: a skipped
         // re-vote would leave the abort cascade chasing the v4.0 lens `-s1` phantom.
-        runState.updateStage(o.runDir, 'debate-revote', { status: 'complete', completedAt: now() });
+        // Mirror run-chair.js's 'skipped' convention (no startedAt) when nothing was
+        // defended/amended or the cost ceiling skipped it — 'complete' would report
+        // work that never happened.
+        runState.updateStage(o.runDir, 'debate-revote', dbg.revoteLaunched
+          ? { status: 'complete', completedAt: now() } : { status: 'skipped', completedAt: now() });
         ({ debatedInput, debateFindings, debateSummary } = dbg);
         debatedRecord = tally(debatedInput);
         // Defensive truthiness guard: `[]` is truthy in JS, so an empty outcomes

package/src/mcp-tools.js

@@ -57,7 +57,7 @@ function getTools() {
     inputSchema: {
       model: safeModel.optional().describe(
         `Short alias (${aliasNames}) or full model ID ` +
-        '(bare provider/model is canonical and routes direct-first, e.g. anthropic/claude-opus-4.8; ' +
+        '(bare provider/model is canonical and routes direct-first, e.g. anthropic/claude-opus-4-8; ' +
         'openrouter/provider/model forces OpenRouter). ' +
         'If omitted, uses the configured default. Call amicus_guide to see all aliases.'
       ),
@@ -581,7 +581,7 @@ Include: Objective, Background, Files of interest, Success criteria, Constraints
 |-------|-------|
 ${aliasRows}
 
-Or use a full model ID. Bare \`provider/model\` (e.g. anthropic/claude-opus-4.8) is the canonical,
+Or use a full model ID. Bare \`provider/model\` (e.g. anthropic/claude-opus-4-8) is the canonical,
 policy-routed form — it routes direct-first (your direct provider key if configured, else
 OpenRouter). \`openrouter/provider/model\` is an explicit override that forces OpenRouter. The
 \`gateway\` param (or \`routing.prefer\` in config.json) controls this per call or globally.

package/src/sidecar/setup.js

@@ -353,8 +353,7 @@ async function runReadlineSetup() {
       return;
     }
 
-    const { resolveQuickPicks, toLiveSeedAliases } = require('../utils/quick-picks');
-    const { toCanonicalDefault } = require('../utils/curated-models');
+    const { resolveQuickPicks, toLiveSeedAliases, toStorableRoute } = require('../utils/quick-picks');
     const picks = resolveQuickPicks(catalog);
 
     console.log('Choose your default model:');
@@ -386,7 +385,7 @@ async function runReadlineSetup() {
       // 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]);
+        cfg.aliases[chosen.alias] = toStorableRoute(pick);
       } else if (cfg.aliases[chosen.alias] === undefined) {
         const fallback = getDefaultAliases()[chosen.alias];
         if (fallback !== undefined) { cfg.aliases[chosen.alias] = fallback; }

package/src/utils/config.js

@@ -12,8 +12,9 @@ const { autoRepairAlias } = require('./alias-resolver');
 const { isDirectProvider } = require('./provider-registry');
 
 /** Default model alias map — derived from the curated-models single source (F5) */
-const { toDefaultAliases } = require('./curated-models');
+const { toDefaultAliases, toGatewayRoutes } = require('./curated-models');
 const DEFAULT_ALIASES = toDefaultAliases();
+const CURATED_ROUTES = toGatewayRoutes();
 
 /** Built-in council benches (B23) — consulted only when a name is absent from user config. */
 const { resolveBuiltinCouncil } = require('./council-presets');
@@ -261,10 +262,19 @@ function tryResolveModel(modelArg) {
  * threading only that first session's resolved id is insufficient. So for
  * every alias that resolves to a BARE direct-capable-vendor id (post-#61
  * default aliases are bare, e.g. `openai/gpt-5.5`), this ALSO registers the
- * `openrouter/<vendor>/<model>` form — broadening the catalog to cover BOTH
- * routes the router might pick, regardless of which session created the
- * server. This does NOT change what the alias itself resolves to (still
- * bare, still direct-first) — it only widens what's pre-registered.
+ * alias's OpenRouter form — broadening the catalog to cover BOTH routes the
+ * router might pick, regardless of which session created the server. This
+ * does NOT change what the alias itself resolves to (still bare, still
+ * direct-first) — it only widens what's pre-registered.
+ *
+ * The mirror is read from the alias's authored gateway route, NOT built by
+ * prepending `openrouter/`. For DIVERGENT_VENDORS the two ids are different
+ * strings, not merely differently prefixed — OpenRouter serves
+ * `anthropic/claude-opus-4.8` while the direct API serves
+ * `anthropic/claude-opus-4-8`. v4.1.1 made `toDefaultAliases()` emit the
+ * direct form, at which point prepending produced an id OpenRouter does not
+ * serve (fixed in v4.1.2). Aliases the user has overridden fall back to the
+ * prefix form, since no authored gateway route describes them.
  * @param {string[]} [resolvedRoutes] executable model id(s) actually launched
  * @returns {object} e.g. { openrouter: { models: { "x-ai/grok-4.3": {}, ... } } } */
 function buildProviderModels(resolvedRoutes = []) {
@@ -285,13 +295,23 @@ function buildProviderModels(resolvedRoutes = []) {
     providers[providerID].models[modelID] = {};
   };
 
-  for (const fullModel of Object.values(aliases)) {
+  for (const [alias, fullModel] of Object.entries(aliases)) {
     addRoute(fullModel);
 
     // Broaden: a bare direct-capable-vendor route also gets an OpenRouter
-    // mirror registered (see catalog-broadening note above). Gateway-only
-    // aliases (already `openrouter/...`, e.g. grok/qwen/x-ai) are untouched —
-    // OpenRouter is their only possible route anyway, already covered above.
+    // mirror registered (see catalog-broadening note above). Prefer the
+    // alias's AUTHORED OpenRouter route — for divergent vendors it is a
+    // different id, not a prefixed one. Guarded on the alias still holding its
+    // shipped direct value so a user override never inherits a curated route.
+    const curated = CURATED_ROUTES[alias];
+    if (curated && curated.openrouter && curated.direct === fullModel) {
+      addRoute(curated.openrouter);
+      continue;
+    }
+
+    // Fallback for user-defined aliases. Gateway-only aliases (already
+    // `openrouter/...`, e.g. grok/qwen/x-ai) are untouched — OpenRouter is
+    // their only possible route anyway, already covered above.
     if (typeof fullModel === 'string' && !fullModel.startsWith('openrouter/')) {
       const vendor = fullModel.split('/')[0];
       if (isDirectProvider(vendor)) {

package/src/utils/curated-models.js

@@ -30,8 +30,8 @@ const FAMILIES = [
     vendorPath: 'google',
     idPattern: /^gemini-[\d.]+-flash(-preview|-exp|-latest)?$/,
     directProviders: ['google'],
-    fallback: { openrouter: 'openrouter/google/gemini-3.5-flash',
-                google: 'google/gemini-3.5-flash' } },
+    fallback: { openrouter: 'openrouter/google/gemini-3.6-flash',
+                google: 'google/gemini-3.6-flash' } },
   { alias: 'gemini-pro', label: 'Gemini Pro-class', blurb: 'advanced reasoning',
     vendorPath: 'google',
     idPattern: /^gemini-[\d.]+-pro(-preview|-exp|-latest)?$/,
@@ -119,24 +119,6 @@ function toCanonicalDefault(route) {
   return route;
 }
 
-/**
- * @returns {Object<string,string>} alias → pinned route, direct-first for
- * direct-capable vendors (bare `vendor/model`), openrouter-prefixed for
- * gateway-only vendors. STATIC — runtime-safe.
- */
-function toDefaultAliases() {
-  const out = {};
-  for (const f of FAMILIES) {
-    const route = f.fallback.openrouter || Object.values(f.fallback)[0];
-    out[f.alias] = toCanonicalDefault(route);
-  }
-  for (const e of CARDLESS) {
-    const route = e.routes.openrouter || Object.values(e.routes)[0];
-    out[e.alias] = toCanonicalDefault(route);
-  }
-  return out;
-}
-
 /**
  * @returns {Array<{alias,provider,model}>} every pinned route, flattened (for the alias audit).
  */
@@ -213,6 +195,26 @@ function toGatewayRoutes() {
   return out;
 }
 
+/**
+ * @returns {Object<string,string>} alias → the SINGLE pinned route used for
+ * display and `config.default`: the alias's authored direct form when one
+ * exists, else its OpenRouter route. STATIC — runtime-safe, never networks.
+ *
+ * Derived from `toGatewayRoutes()` on purpose, so the two builders can never
+ * disagree. It previously string-stripped `openrouter/` itself, which emitted
+ * OpenRouter's dot ids for divergent vendors (`anthropic/claude-opus-4.8` —
+ * the direct API only serves the dash form) and invented a bare direct id for
+ * OpenRouter-only models (`fable`). Both made `amicus doctor` and `amicus
+ * models --check` warn about the product's own shipped defaults.
+ */
+function toDefaultAliases() {
+  const out = {};
+  for (const [alias, routes] of Object.entries(toGatewayRoutes())) {
+    out[alias] = routes.direct || routes.openrouter;
+  }
+  return out;
+}
+
 module.exports = {
   getFamilies, toDefaultAliases, toCanonicalDefault, listCuratedRoutes, toGatewayRoutes, DIVERGENT_VENDORS
 };

package/src/utils/model-fetcher.js

@@ -19,6 +19,12 @@ const ANTHROPIC_MODELS = [
   { 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 },
+  // Dated snapshot: the id Anthropic's /v1/models actually lists, and the
+  // `haiku` direct route curated-models.js authors. Without it the floor
+  // (the only anthropic/ rows a keyless or OpenRouter-only user ever has)
+  // reports the shipped `haiku` default as stale.
+  { id: 'anthropic/claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5 (2025-10-01)',
+    contextLength: null, pricing: null },
   { id: 'anthropic/claude-sonnet-4-6', name: 'Claude Sonnet 4.6', contextLength: null, pricing: null }
 ];
 

package/src/utils/quick-picks.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const { getFamilies, toDefaultAliases, toCanonicalDefault } = require('./curated-models');
+const { getFamilies, toDefaultAliases, toCanonicalDefault, DIVERGENT_VENDORS } = require('./curated-models');
 
 const MARKER_RE = /(-preview|-exp|-beta|-latest|:free)+$/;
 
@@ -45,7 +45,7 @@ function pickCurrent(catalog, nsPrefix, vendorPath, idPattern) {
 
 /**
  * @param {Array<{id:string}>} catalog
- * @returns {Array<{alias,label,blurb,source:'live'|'fallback',routes:Object<string,string>}>}
+ * @returns {Array<{alias,label,blurb,vendorPath,source:'live'|'fallback',routes:Object<string,string>}>}
  * `routes` may be empty if a family defines no fallback and the catalog has no match.
  */
 function resolveQuickPicks(catalog) {
@@ -60,30 +60,53 @@ function resolveQuickPicks(catalog) {
       if (direct) { routes[p] = direct; live = true; }
       else if (f.fallback[p]) { routes[p] = f.fallback[p]; }
     }
-    return { alias: f.alias, label: f.label, blurb: f.blurb, routes,
+    return { alias: f.alias, label: f.label, blurb: f.blurb, vendorPath: f.vendorPath, routes,
              source: live ? 'live' : 'fallback' };
   });
 }
 
+/**
+ * The single route value a wizard may STORE for a resolved quick pick.
+ *
+ * For a direct-capable vendor the OpenRouter pick is canonicalised to bare
+ * `vendor/model` so it stays direct-first via the gateway router — otherwise a
+ * fresh `amicus setup` with a live catalog would silently defeat the
+ * direct-first default `toDefaultAliases()` establishes.
+ *
+ * For a DIVERGENT vendor the direct id is never DERIVED from the OpenRouter
+ * one: they are different strings, not differently prefixed (OpenRouter serves
+ * `anthropic/claude-opus-4.8`, the direct API `anthropic/claude-opus-4-8`).
+ * Stripping the prefix there fabricates an id the direct API rejects, which
+ * `amicus doctor` then reports as a stale alias. The row's own direct route is
+ * used verbatim, falling back to the intact `openrouter/` form when the
+ * catalog offered no direct pick. Mirrors the guard already used at
+ * `provider-default-picker.js:82,143,220`.
+ * @param {{vendorPath?:string, routes?:Object<string,string>}} pick
+ * @returns {string|undefined}
+ */
+function toStorableRoute(pick) {
+  const routes = (pick && pick.routes) || {};
+  if (pick && DIVERGENT_VENDORS.has(pick.vendorPath)) {
+    return routes[pick.vendorPath] || routes.openrouter;
+  }
+  return toCanonicalDefault(routes.openrouter || Object.values(routes)[0]);
+}
+
 /**
  * Seed map for fresh configs: static defaults overlaid with live family
- * routes (cardless aliases stay pinned). The overlaid route is run through
- * `toCanonicalDefault` so a direct-capable vendor (e.g. google, openai)
- * lands as bare `vendor/model` (direct-first via the gateway router)
- * instead of the raw `openrouter/<vendor>/<rest>` pick — otherwise a fresh
- * `amicus setup` with a live catalog would silently defeat the direct-first
- * default `toDefaultAliases()` establishes. Gateway-only vendors are
- * returned unchanged by `toCanonicalDefault`.
+ * routes (cardless aliases stay pinned). See `toStorableRoute` for why the
+ * overlaid value is not a raw prefix strip.
  * @returns {Object<string,string>}
  */
 function toLiveSeedAliases(catalog) {
   const seeds = toDefaultAliases();
   for (const r of resolveQuickPicks(catalog || [])) {
     if (r.source === 'live' && r.routes.openrouter) {
-      seeds[r.alias] = toCanonicalDefault(r.routes.openrouter);
+      const stored = toStorableRoute(r);
+      if (stored) { seeds[r.alias] = stored; }
     }
   }
   return seeds;
 }
 
-module.exports = { compareIdsDesc, pickCurrent, resolveQuickPicks, toLiveSeedAliases };
+module.exports = { compareIdsDesc, pickCurrent, resolveQuickPicks, toLiveSeedAliases, toStorableRoute };