mohdel 0.124.0 → 1.0.0

package/js/session/adapters/_output_cap.js

@@ -0,0 +1,30 @@
+/**
+ * The output cap.
+ *
+ * `outputBudget` on the envelope is a request, not a promise. Providers
+ * disagree on what happens when it exceeds the model's own ceiling: some
+ * reject the call outright, others silently serve fewer tokens than asked
+ * for. Neither is useful to a caller, so mohdel never sends more than
+ * `spec.outputTokenLimit`.
+ *
+ * Adapters that add thinking headroom on top of the budget apply the cap
+ * *after* that addition — the sum is what reaches the wire, so the sum is
+ * what has to fit. Capping before would let the headroom push it back over.
+ *
+ * A spec carrying no `outputTokenLimit` cannot be capped and the caller's
+ * number is sent as given; that is the concrete cost of leaving the field
+ * out (docs/CATALOG.md).
+ *
+ * The catalog's `outputCapStrategy` records which of the two provider
+ * behaviours applies. It is informational — published for embedders that
+ * build their own provider requests rather than going through a session —
+ * and mohdel caps regardless of its value.
+ *
+ * @param {unknown} requested
+ * @param {unknown} outputTokenLimit
+ * @returns {unknown} `requested`, capped when both numbers are known.
+ */
+export const capOutput = (requested, outputTokenLimit) => {
+  if (typeof requested !== 'number' || typeof outputTokenLimit !== 'number') return requested
+  return Math.min(requested, outputTokenLimit)
+}

package/js/session/adapters/_registry.js

@@ -0,0 +1,44 @@
+/**
+ * Adapter names and speed lanes, as plain data.
+ *
+ * Importing an adapter pulls its provider SDK; importing the registry in
+ * `index.js` pulls all of them, which is ~300ms. Anything that only needs to
+ * know *which* adapters exist, or what lanes a provider sells, reads this
+ * instead and pays nothing.
+ *
+ * @module session/adapters/registry
+ */
+
+/** Every adapter module under `./`, named for the provider it serves. */
+export const ADAPTER_NAMES = Object.freeze([
+  'anthropic',
+  'cerebras',
+  'deepseek',
+  'echo',
+  'fake',
+  'fireworks',
+  'gemini',
+  'groq',
+  'local',
+  'mistral',
+  'novita',
+  'openai',
+  'openrouter',
+  'qwen',
+  'xai',
+  'xiaomi'
+])
+
+/**
+ * Speed lanes each provider's adapter can emit. The adapter carries the same
+ * set on `adapter.speedLanes`; this is the copy readable without loading it.
+ */
+export const SPEED_LANES = Object.freeze({
+  openai: new Set(['fast', 'priority', 'flex', 'scale'])
+})
+
+/** Image adapters, keyed by provider; the module exports `<provider>Image`. */
+export const IMAGE_ADAPTER_NAMES = Object.freeze(['openai', 'novita', 'fake'])
+
+/** Whether a provider has an image adapter. Answerable without loading one. */
+export const isImageProvider = (provider) => IMAGE_ADAPTER_NAMES.includes(provider)

package/js/session/adapters/anthropic.js

@@ -15,6 +15,7 @@
  */
 
 import Anthropic from '@anthropic-ai/sdk'
