@goodandready/dsh-clinebot 0.3.25 → 0.4.0

package/lib/index.js

@@ -8,7 +8,9 @@ import {
   resolveKeyValue,
   smokeChat,
   fetchUsageLimits,
+  isQuotaExceededError,
 } from './cline-client.js'
+import { PROVIDER_ID } from './models.js'
 import {
   checkRegisteredInPiAi,
   upsertPiAiProvider,
@@ -43,8 +45,8 @@ export function apply(ctx, config) {
         }
         return
       }
-      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-      if (key.value) {
+      const activeKey = await resolveActiveAccountKey(ctx, cfg)
+      if (activeKey.value) {
         await upsertPiAiProvider(ctx, cfg, pub.enabledModels)
       }
     } catch {
@@ -116,20 +118,6 @@ export function apply(ctx, config) {
         settingsApi = undefined
       })
     })
-  } else {
-    const settingsService = (ctx?.get && ctx.get('settings')) || ctx?.settings
-    if (typeof settingsService?.register === 'function') {
-      const scope = settingsService.register(NS, Config, { base: config })
-      settingsApi = scope
-      getConfig = () => (scope?.get?.() ?? config) ?? config
-      if (typeof ctx.effect === 'function') {
-        ctx.effect(() => scope.watch((next) => {
-          syncProviderState(live())
-        }), 'dsh-clinebot: settings')
-      }
-    } else {
-      settingsApi = createSettingsAdapter(settingsService)
-    }
   }
 
   syncProviderState(live())
@@ -138,8 +126,6 @@ export function apply(ctx, config) {
       const timer = setTimeout(triggerAutoDiscover, 500)
       return () => clearTimeout(timer)
     }, 'dsh-clinebot: auto-discover')
-  } else {
-    setTimeout(triggerAutoDiscover, 500)
   }
 
   if (ctx.webServer?.register) {
@@ -171,35 +157,118 @@ export function apply(ctx, config) {
     syncProviderState,
   })
 
