free-coding-models 0.5.75 → 0.5.78

package/README.md

@@ -896,6 +896,7 @@ A: Yes — see [`sources.js`](./sources.js) for the model catalog format.
     <td align="center" width="120"><a href="https://github.com/fan92rus"><img src="https://avatars.githubusercontent.com/u/13201333?v=4&s=80" width="80" height="80" style="border-radius:50%" alt="fan92rus"></a></td>
     <td align="center" width="120"><a href="https://github.com/Muhammad95959"><img src="https://avatars.githubusercontent.com/u/75130655?v=4&s=80" width="80" height="80" style="border-radius:50%" alt="Muhammad95959"></a></td>
     <td align="center" width="120"><a href="https://github.com/FaintFlower"><img src="https://avatars.githubusercontent.com/u/310248465?v=4&s=80" width="80" height="80" style="border-radius:50%" alt="FaintFlower"></a></td>
+    <td align="center" width="120"><a href="https://github.com/lehneres"><img src="https://avatars.githubusercontent.com/u/7437288?v=4&s=80" width="80" height="80" style="border-radius:50%" alt="lehneres"></a></td>
   </tr>
   <tr>
     <td align="center"><a href="https://github.com/vava-nessa"><sub><b>vava-nessa</b></sub></a></td>
@@ -910,15 +911,19 @@ A: Yes — see [`sources.js`](./sources.js) for the model catalog format.
     <td align="center"><a href="https://github.com/fan92rus"><sub><b>fan92rus</b></sub></a></td>
     <td align="center"><a href="https://github.com/Muhammad95959"><sub><b>Muhammad95959</b></sub></a></td>
     <td align="center"><a href="https://github.com/FaintFlower"><sub><b>FaintFlower</b></sub></a></td>
+    <td align="center"><a href="https://github.com/lehneres"><sub><b>lehneres</b></sub></a></td>
   </tr>
   <tr>
-    <td align="center" colspan="12"><sub>🛡️ <b>fan92rus</b> — Windows path traversal fix (<code>path.sep</code>)</sub></td>
+    <td align="center" colspan="13"><sub>🛡️ <b>fan92rus</b> — Windows path traversal fix (<code>path.sep</code>)</sub></td>
   </tr>
   <tr>
-    <td align="center" colspan="12"><sub>📁 <b>Muhammad95959</b> — <code>--config-dir</code> flag & XDG support</sub></td>
+    <td align="center" colspan="13"><sub>📁 <b>Muhammad95959</b> — <code>--config-dir</code> flag & XDG support</sub></td>
   </tr>
   <tr>
-    <td align="center" colspan="12"><sub>⭐ <b>FaintFlower</b> — Star History chart mirror fix</sub></td>
+    <td align="center" colspan="13"><sub>⭐ <b>FaintFlower</b> — Star History chart mirror fix</sub></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="13"><sub>🚀 <b>lehneres</b> — Proxmox VE installation scripts</sub></td>
   </tr>
 </table>
 

package/changelog/v0.5.76.md

