free-coding-models 0.5.36 → 0.5.38

package/changelog/v0.5.37.md

@@ -0,0 +1,14 @@
+# Changelog v0.5.37 - 2026-06-20
+
+### Changed
+- **Router `score` is now a pure latency+uptime composite (issue #120 hardening).** Previously the routing score was `0.4*latency + 0.4*uptime + 0.2*priorityBonus` — mixing explicit priority into the score could mislead tiebreakers and dashboards, because the routing comparator in `getRoutingCandidates` already enforces priority authoritatively. `scoreCandidates()` now exposes `score = 0.5*latency + 0.5*uptime` (pure model quality, normalized to `[0, 1]`), and `priorityBonus` is kept as a separate field for back-compat dashboards and legacy UIs. The remaining `latencyWeight` / `uptimeWeight` were rebalanced to `0.5 / 0.5` so the score stays in `[0, 1]` after priority is removed. Applies uniformly to CLI, Web Dashboard, and Desktop surfaces because the change lives in shared core (`src/core/router-daemon.js` + `src/core/config.js`).
+
+### Fixed
+- **HALF_OPEN recovery is now respected by the priority-first comparator (issue #120 regression test).** The v0.5.36 fix changed `getRoutingCandidates` to sort by explicit priority before circuit state, but had no test for the exact scenario from the issue screenshot: a high-priority model sitting in `HALF_OPEN` recovery vs. a lower-priority `CLOSED` model. Added a regression test that pins `runtime.circuit.get(key).state = 'HALF_OPEN'` for priority `#1` while priority `#5` stays `CLOSED`, then verifies both `/stats.routingOrder[0]` and the actual chat-completions response target the HALF_OPEN priority-#1 model — locking in the fix so it can't silently regress.
+- **Score tiebreaker is deterministic when two models share the same priority (issue #120 regression test).** Added a second regression test that puts two models at the same explicit priority (rare but reachable via direct API or auto-heal) with deliberately asymmetric probe data — fast groq (80 ms) vs. slow nvidia (2000 ms) — and verifies that the higher-score model wins `routingOrder[0]`. This locks in the new pure-latency+uptime score as the deterministic tiebreaker for same-priority same-state candidates, preventing future regressions where Map iteration order or stale priority data could leak back into routing.
+
+### Docs
+- **`DEFAULT_ROUTER_SETTINGS.scoring.priorityWeight` marked as preserved-for-back-compat.** The field still round-trips through `normalizeRouterScoring()` so user configs that customize it are not silently dropped on next save, but it is now ignored by the runtime `scoreCandidates()`. Will be removed in a future major bump. Comment block in `src/core/config.js` documents the rationale.
+
+### Tests
+- **+2 new tests for issue #120** (`test/test.js`, `router daemon integration hardening` suite): `keeps a higher-priority HALF_OPEN model above a lower-priority CLOSED one` and `breaks score ties deterministically by latency/uptime, not priority`. Test count moves from 540 → 542, all passing.

package/changelog/v0.5.38.md

@@ -0,0 +1,15 @@
+# Changelog v0.5.38 - 2026-06-27
+
+### Added
+- feat(zcode): add full ZCode install-target support across all surfaces (PR #128)
+
+### Fixed
+- fix: regenerate pnpm-lock.yaml to unblock Docker CI (PR #123)
+
+### Changed
+- ci: pnpm-lock.yaml sync for @tanstack/react-virtual (PR #123)
+
+### Closed (unresolved conflicts)
+- deps(deps-dev): bump vite-plus from 0.1.24 to 0.2.1 (PR #127) - Closed due to unresolvable pnpm-lock.yaml conflicts
+- deps(deps): bump kandown from 0.8.0 to 0.13.1 (PR #126) - Closed due to unresolvable pnpm-lock.yaml conflicts
+- ci(deps): bump actions/checkout from 4 to 7 (PR #125) - Skipped due to failing audit check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.5.36",
+  "version": "0.5.38",
   "description": "Find the fastest coding LLM models in seconds — ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
   "keywords": [
     "nvidia",

package/src/core/config.js

@@ -167,8 +167,15 @@ export const DEFAULT_ROUTER_SETTINGS = Object.freeze({
     requestTimeoutMs: 15000,
   }),
   scoring: Object.freeze({
-    latencyWeight: 0.4,
-    uptimeWeight: 0.4,
+    latencyWeight: 0.5,
+    uptimeWeight: 0.5,
+    // 📖 priorityWeight is preserved for back-compat with user configs that
+    // 📖 set a custom value, but is no longer mixed into the routing score
+    // 📖 (issue #120 fix, v0.5.37). Priority is now enforced authoritatively
+    // 📖 by the comparator in getRoutingCandidates; folding it into score
+    // 📖 could only mislead tiebreakers and dashboards. The remaining
+    // 📖 latency+uptime weights are rebalanced to 0.5/0.5 so the score stays
+    // 📖 in [0, 1] after priority is removed (previously 0.4/0.4/0.2).
     priorityWeight: 0.2,
   }),
   logLevel: 'info',
@@ -377,6 +384,10 @@ function normalizeRouterScoring(scoring) {
     const numeric = Number(value)
     return Number.isFinite(numeric) && numeric >= 0 ? numeric : fallback
   }
+  // 📖 priorityWeight is normalized but currently IGNORED by the runtime
+  // 📖 scoreCandidates() (issue #120, v0.5.37). Kept here so existing user
+  // 📖 configs that customize this field round-trip cleanly and don't lose
+  // 📖 their setting on next save. Will be removed in a future major bump.
   return {
     latencyWeight: numberOrDefault(safeScoring.latencyWeight, DEFAULT_ROUTER_SETTINGS.scoring.latencyWeight),
     uptimeWeight: numberOrDefault(safeScoring.uptimeWeight, DEFAULT_ROUTER_SETTINGS.scoring.uptimeWeight),

package/src/core/endpoint-installer.js

@@ -54,7 +54,7 @@ import { ensureDir, readJson as sharedReadJson } from './shared-helpers.js'
 const DIRECT_INSTALL_UNSUPPORTED_PROVIDERS = new Set(['replicate'])
 // 📖 Install Endpoints only lists tools whose persisted config shape is actually supported here.
 // 📖 Launch-only tools stay out: the Web dashboard configures endpoints, it never starts CLIs.
-const INSTALL_TARGET_MODES = ['opencode', 'opencode-desktop', 'opencode-web', 'openclaw', 'crush', 'goose', 'pi', 'aider', 'qwen', 'openhands', 'amp', 'forgecode', 'fcm_router']
+const INSTALL_TARGET_MODES = ['opencode', 'opencode-desktop', 'opencode-web', 'openclaw', 'crush', 'goose', 'pi', 'aider', 'qwen', 'openhands', 'amp', 'forgecode', 'fcm_router', 'zcode']
 
 function getDefaultPaths() {
   const home = homedir()
@@ -70,6 +70,8 @@ function getDefaultPaths() {
     ampConfigPath: join(home, '.config', 'amp', 'settings.json'),
     qwenConfigPath: join(home, '.qwen', 'settings.json'),
     forgeCodeConfigPath: join(home, '.forge', '.forge.toml'),
+    zcodeConfigPath: join(home, '.zcode', 'v2', 'config.json'),
+    zcodeModelCachePath: join(home, '.zcode', 'v2', 'bots-model-cache.v2.json'),
   }
 }
 
@@ -625,6 +627,183 @@ function installIntoFcmRouter(providerKey, models, apiKey) {
   return { path: `FCM Router (${baseUrl})`, backupPath: null, providerId: providerKey, modelCount: models.length }
 }
 
+// 📖 installIntoZCode: Writes provider + models into ZCode's config.json and updates
+// 📖 bots-model-cache.v2.json so the models appear immediately in ZCode's model picker.
+// 📖 Uses deterministic provider ID (fcm-{providerKey}) so re-running replaces/merges
+// 📖 without duplicating the provider entry.
+// 📖 When scope === 'selected' — merges models with existing ones.
+// 📖 When scope === 'all' — replaces all models (full sync).
+function installIntoZCode(providerKey, models, apiKey, paths, scope) {
+  const configPath = paths.zcodeConfigPath
+  const cachePath = paths.zcodeModelCachePath
+  const providerId = `fcm-${providerKey}`
+  const baseUrl = resolveProviderBaseUrl(providerKey)
+  const providerLabel = getManagedProviderLabel(providerKey)
+
+  if (!baseUrl) {
+    throw new Error(`Cannot resolve base URL for ${getProviderLabel(providerKey)}`)
+  }
+
+  function buildModelEntry(model) {
+    const ctx = parseContextWindow(model.ctx)
+    const entry = {
+      id: model.modelId,
+      name: model.label || model.modelId,
+      kinds: ['openai-compatible'],
+      defaultKind: 'openai-compatible',
+      modalities: { input: ['text'], output: ['text'] },
+      contextWindow: ctx,
+    }
+    if (ctx > 8192) {
+      entry.maxOutputTokens = getDefaultMaxTokens(ctx)
+    }
+    return entry
+  }
+
+  function buildConfigModelEntry(model) {
+    const ctx = parseContextWindow(model.ctx)
+    const entry = {
+      limit: { context: ctx },
+      modalities: { input: ['text'], output: ['text'] },
+    }
+    if (ctx > 8192) {
+      entry.limit.output = getDefaultMaxTokens(ctx)
+    }
+    return entry
+  }
+
+  const newModelIds = new Set(models.map((m) => m.modelId))
+  let configModified = false
+  let cacheModified = false
+
+  // ── 1. Write to config.json ───────────────────────────────────────────────
+  const config = readJson(configPath, { $schema: 'https://opencode.ai/config.json' })
+  if (!config.provider || typeof config.provider !== 'object') config.provider = {}
+
+  const existingProvider = config.provider[providerId]
+
+  if (scope === 'selected' && existingProvider) {
+    // 📖 Merge mode: add/update selected models, keep existing ones
+    for (const model of models) {
+      existingProvider.models[model.modelId] = buildConfigModelEntry(model)
+    }
+    configModified = true
+  } else if (scope === 'selected' && !existingProvider) {
+    // 📖 No existing provider, but scope is selected — create with only selected models
+    config.provider[providerId] = {
+      name: providerLabel,
+      kind: 'openai-compatible',
+      options: { apiKey, baseURL: baseUrl, apiKeyRequired: true },
+      enabled: true,
+      source: 'custom',
+      models: Object.fromEntries(models.map((m) => [m.modelId, buildConfigModelEntry(m)])),
+    }
+    configModified = true
+  } else {
+    // 📖 scope === 'all' — replace all models (full sync), skip if identical
+    const existingModelIds = existingProvider ? Object.keys(existingProvider.models || {}) : []
+    const modelsUnchanged = existingProvider
+      && existingModelIds.length === models.length
+      && models.every((m) => existingModelIds.includes(m.modelId))
+
+    if (!modelsUnchanged) {
+      config.provider[providerId] = {
+        name: providerLabel,
+        kind: 'openai-compatible',
+        options: { apiKey, baseURL: baseUrl, apiKeyRequired: true },
+        enabled: true,
+        source: 'custom',
+        models: Object.fromEntries(models.map((m) => [m.modelId, buildConfigModelEntry(m)])),
+      }
+      configModified = true
+    }
+  }
+
+  const configBackupPath = configModified ? writeJson(configPath, config) : null
+
+  // ── 2. Write to bots-model-cache.v2.json ──────────────────────────────────
+  const cache = readJson(cachePath, { version: 2, updatedAt: Date.now(), providers: [] })
+  if (!Array.isArray(cache.providers)) cache.providers = []
+
+  const existingCacheIdx = cache.providers.findIndex((p) => p?.id === providerId)
+
+  if (scope === 'selected') {
+    // 📖 Merge mode: add/update selected models in cache, keep existing ones
+    if (existingCacheIdx >= 0) {
+      const existingModels = cache.providers[existingCacheIdx].models || []
+      for (const model of models) {
+        const modelIdx = existingModels.findIndex((m) => m.id === model.modelId)
+        if (modelIdx >= 0) {
+          existingModels[modelIdx] = buildModelEntry(model)
+        } else {
+          existingModels.push(buildModelEntry(model))
+        }
+      }
+      cache.providers[existingCacheIdx].updatedAt = Date.now()
+      cacheModified = true
+    } else {
+      cache.providers.push({
+        id: providerId,
+        name: providerLabel,
+        enabled: true,
+        endpoints: { baseURL: baseUrl, paths: { 'openai-compatible': '/chat/completions' } },
+        apiFormat: 'openai-chat-completions',
+        source: 'custom',
+        apiKeyRequired: true,
+        apiKey: '__zcode_cached_api_key_present__',
+        defaultKind: 'openai-compatible',
+        models: models.map(buildModelEntry),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      })
+      cacheModified = true
+    }
+  } else {
+    // 📖 scope === 'all' — replace all models, skip if identical
+    const cachedModelIds = existingCacheIdx >= 0
+      ? (cache.providers[existingCacheIdx].models || []).map((m) => m.id)
+      : []
+    const cacheUnchanged = existingCacheIdx >= 0
+      && cachedModelIds.length === models.length
+      && models.every((m) => cachedModelIds.includes(m.modelId))
+
+    if (!cacheUnchanged) {
+      if (existingCacheIdx >= 0) {
+        cache.providers[existingCacheIdx].models = models.map(buildModelEntry)
+        cache.providers[existingCacheIdx].updatedAt = Date.now()
+      } else {
+        cache.providers.push({
+          id: providerId,
+          name: providerLabel,
+          enabled: true,
+          endpoints: { baseURL: baseUrl, paths: { 'openai-compatible': '/chat/completions' } },
+          apiFormat: 'openai-chat-completions',
+          source: 'custom',
+          apiKeyRequired: true,
+          apiKey: '__zcode_cached_api_key_present__',
+          defaultKind: 'openai-compatible',
+          models: models.map(buildModelEntry),
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        })
+      }
+      cache.updatedAt = Date.now()
+      cacheModified = true
+    }
+  }
+
+  const cacheBackupPath = cacheModified ? writeJson(cachePath, cache) : null
+
+  return {
+    path: configPath,
+    backupPath: configBackupPath,
+    providerId,
+    modelCount: models.length,
+    extraPath: cachePath,
+    extraBackupPath: cacheBackupPath,
+  }
+}
+
 export function installProviderEndpoints(config, providerKey, toolMode, options = {}) {
   const canonicalToolMode = canonicalizeToolMode(toolMode)
   const support = getDirectInstallSupport(providerKey)
@@ -664,6 +843,8 @@ export function installProviderEndpoints(config, providerKey, toolMode, options
     installResult = installIntoFcmRouter(providerKey, models, apiKey)
   } else if (canonicalToolMode === 'forgecode') {
     installResult = installIntoForgeCode(providerKey, models, apiKey, paths)
+  } else if (canonicalToolMode === 'zcode') {
+    installResult = installIntoZCode(providerKey, models, apiKey, paths, scope)
   } else {
     throw new Error(`Unsupported install target: ${toolMode}`)
   }

package/src/core/installed-models-manager.js

@@ -56,17 +56,19 @@ const BACKUP_PATH = join(homedir(), '.free-coding-models-backups.json')
  * 📖 Get tool config paths
  */
 function getToolConfigPaths(homeDir = homedir()) {
-  return {
-    goose: join(homeDir, '.config', 'goose', 'config.yaml'),
-    crush: join(homeDir, '.config', 'crush', 'crush.json'),
-    aider: join(homeDir, '.aider.conf.yml'),
-    kilo: join(homeDir, '.config', 'kilo', 'opencode.json'),
-    qwen: join(homeDir, '.qwen', 'settings.json'),
-    piModels: join(homeDir, '.pi', 'agent', 'models.json'),
-    piSettings: join(homeDir, '.pi', 'agent', 'settings.json'),
-    openHands: join(homeDir, '.fcm-openhands-env'),
-    amp: join(homeDir, '.config', 'amp', 'settings.json'),
-  }
+	return {
+	    goose: join(homeDir, '.config', 'goose', 'config.yaml'),
+	    crush: join(homeDir, '.config', 'crush', 'crush.json'),
+	    aider: join(homeDir, '.aider.conf.yml'),
+	    kilo: join(homeDir, '.config', 'kilo', 'opencode.json'),
+	    qwen: join(homeDir, '.qwen', 'settings.json'),
+	    piModels: join(homeDir, '.pi', 'agent', 'models.json'),
+	    piSettings: join(homeDir, '.pi', 'agent', 'settings.json'),
+	    openHands: join(homeDir, '.fcm-openhands-env'),
+	    amp: join(homeDir, '.config', 'amp', 'settings.json'),
+	    zcodeConfig: join(homeDir, '.zcode', 'v2', 'config.json'),
+	    zcodeCache: join(homeDir, '.zcode', 'v2', 'bots-model-cache.v2.json'),
+	  }
 }
 
 /**
@@ -463,6 +465,111 @@ function parseAmpConfig(paths = getToolConfigPaths()) {
   }
 }
 
+/**
+ * 📖 Parse ZCode config.json + bots-model-cache.v2.json for installed models.
+ * 📖 Uses a Map keyed by "providerId::modelId" to deduplicate across both files.
+ */
+function parseZCodeConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.zcodeConfig
+  const cachePath = paths.zcodeCache
+
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    /** @type {Map<string, object>} */
+    const modelMap = new Map()
+
+    const configContent = readFileSync(configPath, 'utf8')
+    const config = JSON.parse(configContent)
+
+    // ── 1. Source of truth: config.json provider.models ─────────────────────
+    if (config.provider && typeof config.provider === 'object') {
+      for (const [providerId, provider] of Object.entries(config.provider)) {
+        if (!provider.models || typeof provider.models !== 'object') continue
+
+        const isManaged = providerId.startsWith('fcm-')
+        const sourceKey = isManaged ? providerId.replace('fcm-', '') : providerId
+
+        for (const [modelId, modelConfig] of Object.entries(provider.models)) {
+          const ctx = modelConfig?.limit?.context || 0
+          const key = `${providerId}::${modelId}`
+          modelMap.set(key, {
+            modelId,
+            label: modelId,
+            tier: '-',
+            sweScore: '-',
+            providerKey: sourceKey,
+            isExternal: !isManaged,
+            canLaunch: true,
+            contextWindow: ctx,
+            enabled: provider.enabled !== false,
+            zcodeProviderId: providerId,
+          })
+        }
+      }
+    }
+
+    // ── 2. Cache enrichment: use cache names only (no duplicates) ────────────
+    if (existsSync(cachePath)) {
+      try {
+        const cacheContent = readFileSync(cachePath, 'utf8')
+        const cache = JSON.parse(cacheContent)
+
+        if (Array.isArray(cache.providers)) {
+          for (const cachedProvider of cache.providers) {
+            if (!cachedProvider?.models) continue
+            const providerId = cachedProvider.id || 'unknown'
+
+            for (const cachedModel of cachedProvider.models) {
+              const key = `${providerId}::${cachedModel.id}`
+              const existing = modelMap.get(key)
+
+              if (existing) {
+                // 📖 Upgrade label from cache (prettier name) + fill context if missing
+                if (cachedModel.name) existing.label = cachedModel.name
+                if (cachedModel.contextWindow && !existing.contextWindow) {
+                  existing.contextWindow = cachedModel.contextWindow
+                }
+              } else {
+                // 📖 Model only in cache (edge case — provider.models missing it)
+                const isManaged = providerId.startsWith('fcm-')
+                const sourceKey = isManaged ? providerId.replace('fcm-', '') : providerId
+                modelMap.set(key, {
+                  modelId: cachedModel.id,
+                  label: cachedModel.name || cachedModel.id,
+                  tier: '-',
+                  sweScore: '-',
+                  providerKey: sourceKey,
+                  isExternal: !isManaged,
+                  canLaunch: true,
+                  contextWindow: cachedModel.contextWindow || 0,
+                  enabled: cachedProvider.enabled !== false,
+                  zcodeProviderId: providerId,
+                })
+              }
+            }
+          }
+        }
+      } catch {
+        // 📖 Cache file is optional — silently ignore errors
+      }
+    }
+
+    const models = Array.from(modelMap.values())
+
+    return {
+      isValid: models.length > 0,
+      hasManagedMarker: Object.keys(config.provider || {}).some((id) => id.startsWith('fcm-')),
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
 /**
  * 📖 Enhance model with metadata from sources.js
  */
@@ -507,9 +614,11 @@ export function parseToolConfig(toolMode, paths = getToolConfigPaths()) {
       return parsePiConfig(paths)
     case 'openhands':
       return parseOpenHandsConfig(paths)
-    case 'amp':
-      return parseAmpConfig(paths)
-    default:
+	    case 'zcode':
+	      return parseZCodeConfig(paths)
+	    case 'amp':
+	      return parseAmpConfig(paths)
+	    default:
       return { isValid: false, models: [], configPath: '' }
   }
 }
@@ -518,7 +627,7 @@ export function parseToolConfig(toolMode, paths = getToolConfigPaths()) {
  * 📖 Scan all tool configs and return structured results
  */
 export function scanAllToolConfigs(paths = getToolConfigPaths()) {
-  const toolModes = ['goose', 'crush', 'aider', 'kilo', 'qwen', 'pi', 'openhands', 'amp']
+	  const toolModes = ['goose', 'crush', 'aider', 'kilo', 'qwen', 'pi', 'openhands', 'amp', 'zcode']
 
   return toolModes.map((toolMode) => {
     const result = parseToolConfig(toolMode, paths)
@@ -537,17 +646,18 @@ export function scanAllToolConfigs(paths = getToolConfigPaths()) {
  * 📖 Get tool emoji
  */
 function getToolEmoji(toolMode) {
-  const emojis = {
-    goose: '🪿',
-    crush: '💘',
-    aider: '🛠',
-    kilo: '⚡️',
-    qwen: '🐉',
-    pi: 'π',
-    openhands: '🤲',
-    amp: '⚡',
-  }
-  return emojis[toolMode] || '🧰'
+	  const emojis = {
+	    goose: '🪿',
+	    crush: '💘',
+	    aider: '🛠',
+	    kilo: '⚡️',
+	    qwen: '🐉',
+	    pi: 'π',
+	    openhands: '🤲',
+	    amp: '⚡',
+	    zcode: '🧊',
+	  }
+	  return emojis[toolMode] || '🧰'
 }
 
 /**
@@ -580,7 +690,10 @@ function saveBackups(backups) {
  * 📖 Soft-delete a model from tool config with backup
  */
 export function softDeleteModel(toolMode, modelId, paths = getToolConfigPaths()) {
-  const configPath = paths[toolMode === 'pi' ? 'piSettings' : toolMode]
+	  const pathKey = toolMode === 'pi' ? 'piSettings'
+	    : toolMode === 'zcode' ? 'zcodeConfig'
+	    : toolMode
+	  const configPath = paths[pathKey]
   if (!existsSync(configPath)) {
     return { success: false, error: 'Config file not found' }
   }
@@ -653,15 +766,58 @@ export function softDeleteModel(toolMode, modelId, paths = getToolConfigPaths())
         }
         break
 
-      case 'amp':
-        const ampConfig = JSON.parse(originalContent)
-        if (ampConfig['amp.model'] === modelId) {
-          delete ampConfig['amp.model']
-          newContent = JSON.stringify(ampConfig, null, 2)
-          modified = true
-        }
-        break
-    }
+	      case 'zcode': {
+	        const zconfig = JSON.parse(originalContent)
+	        // 📖 Find the provider entry that contains this modelId
+	        let foundProviderId = null
+	        if (zconfig.provider && typeof zconfig.provider === 'object') {
+	          for (const [provId, prov] of Object.entries(zconfig.provider)) {
+	            if (prov.models && typeof prov.models === 'object' && modelId in prov.models) {
+	              foundProviderId = provId
+	              break
+	            }
+	          }
+	        }
+	        if (foundProviderId) {
+	          delete zconfig.provider[foundProviderId].models[modelId]
+	          // 📖 If no models left, keep the empty provider (don't remove it — user may want to re-add)
+	          newContent = JSON.stringify(zconfig, null, 2)
+	          modified = true
+
+	          // 📖 Also remove from cache file if it exists
+	          const cachePath = paths.zcodeCache
+	          if (existsSync(cachePath)) {
+	            try {
+	              const cacheContent = readFileSync(cachePath, 'utf8')
+	              const cache = JSON.parse(cacheContent)
+	              if (Array.isArray(cache.providers)) {
+	                const cacheProv = cache.providers.find((p) => p.id === foundProviderId)
+	                if (cacheProv && Array.isArray(cacheProv.models)) {
+	                  const before = cacheProv.models.length
+	                  cacheProv.models = cacheProv.models.filter((m) => m.id !== modelId)
+	                  if (cacheProv.models.length !== before) {
+	                    cacheProv.updatedAt = Date.now()
+	                    writeFileSync(cachePath, JSON.stringify(cache, null, 2))
+	                  }
+	                }
+	              }
+	            } catch {
+	              // 📖 Cache file is optional
+	            }
+	          }
+	        }
+	        break
+	      }
+
+	      case 'amp':
+	        const ampConfig = JSON.parse(originalContent)
+	        if (ampConfig['amp.model'] === modelId) {
+	          delete ampConfig['amp.model']
+	          newContent = JSON.stringify(ampConfig, null, 2)
+	          modified = true
+	        }
+	        break
+	    }
 
     if (!modified) {
       return { success: false, error: 'Model not found in config' }

package/src/core/router-daemon.js

@@ -1149,15 +1149,27 @@ class RouterRuntime {
       const hasData = stats.total > 0
       const latencyScore = stats.p95 === null ? 0.5 : Math.max(0, 1 - (stats.p95 / maxP95))
       const uptimeScore = stats.uptime === null ? 0.5 : stats.uptime
+      // 📖 priorityBonus - kept as a separate field for dashboards/legacy UIs
+      // 📖 that previously rendered a single composite "score". Priority is
+      // 📖 NOT folded into `score` anymore (issue #120): the routing comparator
+      // 📖 in getRoutingCandidates sorts by explicit priority authoritatively,
+      // 📖 so mixing priority into the score only confused tiebreakers.
       const priorityBonus = 1 - ((entry.priority - 1) / setSize)
+      // 📖 score - pure latency+uptime composite. Used only as the FINAL
+      // 📖 tiebreaker between candidates that share the same priority AND
+      // 📖 same circuit state (see getRoutingCandidates). A model with no
+      // 📖 probe data yet scores neutral (0.5) - we deliberately do NOT use
+      // 📖 priorityBonus as a cold-start fallback, because that would re-
+      // 📖 introduce the priority-in-score confusion this refactor removes.
       const score = hasData
-        ? (weights.latencyWeight * latencyScore) + (weights.uptimeWeight * uptimeScore) + (weights.priorityWeight * priorityBonus)
-        : priorityBonus
+        ? (weights.latencyWeight * latencyScore) + (weights.uptimeWeight * uptimeScore)
+        : 0.5
       const state = this.updateCircuitForCooldown(key) || {}
       return {
         ...entry,
         key,
         score,
+        priorityBonus,
         stats,
         circuit: state,
         catalog: this.modelCatalog.get(key) || null,