-  return {
-    getStatus: () => buildStatus(ctx, live()),
-    registerProvider: (models) => upsertPiAiProvider(ctx, live(), models),
-    unregisterProvider: () => removePiAiProvider(ctx),
-    recordRequestMetrics: (metrics) => recordSessionRequest(metrics),
-    getSessionStats: () => ({ ...sessionStats }),
-    getUsageLimits: async () => {
-      const pub = publicConfig(live())
-      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-      return fetchUsageLimits(pub.baseUrl, key.value)
-    },
-    runSmokeTest: async (model) => {
-      const pub = publicConfig(live())
-      const activeKey = await resolveActiveAccountKey(ctx, live())
-      const res = await smokeChat(pub.baseUrl, activeKey.value, { model: model || pub.defaultModel })
-      recordSessionRequest({
-        latencyMs: res.latencyMs,
-        ok: res.ok,
-        error: res.error,
-        promptTokens: res.promptTokens || 5,
-        completionTokens: res.completionTokens || 10,
-      })
-      if (res.status === 429) {
-        const failover = await rotateToNextAccount(ctx, live(), 'service_429', settingsApi)
-        if (failover.rotated) {
-          await syncProviderState(live())
-        }
+  let lastFailoverAt = 0
+
+  const handleStream429 = async () => {
+    const now = Date.now()
+    if (now - lastFailoverAt < 30000) {
+      ctx?.logger?.warn?.('[dsh-clinebot] Suppressing rapid failover rotation within 30s storm window')
+      return
+    }
+    lastFailoverAt = now
+    try {
+      const failover = await rotateToNextAccount(ctx, live(), 'stream_429', settingsApi)
+      if (failover?.rotated) {
+        await syncProviderState(live())
       }
-      return res
-    },
+    } catch (err) {
+      ctx?.logger?.warn?.('[dsh-clinebot] Auto-failover rotation failed: ' + (err?.message || err))
+    }
+  }
+
+  if (typeof ctx.on === 'function') {
+    const unlisten = ctx.on('llm/stream', (options, next) => {
+      const isCline = options?.provider === PROVIDER_ID
+      const stream = next()
+      const startTime = Date.now()
+      let promptTokens = 0
+      let completionTokens = 0
+      let finished = false
+
+      return (async function* () {
+        try {
+          for await (const chunk of stream) {
+            if (isCline && chunk?.type === 'usage' && chunk?.usage) {
+              const u = chunk.usage
+              promptTokens += (Number(u.inputTokens) || 0) + (Number(u.cacheReadTokens) || 0) + (Number(u.cacheWriteTokens) || 0)
+              completionTokens += Number(u.outputTokens) || 0
+            }
+            if (isCline && chunk?.type === 'finish' && chunk?.reason) {
+              finished = true
+              const latencyMs = Date.now() - startTime
+              const reason = chunk.reason
+              const failure = reason.failure || {}
+              const isError = reason.kind === 'error'
+              const isAborted = reason.kind === 'aborted'
+              const is429 = failure.status === 429 || failure.code === 429 || failure.code === 'rate_limit_exceeded'
+              const isExceeded = isQuotaExceededError(`${failure.message || ''} ${failure.code || ''}`)
+
+              if (isError) {
+                recordSessionRequest({
+                  latencyMs,
+                  ok: false,
+                  error: failure.message || 'Stream error',
+                  promptTokens,
+                  completionTokens,
+                  model: options?.model,
+                })
+                if (is429 || isExceeded) {
+                  handleStream429()
+                }
+              } else if (isAborted) {
+                recordSessionRequest({
+                  latencyMs,
+                  ok: true,
+                  aborted: true,
+                  promptTokens,
+                  completionTokens,
+                  model: options?.model,
+                })
+              } else {
+                recordSessionRequest({
+                  latencyMs,
+                  ok: true,
+                  promptTokens,
+                  completionTokens,
+                  model: options?.model,
+                })
+              }
+            }
+            yield chunk
+          }
+          if (isCline && !finished) {
+            recordSessionRequest({
+              latencyMs: Date.now() - startTime,
+              ok: true,
+              promptTokens,
+              completionTokens,
+              model: options?.model,
+            })
+          }
+        } catch (err) {
+          if (isCline) {
+            const latencyMs = Date.now() - startTime
+            const status = err?.status || err?.statusCode
+            const msg = String(err?.message || err)
+            recordSessionRequest({
+              latencyMs,
+              ok: false,
+              error: msg,
+              promptTokens,
+              completionTokens,
+              model: options?.model,
+            })
+            if (status === 429 || isQuotaExceededError(msg)) {
+              handleStream429()
+            }
+          }
+          throw err
+        }
+      })()
+    }, { global: true, prepend: true })
+
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => () => unlisten?.(), 'dsh-clinebot: llm/stream failover')
+    }
   }
 }

package/lib/models.js

@@ -18,7 +18,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/deepseek-v4-flash',
     name: 'DeepSeek V4 Flash',
     description: 'High-speed reasoning & code completion model optimized for agentic loops.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'coding',
@@ -30,7 +30,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/deepseek-v4-pro',
     name: 'DeepSeek V4 Pro',
     description: 'Flagship reasoning and multi-turn architectural coding model.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'coding',
@@ -42,7 +42,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/glm-5.2',
     name: 'GLM 5.2',
     description: 'Bilingual general & coding model with strong instruction following.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text'],
     category: 'general',
@@ -88,7 +88,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/qwen3.7-max',
     name: 'Qwen 3.7 Max',
     description: 'Large-scale multimodal foundation model from Alibaba Cloud with reasoning support.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'multimodal',
@@ -100,7 +100,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/qwen3.7-plus',
     name: 'Qwen 3.7 Plus',
     description: 'Fast, capable multimodal model with strong multilingual skills and reasoning.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'multimodal',
@@ -124,7 +124,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/mimo-v2.5',
     name: 'MiMo V2.5',
     description: 'Xiaomi MiMo efficient instruction model with reasoning and multimodal support.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'general',
@@ -136,7 +136,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/mimo-v2.5-pro',
     name: 'MiMo V2.5 Pro',
     description: 'Xiaomi MiMo advanced agentic reasoning model with multimodal support.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'coding',
