amicus 4.6.1 → 4.6.3

package/src/sidecar/models.js

@@ -5,6 +5,7 @@
  *   amicus models --search <q>     substring filter over id+name
  *   amicus models --refresh        force-refresh the cache
  *   amicus models --check          stale-alias audit (exit = stale count, max 100)
+ *   amicus models --check --live   + probe every stored alias with a real leg (spends)
  *   --json on all of the above     versioned documents (result-schema)
  *
  * Returns an exit code; bin/amicus.js plumbs it like fanout's.
@@ -13,11 +14,13 @@
 'use strict';
 
 const { getCatalogInfo, refreshCatalog, catalogPath } = require('../utils/model-catalog');
-const { collectAliasSources, findStaleAliases, suggestReplacements } = require('../utils/alias-audit');
+const { collectAliasSources, findStaleAliases, findDriftedStoredAliases, 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');
+const { probeStoredAliases, selectStoredAliases } = require('./models-probe');
+const { DEFAULT_MAX_LEGS } = require('./fanout-validate');
 
 const CHECK_EXIT_CAP = 100;
 
@@ -91,9 +94,19 @@ async function runList(args) {
   return 0;
 }
 
+// v4.6.2 PR3 Task 4: shared --live skip line; reason doubles as the JSON probeSkipped slug.
+function fmtLiveSkipped(reason) {
+  return `--live skipped: ${reason} — nothing was probed`;
+}
+
 async function runRefresh(args) {
   const models = await refreshCatalog();
   const { fetchedAt, lastRefreshAttempt, lastRefreshError } = await getCatalogInfo({ maxAgeMs: Number.POSITIVE_INFINITY });
+  // --refresh short-circuits --check below (args.check is guaranteed true here) — must announce, not silently skip.
+  if (args.live) {
+    const line = fmtLiveSkipped('refresh-precedes-check');
+    (args.json ? process.stderr : process.stdout).write(line + '\n');
+  }
   if (args.json) {
     process.stdout.write(JSON.stringify(buildCatalogDoc({
       models, fetchedAt, refreshed: true, lastRefreshAttempt, lastRefreshError
@@ -128,41 +141,87 @@ function fmtGatewayFinding(f) {
   return `  GATEWAY DIVERGENT: ${f.alias} direct form ${f.model} no longer matches catalog (now ${f.expected})`;
 }
 
+const PROBE_LABELS = { served: 'SERVED', 'accepted-but-silent': 'SILENT', error: 'ERROR' };
+
+/** '$0.0004' | '$1.23' | '—' (unknown). Deliberately NOT formatCost (pricing.js):
+ * a probe result's `cost` is a bare number (models-probe.js doesn't carry the
+ * reported/estimated source tag), so this never claims a precision it can't back. */
+function fmtProbeCost(cost) {
+  if (cost === null || cost === undefined || Number.isNaN(cost)) { return '—'; }
+  return cost < 1 ? `$${cost.toFixed(4)}` : `$${cost.toFixed(2)}`;
+}
+
+/** One readable line per probed alias (`--check --live`, v4.6.2 PR3): uppercase
+ * class prefix padded to a fixed column, two-space indent — mirrors the STALE/
+ * DRIFTED/GATEWAY line style above. @param {object} r probeStoredAliases() row */
+function fmtProbeLine(r) {
+  const head = `  ${(PROBE_LABELS[r.outcome] + ':').padEnd(8)}${r.alias} -> ${r.target}`;
+  if (r.outcome === 'served') { return `${head} (${fmtProbeCost(r.cost)})`; }
+  if (r.outcome === 'accepted-but-silent') { return `${head} — ${r.detail} (accepted but not serving)`; }
+  return `${head} — ${r.detail}`;
+}
+
 async function runCheck(args) {
   const catalogInfo = await getCatalogInfo();
   const catalog = catalogInfo.models;
   if (!catalog || catalog.length === 0) {
+    const probeSkipped = args.live ? 'catalog-unavailable' : null;
     if (args.json) {
       process.stdout.write(JSON.stringify(buildAuditDoc({
-        stale: [], catalogAvailable: false
+        stale: [], catalogAvailable: false, probeSkipped
       }), null, 2) + '\n');
     } else {
       process.stdout.write('Catalog unavailable (offline or no providers reachable); cannot check.\n');
+      if (probeSkipped) { process.stdout.write(fmtLiveSkipped(probeSkipped) + '\n'); }
     }
     return 0;
   }
   const sources = collectAliasSources();
   const stale = findStaleAliases(sources, catalog)
     .map(s => ({ ...s, suggestions: suggestReplacements(s.model, catalog) }));
+  const drifted = findDriftedStoredAliases(sources, 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
+  let exitCode = args.strict
     ? Math.max(legacyExitCode, Math.min(gatewayFindings.length, CHECK_EXIT_CAP))
     : legacyExitCode;
 
+  // v4.6.2 PR3 (spec §6, D5): opt-in --live probe of stored aliases with real
+  // engine legs. Never spends without --live — probeStoredAliases is only
+  // ever called inside this block (regression-tested: a mocked module must
+  // see zero calls when the flag is absent). The cap pre-check runs BEFORE
+  // the call so a doomed wave never spends a token (Task 2 review carry-in:
+  // without it, runFanout fails wave-creation and models-probe.js degrades
+  // every row to a generic error, losing the real reason).
+  let probeResults = [];
+  if (args.live) {
+    const storedCount = selectStoredAliases(sources).length;
+    const envCap = Number(process.env.AMICUS_FANOUT_MAX_LEGS);
+    const maxLegs = (Number.isInteger(envCap) && envCap > 0) ? envCap : DEFAULT_MAX_LEGS;
+    if (storedCount > maxLegs) {
+      process.stderr.write(`Error: --live would probe ${storedCount} stored aliases, exceeding the `
+        + `fan-out cap of ${maxLegs} (set AMICUS_FANOUT_MAX_LEGS to raise)\n`);
+      return 1;
+    }
+    const probe = await probeStoredAliases({ project: args.cwd || process.cwd() });
+    probeResults = probe.results;
+    const nonServed = probeResults.filter(r => r.outcome !== 'served').length;
+    exitCode = Math.max(exitCode, Math.min(nonServed, CHECK_EXIT_CAP));
+  }
+
   if (args.json) {
     process.stdout.write(JSON.stringify(buildAuditDoc({
-      stale, catalogAvailable: true, gatewayFindings
+      stale, catalogAvailable: true, gatewayFindings, drifted, probe: probeResults
     }), null, 2) + '\n');
     return exitCode;
   }
   const driftLines = buildFallbackDriftReport(catalog);
-  if (stale.length === 0) {
+  if (stale.length === 0 && drifted.length === 0) {
     process.stdout.write(`All aliases resolve to catalog models (${sources.length} checked).\n`);
-  } else {
+  } else if (stale.length > 0) {
     for (const s of stale) {
       process.stdout.write(`STALE: ${s.alias} -> ${s.model} (${s.source})\n`);
       if (s.suggestions.length > 0) {
@@ -173,10 +232,22 @@ async function runCheck(args) {
       }
     }
   }
+  for (const dr of drifted) {
+    process.stdout.write(`DRIFTED: ${dr.alias} -> ${dr.stored} (stored; current resolution: ${dr.current})\n`);
+    process.stdout.write(`  stored aliases don't follow catalog updates — refresh: amicus setup --add-alias ${dr.alias}=${dr.current}\n`);
+  }
   if (driftLines.length > 0) {
     process.stdout.write('Pinned fallback drift:\n');
     for (const l of driftLines) { process.stdout.write(l + '\n'); }
   }
+  if (args.live) {
+    if (probeResults.length === 0) {
+      process.stdout.write('Live probe: no stored aliases to probe\n');
+    } else {
+      process.stdout.write(`Live probe (${probeResults.length} stored aliases):\n`);
+      for (const r of probeResults) { process.stdout.write(fmtProbeLine(r) + '\n'); }
+    }
+  }
   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'); }
@@ -209,6 +280,10 @@ async function handleModels(args) {
     process.stderr.write('Error: --search requires a value\n');
     return 1;
   }
+  if (args.live && !args.check) {
+    process.stderr.write('Error: --live requires --check\n');
+    return 1;
+  }
   if (args.refresh) { return runRefresh(args); }
   if (args.check) { return runCheck(args); }
   return runList(args);

package/src/utils/alias-audit.js

@@ -62,6 +62,12 @@ function idsByProvider(catalog) {
  * at least one live resolution from any other source. This ensures the
  * suggested `--add-alias` fix actually clears the warning, and prevents
  * permanently unclearable noise when the default openrouter route is live.
+ *
+ * A stale 'defaults' entry is additionally suppressed when it is the alias's
+ * DERIVED direct-form pin (per curated-models.directFormProvenance()) and the
+ * alias is either covered live from another source or declares gatewayOnly
+ * (v4.6.3 PR1, spec D2) — an AUTHORED defaults pin and user-config rows are
+ * never suppressed this way.
  * @param {Array<{alias,model,source}>} sources
  * @param {Array<{id:string}>} catalog
  */
@@ -75,11 +81,24 @@ function findStaleAliases(sources, catalog) {
   const covered = new Set(
     sources.filter(({ model }) => isLive(model) === true).map(({ alias }) => alias)
   );
+  // v4.6.3 PR1 (spec D2). Lazy-required so suites that doMock curated-models
+  // for other cases keep working; a stub without the accessor simply gets no
+  // suppression (fail-open toward reporting).
+  const cm = require('./curated-models');
+  const provenance = typeof cm.directFormProvenance === 'function' ? (cm.directFormProvenance() || {}) : {};
   return sources.filter(({ alias, model, source }) => {
     const ids = byProvider.get(model.split('/')[0]);
     if (!ids) { return false; } // provider unverifiable
     if (ids.has(model)) { return false; } // live
     if (source.startsWith('curated-route') && covered.has(alias)) { return false; }
+    // A 'defaults' pin that is the alias's DERIVED direct form: its absence
+    // from the direct namespace is a routing fact, not staleness, while the
+    // alias has live coverage (or declares gatewayOnly). The fix: suggestion
+    // this row would otherwise print is a retarget nobody should run — the
+    // 2026-08-05 release-gate false positive (v4.6.3 spec §3).
+    const prov = provenance[alias];
+    if (source === 'defaults' && prov && prov.directForm === 'derived' &&
+        (prov.gatewayOnly || covered.has(alias))) { return false; }
     return true;
   });
 }
@@ -108,4 +127,55 @@ function suggestReplacements(staleModel, catalog, n = 3) {
     .slice(0, n);
 }
 
-module.exports = { collectAliasSources, findStaleAliases, suggestReplacements };
+/**
+ * Stored aliases whose target is LIVE in the catalog but no longer what a
+ * fresh `amicus setup` would seed today — the v4.6.1 release-gate class
+ * (stored `gemini` -> 3.1-flash-lite-preview: still catalog-listed so
+ * findStaleAliases passes it, no longer what the family resolves to).
+ * Report + suggest, never auto-repair (this module's charter).
+ *
+ * Only user-config rows are checked (defaults/curated follow the catalog by
+ * construction), only for aliases that are quick-pick families (a custom
+ * alias has no "current" to drift from), and only when the stored target is
+ * itself catalog-live (a dead target is findStaleAliases's finding, not
+ * ours). The `current` display value goes through toStorableRoute() — the
+ * guarded 4.1.2 helper — never a bare prefix strip (spec D3).
+ *
+ * Drift membership, however, is NOT a raw compare against that single
+ * canonicalized display string. toStorableRoute() canonicalizes a
+ * direct-capable vendor's OpenRouter pick down to the bare direct form
+ * (e.g. 'google/gemini-3.6-flash'), but a stored alias may legitimately hold
+ * the gateway-prefixed form of that SAME model ('openrouter/google/gemini-
+ * 3.6-flash' — the exact route pickCurrent/resolveQuickPicks resolves live,
+ * and what a STALE fix's own suggestion may have pointed a user to store).
+ * Comparing only against the canonicalized string would false-positive that
+ * as drift. Instead, a stored row only counts as drift when its model is
+ * absent from the family's FULL live route-value set (every value in that
+ * family's `routes` map — openrouter form and any direct form together, per
+ * resolveQuickPicks) — i.e. it names a genuinely different model, not the
+ * same model under a different gateway form.
+ * @param {Array<{alias:string,model:string,source:string}>} sources
+ * @param {Array<{id:string}>} catalog
+ * @returns {Array<{alias:string,stored:string,current:string}>}
+ */
+function findDriftedStoredAliases(sources, catalog) {
+  if (!catalog || catalog.length === 0) { return []; }
+  const { resolveQuickPicks, toStorableRoute } = require('./quick-picks');
+  const current = new Map();
+  for (const r of resolveQuickPicks(catalog)) {
+    if (r.source !== 'live') { continue; }
+    const stored = toStorableRoute(r);
+    if (stored) { current.set(r.alias, { display: stored, routeValues: new Set(Object.values(r.routes)) }); }
+  }
+  const byProvider = idsByProvider(catalog);
+  return sources
+    .filter(({ source }) => source === 'user-config')
+    .filter(({ model }) => {
+      const ids = byProvider.get(model.split('/')[0]);
+      return !!(ids && ids.has(model));
+    })
+    .filter(({ alias, model }) => current.has(alias) && !current.get(alias).routeValues.has(model))
+    .map(({ alias, model }) => ({ alias, stored: model, current: current.get(alias).display }));
+}
+
+module.exports = { collectAliasSources, findStaleAliases, findDriftedStoredAliases, suggestReplacements };

package/src/utils/base-url-classify.js

@@ -0,0 +1,74 @@
+/**
+ * @module base-url-classify
+ * v4.6.2 PR1 (spec §4, D1/D2): ANTHROPIC_BASE_URL classification, the
+ * normalization decision, and the once-per-process notice.
+ *
+ * The convention split (field-proven by a control pair on run 0084d48c):
+ * Anthropic SDKs — including Claude Code itself — treat the var as a HOST and
+ * append /v1 themselves; OpenCode's provider layer treats it as the FULL
+ * prefix and appends /messages. A host-form value is therefore correct for
+ * Claude Code and fatal for every OpenCode direct-anthropic leg
+ * (host/messages -> 404 "Not Found").
+ *
+ * Forms: absent (unset/blank) · host (path '' or '/') · v1 (path ends /v1)
+ * · other (any other path, or unparseable — passed through untouched; an
+ * exotic proxy serving /messages at a custom root stays possible, D1).
+ */
+'use strict';
+
+/** @param {string|undefined|null} value @returns {{form:string, normalized:string|null}} */
+function classifyBaseUrl(value) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    return { form: 'absent', normalized: null };
+  }
+  const trimmed = value.trim();
+  let url;
+  try { url = new URL(trimmed); } catch { return { form: 'other', normalized: null }; }
+  const path = url.pathname.replace(/\/+$/, '');
+  if (path === '') {
+    return { form: 'host', normalized: trimmed.replace(/\/+$/, '') + '/v1' };
+  }
+  if (path.endsWith('/v1')) { return { form: 'v1', normalized: null }; }
+  return { form: 'other', normalized: null };
+}
+
+/**
+ * The baseURL override the OpenCode server config should carry, or null.
+ * Null when: var absent, already /v1, nonstandard path, or normalization
+ * disabled via AMICUS_BASE_URL_NORMALIZE=0 (D1's escape hatch).
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string|null}
+ */
+function resolveBaseUrlOverride(env = process.env) {
+  if (env.AMICUS_BASE_URL_NORMALIZE === '0') { return null; }
+  const { form, normalized } = classifyBaseUrl(env.ANTHROPIC_BASE_URL);
+  return form === 'host' ? normalized : null;
+}
+
+let noticeShown = false;
+
+/**
+ * One notice per process (D2): the server may start many times (shared-server
+ * retries, fanout waves) and the treatment is identical every time.
+ * @param {string} value - the raw env value seen
+ * @param {string} normalized - the value handed to the engine config
+ * @param {{write?:Function, logger?:object}} [deps] - test seams
+ */
+function announceBaseUrlNormalizationOnce(value, normalized, deps = {}) {
+  if (noticeShown) { return; }
+  noticeShown = true;
+  const write = deps.write || (s => process.stderr.write(s));
+  const log = deps.logger || require('./logger').logger;
+  write(`Notice: ANTHROPIC_BASE_URL is host-form (${value}); passing ${normalized} to the engine `
+    + '(Anthropic SDKs append /v1 themselves; OpenCode treats the value as a full prefix; '
+    + 'set AMICUS_BASE_URL_NORMALIZE=0 to disable).\n');
+  log.info('ANTHROPIC_BASE_URL normalized for engine config', { value, normalized });
+}
+
+/** Test seam: reset the once-guard. */
+function _resetBaseUrlNotice() { noticeShown = false; }
+
+module.exports = {
+  classifyBaseUrl, resolveBaseUrlOverride,
+  announceBaseUrlNormalizationOnce, _resetBaseUrlNotice,
+};

package/src/utils/council-presets.js

@@ -42,13 +42,17 @@ const BUDGET_ALIASES = ['minimax', 'qwen-coder', 'deepseek'];
 /**
  * Frontier bench: three premium-flagship DEFAULT_ALIASES entries, one per
  * vendor family, verified against the same catalog snapshot:
- *   gpt-pro     openrouter/openai/gpt-5.5-pro          $0.00003 / $0.00018
- *   opus        openrouter/anthropic/claude-opus-4.8   $0.000005 / $0.000025
+ *   gpt-pro     openrouter/openai/gpt-5.6-sol-pro      $0.000005 / $0.00003
+ *   opus        openrouter/anthropic/claude-opus-5     $0.000005 / $0.000025
  *   gemini-pro  openrouter/google/gemini-3.1-pro-preview  $0.000002 / $0.000012
  * These are the three highest total (prompt+completion) prices in
  * DEFAULT_ALIASES that are also each a distinct vendor family (OpenAI /
  * Anthropic / Google) — `gpt` and `codex` (also OpenAI) and `claude`/`sonnet`
  * (also Anthropic) were skipped as same-family duplicates of the pick above.
+ * (opus re-pinned to claude-opus-5 on 2026-08-04 at the same live price;
+ * gpt-pro retargeted to gpt-5.6-sol-pro on 2026-08-04 — cheaper than the
+ * old gpt-5.5-pro pin but still OpenAI's premium tier, so the selection
+ * logic above is unchanged.)
  */
 const FRONTIER_ALIASES = ['gpt-pro', 'opus', 'gemini-pro'];
 

package/src/utils/curated-models.js

@@ -21,9 +21,11 @@ const { isDirectProvider } = require('./provider-registry');
  * resolve live from the catalog. A per-provider `fallback` entry is
  * OPTIONAL: when absent and the catalog cannot resolve that namespace,
  * the direct route is omitted (no pinned guess is better than a wrong one).
- * `gpt`'s pattern intentionally matches any plain numeric flagship id
- * (gpt-5.5, gpt-6) and excludes suffixed variants (-pro/-mini/-codex).
- * Pinned ids verified against the live catalog 2026-06-24.
+ * `gpt`'s pattern intentionally matches a plain numeric flagship id
+ * (gpt-5.5, gpt-6) OR that id's `-terra` tier variant (gpt-5.6-terra), and
+ * excludes every other suffixed variant (-pro/-mini/-codex/-sol/-luna) —
+ * see the tier-semantics comment on the entry below.
+ * Pinned ids verified against the live catalog 2026-08-04.
  */
 const FAMILIES = [
   { alias: 'gemini', label: 'Gemini Flash-class', blurb: 'fast, large context',
@@ -37,17 +39,26 @@ const FAMILIES = [
     idPattern: /^gemini-[\d.]+-pro(-preview|-exp|-latest)?$/,
     directProviders: ['google'],
     fallback: { openrouter: 'openrouter/google/gemini-3.1-pro-preview' } },
+  // 5.6 split the flagship into tiers: sol (premium, $5/$30), terra (mid,
+  // $1/$6), luna (economy, $0.10/$0.60), each with a -pro sibling, plus the
+  // unrelated gpt-5.3-codex family. Owner ruling: `gpt` tracks the TERRA
+  // (mid) tier — sol/luna/pro variants and codex are excluded deliberately.
+  // Bare numeric ids (gpt-5.5-style) stay matched as a within-family
+  // fallback if the terra naming ever disappears from the catalog.
   { alias: 'gpt', label: 'GPT flagship', blurb: 'strong coding',
     vendorPath: 'openai',
-    idPattern: /^gpt-[\d.]+$/,
+    idPattern: /^gpt-[\d.]+(-terra)?$/,
     directProviders: ['openai'],
-    fallback: { openrouter: 'openrouter/openai/gpt-5.5' } },
+    fallback: { openrouter: 'openrouter/openai/gpt-5.6-terra' } },
   { alias: 'opus', label: 'Claude Opus-class', blurb: 'deep analysis',
     vendorPath: 'anthropic',
     idPattern: /^claude-opus-[\d.-]+$/,
     directProviders: ['anthropic'],
-    fallback: { openrouter: 'openrouter/anthropic/claude-opus-4.8',
-                anthropic: 'anthropic/claude-opus-4-8' } },
+    // claude-opus-5 has no dotted version segment, so the two forms coincide —
+    // the anthropic: route is still AUTHORED (DIVERGENT_VENDORS), never derived.
+    // Direct id verified against Anthropic docs 2026-08-04.
+    fallback: { openrouter: 'openrouter/anthropic/claude-opus-5',
+                anthropic: 'anthropic/claude-opus-5' } },
   { alias: 'deepseek', label: 'DeepSeek flagship', blurb: 'open-source',
     vendorPath: 'deepseek',
     idPattern: /^deepseek-v[\d.]+(-pro)?$/,
@@ -57,11 +68,23 @@ const FAMILIES = [
 ];
 
 /**
- * Alias-only entries (no wizard quick pick); openrouter route only.
- * Refreshed against the live catalog 2026-06-11.
+ * Alias-only entries (no wizard quick pick). Every entry authors an
+ * openrouter route; entries whose vendor's direct API genuinely serves the
+ * model also author a direct route (claude/sonnet/haiku/fable).
+ * Refreshed against the live catalog 2026-08-04.
  */
 const CARDLESS = [
-  { alias: 'gpt-pro', routes: { openrouter: 'openrouter/openai/gpt-5.5-pro' } },
+  // gpt-pro: the 5.6 premium (sol) tier's pro sibling, priced at its base
+  // tier ($5/$30 per Mtok). Owner ruling 2026-08-04: retargeted off
+  // gpt-5.5-pro ($30/$180 — still served, but expected to sunset with the
+  // 5.5 line). `gpt-pro` tracks SOL while the `gpt` family tracks terra —
+  // see the tier-semantics comment on the `gpt` family above.
+  // gatewayOnly (owner ruling 2026-08-05, recorded in the v4.6.3 spec): the
+  // openrouter-only route is a deliberate routing choice — OpenAI's direct
+  // namespace does not serve gpt-5.6-sol-pro, so the DERIVED direct form
+  // must never be audited as stale and no direct pairing may be suggested.
+  { alias: 'gpt-pro', gatewayOnly: true,
+    routes: { openrouter: 'openrouter/openai/gpt-5.6-sol-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-5',
@@ -70,12 +93,19 @@ const CARDLESS = [
                                 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' } },
+  // fable: direct route authored 2026-08-05 (owner ruling R2, v4.6.3 spec §3).
+  // Anthropic's /v1/models lists claude-fable-5 AND the direct route serves
+  // (live smoke wave 47278069) — the entry was OpenRouter-only at authoring.
+  { alias: 'fable', routes: { openrouter: 'openrouter/anthropic/claude-fable-5',
+                              anthropic: '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' } },
   { alias: 'mistral', routes: { openrouter: 'openrouter/mistralai/mistral-medium-3-5' } },
-  { alias: 'devstral', routes: { openrouter: 'openrouter/mistralai/devstral-2512' } },
+  // devstral was dropped 2026-08-04 (owner ruling): OpenRouter delisted the
+  // whole devstral family and the alias had no other route. No retarget — no
+  // served model is a devstral successor ("no pinned guess is better than a
+  // wrong one"); `mistral` remains the vendor's alias.
   { alias: 'glm', routes: { openrouter: 'openrouter/z-ai/glm-5.1' } },
   { alias: 'minimax', routes: { openrouter: 'openrouter/minimax/minimax-m2.7' } },
   { alias: 'grok', routes: { openrouter: 'openrouter/x-ai/grok-4.3' } },
@@ -141,7 +171,8 @@ function 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).
+ * for a model the direct API does not serve (fable was that case until its
+ * direct route was verified and authored, 2026-08-05).
  * Frozen so consumers can only read it (`.has()`) — a frozen Set still
  * supports lookups, it just can't be `.add()`/`.delete()`/`.clear()`-ed.
  */
@@ -181,6 +212,28 @@ function gatewayRoutesFor(vendorPath, obj) {
   return routes;
 }
 
+/**
+ * Per-alias provenance of the `direct` form in toGatewayRoutes(), for the
+ * auditors (alias-audit.js / gateway-route-audit.js): an AUTHORED direct
+ * form absent from its namespace is stale; a DERIVED one is a computed
+ * convenience whose absence is a routing fact, not staleness, while the
+ * authoring openrouter route is live. `gatewayOnly` mirrors an entry's
+ * explicit routing-choice annotation (owner-ruled): suppress derived-form
+ * findings unconditionally and never suggest a direct pairing.
+ * @returns {Object<string, {directForm: 'authored'|'derived'|'none', gatewayOnly: boolean}>}
+ */
+function directFormProvenance() {
+  const out = {};
+  const entryProv = (vendorPath, obj, gatewayOnly) => {
+    const direct = directFormFor(vendorPath, obj);
+    const directForm = !direct ? 'none' : (obj[vendorPath] ? 'authored' : 'derived');
+    return { directForm, gatewayOnly: gatewayOnly === true };
+  };
+  for (const f of FAMILIES) { out[f.alias] = entryProv(f.vendorPath, f.fallback, f.gatewayOnly); }
+  for (const e of CARDLESS) { out[e.alias] = entryProv(vendorOf(e.routes.openrouter), e.routes, e.gatewayOnly); }
+  return out;
+}
+
 /**
  * @returns {Object<string,{direct?: string, openrouter: string}>} alias →
  * per-gateway executable ids. Unlike `toDefaultAliases` (a single pinned
@@ -204,8 +257,9 @@ function toGatewayRoutes() {
  * 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.
+ * then-OpenRouter-only models (`fable`, direct-authored 2026-08-05). Both made
+ * `amicus doctor` and `amicus models --check` warn about the product's own
+ * shipped defaults.
  */
 function toDefaultAliases() {
   const out = {};
@@ -216,5 +270,6 @@ function toDefaultAliases() {
 }
 
 module.exports = {
-  getFamilies, toDefaultAliases, toCanonicalDefault, listCuratedRoutes, toGatewayRoutes, DIVERGENT_VENDORS
+  getFamilies, toDefaultAliases, toCanonicalDefault, listCuratedRoutes, toGatewayRoutes,
+  directFormProvenance, DIVERGENT_VENDORS
 };

package/src/utils/doctor-base-url-check.js

@@ -0,0 +1,41 @@
+/**
+ * @module doctor-base-url-check
+ * v4.6.2 PR1 (spec §4): the 'anthropic-base-url' doctor row.
+ *
+ * VERIFIABLE voice (BACKLOG ruling): states only what it string-inspected.
+ * It always prints the value the process SEES — the var can live ONLY in a
+ * parent process env (the field case: set in the Claude Code app process,
+ * absent from every persisted scope on disk), so the seen value IS the
+ * diagnostic; "where it is set" may be unfindable.
+ */
+'use strict';
+
+const { classifyBaseUrl } = require('./base-url-classify');
+
+/** @param {{env?:NodeJS.ProcessEnv}} [d] @returns {{id,name,status,message,hint}} */
+function evaluateAnthropicBaseUrl(d = {}) {
+  const id = 'anthropic-base-url'; const name = 'ANTHROPIC_BASE_URL';
+  const env = d.env || process.env;
+  const value = env.ANTHROPIC_BASE_URL;
+  const { form, normalized } = classifyBaseUrl(value);
+  if (form === 'absent') {
+    return { id, name, status: 'ok', message: 'not set', hint: null };
+  }
+  if (form === 'v1') {
+    return { id, name, status: 'ok', message: `${value} (full-prefix form)`, hint: null };
+  }
+  if (form === 'host') {
+    const disabled = env.AMICUS_BASE_URL_NORMALIZE === '0';
+    const treatment = disabled
+      ? 'normalization is disabled (AMICUS_BASE_URL_NORMALIZE=0) — direct-anthropic legs will 404'
+      : `amicus passes ${normalized} to the engine`;
+    return {
+      id, name, status: 'warn',
+      message: `host-form: ${value} — Anthropic SDKs append /v1; OpenCode treats it as the full prefix; ${treatment}`,
+      hint: disabled ? `set ANTHROPIC_BASE_URL=${normalized} (or unset AMICUS_BASE_URL_NORMALIZE)` : null,
+    };
+  }
+  return { id, name, status: 'ok', message: `${value} (nonstandard path — passed through unchanged)`, hint: null };
+}
+
+module.exports = { evaluateAnthropicBaseUrl };

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

@@ -30,7 +30,7 @@
 
 'use strict';
 
-const { toGatewayRoutes } = require('./curated-models');
+const { toGatewayRoutes, directFormProvenance } = require('./curated-models');
 const { classifyModel } = require('./model-classification');
 const { pairAcrossGateways } = require('./gateway-route-catalog');
 const { isDirectProvider } = require('./provider-registry');
@@ -70,19 +70,32 @@ function isAuthoritative(catalogInfo, id) {
  */
 function auditGatewayRoutes(catalogInfo) {
   const routes = toGatewayRoutes();
+  const provenance = directFormProvenance();
   const findings = [];
 
   for (const [alias, forms] of Object.entries(routes)) {
+    const prov = provenance[alias] || { directForm: 'none', gatewayOnly: false };
     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 });
+      if (classifyModel(id, gateway, catalogInfo) !== 'invalid') { continue; }
+      // v4.6.3 PR1 (spec D2): a DERIVED direct form is a computed convenience,
+      // not an authored claim. Its absence from the direct namespace is a
+      // routing fact — not staleness — while the authoring openrouter route
+      // is live, or when the entry declares gatewayOnly (an owner-ruled
+      // routing choice). An AUTHORED direct form absent from its namespace
+      // reports exactly as before.
+      if (gateway === 'direct' && prov.directForm === 'derived' &&
+          (prov.gatewayOnly ||
+           classifyModel(forms.openrouter, 'openrouter', catalogInfo) === 'valid')) {
+        continue;
       }
+      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
+    if (prov.gatewayOnly) { continue; } // declared routing choice: never suggest a direct pairing
     const token = bareSegment(forms.openrouter, vendor);
     if (!token) { continue; }
     const paired = pairAcrossGateways(vendor, token, catalogInfo); // Task-5 contract: bare segment only

package/src/utils/model-fetcher.js

@@ -8,16 +8,19 @@
 const https = require('https');
 
 /**
- * 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.
+ * Hardcoded Anthropic floor: the anthropic/ rows a KEYLESS user (or a
+ * failed live fetch) gets. Every id here must be one the direct API
+ * GENUINELY serves — classifyModel() returns 'valid' on a floor HIT before
+ * it ever checks `authoritative`, so a speculative row would mislabel a
+ * dead direct-API request as valid. (fable joined 2026-08-05 after live
+ * verification — /v1/models lists claude-fable-5 and a direct smoke leg
+ * served; v4.6.3 spec §3.)
  */
 const ANTHROPIC_MODELS = [
+  { id: 'anthropic/claude-opus-5', name: 'Claude Opus 5', 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-fable-5', name: 'Claude Fable 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