+import { capOutput } from './_output_cap.js'
 
 import {
   STATUS_COMPLETED,
@@ -354,6 +355,8 @@ function buildRequest (envelope, conversation, system, conversationCacheTtl = nu
 
   applyCacheBreakpoints(request, conversationCacheTtl)
 
+  request.max_tokens = capOutput(request.max_tokens, outputTokenLimit)
+
   return request
 }
 
@@ -453,11 +456,11 @@ function splitPrompt (prompt) {
       }
     }
     if (m.role === 'system') {
-      // Translate spore-style cache markers ({text, cache: '5m'|'1h'}) into
-      // Anthropic's cache_control. Preserves the block boundary that spore
-      // chose; collapsing into a single string would silently disable
-      // caching even when the upstream tier composed the prompt with
-      // explicit breakpoints.
+      // Translate caller-supplied cache markers ({text, cache: '5m'|'1h'})
+      // into Anthropic's cache_control. Preserves the block boundary the
+      // caller chose; collapsing into a single string would silently disable
+      // caching even when the prompt was composed with explicit
+      // breakpoints.
       if (Array.isArray(m.content)) {
         for (const p of m.content) {
           if (!p?.text) continue

package/js/session/adapters/gemini.js

@@ -16,6 +16,7 @@
  */
 
 import { GoogleGenAI } from '@google/genai'
+import { capOutput } from './_output_cap.js'
 
 import {
   STATUS_COMPLETED,
@@ -265,6 +266,9 @@ function buildRequest (envelope, contents, systemInstruction) {
     }
   }
 
+  config.maxOutputTokens = capOutput(config.maxOutputTokens, spec?.outputTokenLimit)
+  if (config.maxOutputTokens === undefined) delete config.maxOutputTokens
+
   /** @type {Record<string, any>} */
   const request = {
     model: spec?.model ?? bareOf(envelope.model),

package/js/session/adapters/openai.js

@@ -16,6 +16,7 @@
  */
 
 import OpenAI from 'openai'
+import { SPEED_LANES } from './_registry.js'
 
 import {
   STATUS_COMPLETED,
@@ -230,7 +231,7 @@ export async function * openai (envelope, deps = {}) {
  * Lane names the OpenAI adapter can put on `service_tier`. `run.js`
  * reads this before dispatch; a lane outside it never reaches here.
  */
-openai.speedLanes = new Set(['fast', 'priority', 'flex', 'scale'])
+openai.speedLanes = SPEED_LANES.openai
 
 /**
  * Lane the response says was served, given the one requested.

package/js/session/run.js

@@ -22,8 +22,7 @@
  * @module session/run
  */
 
-import { getAdapter } from './adapters/index.js'
-import { isImageProvider } from './adapters/image/index.js'
+import { ADAPTER_NAMES, isImageProvider } from './adapters/_registry.js'
 import { getSpec } from './adapters/_catalog.js'
 import { getProviderLimits } from './adapters/_providers.js'
 import { hasSpeed, mergeSpeed, speedHasOwnQuota, speedNames } from './adapters/_speed.js'
@@ -57,8 +56,19 @@ import { STATUS_INCOMPLETE, WARNING_CANCELLED } from '#core/status.js'
  * }} [options]
  * @returns {AsyncGenerator<import('#core/events.js').Event>}
  */
+// Load one adapter rather than the registry: importing every adapter pulls
+// every provider SDK, which is ~300ms a caller pays to use one of them. The
+// name is checked against the known list before it reaches the import path —
+// it comes off the envelope, and a computed specifier must never take an
+// arbitrary string.
+const loadAdapter = async (provider) => {
+  if (!ADAPTER_NAMES.includes(provider)) throw new Error(`unknown provider: ${provider}`)
+  const module = await import(`./adapters/${provider}.js`)
+  return module[provider]
+}
+
 export async function * run (envelope, {
-  resolveAdapter = getAdapter,
+  resolveAdapter = loadAdapter,
   resolveSpec = getSpec,
   resolveProviderLimits = getProviderLimits,
   cooldown = defaultCooldown,
@@ -92,7 +102,7 @@ export async function * run (envelope, {
 
   let adapter
   try {
-    adapter = resolveAdapter(provider)
+    adapter = await resolveAdapter(provider)
   } catch (e) {
     // Distinguish "image-only provider invoked via answer" from
     // truly-unknown. Novita-and-friends have no text adapter but a

package/js/session/run_image.js

@@ -13,7 +13,7 @@
  * @module session/run_image
  */
 
-import { getImageAdapter } from './adapters/image/index.js'
+import { IMAGE_ADAPTER_NAMES } from './adapters/_registry.js'
 import { classifyProviderError } from './adapters/_errors.js'
 import { providerOf } from '#core/model-id.js'
 
@@ -31,10 +31,19 @@ import { providerOf } from '#core/model-id.js'
  *   | {ok: false, error: import('#core/errors.js').TypedError}
  * >}
  */
-export async function runImage (envelope, { resolveAdapter = getImageAdapter, spec } = {}) {
+// Loaded per provider rather than as a registry: the image adapters pull the
+// OpenAI SDK, which a text-only caller never needs. Checked against the known
+// list first — the name comes off the envelope.
+const loadImageAdapter = async (provider) => {
+  if (!IMAGE_ADAPTER_NAMES.includes(provider)) throw new Error(`no image adapter for provider: ${provider}`)
+  const module = await import(`./adapters/image/${provider}.js`)
+  return module[`${provider}Image`]
+}
+
+export async function runImage (envelope, { resolveAdapter = loadImageAdapter, spec } = {}) {
   let adapter
   try {
-    adapter = resolveAdapter(providerOf(envelope.model))
+    adapter = await resolveAdapter(providerOf(envelope.model))
   } catch (e) {
     return {
       ok: false,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "mohdel",
-  "version": "0.124.0",
+  "version": "1.0.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
     "email": "clb@toort.net"
   },
-  "description": "Self-hosted LLM gateway and SDK for Node — a LiteLLM-style unified API for 11 providers (Anthropic, OpenAI, Gemini, Mistral, Groq, xAI, DeepSeek, OpenRouter, …) with per-call USD cost tracking, streaming, tool calls, vision, speech-to-text, and built-in OpenTelemetry. Run in-process, or behind the process-isolated thin-gate for fault containment.",
+  "description": "Self-hosted LLM gateway and SDK for Node — a LiteLLM-style unified API for 13 providers (Anthropic, OpenAI, Gemini, Mistral, Groq, xAI, DeepSeek, OpenRouter, …) with per-call USD cost tracking, streaming, tool calls, vision, speech-to-text, and built-in OpenTelemetry. Run in-process, or behind the process-isolated thin-gate for fault containment.",
   "type": "module",
   "keywords": [
     "llm",
@@ -42,14 +42,38 @@
   },
   "main": "src/lib/index.js",
   "exports": {
-    ".": "./src/lib/index.js",
-    "./providers": "./src/lib/providers.js",
-    "./creators": "./src/lib/creators.js",
-    "./utils": "./src/lib/utils.js",
-    "./errors": "./js/core/errors.js",
-    "./client": "./js/client/index.js",
-    "./session": "./js/session/index.js",
-    "./session/bin": "./js/session/bin.js"
+    ".": {
+      "types": "./src/lib/index.d.ts",
+      "default": "./src/lib/index.js"
+    },
+    "./providers": {
+      "types": "./src/lib/providers.d.ts",
+      "default": "./src/lib/providers.js"
+    },
+    "./creators": {
+      "types": "./src/lib/creators.d.ts",
+      "default": "./src/lib/creators.js"
+    },
+    "./utils": {
+      "types": "./src/lib/utils.d.ts",
+      "default": "./src/lib/utils.js"
+    },
+    "./errors": {
+      "types": "./js/core/errors.d.ts",
+      "default": "./js/core/errors.js"
+    },
+    "./client": {
+      "types": "./js/client/index.d.ts",
+      "default": "./js/client/index.js"
+    },
+    "./session": {
+      "types": "./js/session/index.d.ts",
+      "default": "./js/session/index.js"
+    },
+    "./session/bin": {
+      "types": "./js/session/bin.d.ts",
+      "default": "./js/session/bin.js"
+    }
   },
   "imports": {
     "#core": "./js/core/index.js",
@@ -64,7 +88,9 @@
     "src/cli",
     "config",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "js/**/*.d.ts",
+    "src/lib/**/*.d.ts"
   ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -73,10 +99,12 @@
   },
   "scripts": {
     "lint": "standard",
+    "clean:types": "find js src/lib -name '*.d.ts' -delete",
+    "build:types": "npm run clean:types && tsc -p tsconfig.build.json",
     "test": "npm run test:js && npm run test:rust",
     "test:js": "vitest run test/unit",
     "test:rust": "cargo test --manifest-path rust/thin-gate/Cargo.toml && cargo test --manifest-path rust/napi-addon/Cargo.toml",
-    "prerelease": "npm run lint && npm run test",
+    "prerelease": "npm run lint && npm run build:types && npm run test",
     "release": "release-it",
     "test:provider": "vitest run test/integration/provider.test.js",
     "test:multiturn": "vitest run test/integration/multiturn.test.js",
@@ -104,20 +132,20 @@
     }
   },
   "optionalDependencies": {
-    "@clack/prompts": "^1.7.0",
+    "@clack/prompts": "^1.8.8",
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.0",
-    "mohdel-thin-gate-linux-x64-gnu": "0.124.0"
+    "mohdel-thin-gate-linux-x64-gnu": "1.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.123.0",
+    "@anthropic-ai/sdk": "^0.125.0",
     "@cerebras/cerebras_cloud_sdk": "^1.91.0",
-    "@google/genai": "^2.20.0",
+    "@google/genai": "^2.22.0",
     "@opentelemetry/api": "^1.9.1",
     "env-paths": "^4.0.0",
     "groq-sdk": "^1.6.0",
-    "openai": "^7.9.0",
+    "openai": "^7.15.0",
     "undici": "^7.29.0"
   },
   "lint-staged": {
@@ -125,9 +153,11 @@
   },
   "devDependencies": {
     "gpt-tokenizer": "^4.0.0",
-    "lint-staged": "^17.4.1",
+    "lint-staged": "^17.5.1",
     "release-it": "^21.0.2",
     "standard": "^17.1.2",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.11"
-  }
+  },
+  "types": "./src/lib/index.d.ts"
 }

package/src/cli/aliases.js

@@ -0,0 +1,20 @@
+// Short commands → noun + verb. Shared by dispatch and by completion, which
+// must resolve the same chain the router would.
+export const ALIASES = {
+  models: { noun: 'model', inject: ['list'] },
+  providers: { noun: 'provider', inject: ['list'] },
+  creators: { noun: 'creator', inject: ['list'] },
+  tags: { noun: 'tag', inject: ['list'] },
+  ls: { noun: 'model', inject: ['list'] },
+  show: { noun: 'model', inject: ['show'] },
+  search: { noun: 'model', inject: ['search'] },
+  stats: { noun: 'model', inject: ['stats'] },
+  check: { noun: 'model', inject: ['check'] },
+  setup: { noun: 'provider', inject: ['setup'] },
+  rank: { noun: 'model', inject: ['rank'] },
+  bench: { noun: 'model', inject: ['bench'] },
+  curate: { noun: 'model', inject: ['curate'] },
+  apply: { noun: 'model', inject: ['apply'] },
+  instructions: { noun: 'model', inject: ['instructions'] },
+  rl: { noun: 'ratelimit', inject: [] }
+}

package/src/cli/ask.js

@@ -1,11 +1,28 @@
 import mohdel, { silent } from '../lib/index.js'
-import { loadDefaultEnv } from '../lib/common.js'
+import { getConfig, loadDefaultEnv } from '../lib/common.js'
 
 const noop = () => {}
 
 // Friendly next-step hints for common ask-time failures. Pure pattern match on
 // err.message — keeps the lib layer neutral, but gives CLI users a copy-pasteable
 // command instead of just an error. Shared with `mo transcribe`.
+// Waiting on a model is the one place mohdel has nothing to show for several
+// seconds. The frames carry the resolved id, so the id is visible while it is
+// useful and gone afterwards. stderr only, so pipes see nothing.
+const startSpinner = (text) => {
+  if (!process.stderr.isTTY) return null
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+  let i = 0
+  const timer = setInterval(() => {
+    process.stderr.write(`\r${frames[i++ % frames.length]} ${text}`)
+  }, 80)
+  timer.unref?.()
+  return () => {
+    clearInterval(timer)
+    process.stderr.write('\r\u001b[K')
+  }
+}
+
 export const hintsForError = (err, modelId) => {
   const msg = String(err?.message || '')
   const detail = String(err?.detail || '')
@@ -16,6 +33,7 @@ export const hintsForError = (err, modelId) => {
   if (/not found in catalog/i.test(both)) {
     if (provider) {
       hints.push(`→ run:  mo curate ${provider}        # add upstream models from this provider`)
+      hints.push(`→ then: mo model instructions ${provider}   # let your coding agent fill in the prices`)
       hints.push(`→ or:   mo model add ${modelId}      # add this one manually`)
     } else {
       hints.push('→ run:  mo ls                       # list available models')
@@ -49,18 +67,21 @@ Usage:
   mo ask <model> "question" < file     Combined: args + stdin
 
 Options:
-  --effort <level>     Thinking effort: high, medium, low, none
+  --effort <level>     Thinking effort: none, low, medium, high, xhigh, max
   --budget <tokens>    Output token budget
   --json               Output full result as JSON
   --stream             Stream output to stdout in real time
-  -v, --verbose        Show debug info on stderr (cooldown, rate limit, SDK calls)
+  -v, --verbose        Show debug info on stderr (cooldown, rate limits)
+  -q, --quiet          Nothing on stderr but errors — no usage summary
 
 Output:
   stdout: model output text (raw, no formatting — or JSON with --json)
-  stderr: model name + token usage summary
+  stderr: token usage summary, and errors
+          --json omits the summary (the same numbers are in the payload);
+          --quiet omits it too, leaving stderr for failures alone
 
 Examples:
-  mo ask gemini/gemini-3-flash-preview "why is the sky blue"
+  mo ask openai/gpt-5.6-luna "why is the sky blue"
   cat article.txt | mo ask anthropic/claude-sonnet-4-6 "summarize this"
   mo ask openai/gpt-5.4 --effort high "explain monads" --json | jq .cost`)
     process.exit(0)
@@ -86,18 +107,23 @@ Examples:
   const json = flag('--json')
   const stream = flag('--stream')
   const verbose = flag('--verbose') || flag('-v')
+  const quiet = flag('--quiet') || flag('-q')
   const effort = flagVal('--effort')
   const budget = flagVal('--budget')
 
   // First remaining arg is model
-  const modelId = args[0]
+  // A model id always carries a provider segment, so a first argument without
+  // a slash is prompt text and the configured default model applies. Typing a
+  // full id on every call is the first thing that wears out.
+  const given = args[0]?.includes('/') ? args[0] : null
+  const modelId = given ?? (await getConfig()).defaultModel
   if (!modelId) {
     console.error('Usage: mo ask <model> [prompt]')
+    console.error('→ or:   mo default                   # pick one, then "mo ask" needs no model')
     process.exit(1)
   }
 
-  // Remaining args form the prompt
-  const promptArgs = args.slice(1).join(' ').trim()
+  const promptArgs = args.slice(given ? 1 : 0).join(' ').trim()
 
   // Read stdin if piped
   let stdinContent = ''
@@ -140,15 +166,32 @@ Examples:
   const options = {}
   if (effort) options.outputEffort = effort
   if (budget) options.outputBudget = parseInt(budget, 10)
+
+  // --verbose puts log lines on stderr on purpose; a spinner would be
+  // overwritten by them and leave its last frame behind.
+  const stopSpinner = (json || verbose || quiet) ? null : startSpinner(model.id)
+  let stopped = false
+  const stop = () => {
+    if (stopped) return
+    stopped = true
+    stopSpinner?.()
+  }
+
   if (stream && !json) {
-    options.realtimeHandler = (delta) => process.stdout.write(delta)
+    options.realtimeHandler = (delta) => {
+      stop()
+      process.stdout.write(delta)
+    }
     options.bufferOpts = { maxChars: 1, maxMs: 0 }
   }
 
-  process.stderr.write(`${model.id}\n`)
+  // Without a terminal the id is worth echoing only when it is not what was
+  // typed — an alias or a partial that resolved to something else.
+  if (!stopSpinner && !quiet && model.id !== modelId) process.stderr.write(`${model.id}\n`)
 
   try {
     const result = await model.answer(prompt, options)
+    stop()
     const output = typeof result === 'string' ? result : result?.output || ''
     const tokens = typeof result === 'object' ? result : {}
 
@@ -170,7 +213,7 @@ Examples:
       if (output && !output.endsWith('\n')) process.stdout.write('\n')
     }
 
-    // Token + timing summary to stderr
+    // Token + timing summary to stderr.
     const summary = []
     if (tokens.inputTokens) summary.push(`${tokens.inputTokens} in`)
     if (tokens.outputTokens) summary.push(`${tokens.outputTokens} out`)
@@ -195,8 +238,11 @@ Examples:
       if (ttft != null) summary.push(`${Math.round(ttft)}ms ttft`)
       if (total != null) summary.push(`${Math.round(total)}ms total`)
     }
-    if (summary.length) process.stderr.write(`${summary.join(', ')}\n`)
+    // --json already carries these numbers in the payload; --quiet keeps
+    // stderr free so a caller can treat anything on it as a failure.
+    if (summary.length && !json && !quiet) process.stderr.write(`${summary.join(', ')}\n`)
   } catch (err) {
+    stop()
     console.error(`Error: ${err.detail || err.message}`)
     for (const h of hintsForError(err, modelId)) console.error(h)
     process.exit(1)

package/src/cli/backup.js

@@ -14,7 +14,8 @@ Usage:
   model backup restore <slot>      Restore from a backup slot
   model backup diff <slot>         Show changes between current and slot
 
-Slots: prev (last save), daily (first save of the day), weekly (first save of the week)`)
+Slots: prev (last save), daily (first save of the day),
+       weekly (first save of the week)`)
     process.exit(0)
   }
 

package/src/cli/check.js

@@ -1,106 +1,35 @@
 import { label, err, warn, ok } from './colors.js'
-import providers from '../lib/providers.js'
-import { validate, isValidTag } from '../lib/schema.js'
-import { adapters } from '../../js/session/adapters/index.js'
-import { getCuratedModels, loadDefaultEnv, catalogEntries, catalogValues } from '../lib/common.js'
-
-// --- Local validation ---
-
-const checkLocal = (curated) => {
-  const errors = []
-  const warnings = []
-  const knownProviders = new Set(Object.keys(providers))
-
-  for (const [key, spec] of catalogEntries(curated)) {
-    const [keyProvider] = key.split('/')
-
-    if (spec.deprecated) {
-      if (!curated[spec.deprecated]) {
-        errors.push(`${key}: deprecated target '${spec.deprecated}' not in curated`)
-      }
-      continue
-    }
-
-    for (const issue of validate(spec, key)) {
-      if (issue.severity === 'error') errors.push(`${key}: ${issue.field} — ${issue.message}`)
-      else warnings.push(`${key}: ${issue.field} — ${issue.message}`)
-    }
-
-    if (!knownProviders.has(keyProvider)) {
-      errors.push(`${key}: provider '${keyProvider}' not in providers.js`)
-    }
-    if (spec.provider && spec.provider !== keyProvider) {
-      errors.push(`${key}: spec.provider '${spec.provider}' doesn't match key prefix '${keyProvider}'`)
-    }
-
-    const providerConfig = providers[keyProvider]
-    if (providerConfig && spec.sdk && spec.sdk !== providerConfig.sdk) {
-      errors.push(`${key}: spec.sdk '${spec.sdk}' doesn't match provider sdk '${providerConfig.sdk}'`)
-    }
-
-    if (!spec.label) warnings.push(`${key}: missing label`)
-
-    for (const priceField of ['inputPrice', 'outputPrice', 'thinkingPrice']) {
-      const val = spec[priceField]
-      if (val != null && typeof val === 'object' && val.default == null) {
-        errors.push(`${key}: ${priceField} is tiered but missing 'default' key`)
-      }
-    }
-
-    if (spec.thinkingEffortLevels && !spec.defaultThinkingEffort) {
-      warnings.push(`${key}: has thinkingEffortLevels but no defaultThinkingEffort`)
-    }
-
-    const lanes = adapters[keyProvider]?.speedLanes
-    for (const [lane, overlay] of Object.entries(spec.speeds || {})) {
-      if (!lanes?.has(lane)) {
-        const detail = lanes ? `accepts: ${[...lanes].join(', ')}` : 'implements no speed lanes'
-        errors.push(`${key}: speeds.${lane} — provider '${keyProvider}' ${detail}; calls on that lane would fail at dispatch`)
-      }
-      for (const priceField of ['inputPrice', 'outputPrice', 'thinkingPrice']) {
-        const val = overlay[priceField]
-        if (val != null && typeof val === 'object' && val.default == null) {
-          errors.push(`${key}: speeds.${lane}.${priceField} is tiered but missing 'default' key`)
-        }
-      }
-      const priced = ['inputPrice', 'outputPrice'].some(f => overlay[f] != null)
-      if (!priced) {
-        warnings.push(`${key}: speeds.${lane} restates no prices — the lane will bill at base rates`)
-      }
-    }
-
-    if (Array.isArray(spec.tags)) {
-      for (const t of spec.tags) {
-        if (!isValidTag(t)) warnings.push(`${key}: invalid tag "${t}" — must match /^[a-zA-Z][a-zA-Z0-9._-]{0,31}$/`)
-      }
-    }
-  }
-
-  return { errors, warnings }
-}
+import { reviewCatalog } from '../lib/catalog-review.js'
+import { localConventionsOrExit } from './local.js'
+import { getCuratedModels, loadDefaultEnv, catalogValues } from '../lib/common.js'
 
 // --- CLI ---
 
 export async function runCheck (args) {
   if (args.includes('-h') || args.includes('--help')) {
-    console.log(`mohdel model check — validate curated catalog
+    console.log(`mohdel model check — validate the catalog
 
 Usage:
   model check [options]
+  model check --entry <file|->   Validate entries not yet in the catalog
 
 Options:
   --json               Output as JSON
+  --entry <file|->     Read entries in curated.json shape and report what they
+                       would change, without writing. 'mo model apply' writes.
 
 Checks:
   Schema types, required fields, deprecated targets, provider/sdk
-  consistency, tiered pricing, thinking config.
-
-Note: 0.90 drops the upstream-drift check that piggybacked on the
-legacy per-provider SDK factory. If you need upstream drift
-detection, file an issue — it'll be rebuilt on the /session stack.`)
+  consistency, tiered pricing, thinking config.`)
     process.exit(0)
   }
 
+  if (args.includes('--entry')) {
+    const { runCheckEntry } = await import('./entry.js')
+    await runCheckEntry(args)
+    return
+  }
+
   loadDefaultEnv()
 
   const json = args.includes('--json')
@@ -114,7 +43,7 @@ detection, file an issue — it'll be rebuilt on the /session stack.`)
     console.log(`${label('Catalog:')} ${active} active, ${deprecated} deprecated\n`)
   }
 
-  const { errors, warnings: localWarnings } = checkLocal(curated)
+  const { errors, warnings: localWarnings } = reviewCatalog(curated, { local: await localConventionsOrExit() })
 
   if (!json) {
     if (errors.length) {