amicus 4.6.1 → 4.6.2

package/src/sidecar/models-probe.js

@@ -0,0 +1,119 @@
+// src/sidecar/models-probe.js
+'use strict';
+
+/**
+ * @module models-probe
+ * v4.6.2 PR3 (spec §6, D5): `models --check --live` probe tier. Presence in
+ * the catalog is not proof of service — a stored alias can point at a model
+ * id the catalog still lists but the provider no longer actually serves (the
+ * v4.6.1 `gemini` incident: stored `google/gemini-3.1-flash-lite-preview`,
+ * catalog-live, silently dead). This module is the check that would have
+ * caught it: probe every STORED alias with one ordinary engine leg — real
+ * session dir, real spend-ledger row (D5) — on a single quiet fanout wave,
+ * and classify each leg served / accepted-but-silent / error.
+ *
+ * Never called without `--live`; the spend gate lives in the CLI layer
+ * (src/sidecar/models.js), not here — this module always spends when called.
+ */
+
+/** Probe backstop override (spec D5) — a fixed constant, NOT env-configurable;
+ * the env knob (AMICUS_NO_OUTPUT_BACKSTOP_MS) stays the ordinary 120s leg default. */
+const PROBE_WINDOW_MS = 30000;
+
+/** Fixed tiny prompt — a probe leg only needs to prove the model answers at all. */
+const PROBE_PROMPT = 'Reply with exactly: OK';
+
+/**
+ * Classify one leg run-document (buildRunResult shape, src/utils/result-
+ * schema.js) per the plan's Global Constraints classification contract.
+ * Precedence matters: 'complete' wins outright; otherwise a NO_OUTPUT_
+ * BACKSTOP error (PR2's silent-leg detector, armed here at PROBE_WINDOW_MS
+ * instead of its 120s default) is the one specific error shape that means
+ * "the model accepted the request and never produced a token" rather than an
+ * ordinary routing/auth/timeout failure.
+ * @param {{status?:string, error?:string|null}} leg
+ * @returns {'served'|'accepted-but-silent'|'error'}
+ */
+function classifyLeg(leg) {
+  if (leg.status === 'complete') { return 'served'; }
+  if (typeof leg.error === 'string' && /^NO_OUTPUT_BACKSTOP:/.test(leg.error)) { return 'accepted-but-silent'; }
+  return 'error';
+}
+
+/**
+ * Stored (user-config) aliases only — the `--live` probe's scope (spec §6):
+ * defaults/curated-route rows follow the catalog by construction and have no
+ * "was it actually served" question for a live probe to answer. Exported so
+ * the CLI's cap pre-check (models.js) and this module share one predicate.
+ * @param {Array<{source:string}>} sources collectAliasSources() output
+ * @returns {Array<{alias:string,model:string,source:string}>}
+ */
+function selectStoredAliases(sources) {
+  return sources.filter(s => s.source === 'user-config');
+}
+
+/**
+ * Probe every STORED alias with one ordinary engine leg (real session dirs,
+ * real spend rows — D5) on one quiet fanout wave. Returns per-alias outcomes;
+ * never called without --live (the spend gate lives in the CLI layer).
+ * @param {{project?:string}} opts
+ * @param {{runFanout?:Function, collectAliasSources?:Function}} [deps]
+ * @returns {Promise<{results:Array<{alias:string,target:string,outcome:'served'|'accepted-but-silent'|'error',detail:string|null,cost:number|null}>, waveId:string|null}>}
+ */
+async function probeStoredAliases(opts = {}, deps = {}) {
+  const collectAliasSources = deps.collectAliasSources || require('../utils/alias-audit').collectAliasSources;
+  const runFanout = deps.runFanout || require('./fanout').runFanout;
+
+  const stored = selectStoredAliases(collectAliasSources());
+  if (stored.length === 0) { return { results: [], waveId: null }; }
+
+  // runFanout's `models` is the same comma-separated STRING the CLI --models
+  // flag takes (validateFanoutModels -> parseModelsList splits it back apart)
+  // — NOT an array; see council/run-launch.js's launchWave for the identical
+  // `.join(',')` seam. An array here would parse to [] and fail the whole
+  // wave with BAD_ARGS.
+  const { wave, errorDoc } = await runFanout({
+    models: stored.map(s => s.model).join(','),
+    prompt: PROBE_PROMPT,
+    quiet: true,
+    noOutputBackstopMs: PROBE_WINDOW_MS,
+    timeout: 2, // minutes — the overall ceiling behind the backstop
+    project: opts.project,
+  });
+
+  // Final-review blocker 1: two classes of wave never reach leg-creation at
+  // all — the budget preflight refusing before any session exists (failPre ->
+  // {wave: null, errorDoc}) or the shared server failing to start (errorWave ->
+  // {legs: [], error: message}) — so EVERY stored alias would otherwise hit
+  // the `legs[i] || {}` fallback and fabricate a generic `detail: null` row,
+  // which the CLI's `${head} — ${r.detail}` template renders as the literal
+  // string "null", masking the real reason (worse with `quiet: true`, which
+  // suppresses every other print this failure would normally surface on).
+  // Both failure classes carry a real message; thread it onto every row that
+  // has no leg of its own to explain itself.
+  const waveFailure = errorDoc ? errorDoc.message : ((wave && wave.error) || null);
+
+  // Positional zip, not a model-id lookup: deriveLegIds (fanout.js) assigns
+  // legs 1:1 in --models order, and two stored aliases may legitimately share
+  // one target model, so a leg's own identity can't disambiguate which alias
+  // it answers for — only its index can.
+  const legs = (wave && wave.legs) || [];
+  const results = stored.map((s, i) => {
+    const leg = legs[i] || {};
+    const outcome = classifyLeg(leg);
+    const cost = (leg.usage && leg.usage.cost && typeof leg.usage.cost.amount === 'number')
+      ? leg.usage.cost.amount
+      : null;
+    return {
+      alias: s.alias,
+      target: s.model,
+      outcome,
+      detail: leg.error || waveFailure || null,
+      cost,
+    };
+  });
+
+  return { results, waveId: (wave && wave.waveId) || null };
+}
+
+module.exports = { probeStoredAliases, selectStoredAliases, PROBE_WINDOW_MS, PROBE_PROMPT };

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

