free-coding-models 0.5.37 → 0.5.39

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/changelog/v0.5.39.md

@@ -0,0 +1,16 @@
+# Changelog v0.5.39 - 2026-06-27
+
+### Added
+- **groq**: +`qwen/qwen3.6-27b` (preview, 131k, A tier)
+- **cloudflare**: +`@cf/zai-org/glm-5.2` (S+, 262k), +`@cf/moonshotai/kimi-k2.5` (S+, 256k)
+- **ovhcloud**: +`Qwen3-Embedding-8B`, +`bge-m3`, +`bge-multilingual-gemma2` (embeddings)
+- **openrouter**: +`cohere/north-mini-code:free` (S tier, 256k), +`nvidia/nemotron-3-ultra-550b-a55b:free` (S+ tier, 1M)
+
+### Changed
+- **openrouter**: full cleanup — removed 11 models no longer on free tier (`qwen3-coder`, `glm-4.5-air`, `kimi-k2.6`, `qwen3-next-80b`, `arcee-trinity`, `hermes-3-405b`, `dolphin-mistral`, `llama-3.3-70b`, `llama-3.2-3b`, `lfm-2.5-1.2b`, `lfm-2.5-thinking`), updated tiers to match live free models page
+- **cloudflare**: fixed `nemotron-3-120b-a12b` context window 32k→128k
+- **openrouter**: corrected ctx for `laguna-xs.2` (131k→262k), `gemma-4-31b` (256k→262k), `gemma-4-26b` (256k→262k), `nemotron-3-super` (262k→1M)
+- **openrouter**: `gemma-4-26b-a4b-it` tier A-→A (corrected)
+
+### Fixed
+- **openrouter**: `nemotron-3-super-120b-a12b:free` ctx 262k→1M (confirmed on openrouter.ai)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.5.37",
+  "version": "0.5.39",
   "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/sources.js

@@ -86,6 +86,7 @@ export const groq = [
   ['openai/gpt-oss-120b',                  'GPT OSS 120B',       'S',  '60.0%', '131k'],
   ['openai/gpt-oss-20b',                   'GPT OSS 20B',        'A',  '42.0%', '131k'],
   ['qwen/qwen3-32b',                       'Qwen3 32B',          'A+', '50.0%', '131k'],
+  ['qwen/qwen3.6-27b',                     'Qwen3.6 27B',        'A',  '-',     '131k'],
   ['groq/compound',                        'Groq Compound',      'A',  '45.0%', '131k'],
   ['groq/compound-mini',                   'Groq Compound Mini', 'B+', '32.0%', '131k'],
 ]