@@ -215,27 +215,49 @@ export function parsePlanIncludedModels(includedInput) {
 }
 
 /**
- * Get all models from known catalog.
+ * Get all models:
+ * 1. When plan is synchronized (dynamicModels is a non-empty array):
+ *    Registers strictly the models included in the active plan, enriching them
+ *    with curated capabilities, reasoning efforts, and descriptions from CLINE_MODELS.
+ * 2. When plan is unsynced (dynamicModels is empty):
+ *    Falls back to the full curated CLINE_MODELS catalog marked with unverified: true.
  */
 export function getAllModels(dynamicModels = []) {
-  const result = [...CLINE_MODELS]
-  const seenIds = new Set(result.map((m) => m.id))
-
-  if (Array.isArray(dynamicModels)) {
-    for (const item of dynamicModels) {
-      if (item && item.id && !seenIds.has(item.id)) {
-        result.push(item)
-        seenIds.add(item.id)
+  if (Array.isArray(dynamicModels) && dynamicModels.length > 0) {
+    const normalize = (s) => String(s || '').toLowerCase().replace(/[\s._-]+/g, '')
+    return dynamicModels.map((dm) => {
+      const targetNorm = normalize(dm.id.replace(/^cline-pass\//, ''))
+      const curated = CLINE_MODELS.find(
+        (cm) => cm.id === dm.id || normalize(cm.id.replace(/^cline-pass\//, '')) === targetNorm || normalize(cm.name) === targetNorm
+      )
+      if (curated) {
+        return {
+          ...curated,
+          ...dm,
+          description: dm.description || curated.description,
+          contextLength: dm.contextLength || curated.contextLength,
+          maxTokens: dm.maxTokens || curated.maxTokens,
+          input: dm.input && dm.input.length ? dm.input : curated.input,
+          category: dm.category || curated.category,
+          reasoningEfforts: dm.reasoningEfforts !== undefined ? dm.reasoningEfforts : curated.reasoningEfforts,
+          unverified: false,
+        }
       }
-    }
+      return {
+        ...dm,
+        unverified: false,
+      }
+    })
   }
 
-  return result
+  return CLINE_MODELS.map((m) => ({ ...m, unverified: true }))
 }
 
 export function findModel(id, dynamicModels = []) {
   const all = getAllModels(dynamicModels)
-  return all.find((m) => m.id === id) || null
+  const found = all.find((m) => m.id === id)
+  if (found) return found
+  return CLINE_MODELS.find((m) => m.id === id) || null
 }
 
 export function isSupportedModel(id, dynamicModels = []) {
@@ -298,14 +320,14 @@ export function isVisionModel(id, dynamicModels = []) {
 /**
  * Disk caching for discovered models.
  */
-export async function saveModelsDiskCache(cachePath, models = []) {
+export async function saveModelsDiskCache(cachePath, models = [], planSyncedAt = Date.now()) {
   if (!cachePath || !Array.isArray(models) || !models.length) return false
   try {
     const fs = await import('node:fs/promises')
     const path = await import('node:path')
     const dir = path.dirname(cachePath)
     await fs.mkdir(dir, { recursive: true })
-    const payload = JSON.stringify({ savedAt: Date.now(), models }, null, 2)
+    const payload = JSON.stringify({ savedAt: Date.now(), planSyncedAt, models }, null, 2)
     await fs.writeFile(cachePath, payload, 'utf8')
     return true
   } catch {
@@ -319,7 +341,10 @@ export async function loadModelsDiskCache(cachePath) {
     const fs = await import('node:fs/promises')
     const raw = await fs.readFile(cachePath, 'utf8')
     const parsed = JSON.parse(raw)
-    return Array.isArray(parsed?.models) ? parsed.models : null
+    const list = Array.isArray(parsed?.models) ? parsed.models : (Array.isArray(parsed) ? parsed : null)
+    if (!list) return null
+    list.planSyncedAt = typeof parsed?.planSyncedAt === 'number' ? parsed.planSyncedAt : (typeof parsed?.savedAt === 'number' ? parsed.savedAt : 0)
+    return list
   } catch {
     return null
   }

package/lib/provider-sync.js

@@ -1,6 +1,6 @@
 import os from 'node:os'
 import path from 'node:path'
-import { publicConfig, Config, LLM_PI_AI_NS } from './config.js'
+import { publicConfig, plainConfig, Config, LLM_PI_AI_NS } from './config.js'
 import { publicUsage } from './http.js'
 import {
   PROVIDER_ID,
@@ -16,6 +16,7 @@ import {
   fetchUsageLimits,
   buildPiAiProvider,
   sessionStats,
+  getLastRotation,
 } from './cline-client.js'
 
 export function resolvePathWithHome(p) {
@@ -113,6 +114,7 @@ export async function buildStatus(ctx, cfg) {
     usage: publicUsage(usage),
     quotaWarning,
     sessionStats: { ...sessionStats },
+    lastRotation: getLastRotation(),
     isRegistered,
     availableModels: allModels,
   }
@@ -129,9 +131,11 @@ export async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
   const allowedSet = new Set(activeModelIds || pub.enabledModels)
   const modelsToRegister = allModels.filter((m) => allowedSet.has(m.id))
 
+  const activeAcc = await resolveActiveAccountKey(ctx, cfg)
+
   const providerObj = buildPiAiProvider({
     baseUrl: pub.baseUrl,
-    apiKeyEnv: pub.apiKeyEnv,
+    apiKeyEnv: activeAcc?.apiKeyEnv || pub.apiKeyEnv,
     models: modelsToRegister.length ? modelsToRegister : allModels,
     customModels: pub.dynamicModels,
     displayName: PROVIDER_DISPLAY_NAME,
@@ -180,7 +184,11 @@ export async function autoDiscoverPlanModels(ctx, { live, getSettingsApi, syncPr
     if ((!pub.dynamicModels || !pub.dynamicModels.length) && cacheFile) {
       const fromDisk = await loadModelsDiskCache(cacheFile)
       if (Array.isArray(fromDisk) && fromDisk.length && settingsApi?.replace) {
-        const next = Config({ ...live(), dynamicModels: fromDisk })
+        const next = Config({
+          ...plainConfig(live()),
+          dynamicModels: fromDisk,
+          planSyncedAt: fromDisk.planSyncedAt || Date.now(),
+        })
         await settingsApi.replace(next)
         await syncProviderState(next)
       }
@@ -200,14 +208,16 @@ export async function autoDiscoverPlanModels(ctx, { live, getSettingsApi, syncPr
       const hasNew = usageData.dynamicModels.some((m) => !existingIds.has(m.id))
 
       if (hasNew && settingsApi?.replace) {
+        const now = Date.now()
         const next = Config({
-          ...live(),
+          ...plainConfig(live()),
           dynamicModels: usageData.dynamicModels,
+          planSyncedAt: now,
         })
         await settingsApi.replace(next)
         await syncProviderState(next)
         if (cacheFile) {
-          await saveModelsDiskCache(cacheFile, usageData.dynamicModels)
+          await saveModelsDiskCache(cacheFile, usageData.dynamicModels, now)
         }
       }
     }

package/lib/routes/accounts.js

@@ -1,6 +1,6 @@
 import { writeJson, readBody } from '../http.js'
 import { isTrustedSettingsRequest, assertTrustedSettingsRequest } from '../access.js'
-import { publicConfig, Config } from '../config.js'
+import { publicConfig, plainConfig, Config } from '../config.js'
 import { upsertPiAiProvider, removePiAiProvider } from '../provider-sync.js'
 import { clearUsageCache, clearProbeCache } from '../cline-client.js'
 
@@ -21,14 +21,14 @@ export function registerAccountsRoutes(ctx, { live, getSettingsApi, syncProvider
         clearUsageCache()
         clearProbeCache()
         const settingsApi = getSettingsApi()
-        if (settingsApi?.replace) {
-          const next = Config({ ...live(), activeAccount: account })
-          await settingsApi.replace(next)
-          await syncProviderState(next)
-          writeJson(res, 200, { ok: true, activeAccount: next.activeAccount })
-        } else {
-          writeJson(res, 200, { ok: true, activeAccount: account })
+        if (!settingsApi || typeof settingsApi.replace !== 'function') {
+          return writeJson(res, 503, { ok: false, error: 'Settings service unavailable or read-only' })
         }
+
+        const next = Config({ ...plainConfig(live()), activeAccount: account })
+        await settingsApi.replace(next)
+        await syncProviderState(next)
+        writeJson(res, 200, { ok: true, activeAccount: account })
       } catch (err) {
         writeJson(res, 500, { ok: false, error: String(err?.message || err) })
       }

package/lib/routes/auth.js

@@ -2,50 +2,79 @@ import { writeJson, readBody } from '../http.js'
 import { isTrustedSettingsRequest, assertTrustedSettingsRequest } from '../access.js'
 import { publicConfig } from '../config.js'
 import { resolveActiveAccountKey } from '../provider-sync.js'
-import { smokeChat, recordSessionRequest, rotateToNextAccount, DEFAULT_MODEL_ID } from '../cline-client.js'
+import {
+  smokeChat,
+  recordSmokeTest,
+  rotateToNextAccount,
+  DEFAULT_MODEL_ID,
+  normalizeBaseUrl,
+} from '../cline-client.js'
 
 export function registerAuthRoutes(ctx, { live, getSettingsApi, syncProviderState }) {
-  let authSession = null
-
-  // POST /dsh-clinebot/auth/begin — start loopback auth listener
+  // POST /dsh-clinebot/key/verify — on-the-fly verification of Cline API key
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
-    path: '/dsh-clinebot/auth/begin',
+    path: '/dsh-clinebot/key/verify',
     handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
       if (!assertTrustedSettingsRequest(req, res)) return
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
       try {
-        const authUrl = 'https://app.cline.bot'
-        authSession = {
-          state: 'waiting',
-          startedAt: Date.now(),
-          authUrl,
+        const bodyBuf = await readBody(req)
+        let body = {}
+        try { body = JSON.parse(bodyBuf.toString('utf8')) } catch { body = {} }
+        const key = String(body.key || '').trim()
+        if (!key) {
+          return writeJson(res, 400, { ok: false, valid: false, error: 'Key is empty' })
+        }
+        const pub = publicConfig(live())
+        const base = normalizeBaseUrl(pub.baseUrl)
+
+        const ac = new AbortController()
+        const timer = setTimeout(() => ac.abort(), 6000)
+        try {
+          const [meRes, planRes] = await Promise.all([
+            fetch(`${base}/users/me`, {
+              headers: { Authorization: `Bearer ${key}`, Accept: 'application/json' },
+              signal: ac.signal,
+            }).catch((err) => ({ ok: false, status: 500, error: err })),
+            fetch(`${base}/users/me/plan`, {
+              headers: { Authorization: `Bearer ${key}`, Accept: 'application/json' },
+              signal: ac.signal,
+            }).catch(() => null),
+          ])
+
+          if (!meRes.ok) {
+            return writeJson(res, 200, {
+              ok: false,
+              valid: false,
+              error: meRes.status === 401 ? 'Invalid API key (HTTP 401 Unauthorized)' : `Upstream returned HTTP ${meRes.status}`,
+            })
+          }
+
+          const meData = await meRes.json().catch(() => ({}))
+          const email = meData?.data?.email || meData?.email || 'authenticated user'
+
+          let planName = 'ClinePass'
+          if (planRes && planRes.ok) {
+            const planData = await planRes.json().catch(() => ({}))
+            const plan = planData?.data?.plan || planData?.data || planData?.plan || planData
+            planName = plan?.displayName || plan?.title || plan?.name || 'ClinePass'
+          }
+
+          return writeJson(res, 200, {
+            ok: true,
+            valid: true,
+            email,
+            plan: planName,
+          })
+        } finally {
+          clearTimeout(timer)
         }
-        writeJson(res, 200, {
-          ok: true,
-          status: authSession.state,
-          authUrl,
-        })
       } catch (err) {
-        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+        return writeJson(res, 500, { ok: false, valid: false, error: String(err?.message || err) })
       }
     },
-  }), 'dsh-clinebot: /auth/begin')
-
-  // GET /dsh-clinebot/auth/status — query current fast auth state
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-clinebot/auth/status',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
-      if (!assertTrustedSettingsRequest(req, res)) return
-      writeJson(res, 200, {
-        ok: true,
-        status: authSession?.state || 'idle',
-        authUrl: authSession?.authUrl || 'https://app.cline.bot',
-      })
-    },
-  }), 'dsh-clinebot: /auth/status')
+  }), 'dsh-clinebot: /key/verify')
 
   // POST /dsh-clinebot/smoke — live ping test
   ctx.effect(() => ctx.webServer.register({
@@ -73,12 +102,11 @@ export function registerAuthRoutes(ctx, { live, getSettingsApi, syncProviderStat
           model: modelToTest,
           timeoutMs: pub.smokeTimeoutMs,
         })
-        recordSessionRequest({
+        recordSmokeTest({
           latencyMs: outcome.latencyMs,
           ok: outcome.ok,
           error: outcome.error,
-          promptTokens: outcome.promptTokens || 5,
-          completionTokens: outcome.completionTokens || 10,
+          model: modelToTest,
         })
 
         let failover = null
@@ -91,7 +119,7 @@ export function registerAuthRoutes(ctx, { live, getSettingsApi, syncProviderStat
 
         writeJson(res, outcome.ok ? 200 : 502, { ...outcome, failover })
       } catch (err) {
-        recordSessionRequest({ ok: false, error: String(err?.message || err) })
+        recordSmokeTest({ ok: false, error: String(err?.message || err) })
         writeJson(res, 500, { ok: false, error: String(err?.message || err) })
       }
     },

package/lib/routes/models.js

@@ -1,6 +1,6 @@
 import { writeJson, readBody } from '../http.js'
 import { isTrustedSettingsRequest, assertTrustedSettingsRequest } from '../access.js'
-import { publicConfig, Config } from '../config.js'
+import { publicConfig, plainConfig, Config } from '../config.js'
 import { resolveActiveAccountKey, resolvePathWithHome } from '../provider-sync.js'
 import { getAllModels, saveModelsDiskCache } from '../models.js'
 import { fetchUsageLimits } from '../cline-client.js'
@@ -35,18 +35,21 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         const dynamicModels = Array.isArray(usageData.dynamicModels) ? usageData.dynamicModels : []
         const allModels = getAllModels(dynamicModels)
         const settingsApi = getSettingsApi()
+        if (!settingsApi || typeof settingsApi.replace !== 'function') {
+          return writeJson(res, 503, { ok: false, error: 'Settings service unavailable or read-only' })
+        }
 
-        if (settingsApi?.replace) {
-          const next = Config({
-            ...live(),
-            dynamicModels,
-          })
-          await settingsApi.replace(next)
-          await syncProviderState(next)
-          const cacheFile = resolvePathWithHome(pub.modelsCachePath)
-          if (cacheFile) {
-            await saveModelsDiskCache(cacheFile, dynamicModels)
-          }
+        const now = Date.now()
+        const next = Config({
+          ...plainConfig(live()),
+          dynamicModels,
+          planSyncedAt: now,
+        })
+        await settingsApi.replace(next)
+        await syncProviderState(next)
+        const cacheFile = resolvePathWithHome(pub.modelsCachePath)
+        if (cacheFile) {
+          await saveModelsDiskCache(cacheFile, dynamicModels, now)
         }
 
         return writeJson(res, 200, {
@@ -75,23 +78,23 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         try { body = JSON.parse(bodyBuf.toString('utf8')) } catch { body = {} }
 
         const settingsApi = getSettingsApi()
-        if (settingsApi?.replace) {
-          const patch = {}
-          if (Array.isArray(body.disabledModels)) {
-            patch.disabledModels = body.disabledModels
-          } else if (Array.isArray(body.enabledModels)) {
-            const allModels = getAllModels(live().dynamicModels)
-            const enabledSet = new Set(body.enabledModels)
-            patch.disabledModels = allModels.map((m) => m.id).filter((id) => !enabledSet.has(id))
-          }
-          if (body.defaultModel) patch.defaultModel = body.defaultModel
-          const next = Config({ ...live(), ...patch })
-          await settingsApi.replace(next)
-          await syncProviderState(next)
-          writeJson(res, 200, { ok: true, disabledModels: next.disabledModels, enabledModels: publicConfig(next).enabledModels })
-        } else {
-          writeJson(res, 200, { ok: true })
+        if (!settingsApi || typeof settingsApi.replace !== 'function') {
+          return writeJson(res, 503, { ok: false, error: 'Settings service unavailable or read-only' })
+        }
+
+        const patch = {}
+        if (Array.isArray(body.disabledModels)) {
+          patch.disabledModels = body.disabledModels
+        } else if (Array.isArray(body.enabledModels)) {
+          const allModels = getAllModels(publicConfig(live()).dynamicModels)
+          const enabledSet = new Set(body.enabledModels)
+          patch.disabledModels = allModels.map((m) => m.id).filter((id) => !enabledSet.has(id))
         }
+        if (body.defaultModel) patch.defaultModel = body.defaultModel
+        const next = Config({ ...plainConfig(live()), ...patch })
+        await settingsApi.replace(next)
+        await syncProviderState(next)
+        writeJson(res, 200, { ok: true, disabledModels: next.disabledModels, enabledModels: publicConfig(next).enabledModels })
       } catch (err) {
         writeJson(res, 500, { ok: false, error: String(err?.message || err) })
       }