@@ -0,0 +1,16 @@
+# Changelog v0.5.76 - 2026-08-22
+
+### Added
+- **Proxmox VE one-command deployment** — new `scripts/proxmoxve-create.sh` and `scripts/proxmoxve-install.sh` built on the `community-scripts/ProxmoxVE` framework (Debian 12, 2 vCPU / 2 GB RAM / 8 GB disk, `fcm-web` systemd service on `19280` with `update` subcommand). Thanks @lehneres (PR #157).
+- **Live router request tracking** — `src/core/router-daemon.js:890` now keeps an `activeRequests` map (requestId, model, current candidate, attempt, tokens, last activity) surfaced in both `src/core/router-dashboard.js` (TUI "Active Requests" panel) and `web/src/components/router/RouterView.jsx` (web "Active Requests" panel with 2s polling, request IDs in log). Helps see routing vs stalled vs processing in real time.
+
+### Fixed
+- **Router retry & failover robustness** — `src/core/router-daemon.js:125` retryable codes now include `408` and `504`, `maxAttempts` is correctly `1 + maxRetries` (was `maxRetries`), and stream stall after partial response now sends a `CAUTION` delta instead of an `error` payload so clients stay connected. Added `getRouterTokensPath()` and fixed `web/server.js` to use it. (PR #157)
+- **Config persistence no longer clobbers custom router settings** — `src/core/config.js:340` adds `normalizeSyncSection` / `normalizeUpdaterSection`, deep-merges `router.failover` / `probeIntervals` / `circuitBreaker` / `scoring` in `buildPersistedConfig`, and `normalizeRouterFailover` falls back to router-level values. Partial updates (e.g. telemetry auto-save) no longer reset custom values to defaults. (PR #157)
+
+### Changed
+- **Major dependency updates (deps #151)** — `@tanstack/react-table` `8.21.3` -> `9.1.2` (requires `node >=20`, `react >=18`, new `@tanstack/react-store` + `@tanstack/store` peers) and `chalk` `5.6.2` -> `6.0.0` (requires `node >=22`, adds underline styles/colors). `package.json:85` `engines` bumped from `>=18.0.0` to `>=22.0.0` to reflect the new requirement. All checks green (`audit`, `lockfile-lint`, `Vercel`, `notify-discord`). `pnpm test` still `813/813`.
+- **Contributors table** — `README.md:885` now shows 13 avatars (added `lehneres` alongside `Muhammad95959` and `FaintFlower`) with corrected `colspan 13` and footer line `🚀 lehneres — Proxmox VE installation scripts`. `AGENTS.md:104` updated.
+
+### Tests
+- **Updated SSE truncation assertion** — `test/test.js:3160` now asserts `CAUTION` + `Stream truncated by router` instead of `fcm_stream_failover` to match the new stream handling. All 813 tests pass.

package/changelog/v0.5.77.md

@@ -0,0 +1,11 @@
+# Changelog v0.5.77 - 2026-08-23
+
+### Fixed
+- **Release 0.5.76 failed to build and never reached npm** — the `deps: major-updates` merge in 0.5.76 bumped `@tanstack/react-table` `8.21.3` -> `9.1.2` and `chalk` `5.6.2` -> `6.0.0`. Table v9 changed its exports (`useReactTable` / `getCoreRowModel` no longer at the top level, new `useTable` + `tableFeatures` API), so `web/src/components/dashboard/ModelTable.jsx:17` threw `MISSING_EXPORT` and `vite build` failed in CI. Reverted both deps to their last working majors (`8.21.3` and `5.6.2`), restored `web/src/components/dashboard/ModelTable.jsx:17` to the v8 API (`useReactTable`, `createColumnHelper`), and set `package.json:85` `engines` back to `>=18.0.0` with `pnpm-lock.yaml` synced. The major bump is kept on hold until a proper v9 migration (`useTable` + `tableFeatures` or `useLegacyTable`) is done and manually tested. `pnpm test` is `813/813` and `pnpm build:web` now succeeds again.
+- **Test `engines requires node >= 18` was flipped to `>=22`** — reverted `test/test.js:2376` to expect `18` to match the reverted engines.
+
+### Changed
+- No new features — this is a pure build-fix release so the Proxmox + router tracking from 0.5.76 (which was merged but never published) can finally ship as 0.5.77.
+
+### Tests
+- 813/813 passing, `vite build` green.

package/changelog/v0.5.78.md

@@ -0,0 +1,17 @@
+# Changelog v0.5.78 - 2026-08-23
+
+### Fixed
+- **Router forwards `prompt_cache_key` to NVIDIA -> HTTP 400 (fixes #160).** Clients using OpenAI JS SDK (pi agent) set `prompt_cache_key` to session UUID for prompt caching; NVIDIA rejects it with `Unsupported parameter(s): prompt_cache_key`. Added `prompt_cache_key` to `STRIP_PARAMS` in `src/core/schema-normalizer.js` and added `nvidia: normalizeNvidia` (strip + orphan tool drop) to `PROVIDER_NORMALIZERS` so `normalizeRequestBody(body, 'nvidia')` now strips the hint before forwarding. Verified with direct replay against `integrate.api.nvidia.com` and `pnpm test` 813/813. Thanks @pelvity.
+
+- **Config `pingInterval` not respected at startup (fixes #155).** TUI always started in speed mode (2s) ignoring `settings.pingInterval` and `--ping-interval`. Now `src/tui/tui-state.js` `createTuiState()` derives `initialInterval` from `config.settings.pingInterval` (already merged from CLI in `src/tui/app.js:283`) and maps to mode via `intervalToPingMode` (30000 -> slow, 10000 -> normal, 4000 -> forced, <=3000 -> speed). Sets `pingModeSource` to `config` vs `startup` and only sets `speedModeUntil` when initial mode is speed. Users with 30s interval no longer burn quota on startup burst. Thanks @BetterToAutomateTheWorld.
+
+- **jcode configuration option for CLI and web (fixes #145).** CLI Z cycle already had `jcode` but launch hung (stdin left in raw mode, REPL appeared frozen) and web had no jcode option at all.
+  - CLI hang: `src/tui/key-handler.js` `launchSelectedModel` now calls `stopUi({ resetRawMode: true })` (was `stopUi()` with raw mode still enabled) and `src/core/tool-launchers.js` `spawnCommand` defensively resets `stdin.setRawMode(false)` before handing TTY to child.
+  - Web: Added `jcode` to `INSTALL_TARGET_MODES` in `src/core/endpoint-installer.js` (now 15 targets, `jcode` after `pi` to match `TOOL_MODE_ORDER` order) with env-based installer (`~/.fcm-jcode-env`), mirrored in `web/src/utils/m3.js` `INSTALL_ENDPOINT_TOOL_MODES`, and fixed `web/src/hooks/useToolMode.js` cycle bug (`TOOL_MODE_ORDER` -> `INSTALL_ENDPOINT_TOOL_MODES`). Web `/api/tool-mode` now accepts `jcode` without 422 and dropdown/cycle shows it. Thanks @plahakps.
+
+### Changed
+- `src/core/schema-normalizer.js` JSDoc now exports `normalizeNvidia` and clarifies per-provider normalization.
+- `web/src/utils/m3.js` and `src/core/endpoint-installer.js` tool order now matches CLI's `TOOL_MODE_ORDER` (opencode -> pi -> jcode -> opencode-desktop ...).
+
+### Tests
+- 813/813 passing. Updated `test/test.js` endpoint install target expectation to include `jcode`.

package/package.json

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

package/src/core/config.js

@@ -342,12 +342,30 @@ function normalizeTelemetrySection(telemetry) {
   }
 }
 
+function normalizeSyncSection(sync) {
+  const safeSync = isPlainObject(sync) ? { ...sync } : {}
+  return {
+    enabled: typeof safeSync.enabled === 'boolean' ? safeSync.enabled : false,
+    lastSyncedAt: typeof safeSync.lastSyncedAt === 'string' ? safeSync.lastSyncedAt : null,
+  }
+}
+
+function normalizeUpdaterSection(updater) {
+  const safeUpdater = isPlainObject(updater) ? { ...updater } : {}
+  return {
+    lastCheckedAt: typeof safeUpdater.lastCheckedAt === 'string' ? safeUpdater.lastCheckedAt : null,
+    lastNotificationAt: typeof safeUpdater.lastNotificationAt === 'string' ? safeUpdater.lastNotificationAt : null,
+    skippedVersions: Array.isArray(safeUpdater.skippedVersions) ? safeUpdater.skippedVersions.filter(v => typeof v === 'string') : [],
+  }
+}
+
 function normalizeRouterName(value, fallback = '') {
   if (typeof value !== 'string') return fallback
   return value.trim().replace(/\s+/g, '-').replace(/[^a-zA-Z0-9._-]/g, '').slice(0, 64) || fallback
 }
 
 function normalizePositiveInteger(value, fallback, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
+  if (value === null || value === undefined || value === '') return fallback
   const numeric = Number(value)
   if (!Number.isFinite(numeric)) return fallback
   return Math.max(min, Math.min(max, Math.round(numeric)))
@@ -413,12 +431,21 @@ function normalizeRouterCircuitBreaker(circuitBreaker) {
   }
 }
 
-function normalizeRouterFailover(failover) {
+function normalizeRouterFailover(failover, routerFallback = {}) {
   const safeFailover = isPlainObject(failover) ? failover : {}
+  const numberOrNull = (val) => {
+    const n = Number(val)
+    return (val !== null && val !== '' && Number.isFinite(n)) ? n : null
+  }
+
+  const rawMaxRetries = numberOrNull(safeFailover.maxRetries) ?? numberOrNull(routerFallback.maxRetries)
+  const rawStreamStall = numberOrNull(safeFailover.streamStallTimeoutMs) ?? numberOrNull(routerFallback.streamStallTimeoutMs)
+  const rawRequestTimeout = numberOrNull(safeFailover.requestTimeoutMs) ?? numberOrNull(routerFallback.requestTimeoutMs)
+
   return {
-    maxRetries: normalizePositiveInteger(safeFailover.maxRetries, DEFAULT_ROUTER_SETTINGS.failover.maxRetries, { min: 1, max: 10 }),
-    streamStallTimeoutMs: normalizePositiveInteger(safeFailover.streamStallTimeoutMs, DEFAULT_ROUTER_SETTINGS.failover.streamStallTimeoutMs, { min: 1000, max: 120000 }),
-    requestTimeoutMs: normalizePositiveInteger(safeFailover.requestTimeoutMs, DEFAULT_ROUTER_SETTINGS.failover.requestTimeoutMs, { min: 1000, max: 300000 }),
+    maxRetries: normalizePositiveInteger(rawMaxRetries, DEFAULT_ROUTER_SETTINGS.failover.maxRetries, { min: 1, max: 20 }),
+    streamStallTimeoutMs: normalizePositiveInteger(rawStreamStall, DEFAULT_ROUTER_SETTINGS.failover.streamStallTimeoutMs, { min: 1000, max: 120000 }),
+    requestTimeoutMs: normalizePositiveInteger(rawRequestTimeout, DEFAULT_ROUTER_SETTINGS.failover.requestTimeoutMs, { min: 1000, max: 300000 }),
   }
 }
 
@@ -470,7 +497,7 @@ export function normalizeRouterConfig(router) {
     probeMode,
     probeIntervals: normalizeRouterIntervals(router.probeIntervals),
     circuitBreaker: normalizeRouterCircuitBreaker(router.circuitBreaker),
-    failover: normalizeRouterFailover(router.failover),
+    failover: normalizeRouterFailover(router.failover, router),
     scoring: normalizeRouterScoring(router.scoring),
     logLevel,
     prePrompt: normalizeRouterPrePrompt(router.prePrompt),
@@ -528,6 +555,8 @@ function normalizeConfigShape(config) {
     settings: normalizeSettingsSection(safeConfig.settings),
     favorites: normalizeFavoriteList(safeConfig.favorites),
     telemetry: normalizeTelemetrySection(safeConfig.telemetry),
+    sync: normalizeSyncSection(safeConfig.sync),
+    updater: normalizeUpdaterSection(safeConfig.updater),
     endpointInstalls: normalizeEndpointInstalls(safeConfig.endpointInstalls),
     // 📖 hiddenModels: Set of "provider/modelId" keys auto-hidden by the 404 probe (Ctrl+Shift+P).
     // 📖 Only populated when settings.autoHideBrokenModels is true (default).
@@ -595,10 +624,15 @@ export function buildPersistedConfig(incomingConfig, diskConfig = _emptyConfig()
     favorites: options.replaceFavorites === true
       ? [...normalizedIncoming.favorites]
       : mergeOrderedUniqueStrings(normalizedIncoming.favorites, normalizedDisk.favorites),
-    telemetry: {
-      ...normalizedDisk.telemetry,
-      ...normalizedIncoming.telemetry,
-    },
+    telemetry: isPlainObject(incomingConfig.telemetry)
+      ? { ...normalizedDisk.telemetry, ...normalizedIncoming.telemetry }
+      : cloneConfigValue(normalizedDisk.telemetry),
+    sync: isPlainObject(incomingConfig.sync)
+      ? { ...normalizedDisk.sync, ...normalizedIncoming.sync }
+      : cloneConfigValue(normalizedDisk.sync),
+    updater: isPlainObject(incomingConfig.updater)
+      ? { ...normalizedDisk.updater, ...normalizedIncoming.updater }
+      : cloneConfigValue(normalizedDisk.updater),
     // 📖 Managed endpoint installs sometimes need an exact snapshot so stale disk
     // 📖 records do not come back after a fresh install/refresh pass.
     endpointInstalls: options.replaceEndpointInstalls === true
@@ -606,7 +640,32 @@ export function buildPersistedConfig(incomingConfig, diskConfig = _emptyConfig()
       : mergeEndpointInstalls(normalizedDisk.endpointInstalls, normalizedIncoming.endpointInstalls),
     // 📖 Profile system removed - always null
   }
-  if (Object.prototype.hasOwnProperty.call(normalizedIncoming, 'router')) {
+  if (isPlainObject(incomingConfig.router) && isPlainObject(normalizedDisk.router)) {
+    // 📖 Deep merge router settings so partial updates (e.g. from telemetry auto-save)
+    // 📖 do not reset custom failover/scoring/intervals to defaults.
+    merged.router = {
+      ...normalizedDisk.router,
+      ...normalizedIncoming.router,
+      failover: {
+        ...normalizedDisk.router.failover,
+        ...(isPlainObject(incomingConfig.router.failover) ? normalizedIncoming.router.failover : {}),
+        // 📖 Also support top-level maxRetries/timeout overrides from incoming RAW config
+        ...(typeof incomingConfig.router.maxRetries === 'number' ? { maxRetries: incomingConfig.router.maxRetries } : {}),
+      },
+      probeIntervals: {
+        ...normalizedDisk.router.probeIntervals,
+        ...(isPlainObject(incomingConfig.router.probeIntervals) ? normalizedIncoming.router.probeIntervals : {}),
+      },
+      circuitBreaker: {
+        ...normalizedDisk.router.circuitBreaker,
+        ...(isPlainObject(incomingConfig.router.circuitBreaker) ? normalizedIncoming.router.circuitBreaker : {}),
+      },
+      scoring: {
+        ...normalizedDisk.router.scoring,
+        ...(isPlainObject(incomingConfig.router.scoring) ? normalizedIncoming.router.scoring : {}),
+      },
+    }
+  } else if (Object.prototype.hasOwnProperty.call(incomingConfig, 'router')) {
     merged.router = cloneConfigValue(normalizedIncoming.router)
   } else if (Object.prototype.hasOwnProperty.call(normalizedDisk, 'router')) {
     merged.router = cloneConfigValue(normalizedDisk.router)
@@ -1244,6 +1303,8 @@ function _emptyConfig() {
     providers: {},
     favorites: [],
     telemetry: { enabled: null, consentVersion: 0, anonymousId: null },
+    sync: { enabled: false, lastSyncedAt: null },
+    updater: { lastCheckedAt: null, lastNotificationAt: null, skippedVersions: [] },
     endpointInstalls: [],
     settings: _emptyProfileSettings(),
     hiddenModels: new Set(),

package/src/core/endpoint-installer.js

@@ -53,8 +53,8 @@ import { ensureDir, readJson as sharedReadJson } from './shared-helpers.js'
 // 📖 zai and opencode-zen ARE OpenAI-compatible and CAN be installed into any tool.
 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', 'zcode']
+// 📖 jcode is CLI-only and uses an env-file helper (same as openhands) — selectable in both CLI and Web.
+const INSTALL_TARGET_MODES = ['opencode', 'pi', 'jcode', 'opencode-desktop', 'opencode-web', 'openclaw', 'crush', 'goose', 'aider', 'qwen', 'openhands', 'amp', 'forgecode', 'fcm_router', 'zcode']
 
 function getDefaultPaths() {
   const home = homedir()
@@ -839,6 +839,8 @@ export function installProviderEndpoints(config, providerKey, toolMode, options
     installResult = installIntoAmp(providerKey, models, apiKey, paths)
   } else if (canonicalToolMode === 'qwen') {
     installResult = installIntoQwen(providerKey, models, apiKey, paths)
+  } else if (canonicalToolMode === 'jcode') {
+    installResult = installIntoEnvBasedTool(providerKey, models, apiKey, canonicalToolMode, paths)
   } else if (canonicalToolMode === 'openhands') {
     installResult = installIntoEnvBasedTool(providerKey, models, apiKey, canonicalToolMode, paths)
   } else if (canonicalToolMode === 'fcm_router') {

package/src/core/router-daemon.js

@@ -105,6 +105,7 @@ export const ROUTER_TOKENS_PATH = join(homedir(), `.free-coding-models-tokens${_
 export function getRouterPidPath() { return join(homedir(), `.free-coding-models-daemon${_isDev() ? '-dev' : ''}.pid`) }
 export function getRouterPortPath() { return join(homedir(), `.free-coding-models-daemon${_isDev() ? '-dev' : ''}.port`) }
 export function getRouterLogPath() { return join(homedir(), `.free-coding-models-daemon${_isDev() ? '-dev' : ''}.log`) }
+export function getRouterTokensPath() { return join(homedir(), `.free-coding-models-tokens${_isDev() ? '-dev' : ''}.json`) }
 
 // 📖 Returns effective port range for current mode (dev vs production)
 export function getRouterPortRange() {
@@ -124,7 +125,7 @@ const MAX_PROBE_WINDOW = 20
 const TOKEN_FLUSH_INTERVAL_MS = 60000
 const CONFIG_RELOAD_INTERVAL_MS = 10000
 const STATS_RETENTION_DAYS = 90
-const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 529])
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504, 529])
 const AUTH_STATUS_CODES = new Set([401, 403])
 const RATE_LIMIT_HEADER_NAMES = [
   'retry-after',
@@ -889,6 +890,7 @@ class RouterRuntime {
     this.probeWindows = new Map()
     this.circuit = new Map()
     this.requestLog = []
+    this.activeRequests = new Map()
     this.sseClients = new Set()
     this.lastProbeAt = null
     this.totalRequestsRouted = 0
@@ -1608,6 +1610,15 @@ class RouterRuntime {
         completed: this.webGlobalBenchmarkCompleted || 0,
       },
       requestLog: this.requestLog.slice(0, 20),
+      activeRequests: Array.from(this.activeRequests.values()).map(r => ({
+        requestId: r.requestId,
+        at: r.at,
+        model: r.model,
+        current_model: r.current_model,
+        attempts: r.attempts,
+        tokens: r.tokens,
+        stalled: r.stalled
+      })),
       circuitBreakers: Object.fromEntries([...this.circuit.entries()].map(([key, value]) => [key, {
         state: value.authError ? 'AUTH_ERROR' : value.stale ? 'STALE' : value.unsupported ? 'UNSUPPORTED' : value.state,
         consecutiveFailures: value.consecutiveFailures,
@@ -1963,6 +1974,15 @@ class RouterRuntime {
   }
 
   async routeRequest({ req, res, body, setName, requestId }) {
+    this.activeRequests.set(requestId, {
+      requestId,
+      at: Date.now(),
+      model: body?.model || 'fcm',
+      current_model: null,
+      attempts: 0,
+      tokens: 0,
+      stalled: false
+    })
     if (this.shuttingDown) {
       sendError(res, 503, 'Daemon is shutting down', 'service_unavailable', 'daemon_shutting_down', requestId)
       return
@@ -1988,7 +2008,7 @@ class RouterRuntime {
 
     const candidates = this.getRoutingCandidates(set)
     const maxRetries = this.routerConfig().failover.maxRetries
-    const maxAttempts = Math.max(1, maxRetries)
+    const maxAttempts = 1 + maxRetries
     if (candidates.length === 0) {
       const health = this.getModelHealth(set)
       const quotaExhausted = [...this.quotaExhausted].filter((key) => set.models.some((model) => modelKey(model.provider, model.model) === key))
@@ -2042,6 +2062,13 @@ class RouterRuntime {
       for (const candidate of candidates) {
         if (attemptIndex >= maxAttempts) break
         if (blockedProviders.has(candidate.provider)) continue
+
+        const activeReq = this.activeRequests.get(requestId)
+        if (activeReq) {
+          activeReq.current_model = candidate.key
+          activeReq.attempts = attemptIndex + 1
+        }
+
         tried.push(candidate.key)
         const result = body.stream === true
           ? await this.proxyStreamingRequest({ req, res, body, candidate, requestId, attemptIndex })
@@ -2101,6 +2128,7 @@ class RouterRuntime {
       })
     } finally {
       this.inFlight -= 1
+      this.activeRequests.delete(requestId)
     }
   }
 
@@ -2269,6 +2297,11 @@ class RouterRuntime {
 
   async proxyStreamingRequest({ req, res, body, candidate, requestId, attemptIndex }) {
     const key = candidate.key
+    const activeReq = this.activeRequests.get(requestId)
+    if (activeReq) {
+      activeReq.current_model = key
+      if (activeReq.last_activity_at) activeReq.last_activity_at = Date.now()
+    }
     const apiKey = this.getApiKeyForProvider(candidate.provider)
     // 📖 Guard: bail early if provider URL cannot be resolved
     const providerUrl = resolveProviderUrl(candidate.provider)
@@ -2397,6 +2430,10 @@ class RouterRuntime {
         // 📖 Guard: ensure chunk value is safe for Buffer conversion
         const buf = Buffer.isBuffer(chunk.value) ? chunk.value : Buffer.from(chunk.value)
         res.write(buf)
+        if (activeReq) {
+          if (activeReq.last_activity_at) activeReq.last_activity_at = Date.now()
+          activeReq.tokens += 1 // Increment a counter to show progress
+        }
       }
 
       this.markSuccess(key, latencyMs)
@@ -2443,15 +2480,18 @@ class RouterRuntime {
           this.logger.warn(`Stream stall after partial response from ${key}, attempting failover`, { request_id: requestId, reason })
           if (!res.writableEnded) {
             try {
-              const errorPayload = JSON.stringify({
-                error: {
-                  message: `Stream truncated by router due to upstream ${reason}; failing over to next model.`,
-                  type: 'stream_error',
-                  code: 'fcm_stream_failover',
-                  reason,
-                },
+              // 📖 Issue #137: failover even after a partial response.
+              // 📖 We use a regular chat delta instead of an error payload so
+              // 📖 that clients (which often abort on "error") stay connected.
+              const failoverMsg = `\n\n> [!CAUTION]\n> Stream truncated by router due to upstream ${reason}; failing over to next model.\n\n`
+              const deltaPayload = JSON.stringify({
+                choices: [{
+                  index: 0,
+                  delta: { content: failoverMsg },
+                  finish_reason: null,
+                }],
               })
-              res.write(`data: ${errorPayload}\n\n`)
+              res.write(`data: ${deltaPayload}\n\n`)
             } catch { /* best-effort */ }
           }
           return { done: false, failoverToNext: true, reason: `stream_stall_${reason}` }
@@ -3301,8 +3341,8 @@ class RouterRuntime {
     flushProbeCache()  // 📖 t1: persist any pending probe-cache deltas before exit
     if (this.runtimeTelemetryDirty) flushRuntimeTelemetryStore()  // 📖 t3
     try { this.server?.close() } catch {}
-    try { unlinkSync(ROUTER_PID_PATH) } catch {}
-    try { unlinkSync(ROUTER_PORT_PATH) } catch {}
+    try { unlinkSync(getRouterPidPath()) } catch {}
+    try { unlinkSync(getRouterPortPath()) } catch {}
     void sendUsageTelemetry(this.config, {}, {
       event: 'app_daemon_stop',
       mode: 'daemon',
@@ -3846,16 +3886,28 @@ export async function startRouterDaemonBackground() {
 }
 
 export async function stopRouterDaemon() {
-  const pid = readNumberFile(ROUTER_PID_PATH)
-  if (!pid) return { ok: false, stopped: false, error: 'No daemon PID file found' }
+  const pidPath = getRouterPidPath()
+  let pid = readNumberFile(pidPath)
+
+  // 📖 Fallback: if the PID file is missing or invalid, try to discover the
+  // 📖 running daemon via its health port and get the PID from there.
+  if (!pid) {
+    const status = await getRouterDaemonStatus()
+    if (status.ok && status.pid) pid = status.pid
+  }
+
+  if (!pid) return { ok: false, stopped: false, error: 'No daemon PID found' }
   if (!isProcessAlive(pid)) {
-    try { unlinkSync(ROUTER_PID_PATH) } catch {}
+    try { unlinkSync(pidPath) } catch {}
     return { ok: true, stopped: false, stalePid: pid }
   }
   process.kill(pid, 'SIGTERM')
   for (let i = 0; i < 60; i += 1) {
     await sleep(250)
-    if (!isProcessAlive(pid)) return { ok: true, stopped: true, pid }
+    if (!isProcessAlive(pid)) {
+      try { unlinkSync(pidPath) } catch {}
+      return { ok: true, stopped: true, pid }
+    }
   }
   return { ok: false, stopped: false, pid, error: 'Daemon did not stop before timeout' }
 }

package/src/core/router-dashboard.js

@@ -301,6 +301,7 @@ export function normalizeRouterDashboardSnapshot(healthPayload, statsPayload) {
     models,
     routingOrder,
     requestLog,
+    activeRequests: Array.isArray(merged.activeRequests) ? merged.activeRequests : [],
   }
 }
 
@@ -1034,12 +1035,29 @@ export function renderRouterDashboard(state, deps = {}) {
   // ── Token Summary (compact, visual) ─────────────────────────────────────────
   lines.push(`  ${themeColors.textBold('📊 Tokens')}  ${themeColors.dim('Today:')} ${themeColors.info(formatTokenTotalCompact(snapshot.tokens.today.total_tokens))} ${themeColors.dim(`(${snapshot.tokens.today.requests} req)`)}  ${themeColors.dim('Lifetime:')} ${themeColors.info(formatTokenTotalCompact(snapshot.tokens.all_time.total_tokens))} ${themeColors.dim(`(${snapshot.tokens.all_time.requests} req)`)}`)
 
+  // ── Active Requests ────────────────────────────────────────────────────────
+  lines.push('')
+  lines.push(`  ${themeColors.warningBold('⚡ Active Requests')} ${themeColors.dim(`(${snapshot.activeRequests?.length || 0})`)}`)
+  if (snapshot.activeRequests?.length > 0) {
+    for (const req of snapshot.activeRequests) {
+      const model = compactText(req.model, 24)
+      const current = compactText(req.current_model || 'Routing...', 24)
+      const duration = formatRouterDuration(Math.floor((Date.now() - req.started_at) / 1000))
+      const status = req.stalled ? themeColors.errorBold('STALLED?') : themeColors.success('Processing...')
+      const tokens = req.stream ? ` ${themeColors.dim(`(${req.tokens} tok)`)}` : ''
+      const shortId = req.request_id ? themeColors.dim(`[${req.request_id.slice(-4)}] `) : ''
+      lines.push(`  ${themeColors.dim('•')} ${shortId}${model} → ${themeColors.info(current)} ${status}${tokens} ${themeColors.dim(duration)}`)
+    }
+  } else {
+    lines.push(`  ${themeColors.dim('No active requests')}`)
+  }
+
   // ── Live Request Log (compact) ──────────────────────────────────────────────
   const requestRows = requestLogRows(state, snapshot)
   lines.push('')
   lines.push(`  ${themeColors.textBold('Recent Requests')}`)
   if (requestRows.length > 0) {
-    const header = `  ${padEndDisplay('Time', 10)} ${padEndDisplay('Model', 34)} ${padEndDisplay('Status', 8)} ${padEndDisplay('Latency', 9)} Detail`
+    const header = `  ${padEndDisplay('ID', 5)} ${padEndDisplay('Time', 10)} ${padEndDisplay('Model', 34)} ${padEndDisplay('Status', 8)} ${padEndDisplay('Latency', 9)} Detail`
     lines.push(themeColors.dim(header))
     for (const row of requestRows.slice(0, 6)) {
       const atMs = Date.parse(row.at)
@@ -1052,12 +1070,14 @@ export function renderRouterDashboard(state, deps = {}) {
         row.stream ? 'stream' : '',
         row.error || '',
       ].filter(Boolean).join(', ') || '—'
+      const shortId = row.request_id ? row.request_id.slice(-4) : '—'
       lines.push(
-        `  ${padEndDisplay(time, 10)} ` +
+        `  ${padEndDisplay(shortId, 5)} ` +
+        `${padEndDisplay(time, 10)} ` +
         `${compactText(row.model, 34)} ` +
         `${padEndDisplay(statusColor(statusText), 8)} ` +
         `${padEndDisplay(latency, 9)} ` +
-        `${compactText(detail, Math.max(10, width - 68)).trimEnd()}`
+        `${compactText(detail, Math.max(10, width - 74)).trimEnd()}`
       )
     }
   } else {

package/src/core/schema-normalizer.js

@@ -30,8 +30,9 @@
  *   → `clampTemperature` — clamps `temperature` to the provider's accepted range
  *   → `normalizeZai` — for `zai` (GLM) provider
  *   → `normalizeMistral` — for `mistral` and `codestral` providers
+ *   → `normalizeNvidia` — for `nvidia` provider (strips unsupported params like prompt_cache_key)
  *
- * @exports normalizeRequestBody, normalizeZai, normalizeMistral, PROVIDER_NORMALIZERS
+ * @exports normalizeRequestBody, normalizeZai, normalizeMistral, normalizeNvidia, PROVIDER_NORMALIZERS
  *
  * @see src/core/router-daemon.js — calls `normalizeRequestBody` before forwarding upstream
  */
@@ -48,6 +49,7 @@ const STRIP_PARAMS = [
   'echo',                 // not in OpenAI spec
   'user',                 // PII risk; not used by FCM
   'metadata',             // not always supported
+  'prompt_cache_key',     // OpenAI prompt-caching hint; NVIDIA rejects with 400
   'store',                // GLM rejects
 ]
 
@@ -146,6 +148,20 @@ export function normalizeMistral(body) {
   return result
 }
 
+/**
+ * 📖 `normalizeNvidia` — transforms a request body for the `nvidia` provider.
+ *
+ *   1. Strips parameters NVIDIA rejects with 400 (e.g. prompt_cache_key)
+ *   2. Removes orphan `tool` messages that lack a matching assistant tool_call
+ *   3. Strips `stream_options` when not streaming
+ */
+export function normalizeNvidia(body) {
+  if (!body || typeof body !== 'object') return body
+  let result = stripUnsupportedParams(body)
+  result = dropOrphanToolMessages(result)
+  return result
+}
+
 // 📖 Map of provider key → normalizer function. Providers that don't need
 // 📖 any tweak (most OpenAI-compat ones like Groq, Cerebras, etc.) are not
 // 📖 listed and pass through `normalizeRequestBody` unchanged.
@@ -153,6 +169,7 @@ export const PROVIDER_NORMALIZERS = {
   zai: normalizeZai,
   mistral: normalizeMistral,
   codestral: normalizeMistral,
+  nvidia: normalizeNvidia,
 }
 
 /**

package/src/core/tool-launchers.js

@@ -209,6 +209,12 @@ const JCODE_NATIVE_PROVIDERS = {
 }
 
 function spawnCommand(command, args, env) {
+  // 📖 Defensive: ensure stdin is back in cooked mode before handing the TTY to
+  // 📖 an interactive child (jcode REPL etc). The TUI leaves raw mode enabled;
+  // 📖 if the caller forgot to reset it the child will appear to hang.
+  try {
+    if (process.stdin.isTTY && process.stdin.isRaw) process.stdin.setRawMode(false)
+  } catch {}
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       stdio: 'inherit',

package/src/tui/command-palette.js

@@ -219,12 +219,29 @@ const BASE_COMMAND_TREE = [
 /**
  * 📖 Build the command palette tree with dynamic model filters.
  * @param {Array} visibleModels - Optional list of visible models to create model filter entries
+ * @param {object} config - Optional FCM config to customize dynamic labels
  * @returns {Array} The command tree with model filters added
  */
-export function buildCommandPaletteTree(visibleModels = []) {
+export function buildCommandPaletteTree(visibleModels = [], config = null) {
   // 📖 Clone the base tree
   const tree = JSON.parse(JSON.stringify(BASE_COMMAND_TREE))
-  
+
+  // 📖 Update Normal mode label if config is provided
+  if (config) {
+    const normalInterval = config.settings?.pingInterval ?? 10000
+    const normalSec = Math.round(normalInterval / 1000)
+    const actionsNode = tree.find(n => n.id === 'actions')
+    const pingNode = actionsNode?.children.find(n => n.id === 'action-ping-mode')
+    const normalCommand = pingNode?.children.find(n => n.id === 'action-set-ping-normal')
+    if (normalCommand) {
+      normalCommand.label = `Normal mode (${normalSec}s)`
+      if (Array.isArray(normalCommand.keywords)) {
+        normalCommand.keywords = normalCommand.keywords.filter(k => !k.endsWith('s'))
+        normalCommand.keywords.push(`${normalSec}s`)
+      }
+    }
+  }
+
   // 📖 Find the filter-model category and add dynamic model entries
   const filterModelCategory = tree.find(cat => cat.id === 'filters')
     ?.children.find(sub => sub.id === 'filter-model')

package/src/tui/key-handler.js

@@ -278,9 +278,7 @@ export function createKeyHandler(ctx) {
     userSelected = { modelId: selected.modelId, label: selected.label, tier: selected.tier, providerKey: selected.providerKey, ctx: selected.ctx }
 
     if (!uiAlreadyStopped) {
-      readline.emitKeypressEvents(process.stdin)
-      if (process.stdin.isTTY) process.stdin.setRawMode(true)
-      stopUi()
+      stopUi({ resetRawMode: true })
     }
 
     // 📖 If router is enabled, push [selected, ...favorites] to daemon as the active set

package/src/tui/overlays.js

@@ -336,6 +336,8 @@ export function createOverlayRenderers(state, deps) {
       themeColors.dim('  ') +
       themeColors.footerLove('Made with 💖 & ☕ by ') +
       themeColors.link('\x1b]8;;https://github.com/vava-nessa\x1b\\vava-nessa\x1b]8;;\x1b\\') +
+      themeColors.dim('  •  ⭐ ') +
+      themeColors.link('\x1b]8;;https://github.com/vava-nessa/free-coding-models/graphs/contributors\x1b\\Contributors\x1b]8;;\x1b\\') +
       themeColors.dim('  •  💬 ') +
       themeColors.footerDiscord('\x1b]8;;https://discord.gg/ZTNFHvvCkU\x1b\\Join the Discord\x1b]8;;\x1b\\') +
       themeColors.dim('  •  ☕ ') +

package/src/tui/tui-state.js

@@ -87,6 +87,16 @@ export function createTuiState({
 }) {
   const now = Date.now()
 
+  // 📖 Dynamic normal interval from config (default 10s)
+  const normalInterval = config.settings?.pingInterval ?? PING_MODE_INTERVALS.normal
+  // 📖 Respect config.settings.pingInterval at startup (issue #155).
+  // 📖 CLI override is already merged into config.settings.pingInterval in app.js.
+  const configuredInterval = config.settings?.pingInterval
+  const hasConfiguredInterval =
+    typeof configuredInterval === 'number' && Number.isFinite(configuredInterval) && configuredInterval > 0
+  const initialInterval = hasConfiguredInterval ? configuredInterval : PING_MODE_INTERVALS.speed
+  const initialMode = intervalToPingMode(initialInterval)
+
   return {
     // 📖 Core data: model results (mutated in-place by ping loop)
     results,
@@ -104,10 +114,14 @@ export function createTuiState({
     sortDirection: (config.settings?.sortAsc ?? true) ? 'asc' : 'desc',
 
     // 📖 Ping cadence — drives the interval between background ping cycles
-    pingInterval: PING_MODE_INTERVALS.speed,
-    pingMode: 'speed',
-    pingModeSource: 'startup',
-    speedModeUntil: now + SPEED_MODE_DURATION_MS,
+    pingInterval: initialInterval,
+    pingMode: initialMode,
+    pingModeSource: hasConfiguredInterval ? 'config' : 'startup',
+    pingModeIntervals: {
+      ...PING_MODE_INTERVALS,
+      normal: normalInterval,
+    },
+    speedModeUntil: initialMode === 'speed' ? now + SPEED_MODE_DURATION_MS : null,
     lastPingTime: now,
     lastUserActivityAt: now,
     resumeSpeedOnActivity: false,