@goodandready/dsh-clinebot 0.5.6 → 0.5.8

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to `@goodandready/dsh-clinebot` will be documented in this f
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.8] - 2026-09-30
+
+### Fixed
+- **Settings PUT Method & Form Error Recovery (Issue #156)**: Fixed `handleConfigPatch` in settings UI client to use `PUT /config` conforming to API routes and preserve unsaved form drafts on server errors.
+- **Client Telemetry Wire Envelope Normalization (Issue #159)**: Fixed `statsSummary` in status payload to align with persistent storage format and accurately display model token consumption and totals.
+- **Deduplication of Proxy & LLM Stream Telemetry (Issue #160)**: Avoided double-counting tokens and latency when requests pass through loopback proxy into `llm/stream`.
+- **Proxy Error Mapping & 429 Header Preservation (Issue #166)**: Differentiated network unreachable/ECONNREFUSED errors as HTTP 502 Bad Gateway instead of false 429, and preserved upstream `Retry-After` headers.
+- **Fetch Response Body Disposal Before Retry (Issue #167)**: Explicitly cancelled upstream HTTP response bodies before triggering retry or account failover on rate-limited or error attempts.
+- **Dynamic Models Catalog Synchronization (Issue #168)**: Pruned deleted upstream models and reconciled metadata diffs on subscription plan updates using `isCatalogDifferent`.
+- **Collision-Free Opaque Usage Cache Key (Issue #169)**: Replaced 8-character key suffix with SHA-256 hash of `baseUrl` and full API key to prevent cross-account cache collisions and protect key secrecy.
+- **Custom Models Resolution Across Routes & Slash Commands (Issue #170)**: Forwarded user-defined custom models through catalog lookup, validation, `/cline test`, `/cline models`, and context configuration routes.
+- **Local Proxy Bearer Token Redaction in Provider Settings (Issue #171)**: Omitted plaintext local proxy token from pi-ai provider descriptor and settings mutation payload, resolving authentication strictly through credential references.
+
+## [0.5.7] - 2026-09-30
+
+### Fixed
+- **Active Account Pinning & Account Identity Unification (Issue #161)**: Resolved issue where proxy router ignored manually pinned active account and routed requests to secondary keys. Unified account identification across `id`, `apiKeyEnv`, and `label` in session routing, round-robin fallback, and cooldown tracking.
+- **Account Pool Quota Metadata Enrichment (Issue #162)**: Provided real-time quota window utilization metadata (`remainingPercent`, `percentUsed`, `resetsAt`) to least-used account routing strategy. Handled unknown/unprobed quotas safely to prevent routing bias towards exhausted accounts.
+- **Pi-AI Provider Session Affinity Header Propagation (Issue #163)**: Enabled `sendSessionAffinityHeaders: true` and `sessionAffinityFormat: 'openrouter'` in `@earendil-works/pi-ai` provider and model compatibility options. Expanded proxy session identification to extract session IDs from `x-session-id`, `x-dsh-session-id`, `session-id`, `x-session-affinity`, and client body parameters, preserving conversation affinity.
+- **Client SSE Disconnection Upstream Abort (Issue #164)**: Monitored client response `close` events during streaming. Aborts upstream fetch and cancels ReadableStream reader immediately when a client disconnects prematurely, avoiding resource waste and orphaned upstream requests. Guarded writes and cleaned up listeners reliably.
+- **Decoupled Connect Timeout & Streaming Idle Watchdog (Issue #165)**: Separated initial HTTP connect / header timeout (`connectTimeoutMs`, default 15s) from active streaming idle timeout (`streamIdleTimeoutMs`, default 30s). Prevented healthy long SSE streams from being cut off by monolithic timeouts. Added rearmable idle watchdog that signals client errors on stalls and accurately accounts failed streams with `isError: true` in token analytics instead of false successes.
+
 ## [0.5.6] - 2026-09-30
 
 ### Security

package/lib/account-pool.js

@@ -1,4 +1,4 @@
-import { resolveKeyValue, usageCache, clearUsageCache, clearProbeCache, DEFAULT_API_KEY_ENV } from './cline-client.js'
+import { resolveKeyValue, usageCache, clearUsageCache, clearProbeCache, DEFAULT_API_KEY_ENV, DEFAULT_BASE_URL, buildUsageCacheKey } from './cline-client.js'
 
 /**
  * Resolve all accounts in pool with their status and keys.
@@ -32,7 +32,42 @@ function toPlainSnapshot(cfg) {
   return out
 }
 
+export function getAccountQuotaSnapshot(accValue, baseUrl = DEFAULT_BASE_URL) {
+  if (!accValue || typeof accValue !== 'string') return null
+  const cacheKey = buildUsageCacheKey(baseUrl, accValue)
+  const cached = usageCache.get(cacheKey)?.data
+  if (!cached?.windows) return null
+
+  const now = Date.now()
+  const evaluateWindow = (w) => {
+    if (!w || typeof w.percentUsed !== 'number') return null
+    if (w.resetsAt) {
+      const resetTime = new Date(w.resetsAt).getTime()
+      if (!Number.isNaN(resetTime) && now >= resetTime) {
+        return 0
+      }
+    }
+    return w.percentUsed
+  }
+
+  const fh = evaluateWindow(cached.windows.fiveHour)
+  const wk = evaluateWindow(cached.windows.weekly)
+  const mo = evaluateWindow(cached.windows.monthly)
+
+  const activePcts = [fh, wk, mo].filter((p) => typeof p === 'number')
+  const percentUsed = activePcts.length > 0 ? Math.max(...activePcts) : null
+
+  return {
+    percentUsed,
+    fiveHour: fh,
+    weekly: wk,
+    monthly: mo,
+    raw: cached,
+  }
+}
+
 export async function resolveAccountPool(ctx, cfg) {
+  const baseUrl = textSetting(cfg?.baseUrl) || DEFAULT_BASE_URL
   const apiKeyEnv = textSetting(cfg?.apiKeyEnv) || DEFAULT_API_KEY_ENV
   const defaultSlot = {
     id: 'default',
@@ -48,14 +83,21 @@ export async function resolveAccountPool(ctx, cfg) {
     const slot = allSlots[i]
     const envName = textSetting(slot.apiKeyEnv) || (i === 0 ? apiKeyEnv : `CLINEBOT_API_KEY_${i + 1}`)
     const keyInfo = await resolveKeyValue(ctx, envName)
+    const slotId = slot.id || (i === 0 ? 'default' : `account-${i + 1}`)
+    const isPinned = activeAccount === 'auto'
+      ? false
+      : (activeAccount ? (activeAccount === envName || activeAccount === slotId) : i === 0)
+    const quota = keyInfo.value ? getAccountQuotaSnapshot(keyInfo.value, baseUrl) : null
     resolved.push({
-      id: slot.id || (i === 0 ? 'default' : `account-${i + 1}`),
+      id: slotId,
       label: textSetting(slot.label) || (i === 0 ? 'Default' : `Account ${i + 1}`),
       apiKeyEnv: envName,
       present: Boolean(keyInfo.value),
       source: keyInfo.source,
       value: keyInfo.value,
-      isPinned: activeAccount ? activeAccount === envName : i === 0,
+      isPinned,
+      percentUsed: typeof quota?.percentUsed === 'number' ? quota.percentUsed : null,
+      quota,
     })
   }
 
@@ -87,6 +129,7 @@ export function isAccountQuotaExhausted(usage) {
  * Prioritizes accounts with lowest percentUsed and respects resetsAt recovery.
  */
 export async function rotateToNextAccount(ctx, cfg, reason = 'rate_limit', settingsApi = null) {
+  const baseUrl = textSetting(cfg?.baseUrl) || DEFAULT_BASE_URL
   const pool = await resolveAccountPool(ctx, cfg)
   const configured = pool.filter((acc) => acc.present && acc.value)
   if (configured.length <= 1) {
@@ -107,7 +150,7 @@ export async function rotateToNextAccount(ctx, cfg, reason = 'rate_limit', setti
   let lowestUsagePct = Infinity
 
   for (const cand of candidates) {
-    const cacheKey = `cline:usage:${cand.value.slice(-8)}`
+    const cacheKey = buildUsageCacheKey(baseUrl, cand.value)
     const cached = usageCache.get(cacheKey)?.data
     const isExhausted = isAccountQuotaExhausted(cached)
 

package/lib/client.js

@@ -1609,10 +1609,19 @@ function StatsSection({ status, onResetStats, busy, t }) {
   const [confirmReset, setConfirmReset] = React.useState(false)
 
   const s = status?.statsSummary || {}
+  const totals = s.totals || {}
   const sess = status?.sessionStats || {}
 
+  const requests = typeof totals.requests === 'number' ? totals.requests : (typeof s.requests === 'number' ? s.requests : 0)
+  const totalTokens = typeof totals.totalTokens === 'number' ? totals.totalTokens : (typeof s.totalTokens === 'number' ? s.totalTokens : 0)
+  const errors429 = typeof totals.rateLimited429 === 'number' ? totals.rateLimited429 : (typeof s.errors429 === 'number' ? s.errors429 : (typeof totals.failed === 'number' ? totals.failed : 0))
+
   const topModels = Object.entries(s.byModel || {})
-    .sort((a, b) => (b[1].tokens || 0) - (a[1].tokens || 0))
+    .sort((a, b) => {
+      const bTokens = Number(b[1]?.totalTokens ?? b[1]?.tokens ?? 0)
+      const aTokens = Number(a[1]?.totalTokens ?? a[1]?.tokens ?? 0)
+      return bTokens - aTokens
+    })
     .slice(0, 5)
 
   return React.createElement(
@@ -1674,19 +1683,19 @@ function StatsSection({ status, onResetStats, busy, t }) {
       React.createElement(
         'div',
         { className: 'cb-stat-box' },
-        React.createElement('div', { className: 'cb-stat-val' }, `${s.requests || 0} (${sess.successfulRequests || 0} sess)`),
+        React.createElement('div', { className: 'cb-stat-val' }, `${requests} (${sess.successfulRequests || 0} sess)`),
         React.createElement('div', { className: 'cb-stat-lbl' }, t('stats.requests'))
       ),
       React.createElement(
         'div',
         { className: 'cb-stat-box' },
-        React.createElement('div', { className: 'cb-stat-val' }, `${Number(s.totalTokens || 0).toLocaleString()}`),
+        React.createElement('div', { className: 'cb-stat-val' }, `${Number(totalTokens).toLocaleString()}`),
         React.createElement('div', { className: 'cb-stat-lbl' }, t('stats.tokens'))
       ),
       React.createElement(
         'div',
         { className: 'cb-stat-box' },
-        React.createElement('div', { className: 'cb-stat-val' }, `${s.errors429 || 0}`),
+        React.createElement('div', { className: 'cb-stat-val' }, `${errors429}`),
         React.createElement('div', { className: 'cb-stat-lbl' }, t('stats.errors429'))
       ),
       React.createElement(
@@ -1719,7 +1728,7 @@ function StatsSection({ status, onResetStats, busy, t }) {
                   },
                 },
                 React.createElement('span', { style: { fontFamily: 'monospace' } }, modId),
-                React.createElement('span', null, `${data.requests || 0} reqs · ${Number(data.tokens || 0).toLocaleString()} tok`)
+                React.createElement('span', null, `${data.requests || 0} reqs · ${Number(data.totalTokens ?? data.tokens ?? 0).toLocaleString()} tok`)
               )
             )
           )
@@ -1827,8 +1836,9 @@ function SettingsPage(props) {
     ])
     const data = await res.json().catch(() => ({}))
     if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`)
-    const statsData = statsRes && statsRes.ok ? await statsRes.json().catch(() => null) : null
-    setStatus({ ...data, statsSummary: statsData || data.statsSummary })
+    const rawStats = statsRes && statsRes.ok ? await statsRes.json().catch(() => null) : null
+    const statsObj = (rawStats && typeof rawStats === 'object' && rawStats.stats) ? rawStats.stats : (rawStats || data.statsSummary || {})
+    setStatus({ ...data, statsSummary: statsObj })
     setDraft(data.config || {})
   }, [])
 
@@ -2058,14 +2068,15 @@ function SettingsPage(props) {
   }
 
   async function handleConfigPatch(patch) {
+    setDraft((d) => ({ ...(d || {}), ...(patch || {}) }))
     await performAction('patch-config', async () => {
       const res = await fetch(`${ROUTE_PREFIX}/config`, {
-        method: 'POST',
+        method: 'PUT',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(patch),
+        body: JSON.stringify({ config: patch }),
       })
       const data = await res.json().catch(() => ({}))
-      if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`)
+      if (!res.ok || data.ok === false) throw new Error(data.error || `HTTP ${res.status}`)
       await load()
     })
   }

package/lib/cline-client.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto'
 export {
   toCredentialRef,
   resolveApiKey,
@@ -26,6 +27,7 @@ export const DEFAULT_BASE_URL = 'https://api.cline.bot/api/v1'
 export const DEFAULT_API_KEY_ENV = 'CLINEBOT_API_KEY'
 export const DEFAULT_TIMEOUT_MS = 15000
 export const DEFAULT_SMOKE_TIMEOUT_MS = 25000
+export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 30000
 const USAGE_CACHE_TTL_MS = 60000
 
 export { PROVIDER_ID, PROVIDER_DISPLAY_NAME, DEFAULT_MODEL_ID }
@@ -86,8 +88,32 @@ export function clearProbeCache() {
   probeCache.clear()
 }
 
-export function clearUsageCache() {
-  usageCache.clear()
+/**
+ * Build an opaque, collision-free cache key from normalized baseUrl and full apiKey.
+ * Never leaks the raw apiKey or fingerprint into UI/logs.
+ *
+ * @param {string} baseUrl
+ * @param {string} apiKey
+ * @returns {string}
+ */
+export function buildUsageCacheKey(baseUrl = '', apiKey = '') {
+  const normBase = normalizeBaseUrl(baseUrl)
+  const normKey = String(apiKey || '').trim()
+  if (!normKey) return ''
+  const hash = createHash('sha256')
+    .update(`${normBase}\0${normKey}`)
+    .digest('hex')
+    .slice(0, 32)
+  return `cline:usage:${hash}`
+}
+
+export function clearUsageCache(baseUrl, apiKey) {
+  if (baseUrl && apiKey) {
+    const key = buildUsageCacheKey(baseUrl, apiKey)
+    usageCache.delete(key)
+  } else {
+    usageCache.clear()
+  }
 }
 
 /**
@@ -105,6 +131,17 @@ export async function retryWithBackoff(fn, {
       const res = await fn()
       if (res && typeof res.status === 'number' && [429, 502, 503, 504].includes(res.status) && attempt < maxRetries) {
         attempt++
+        if (res.body) {
+          try {
+            if (typeof res.body.cancel === 'function') {
+              res.body.cancel().catch(() => {})
+            } else if (typeof res.body.destroy === 'function') {
+              res.body.destroy()
+            }
+          } catch {
+            /* ignore cancel error */
+          }
+        }
         const retryAfter = res.headers?.get ? Number(res.headers.get('retry-after')) * 1000 : 0
         const waitTime = retryAfter > 0 ? Math.min(retryAfter, maxDelayMs) : delay
         await new Promise((r) => setTimeout(r, waitTime))
@@ -139,7 +176,7 @@ export async function fetchUsageLimits(baseUrl, apiKey, {
     return { ok: false, error: 'API key is missing' }
   }
 
-  const cacheKey = `cline:usage:${apiKey.slice(-8)}`
+  const cacheKey = buildUsageCacheKey(base, apiKey)
   const now = Date.now()
 
   const doFetch = async () => {
@@ -449,15 +486,20 @@ export function buildPiAiProvider({
   baseUrl = DEFAULT_BASE_URL,
   apiKeyEnv = DEFAULT_API_KEY_ENV,
   apiKey,
+  dynamicModels = [],
+  modelContextOverrides = [],
   models = [],
   customModels = [],
   displayName = PROVIDER_DISPLAY_NAME,
 } = {}) {
-  const allAvailable = getAllModels(customModels)
+  const allAvailable = getAllModels(dynamicModels, modelContextOverrides, customModels)
+  const customModelsMap = new Map((Array.isArray(customModels) ? customModels : []).filter(Boolean).map(cm => [cm.id, cm]))
   const modelList = (Array.isArray(models) && models.length ? models : allAvailable).map((m) => {
     let item
     if (typeof m === 'string') {
-      item = allAvailable.find((x) => x.id === m) || { id: m, name: m }
+      const customMatch = customModelsMap.get(m)
+      const baseMatch = allAvailable.find((x) => x.id === m)
+      item = customMatch ? { ...baseMatch, ...customMatch } : (baseMatch || { id: m, name: m })
     } else {
       item = m
     }
@@ -486,13 +528,18 @@ export function buildPiAiProvider({
         if (validEfforts.includes(key)) efforts[key] = key === 'off' ? (v === undefined ? null : v) : (typeof v === 'string' && v.trim() ? v.trim() : key)
       }
     }
+    const modelCompat = {
+      sendSessionAffinityHeaders: true,
+      sessionAffinityFormat: 'openrouter',
+    }
     if (efforts && Object.keys(efforts).length) {
       if (!('off' in efforts)) efforts.off = null
       res.reasoningEfforts = efforts
-      res.compat = { supportsReasoningEffort: true }
+      modelCompat.supportsReasoningEffort = true
     } else {
       res.reasoningEfforts = false
     }
+    res.compat = modelCompat
     return res
   })
 
@@ -501,8 +548,11 @@ export function buildPiAiProvider({
     api: 'openai-completions',
     baseURL: normalizeBaseUrl(baseUrl),
     apiKeyEnv: apiKeyEnv || DEFAULT_API_KEY_ENV,
-    ...(apiKey ? { apiKey } : {}),
-    compat: { supportsReasoningEffort: true },
+    compat: {
+      supportsReasoningEffort: true,
+      sendSessionAffinityHeaders: true,
+      sessionAffinityFormat: 'openrouter',
+    },
     models: modelList,
   }
 }

package/lib/config.js

@@ -4,6 +4,7 @@ import {
   DEFAULT_API_KEY_ENV,
   DEFAULT_TIMEOUT_MS,
   DEFAULT_SMOKE_TIMEOUT_MS,
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   normalizeBaseUrl,
 } from './cline-client.js'
 import {
@@ -76,6 +77,8 @@ export const Config = z.object({
     .description('HTTP probe timeout in milliseconds.').volatile(),
   smokeTimeoutMs: z.number().default(DEFAULT_SMOKE_TIMEOUT_MS)
     .description('Timeout for smoke chat completions in milliseconds.').volatile(),
+  streamIdleTimeoutMs: z.number().default(DEFAULT_STREAM_IDLE_TIMEOUT_MS)
+    .description('Idle timeout between SSE stream chunks in milliseconds.').volatile(),
   modelsCachePath: z.string().default('~/.dsh/clinebot-models-cache.json')
     .description('Local on-disk cache path for models snapshot.').volatile(),
   accounts: z.array(z.object({
@@ -170,6 +173,7 @@ export function publicConfig(cfg) {
     enabledModels: activeIds,
     timeoutMs: Number(cfg?.timeoutMs) || DEFAULT_TIMEOUT_MS,
     smokeTimeoutMs: Number(cfg?.smokeTimeoutMs) || DEFAULT_SMOKE_TIMEOUT_MS,
+    streamIdleTimeoutMs: Number(cfg?.streamIdleTimeoutMs) || DEFAULT_STREAM_IDLE_TIMEOUT_MS,
     modelsCachePath: String(cfg?.modelsCachePath || '~/.dsh/clinebot-models-cache.json'),
     accounts: Array.isArray(cfg?.accounts) ? cfg.accounts : [],
     activeAccount: String(cfg?.activeAccount || ''),

package/lib/index.js

@@ -230,6 +230,7 @@ export function apply(ctx, config) {
               const is429 = failure.status === 429 || failure.code === 429 || failure.code === 'rate_limit_exceeded'
               const isExceeded = isQuotaExceededError(`${failure.message || ''} ${failure.code || ''}`)
 
+              const isProxy = publicConfig(live()).proxyMode !== false
               if (isError) {
                 recordSessionRequest({
                   latencyMs,
@@ -239,15 +240,17 @@ export function apply(ctx, config) {
                   completionTokens,
                   model: options?.model,
                 })
-                recordUsage({
-                  model: options?.model,
-                  promptTokens,
-                  completionTokens,
-                  totalTokens: promptTokens + completionTokens,
-                  isError: true,
-                  is429,
-                  statsPath: publicConfig(live()).statsPath,
-                })
+                if (!isProxy) {
+                  recordUsage({
+                    model: options?.model,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                    isError: true,
+                    is429,
+                    statsPath: publicConfig(live()).statsPath,
+                  })
+                }
                 if (is429 || isExceeded) {
                   handleStream429()
                 }
@@ -268,13 +271,15 @@ export function apply(ctx, config) {
                   completionTokens,
                   model: options?.model,
                 })
-                recordUsage({
-                  model: options?.model,
-                  promptTokens,
-                  completionTokens,
-                  totalTokens: promptTokens + completionTokens,
-                  statsPath: publicConfig(live()).statsPath,
-                })
+                if (!isProxy) {
+                  recordUsage({
+                    model: options?.model,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                    statsPath: publicConfig(live()).statsPath,
+                  })
+                }
               }
             }
             yield chunk
@@ -287,13 +292,16 @@ export function apply(ctx, config) {
               completionTokens,
               model: options?.model,
             })
-            recordUsage({
-              model: options?.model,
-              promptTokens,
-              completionTokens,
-              totalTokens: promptTokens + completionTokens,
-              statsPath: publicConfig(live()).statsPath,
-            })
+            const isProxy = publicConfig(live()).proxyMode !== false
+            if (!isProxy) {
+              recordUsage({
+                model: options?.model,
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+                statsPath: publicConfig(live()).statsPath,
+              })
+            }
           }
         } catch (err) {
           if (isCline) {
@@ -308,15 +316,18 @@ export function apply(ctx, config) {
               completionTokens,
               model: options?.model,
             })
-            recordUsage({
-              model: options?.model,
-              promptTokens,
-              completionTokens,
-              totalTokens: promptTokens + completionTokens,
-              isError: true,
-              is429: status === 429,
-              statsPath: publicConfig(live()).statsPath,
-            })
+            const isProxy = publicConfig(live()).proxyMode !== false
+            if (!isProxy) {
+              recordUsage({
+                model: options?.model,
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+                isError: true,
+                is429: status === 429,
+                statsPath: publicConfig(live()).statsPath,
+              })
+            }
             if (status === 429 || isQuotaExceededError(msg)) {
               handleStream429()
             }

package/lib/models.js

@@ -422,10 +422,10 @@ export function getAllModels(dynamicModels = [], modelContextOverrides = [], cus
           description: cm.description || `Custom model ${cm.name || cm.id}`,
           contextLength: cm.contextLength || 128000,
           maxTokens: cm.maxTokens || 8192,
-          input: ['text'],
+          input: Array.isArray(cm.input) && cm.input.length ? cm.input : ['text'],
           category: cm.category || 'general',
           isCustom: true,
-          reasoningEfforts: cm.isReasoning ? ['low', 'medium', 'high', 'max'] : undefined,
+          reasoningEfforts: cm.reasoningEfforts !== undefined ? cm.reasoningEfforts : (cm.isReasoning ? ['low', 'medium', 'high', 'max'] : undefined),
           unverified: false,
         }
         baseModels.push(applyOverride(fullCustom))
@@ -437,19 +437,19 @@ export function getAllModels(dynamicModels = [], modelContextOverrides = [], cus
   return baseModels
 }
 
-function findModel(id, dynamicModels = [], modelContextOverrides = [], customModels = []) {
-  const all = getAllModels(dynamicModels, modelContextOverrides)
+export function findModel(id, dynamicModels = [], modelContextOverrides = [], customModels = []) {
+  const all = getAllModels(dynamicModels, modelContextOverrides, customModels)
   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 = [], modelContextOverrides = [], customModels = []) {
-  return findModel(id, dynamicModels, modelContextOverrides) !== null
+  return findModel(id, dynamicModels, modelContextOverrides, customModels) !== null
 }
 
-function getDefaultModelIds(dynamicModels = [], modelContextOverrides = [], customModels = []) {
-  return getAllModels(dynamicModels, modelContextOverrides).map((m) => m.id)
+export function getDefaultModelIds(dynamicModels = [], modelContextOverrides = [], customModels = []) {
+  return getAllModels(dynamicModels, modelContextOverrides, customModels).map((m) => m.id)
 }
 
 /**
@@ -501,8 +501,8 @@ export function formatModelDescription(model) {
 /**
  * Check if a model supports vision input.
  */
-export function isVisionModel(id, dynamicModels = [], modelContextOverrides = []) {
-  const m = findModel(id, dynamicModels, modelContextOverrides)
+export function isVisionModel(id, dynamicModels = [], modelContextOverrides = [], customModels = []) {
+  const m = findModel(id, dynamicModels, modelContextOverrides, customModels)
   if (!m) return false
   return Boolean(m.input?.includes('image') || m.input?.includes('vision'))
 }
@@ -548,3 +548,29 @@ export async function loadModelsDiskCache(cachePath) {
     return null
   }
 }
+
+/**
+ * Detects whether the authoritative dynamic models catalog differs from the current catalog
+ * in model count, IDs, or metadata (e.g. contextLength, maxTokens, category, etc.).
+ */
+export function isCatalogDifferent(currentList = [], authoritativeList = []) {
+  if (!Array.isArray(currentList) || !Array.isArray(authoritativeList)) return true
+  if (currentList.length !== authoritativeList.length) return true
+  const currentMap = new Map(currentList.map((m) => [m.id, m]))
+  for (const auth of authoritativeList) {
+    const cur = currentMap.get(auth.id)
+    if (!cur) return true
+    if (
+      cur.name !== auth.name ||
+      cur.contextLength !== auth.contextLength ||
+      cur.maxTokens !== auth.maxTokens ||
+      cur.category !== auth.category ||
+      cur.description !== auth.description ||
+      JSON.stringify(cur.input || []) !== JSON.stringify(auth.input || []) ||
+      JSON.stringify(cur.reasoningEfforts || []) !== JSON.stringify(auth.reasoningEfforts || [])
+    ) {
+      return true
+    }
+  }
+  return false
+}

package/lib/provider-sync.js

@@ -1,3 +1,4 @@
+import { getStatsSummary } from './stats-storage.js'
 import os from 'node:os'
 import path from 'node:path'
 import {
@@ -8,6 +9,7 @@ import {
   loadModelsDiskCache,
   OBSOLETE_MODEL_ID_MAP,
   migrateModelEntry,
+  isCatalogDifferent,
 } from './models.js'
 import {
   probeHealth,
@@ -161,9 +163,6 @@ export async function buildStatus(ctx, cfg) {
       source: activeAcc.source || key.source,
     },
     accounts: pool.map((acc) => {
-      const cacheKey = `cline:usage:${(acc.value || '').slice(-8)}`
-      const cached = usageCache.get(cacheKey)?.data
-      const pct = cached?.windows?.weekly?.percentUsed ?? cached?.windows?.monthly?.percentUsed ?? cached?.windows?.fiveHour?.percentUsed ?? null
       return {
         id: acc.id,
         label: acc.label,
@@ -171,7 +170,7 @@ export async function buildStatus(ctx, cfg) {
         present: acc.present,
         source: acc.source,
         isPinned: acc.isPinned,
-        percentUsed: typeof pct === 'number' ? pct : null,
+        percentUsed: typeof acc.percentUsed === 'number' ? acc.percentUsed : null,
       }
     }),
     activeAccount: activeAcc.apiKeyEnv,
@@ -179,6 +178,7 @@ export async function buildStatus(ctx, cfg) {
     usage: publicUsage(usage),
     quotaWarning,
     sessionStats: { ...sessionStats },
+    statsSummary: getStatsSummary(),
     lastRotation: getLastRotation(),
     isRegistered,
     availableModels: allModels,
@@ -216,9 +216,10 @@ export async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
   const providerObj = buildPiAiProvider({
     baseUrl: effectiveBaseUrl,
     apiKeyEnv: isProxy ? LOCAL_PROXY_KEY_ENV : (activeAcc?.apiKeyEnv || pub.apiKeyEnv),
-    apiKey: localToken,
     models: modelsToRegister.length ? modelsToRegister : allModels,
-    customModels: [...(pub.dynamicModels || []), ...(pub.customModels || [])],
+    dynamicModels: pub.dynamicModels,
+    modelContextOverrides: pub.modelContextOverrides,
+    customModels: pub.customModels,
     displayName: PROVIDER_DISPLAY_NAME,
   })
 
@@ -304,12 +305,11 @@ export async function autoDiscoverPlanModels(ctx, { live, getSettingsApi, syncPr
       bypassCache: true,
     })
 
-    if (usageData?.ok && Array.isArray(usageData.dynamicModels) && usageData.dynamicModels.length > 0) {
+    if (usageData?.ok && Array.isArray(usageData.dynamicModels)) {
       const existingDynamic = pub.dynamicModels || []
-      const existingIds = new Set(existingDynamic.map((m) => m.id))
-      const hasNew = usageData.dynamicModels.some((m) => !existingIds.has(m.id))
+      const isDifferent = isCatalogDifferent(existingDynamic, usageData.dynamicModels)
 
-      if (hasNew && settingsApi?.replace) {
+      if (isDifferent && settingsApi?.replace) {
         const now = Date.now()
         const next = plainConfig(Config({
           ...plainConfig(live()),

package/lib/routes/models.js

@@ -33,7 +33,7 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         }
 
         const dynamicModels = Array.isArray(usageData.dynamicModels) ? usageData.dynamicModels : []
-        const allModels = getAllModels(dynamicModels, pub.modelContextOverrides)
+        const allModels = getAllModels(dynamicModels, pub.modelContextOverrides, pub.customModels)
         const settingsApi = getSettingsApi()
         if (!settingsApi || typeof settingsApi.replace !== 'function') {
           return writeJson(res, 503, { ok: false, error: 'Settings service unavailable or read-only' })
@@ -87,7 +87,7 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         if (Array.isArray(body.disabledModels)) {
           patch.disabledModels = body.disabledModels
         } else if (Array.isArray(body.enabledModels)) {
-          const allModels = getAllModels(pub.dynamicModels, pub.modelContextOverrides)
+          const allModels = getAllModels(pub.dynamicModels, pub.modelContextOverrides, pub.customModels)
           const enabledSet = new Set(body.enabledModels)
           patch.disabledModels = allModels.map((m) => m.id).filter((id) => !enabledSet.has(id))
         }
@@ -120,7 +120,7 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         }
 
         const pub = publicConfig(live())
-        const allModels = getAllModels(pub.dynamicModels, [])
+        const allModels = getAllModels(pub.dynamicModels, [], pub.customModels)
         let currentOverrides = Array.isArray(pub.modelContextOverrides) ? [...pub.modelContextOverrides] : []
 
         if (body.mode === 'all-original') {
@@ -171,7 +171,7 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         await settingsApi.replace(next)
         await syncProviderState(next)
 
-        const updatedModels = getAllModels(pub.dynamicModels, currentOverrides)
+        const updatedModels = getAllModels(pub.dynamicModels, currentOverrides, pub.customModels)
         return writeJson(res, 200, {
           ok: true,
           modelContextOverrides: next.modelContextOverrides,

package/lib/routes/proxy.js

@@ -106,6 +106,11 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
       const sessionId = String(
         req.headers['x-dsh-session-id'] ||
         req.headers['x-session-id'] ||
+        req.headers['session-id'] ||
+        req.headers['session_id'] ||
+        req.headers['x-session-affinity'] ||
+        req.headers['x-client-request-id'] ||
+        body?.session_id ||
         body?.conversation_id ||
         body?.chat_id ||
         body?.user ||
@@ -127,18 +132,45 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
       const isStreaming = Boolean(body.stream)
       const configuredAccounts = pool.filter(a => a.present && a.value)
 
+      const clientAbortCtrl = new AbortController()
+      let clientClosed = false
+      const onClientClose = () => {
+        clientClosed = true
+        if (!res.writableFinished) {
+          clientAbortCtrl.abort()
+        }
+      }
+      if (typeof res.on === 'function') res.on('close', onClientClose)
+      if (typeof req.on === 'function') req.on('close', onClientClose)
+
+      const cleanupClientListeners = () => {
+        if (typeof res.off === 'function') res.off('close', onClientClose)
+        else if (typeof res.removeListener === 'function') res.removeListener('close', onClientClose)
+        if (typeof req.off === 'function') req.off('close', onClientClose)
+        else if (typeof req.removeListener === 'function') req.removeListener('close', onClientClose)
+      }
+
       const maxRetries = Math.max(1, configuredAccounts.length)
       let attempt = 0
       let lastError = null
       let hadTimeout = false
+      let lastTargetAccount = null
+      let lastRetryAfter = null
 
       while (attempt < maxRetries) {
         attempt += 1
 
+        if (clientAbortCtrl.signal.aborted || clientClosed) {
+          cleanupClientListeners()
+          return
+        }
+
         const routeResult = resolveSessionAccount(sessionId, pool, pub.activeAccount)
         const targetAccount = routeResult.account
+        lastTargetAccount = targetAccount
 
         if (!targetAccount || !targetAccount.value) {
+          cleanupClientListeners()
           return writeJson(res, 503, {
             error: {
               message: 'No available ClinePass API keys configured in pool',
@@ -156,16 +188,17 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
           'User-Agent': USER_AGENT
         }
 
-        const upstreamTimeoutMs = Math.max(1000, Number(pub.timeoutMs) || 60000)
-        const timeoutSignal = AbortSignal.timeout(upstreamTimeoutMs)
-        const clientAbortCtrl = new AbortController()
-        const onReqClose = () => {
-          clientAbortCtrl.abort()
-        }
-        if (typeof req.on === 'function') {
-          req.on('close', onReqClose)
-        }
-        const fetchSignal = AbortSignal.any([clientAbortCtrl.signal, timeoutSignal])
+        const connectTimeoutMs = Math.max(50, Number(pub.connectTimeoutMs || pub.timeoutMs) || 15000)
+        const streamIdleTimeoutMs = Math.max(50, Number(pub.streamIdleTimeoutMs || pub.idleTimeoutMs) || 30000)
+
+        const connectAbortCtrl = new AbortController()
+        let connectTimedOut = false
+        const connectTimer = setTimeout(() => {
+          connectTimedOut = true
+          connectAbortCtrl.abort(new Error(`Upstream connect timeout after ${connectTimeoutMs}ms`))
+        }, connectTimeoutMs)
+
+        const fetchSignal = AbortSignal.any([clientAbortCtrl.signal, connectAbortCtrl.signal])
 
         let upstreamRes
         try {
@@ -177,32 +210,46 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
             keepalive: true
           })
         } catch (fetchErr) {
-          if (clientAbortCtrl.signal.aborted) {
-            // Client closed connection, stop processing
+          clearTimeout(connectTimer)
+          if (clientAbortCtrl.signal.aborted || clientClosed) {
+            cleanupClientListeners()
             return
           }
           lastError = fetchErr
-          const isTimeout = timeoutSignal.aborted || fetchErr.name === 'TimeoutError' || String(fetchErr).includes('timeout')
+          const isTimeout = connectTimedOut || connectAbortCtrl.signal.aborted || fetchErr.name === 'TimeoutError' || String(fetchErr).includes('timeout')
           if (isTimeout) {
             hadTimeout = true
-            const accountId = targetAccount.id || targetAccount.label
+            const accountId = targetAccount.apiKeyEnv || targetAccount.id || targetAccount.label
             markAccountCooldown(accountId, 60000, null, 'upstream_timeout')
-            ctx?.logger?.warn?.(`[dsh-clinebot:proxy] Account "${accountId}" upstream timed out after ${upstreamTimeoutMs}ms, attempting failover (attempt ${attempt}/${maxRetries})`)
+            if (targetAccount.id && targetAccount.id !== accountId) markAccountCooldown(targetAccount.id, 60000, null, 'upstream_timeout')
+            ctx?.logger?.warn?.(`[dsh-clinebot:proxy] Account "${accountId}" upstream connect timed out after ${connectTimeoutMs}ms, attempting failover (attempt ${attempt}/${maxRetries})`)
           }
           continue
         }
+        clearTimeout(connectTimer)
 
         // If upstream rejected with 429 or 402 quota exhaustion before streaming, failover!
         if (upstreamRes.status === 429 || upstreamRes.status === 402) {
-          const accountId = targetAccount.id || targetAccount.label
+          const accountId = targetAccount.apiKeyEnv || targetAccount.id || targetAccount.label
           markAccountCooldown(accountId, 60000, null, 'upstream_429')
-          recordUsage({
-            model: body.model,
-            accountId,
-            is429: true,
-            isError: true,
-            statsPath: pub.statsPath
-          })
+          if (targetAccount.id && targetAccount.id !== accountId) markAccountCooldown(targetAccount.id, 60000, null, 'upstream_429')
+          lastError = new Error(`Upstream rejected with HTTP ${upstreamRes.status}`)
+          lastError.status = upstreamRes.status
+          const retryAfter = upstreamRes.headers?.get?.('retry-after')
+          if (retryAfter) {
+            lastRetryAfter = retryAfter
+          }
+          if (upstreamRes.body) {
+            try {
+              if (typeof upstreamRes.body.cancel === 'function') {
+                upstreamRes.body.cancel().catch(() => {})
+              } else if (typeof upstreamRes.body.destroy === 'function') {
+                upstreamRes.body.destroy()
+              }
+            } catch {
+              /* ignore cancel error */
+            }
+          }
           ctx?.logger?.warn?.(`[dsh-clinebot:proxy] Account "${accountId}" hit 429, attempting failover (attempt ${attempt}/${maxRetries})`)
           continue
         }
@@ -221,6 +268,8 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
           let completionTokens = 0
           let totalTokens = 0
           let buffer = ''
+          let streamError = null
+          let streamCompletedCleanly = false
 
           const reader = upstreamRes.body.getReader()
           const decoder = new TextDecoder('utf8')
@@ -229,22 +278,67 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
           const onStreamAbort = () => {
             streamAborted = true
             try {
-              reader.cancel().catch(() => {})
-            } catch {
-              /* ignore */
+              reader.cancel('client closed response').catch(() => {})
+            } catch { /* reader already cancelled or closed */ }
+          }
+
+          if (clientAbortCtrl.signal.aborted || clientClosed) {
+            onStreamAbort()
+          } else {
+            clientAbortCtrl.signal.addEventListener('abort', onStreamAbort, { once: true })
+          }
+
+          let idleTimer = null
+          let idleTimedOut = false
+          const resetIdleTimer = () => {
+            if (idleTimer) clearTimeout(idleTimer)
+            idleTimer = setTimeout(() => {
+              idleTimedOut = true
+              streamError = new Error(`Stream idle timeout after ${streamIdleTimeoutMs}ms`)
+              try {
+                reader.cancel('stream idle timeout').catch(() => {})
+              } catch { /* reader already cancelled or closed */ }
+            }, streamIdleTimeoutMs)
+          }
+
+          const clearIdleTimer = () => {
+            if (idleTimer) {
+              clearTimeout(idleTimer)
+              idleTimer = null
             }
           }
-          if (typeof req.on === 'function') {
-            req.on('close', onStreamAbort)
+
+          let totalTimer = null
+          if (pub.streamTotalTimeoutMs && Number(pub.streamTotalTimeoutMs) > 0) {
+            const totalMs = Number(pub.streamTotalTimeoutMs)
+            totalTimer = setTimeout(() => {
+              streamError = new Error(`Stream total timeout after ${totalMs}ms`)
+              try {
+                reader.cancel('stream total timeout').catch(() => {})
+              } catch { /* reader already cancelled or closed */ }
+            }, totalMs)
           }
 
           try {
+            resetIdleTimer()
             while (true) {
+              if (streamAborted || clientAbortCtrl.signal.aborted || clientClosed) break
               const { done, value } = await reader.read()
-              if (done || streamAborted) break
+              if (idleTimedOut || streamError) break
+              if (done || streamAborted) {
+                if (done && !streamAborted && !clientClosed && !idleTimedOut && !streamError) {
+                  streamCompletedCleanly = true
+                }
+                break
+              }
+
+              resetIdleTimer()
 
               const chunkStr = decoder.decode(value, { stream: true })
-              res.write(value)
+              if (!res.destroyed && !res.writableEnded) {
+                res.write(value)
+              }
+              if (streamAborted || clientAbortCtrl.signal.aborted || clientClosed) break
 
               // Parse SSE lines for usage metrics
               buffer += chunkStr
@@ -268,14 +362,34 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
               }
             }
           } catch (streamErr) {
+            streamError = streamErr
             ctx?.logger?.warn?.('[dsh-clinebot:proxy] Stream read error: ' + (streamErr?.message || streamErr))
           } finally {
+            clearIdleTimer()
+            if (totalTimer) clearTimeout(totalTimer)
+            clientAbortCtrl.signal.removeEventListener('abort', onStreamAbort)
+            cleanupClientListeners()
             try {
               reader.releaseLock()
-            } catch (err) {
-              /* ignore lock release error if reader already closed */
+            } catch (err) { /* ignore lock release error if reader closed */ }
+
+            const isStreamFailed = Boolean(streamError || idleTimedOut || clientClosed || clientAbortCtrl.signal.aborted || !streamCompletedCleanly)
+
+            if (!res.destroyed && !res.writableEnded) {
+              if (isStreamFailed && (idleTimedOut || streamError)) {
+                try {
+                  const errPayload = JSON.stringify({
+                    error: {
+                      message: streamError?.message || 'Stream interrupted or timed out',
+                      type: 'stream_error',
+                      code: idleTimedOut ? 'stream_idle_timeout' : 'stream_error'
+                    }
+                  })
+                  res.write(`data: ${errPayload}\n\n`)
+                } catch { /* reader already cancelled or closed */ }
+              }
+              res.end()
             }
-            res.end()
 
             recordUsage({
               model: body.model,
@@ -283,6 +397,7 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
               promptTokens,
               completionTokens,
               totalTokens: totalTokens || (promptTokens + completionTokens),
+              isError: isStreamFailed,
               statsPath: pub.statsPath
             })
           }
@@ -298,17 +413,16 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
           resJson = null
         }
 
-        if (resJson?.usage) {
-          recordUsage({
-            model: body.model,
-            accountId: targetAccount.id || targetAccount.label,
-            promptTokens: resJson.usage.prompt_tokens,
-            completionTokens: resJson.usage.completion_tokens,
-            totalTokens: resJson.usage.total_tokens,
-            isError: upstreamRes.status >= 400,
-            statsPath: pub.statsPath
-          })
-        }
+        cleanupClientListeners()
+        recordUsage({
+          model: body.model,
+          accountId: targetAccount.id || targetAccount.label,
+          promptTokens: resJson?.usage?.prompt_tokens || 0,
+          completionTokens: resJson?.usage?.completion_tokens || 0,
+          totalTokens: resJson?.usage?.total_tokens || 0,
+          isError: upstreamRes.status >= 400,
+          statsPath: pub.statsPath
+        })
 
         res.statusCode = upstreamRes.status
         res.setHeader('Content-Type', 'application/json; charset=utf-8')
@@ -316,22 +430,49 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
         return
       }
 
+      cleanupClientListeners()
       // Exhausted all retries
+      const is429Exhausted = !hadTimeout && (lastError?.status === 429 || lastError?.status === 402)
+      recordUsage({
+        model: body.model,
+        accountId: lastTargetAccount?.id || lastTargetAccount?.label || 'default',
+        isError: true,
+        is429: is429Exhausted,
+        statsPath: pub.statsPath
+      })
       if (hadTimeout) {
         return writeJson(res, 504, {
           error: {
             message: 'Gateway Timeout: upstream provider timed out across all available accounts',
             type: 'gateway_timeout',
-            code: 'upstream_timeout'
+            code: 'upstream_timeout',
+            details: lastError?.message || null
+          }
+        })
+      }
+
+      if (is429Exhausted) {
+        if (lastRetryAfter) {
+          res.setHeader('Retry-After', lastRetryAfter)
+        }
+        return writeJson(res, 429, {
+          error: {
+            message: 'All configured accounts in pool exceeded rate limits or quota',
+            type: 'rate_limit_exceeded',
+            code: 'rate_limit_exceeded',
+            details: lastError?.message || null
           }
         })
       }
 
-      writeJson(res, 429, {
+      const status = typeof lastError?.status === 'number' && lastError.status >= 500 && lastError.status <= 599
+        ? lastError.status
+        : 502
+      return writeJson(res, status, {
         error: {
-          message: 'All configured accounts in pool exceeded rate limits or quota',
-          type: 'rate_limit_exceeded',
-          code: 'rate_limit_exceeded',
+          message: `Bad Gateway: upstream network error or unavailable: ${lastError?.message || 'unknown error'}`,
+          type: 'bad_gateway',
+          code: 'upstream_unavailable',
           details: lastError?.message || null
         }
       })

package/lib/session-router.js

@@ -101,6 +101,20 @@ export function clearAccountCooldown(accountId) {
   }
 }
 
+export function matchesAccount(acc, identifier) {
+  if (!acc || !identifier) return false
+  return acc.id === identifier || acc.apiKeyEnv === identifier || acc.label === identifier
+}
+
+export function isAccountBlocked(acc) {
+  if (!acc) return false
+  return Boolean(
+    (acc.id && isAccountInCooldown(acc.id)) ||
+    (acc.apiKeyEnv && isAccountInCooldown(acc.apiKeyEnv)) ||
+    (acc.label && isAccountInCooldown(acc.label))
+  )
+}
+
 /**
  * Select the best account from the pool based on least-used quota.
  * Lowest percentUsed is prioritized.
@@ -108,6 +122,14 @@ export function clearAccountCooldown(accountId) {
  * @param {Array<Object>} accounts Pool of accounts
  * @returns {Object|null} Selected account or null
  */
+export function getAccountUsageMetric(acc) {
+  if (typeof acc?.percentUsed === 'number') {
+    return acc.percentUsed
+  }
+  // Unknown quota is treated as 50% neutral midpoint rather than assuming 0% completely free
+  return 50
+}
+
 export function selectLeastUsedAccount(accounts = []) {
   if (!Array.isArray(accounts) || accounts.length === 0) {
     return null
@@ -116,7 +138,7 @@ export function selectLeastUsedAccount(accounts = []) {
   // Filter available accounts that have keys present and are not in cooldown
   const available = accounts.filter(acc => {
     if (!acc || acc.present === false) return false
-    return !isAccountInCooldown(acc.id || acc.label)
+    return !isAccountBlocked(acc)
   })
 
   const candidatePool = available.length > 0 ? available : accounts.filter(a => a && a.present !== false)
@@ -124,10 +146,10 @@ export function selectLeastUsedAccount(accounts = []) {
     return accounts[0] || null
   }
 
-  // Sort by lowest percentUsed (least used). If percentUsed is null/undefined, treat as 0% used
+  // Sort by lowest percentUsed (least used). Unknown quota is treated as neutral 50%
   const sorted = [...candidatePool].sort((a, b) => {
-    const aUsed = typeof a.percentUsed === 'number' ? a.percentUsed : 0
-    const bUsed = typeof b.percentUsed === 'number' ? b.percentUsed : 0
+    const aUsed = getAccountUsageMetric(a)
+    const bUsed = getAccountUsageMetric(b)
     return aUsed - bUsed
   })
 
@@ -139,50 +161,85 @@ export function selectLeastUsedAccount(accounts = []) {
  *
  * @param {string|null} sessionId Unique session or conversation identifier
  * @param {Array<Object>} accounts Configured accounts pool
- * @param {string} [defaultActiveId] Fallback active account ID
+ * @param {string} [defaultActiveId] Explicit active account ID, envName or 'auto'
  * @returns {{ account: Object|null, isReassigned: boolean, reason: string }}
  */
 export function resolveSessionAccount(sessionId, accounts = [], defaultActiveId = '') {
-  const safeAccounts = Array.isArray(accounts) ? accounts : []
+  const safeAccounts = Array.isArray(accounts) ? accounts.filter(a => a && a.present !== false) : []
   if (safeAccounts.length === 0) {
-    return { account: null, isReassigned: false, reason: 'empty_pool' }
+    const fallback = Array.isArray(accounts) && accounts.length > 0 ? accounts[0] : null
+    return { account: fallback, isReassigned: false, reason: 'empty_pool' }
   }
 
-  // If no sessionId is provided, use least-used account or default active
+  // Determine explicit pin / active account policy
+  const isAutoMode = defaultActiveId === 'auto'
+  let pinnedAccount = null
+  if (!isAutoMode) {
+    if (defaultActiveId) {
+      pinnedAccount = safeAccounts.find(a => matchesAccount(a, defaultActiveId)) || null
+    }
+    if (!pinnedAccount) {
+      pinnedAccount = safeAccounts.find(a => a.isPinned) || null
+    }
+  }
+
+  const pinnedAvailable = pinnedAccount && !isAccountBlocked(pinnedAccount) ? pinnedAccount : null
+
+  // If no sessionId provided:
   if (!sessionId) {
-    const best = selectLeastUsedAccount(safeAccounts) || safeAccounts.find(a => a.id === defaultActiveId) || safeAccounts[0]
-    return { account: best, isReassigned: false, reason: 'no_session_id' }
+    if (pinnedAvailable) {
+      return { account: pinnedAvailable, isReassigned: false, reason: 'pinned_active' }
+    }
+    const best = selectLeastUsedAccount(safeAccounts) || safeAccounts[0]
+    return { account: best, isReassigned: false, reason: pinnedAccount ? 'pinned_in_cooldown_fallback' : 'no_session_id' }
   }
 
-  let existing = sessions.get(sessionId)
   const now = Date.now()
+  let existing = sessions.get(sessionId)
+
   if (existing) {
-    // TTL eviction check
+    // Check TTL
     if (now - existing.lastUsedAt > SESSION_TTL_MS) {
       sessions.delete(sessionId)
       existing = null
-    } else {
-      const assigned = safeAccounts.find(a => (a.id || a.label) === existing.accountId)
-      // If assigned account is still valid and NOT in cooldown, keep sticky pin
-      if (assigned && !isAccountInCooldown(assigned.id || assigned.label)) {
-        existing.lastUsedAt = now
-        return { account: assigned, isReassigned: false, reason: 'sticky_pinned' }
-      }
-      // Failover: account was deleted or entered cooldown mid-session
     }
   }
 
-  // Prune before adding a brand new session if capacity reached
+  // If manual pin is configured and available:
+  if (pinnedAvailable) {
+    const reassigned = Boolean(existing && !matchesAccount(pinnedAvailable, existing.accountId))
+    sessions.set(sessionId, {
+      accountId: pinnedAvailable.apiKeyEnv || pinnedAvailable.id,
+      assignedAt: existing ? existing.assignedAt : now,
+      lastUsedAt: now
+    })
+    return {
+      account: pinnedAvailable,
+      isReassigned: reassigned,
+      reason: reassigned ? 'pinned_override' : (existing ? 'sticky_pinned' : 'pinned_active')
+    }
+  }
+
+  // If in auto mode or pinned account is unavailable:
+  if (existing) {
+    const assigned = safeAccounts.find(a => matchesAccount(a, existing.accountId))
+    if (assigned && !isAccountBlocked(assigned)) {
+      existing.lastUsedAt = now
+      return { account: assigned, isReassigned: false, reason: 'sticky_pinned' }
+    }
+    // Otherwise, failover is needed
+  }
+
+  // Prune if needed
   if (!existing && sessions.size >= MAX_SESSIONS) {
     pruneSessions(now, MAX_SESSIONS - 1, SESSION_TTL_MS)
   }
 
-  // New session or mid-session failover: pick least-used account
-  const chosen = selectLeastUsedAccount(safeAccounts) || safeAccounts.find(a => a.id === defaultActiveId) || safeAccounts[0]
+  // Pick least-used available account
+  const chosen = selectLeastUsedAccount(safeAccounts) || safeAccounts[0]
   if (chosen) {
-    const chosenId = chosen.id || chosen.label
     sessions.set(sessionId, {
-      accountId: chosenId,
+      accountId: chosen.apiKeyEnv || chosen.id,
       assignedAt: existing ? existing.assignedAt : now,
       lastUsedAt: now
     })
@@ -191,7 +248,7 @@ export function resolveSessionAccount(sessionId, accounts = [], defaultActiveId
   return {
     account: chosen,
     isReassigned: Boolean(existing),
-    reason: existing ? 'mid_session_failover' : 'new_session_assigned'
+    reason: existing ? 'mid_session_failover' : (pinnedAccount ? 'pinned_in_cooldown_fallback' : 'new_session_assigned')
   }
 }
 

package/lib/slash-command.js

@@ -16,6 +16,7 @@ import {
   clearUsageCache,
   clearProbeCache,
   usageCache,
+  buildUsageCacheKey,
   sessionStats,
 } from './cline-client.js'
 
@@ -33,7 +34,7 @@ export function registerSlashCommand(ctx, { live, getSettingsApi, syncProviderSt
 
         // 1. Subcommand /cline models
         if (subcmd === 'models') {
-          const allModels = getAllModels(pub.dynamicModels, pub.modelContextOverrides)
+          const allModels = getAllModels(pub.dynamicModels, pub.modelContextOverrides, pub.customModels)
           const disabledSet = new Set(pub.disabledModels || [])
           const activeCount = allModels.filter((m) => !disabledSet.has(m.id)).length
           const syncStatus = pub.planSynced
@@ -76,7 +77,7 @@ export function registerSlashCommand(ctx, { live, getSettingsApi, syncProviderSt
           for (const acc of pool) {
             const pinStr = acc.isPinned ? ' [Pinned]' : ''
             const statusStr = acc.present ? 'Configured' : 'Missing Key'
-            const cacheKey = `cline:usage:${(acc.value || '').slice(-8)}`
+            const cacheKey = buildUsageCacheKey(pub.baseUrl, acc.value)
             const cached = usageCache.get(cacheKey)?.data
             const usageInfo = cached?.windows?.fiveHour ? ` · 5h ${cached.windows.fiveHour.percentUsed}% used` : ''
             lines.push(`  ${acc.label} (${acc.apiKeyEnv})`)
@@ -156,7 +157,7 @@ export function registerSlashCommand(ctx, { live, getSettingsApi, syncProviderSt
 
         // 7. Subcommand /cline test [model] / smoke
         if (subcmd === 'test' || subcmd === 'smoke') {
-          if (param && !isSupportedModel(param, pub.dynamicModels)) {
+          if (param && !isSupportedModel(param, pub.dynamicModels, pub.modelContextOverrides, pub.customModels)) {
             return `ClineBot: Model "${param}" is not recognized. Use /cline models to see available models.`
           }
           const activeKey = await resolveActiveAccountKey(ctx, live())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-clinebot",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "DeepSeek Harness companion for ClineBot / ClinePass: dynamic subscription models sync, quota exhaustion warnings, session metrics, dedicated settings page, live usage limits, and /cline slash-command.",
   "license": "MIT",
   "type": "module",