@@ -125,38 +126,27 @@ export const sambanova = [
 // 📖 • Free-tier popular models may be additionally rate-limited by the provider itself during peak hours.
 // 📖 API keys at https://openrouter.ai/keys
 export const openrouter = [
-  // ── S+ tier — live :free chat/coding models ──
-  ['qwen/qwen3-coder:free',                     'Qwen3 Coder 480B',   'S+', '70.6%', '1M'],
-  ['z-ai/glm-4.5-air:free',                     'GLM 4.5 Air',        'S+', '72.0%', '131k'],
+  // ── S+ tier — confirmed :free on openrouter.ai/collections/free-models ──
+  ['nvidia/nemotron-3-ultra-550b-a55b:free',    'Nemotron 3 Ultra',   'S+', '-',     '1M'],
   ['poolside/laguna-m.1:free',                  'Poolside Laguna M.1', 'S+', '-',     '262k'],
-  ['poolside/laguna-xs.2:free',                 'Poolside Laguna XS.2','S+', '-',     '131k'],
-  ['moonshotai/kimi-k2.6:free',                 'Kimi K2.6',          'S+', '76.8%', '262k'],
-  // ── S tier — live :free chat/coding models ──
-  ['qwen/qwen3-next-80b-a3b-instruct:free',     'Qwen3 80B Instruct', 'S',  '65.0%', '262k'],
+  ['poolside/laguna-xs.2:free',                 'Poolside Laguna XS.2','S+', '-',     '262k'],
+  // ── S tier ──
   ['openai/gpt-oss-120b:free',                  'GPT OSS 120B',       'S',  '60.0%', '131k'],
-  ['arcee-ai/trinity-large-thinking:free',      'Arcee Trinity Large', 'A',  '-',     '262k'],
-  ['nvidia/nemotron-3-super-120b-a12b:free',    'Nemotron 3 Super',   'A+', '56.0%', '262k'],
-  // ── A+ tier — live :free chat/coding models ──
+  ['cohere/north-mini-code:free',               'North Mini Code',    'S',  '-',     '256k'],
+  // ── A+ tier ──
+  ['nvidia/nemotron-3-super-120b-a12b:free',    'Nemotron 3 Super',   'A+', '56.0%', '1M'],
   ['nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free', 'Nemotron 3 Omni', 'A+', '52.0%', '256k'],
-  ['nvidia/nemotron-nano-12b-v2-vl:free',       'Nemotron Nano 12B VL','A',  '20.0%', '128k'],
   ['openrouter/owl-alpha',                      'Owl Alpha',          'A+', '-',     '1M'],
-  // ── A tier — live :free chat/coding models ──
-  ['nousresearch/hermes-3-llama-3.1-405b:free', 'Hermes 3 405B',      'A',  '44.0%', '131k'],
+  // ── A tier ──
   ['openai/gpt-oss-20b:free',                   'GPT OSS 20B',        'A',  '42.0%', '131k'],
   ['nvidia/nemotron-nano-30b-a3b:free',         'Nemotron Nano 30B',  'A',  '43.0%', '256k'],
-  ['cognitivecomputations/dolphin-mistral-24b-venice-edition:free', 'Dolphin Mistral 24B', 'B+', '30.0%', '33k'],
-  ['google/gemma-4-31b-it:free',                'Gemma 4 31B',        'A',  '45.0%', '256k'],
-  ['google/gemma-4-26b-a4b-it:free',            'Gemma 4 26B MoE',    'A-', '38.0%', '256k'],
-  // ── A- tier — confirmed free ──
-  ['meta-llama/llama-3.3-70b-instruct:free',    'Llama 3.3 70B',      'A-', '39.5%', '131k'],
-  ['meta-llama/llama-3.2-3b-instruct:free',     'Llama 3.2 3B',       'B',  '20.0%', '128k'],
+  ['nvidia/nemotron-nano-12b-v2-vl:free',       'Nemotron Nano 12B VL','A', '20.0%', '128k'],
+  ['google/gemma-4-31b-it:free',                'Gemma 4 31B',        'A',  '45.0%', '262k'],
+  ['google/gemma-4-26b-a4b-it:free',            'Gemma 4 26B MoE',    'A',  '38.0%', '262k'],
   // ── B+ tier ──
   ['nvidia/nemotron-nano-9b-v2:free',           'Nemotron Nano 9B',   'B+', '18.0%', '128k'],
   // ── B tier ──
   ['openrouter/free',                           'OpenRouter Free',    'B',  '-',     '200k'],
-  // ── C tier ──
-  ['liquid/lfm-2.5-1.2b-instruct:free',         'LFM 2.5 1.2B',       'C',  '-',     '32k'],
-  ['liquid/lfm-2.5-1.2b-thinking:free',         'LFM 2.5 Thinking',   'C',  '-',     '32k'],
 ]
 
 // 📖 GitHub Models source - https://models.github.ai
@@ -270,7 +260,9 @@ export const cloudflare = [
   ['@cf/zai-org/glm-4.7-flash',               'GLM-4.7-Flash',     'S',  '59.2%', '131k'],
   ['@cf/openai/gpt-oss-120b',                 'GPT OSS 120B',      'S',  '60.0%', '128k'],
   // ── A+ tier ──
-  ['@cf/nvidia/nemotron-3-120b-a12b',         'Nemotron 3 Super',  'A+', '56.0%', '32k'],
+  ['@cf/nvidia/nemotron-3-120b-a12b',         'Nemotron 3 Super',  'A+', '56.0%', '128k'],
+  ['@cf/zai-org/glm-5.2',                  'GLM-5.2',            'S+', '-',     '262k'],
+  ['@cf/moonshotai/kimi-k2.5',             'Kimi K2.5',          'S+', '-',     '256k'],
   // ── A tier ──
   ['@cf/meta/llama-4-scout-17b-16e-instruct', 'Llama 4 Scout',     'A',  '44.0%', '131k'],
   ['@cf/mistralai/mistral-7b-instruct-v0.2',   'Mistral 7B v0.2',   'A',  '38.0%', '128k'],
@@ -303,6 +295,10 @@ export const ovhcloud = [
   ['Mistral-7B-Instruct-v0.3',                  'Mistral 7B Instruct',  'B',  '25.0%', '127k'],
   ['Mistral-Nemo-Instruct-2407',                'Mistral Nemo',         'B+', '30.0%', '118k'],
   ['Qwen3.5-9B',                                'Qwen3.5 9B',           'B+', '30.0%', '262k'],
+  // ── Embeddings ──
+  ['Qwen3-Embedding-8B',                        'Qwen3 Embedding 8B',   'B',  '-',     '-'],
+  ['bge-m3',                                    'BGE M3',               'B',  '-',     '-'],
+  ['bge-multilingual-gemma2',                   'BGE Multilingual Gemma2','B','-',     '-'],
   // Fix (2026-05-26): Qwen3.5-9B ctx 128k→262k, Mistral-Small ctx 131k→128k, Mistral-Nemo ctx 128k→118k, Mistral-7B ctx 32k→127k
 ]
 

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' }