@@ -108,4 +108,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)?$/,
@@ -58,10 +69,15 @@ const FAMILIES = [
 
 /**
  * Alias-only entries (no wizard quick pick); openrouter route only.
- * Refreshed against the live catalog 2026-06-11.
+ * 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.
+  { alias: 'gpt-pro', 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',
@@ -75,7 +91,10 @@ const CARDLESS = [
   { 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' } },

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/model-fetcher.js

@@ -16,6 +16,7 @@ const https = require('https');
  * would mislabel a direct-API request for it as valid.
  */
 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-haiku-4-5', name: 'Claude Haiku 4.5', contextLength: null, pricing: null },

package/src/utils/model-tiers.js

@@ -28,7 +28,13 @@ const { pickCurrent } = require('./quick-picks');
 const { isDirectProvider } = require('./provider-registry');
 const { toDefaultAliases, listCuratedRoutes } = require('./curated-models');
 
-/** Tier regex table: pattern matches the model segment after `<vendor>/` (or `openrouter/<vendor>/`). */
+/**
+ * Tier pattern table: each tier holds a regex — or an ORDERED regex list,
+ * tried first-match-wins — over the model segment after `<vendor>/` (or
+ * `openrouter/<vendor>/`). List order expresses preference, which a single
+ * regex cannot: ids sort numeric-descending, so `-pro` siblings would
+ * otherwise outrank their same-priced base.
+ */
 const TIERS = {
   anthropic: {
     economy: /^claude-haiku-/,
@@ -36,9 +42,17 @@ const TIERS = {
     frontier: /^claude-opus-/,
   },
   openai: {
-    economy: /^gpt-[\d.]+-mini$/,
-    balanced: /^gpt-[\d.]+$/,
-    frontier: /^gpt-[\d.]+-pro$/,
+    // The 5.6 line renamed the flagship into tiers — luna ($0.10/$0.60 per
+    // Mtok in/out), terra ($1/$6), sol ($5/$30), each with a -pro sibling
+    // priced at its base tier; no bare/-mini/-pro 5.6 ids exist. Owner
+    // ruling 2026-08-04: economy→luna, balanced→terra, frontier→sol, each
+    // preferring the base name, then its -pro sibling, then the 5.5-era
+    // naming so a stale catalog still resolves. balanced's primary is the
+    // same bare-or-terra pattern the `gpt` family uses (curated-models.js),
+    // so a future return to bare flagship ids is tracked automatically.
+    economy: [/^gpt-[\d.]+-luna$/, /^gpt-[\d.]+-luna-pro$/, /^gpt-[\d.]+-mini$/],
+    balanced: [/^gpt-[\d.]+(-terra)?$/, /^gpt-[\d.]+-terra-pro$/],
+    frontier: [/^gpt-[\d.]+-sol$/, /^gpt-[\d.]+-sol-pro$/, /^gpt-[\d.]+-pro$/],
   },
   google: {
     economy: /^gemini-[\d.]+-flash-lite/,
@@ -77,9 +91,16 @@ function buildGatewayOnlyAliasMap() {
 
 const GATEWAY_ONLY_ALIAS = buildGatewayOnlyAliasMap();
 
-/** Newest catalog id matching `regex` under `vendor`; direct namespace preferred over OpenRouter's. */
-function pickForTier(catalog, vendor, regex) {
-  return pickCurrent(catalog, '', vendor, regex) || pickCurrent(catalog, 'openrouter/', vendor, regex);
+/**
+ * First match wins over a tier's ordered patterns; within each pattern the
+ * newest matching id is picked, direct namespace preferred over OpenRouter's.
+ */
+function pickForTier(catalog, vendor, patterns) {
+  for (const regex of [].concat(patterns)) {
+    const pick = pickCurrent(catalog, '', vendor, regex) || pickCurrent(catalog, 'openrouter/', vendor, regex);
+    if (pick) { return pick; }
+  }
+  return null;
 }
 
 /** True when the catalog has ANY row (any tier) under this vendor's namespace, in either gateway. */