cc-viewer 1.7.10 → 1.7.12

package/dist/index.html

@@ -21,11 +21,11 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="./assets/index-ClB3znal.js"></script>
+  <script type="module" crossorigin src="./assets/index-QCUTFwkw.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-DADYo_zg.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-tF6HNoR6.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-CFAmRN3Y.js">
-  <link rel="stylesheet" crossorigin href="./assets/index-f4nPU7KM.css">
+  <link rel="stylesheet" crossorigin href="./assets/index-CGSyt5Ow.css">
 </head>
 <body>
   <!-- Pre-hydration splash: no SPA CSS yet — keep font-family in sync with --font-ui in src/global.css -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",

package/server/i18n.js

@@ -2975,11 +2975,6 @@ const i18nData = {
     "tr": "IM botu '{id}' zaten çalışıyor (pid {pid}); ikinci bir örnek başlatılması reddedildi.",
     "uk": "IM-бот '{id}' вже запущено (pid {pid}); запуск другого екземпляра відхилено."
   },
-  "server.proxyStats.starting": { "zh": "代理重试统计已启动", "en": "Proxy retry stats started", "zh-TW": "代理重試統計已啟動", "ko": "프록시 재시도 통계가 시작됨", "ja": "プロキシリトライ統計を開始しました", "de": "Proxy-Wiederholungsstatistiken gestartet", "es": "Estadísticas de reintentos de proxy iniciadas", "fr": "Statistiques de relances du proxy démarrées", "it": "Statistiche retry del proxy avviate", "da": "Proxy-genforsøgsstatistik startet", "pl": "Statystyki ponownych prób proxy uruchomione", "ru": "Статистика повторов прокси запущена", "ar": "بدأت إحصائيات إعادة محاولات الوكيل", "no": "Proxy-retry-statistikk startet", "pt-BR": "Estatísticas de retry do proxy iniciadas", "th": "เริ่มสถิติการลองใหม่ของพร็อกซีแล้ว", "tr": "Proxy yeniden deneme istatistikleri başladı", "uk": "Статистику повторів проксі запущено" },
-  "server.proxyStats.modeLabel": { "zh": "重试模式", "en": "Retry mode", "zh-TW": "重試模式", "ko": "재시도 모드", "ja": "リトライモード", "de": "Wiederholungsmodus", "es": "Modo de reintento", "fr": "Mode de relance", "it": "Modalità retry", "da": "Genforsøgstilstand", "pl": "Tryb ponownych prób", "ru": "Режим повторов", "ar": "وضع إعادة المحاولة", "no": "Retry-modus", "pt-BR": "Modo de retry", "th": "โหมดการลองใหม่", "tr": "Yeniden deneme modu", "uk": "Режим повторів" },
-  "server.proxyStats.disabled": { "zh": "代理重试已禁用", "en": "Proxy retry disabled", "zh-TW": "代理重試已停用", "ko": "프록시 재시도 비활성화됨", "ja": "プロキシリトライは無効です", "de": "Proxy-Wiederholung deaktiviert", "es": "Reintento de proxy deshabilitado", "fr": "Relance du proxy désactivée", "it": "Retry del proxy disattivato", "da": "Proxy-genforsøg deaktiveret", "pl": "Ponowne próby proxy wyłączone", "ru": "Повторы прокси отключены", "ar": "تم تعطيل إعادة محاولات الوكيل", "no": "Proxy-retry deaktivert", "pt-BR": "Retry do proxy desativado", "th": "ปิดการลองใหม่ของพร็อกซีแล้ว", "tr": "Proxy yeniden deneme devre dışı", "uk": "Повтори проксі вимкнено" },
-  "server.proxyStats.configLoaded": { "zh": "代理重试配置已加载", "en": "Proxy retry config loaded", "zh-TW": "代理重試設定已載入", "ko": "프록시 재시도 설정이 로드됨", "ja": "プロキシリトライ設定を読み込みました", "de": "Proxy-Wiederholungskonfiguration geladen", "es": "Configuración de reintento de proxy cargada", "fr": "Configuration de relance du proxy chargée", "it": "Configurazione retry del proxy caricata", "da": "Proxy-genforsøgskonfiguration indlæst", "pl": "Konfiguracja ponownych prób proxy załadowana", "ru": "Конфигурация повторов прокси загружена", "ar": "تم تحميل تكوين إعادة محاولات الوكيل", "no": "Proxy-retry-konfigurasjon lastet", "pt-BR": "Configuração de retry do proxy carregada", "th": "โหลดการตั้งค่าการลองใหม่ของพร็อกซีแล้ว", "tr": "Proxy yeniden deneme yapılandırması yüklendi", "uk": "Конфігурацію повторів проксі завантажено" },
-  "server.proxyStats.refreshed": { "zh": "代理统计已刷新", "en": "Proxy stats refreshed", "zh-TW": "代理統計已重新整理", "ko": "프록시 통계가 새로고침됨", "ja": "プロキシ統計を更新しました", "de": "Proxy-Statistiken aktualisiert", "es": "Estadísticas de proxy actualizadas", "fr": "Statistiques du proxy actualisées", "it": "Statistiche del proxy aggiornate", "da": "Proxy-statistik opdateret", "pl": "Statystyki proxy odświeżone", "ru": "Статистика прокси обновлена", "ar": "تم تحديث إحصائيات الوكيل", "no": "Proxy-statistikk oppdatert", "pt-BR": "Estatísticas do proxy atualizadas", "th": "รีเฟรชสถิติพร็อกซีแล้ว", "tr": "Proxy istatistikleri yenilendi", "uk": "Статистику проксі оновлено" }
 };
 
 // 将 { key: { lang: text } } 转换为 { lang: { key: text } }

package/server/lib/ccswitch-import.js

@@ -11,7 +11,9 @@
 // is delegated to the caller (preferences.js POST /api/ccswitch-import).
 //
 // Design notes:
-// - Open SQLite read-only (readOnly:true) to avoid SQLITE_BUSY locks while cc-switch is running
+// - Open SQLite read-only by default (readOnly:true) to avoid SQLITE_BUSY locks while cc-switch is running;
+//   escalate once to a read-write + query_only connection only when a malformed leftover journal forces
+//   SQLITE_READONLY recovery (see readCcSwitchProviders)
 // - Multi-path probing: each platform tries the standard Tauri dir first, then falls back to ~/.cc-switch/
 // - settings_config parsing is fully fault-tolerant: null / non-JSON / missing env are all skipped, never throws
 // - Profile ids get a ccs_ prefix to distinguish from user-created proxy_ prefixed ones; updates are idempotent (re-imports update, never duplicate)
@@ -155,18 +157,31 @@ export async function readCcSwitchProviders(dbPath) {
     // localized message off it (ui.proxy.ccswitchNodeUnsupported).
     return { profiles: [], error: 'node:sqlite unavailable on this runtime (requires Node >= 22.5 with --experimental-sqlite, or >= 23.4)' };
   }
-  let db = null;
-  try {
-    // Read-only: cc-switch stays unaffected by our reads (no SQLITE_BUSY)
-    db = new DatabaseSync(dbPath, { readOnly: true });
-  } catch (err) {
-    return { profiles: [], error: `cannot open db: ${err && err.message}` };
-  }
-  try {
+
+  // Open the db. Two contention modes from cc-switch to recover from:
+  //  (1) A leftover MALFORMED cc-switch.db-journal (cc-switch killed mid-write, leaving a
+  //      truncated/corrupt rollback journal) forces SQLite to discard it on the first page
+  //      access — a write — which a read-only connection refuses with SQLITE_READONLY
+  //      ("attempt to write a readonly database"). Escalate once to a read-write open guarded
+  //      by PRAGMA query_only=ON (lets SQLite recover, blocks our own writes), then retry.
+  //      Mirrors what cc-switch itself does on its next normal launch.
+  //  (2) A running cc-switch holding an EXCLUSIVE write lock (its real contention mode — a
+  //      valid hot journal under BEGIN EXCLUSIVE blocks even read-only readers, unlike
+  //      BEGIN IMMEDIATE) makes the read-only connection's first query throw SQLITE_BUSY
+  //      ("database is locked"). Retry once after a short backoff (cc-switch's writes are
+  //      short — transient locks usually clear), and if still held surface a friendly message
+  //      rather than the opaque `query failed: database is locked`.
+  const primaryErrCode = (e) => Number.isInteger(e && e.errcode) ? (e.errcode & 0xff) : null;
+  const isReadonlyErr = (e) => primaryErrCode(e) === 8
+    || /readonly/i.test(e && (e.errstr || e.message || ''));
+  const isBusyErr = (e) => [5, 6].includes(primaryErrCode(e))
+    || /locked|busy/i.test(e && (e.errstr || e.message || ''));
+
+  // Run the providers read against a given connection; returns the result object or throws.
+  const readProviders = (db) => {
     // providers table existence check. A query that throws here means the file is
     // unreadable as a SQLite db (corrupt / non-SQLite / truncated) — the real cause
-    // must surface, not be masked as "table not found". Let it propagate to the
-    // outer catch, which formats it as `query failed: <message>`.
+    // must surface, not be masked as "table not found".
     const r = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='providers'").get();
     if (!r) return { profiles: [], error: `providers table not found in ${dbPath}` };
 
@@ -184,10 +199,56 @@ export async function readCcSwitchProviders(dbPath) {
       }
     }
     return { profiles, currentId, error: null };
-  } catch (err) {
-    return { profiles: [], error: `query failed: ${err && err.message}` };
-  } finally {
-    try { db.close(); } catch { /* best effort */ }
+  };
+
+  // Open read-only and attempt the read. Two recovery paths:
+  //  - SQLITE_BUSY ("database is locked"): cc-switch is running and holding an EXCLUSIVE write
+  //    lock (its real contention mode — a valid hot journal under BEGIN EXCLUSIVE blocks even
+  //    read-only readers, unlike BEGIN IMMEDIATE). The lock is transient (cc-switch mid-write),
+  //    so retry once after a short backoff; if still held, surface a friendly, actionable
+  //    message instead of the opaque `query failed: database is locked` wrapper.
+  //  - SQLITE_READONLY ("attempt to write a readonly database"): a malformed leftover journal
+  //    (cc-switch killed mid-write) forces SQLite to discard it — a write the read-only
+  //    connection refuses. Escalate once to a read-write open guarded by PRAGMA query_only=ON
+  //    (lets SQLite recover, blocks our own writes), then retry. Mirrors cc-switch's own
+  //    next-launch recovery.
+  // Other errors propagate to the outer catch (formatted as `query failed: <message>`),
+  // preserving real-cause surfacing (e.g. "file is not a database").
+  const LOCKED_MSG = 'cc-switch db is locked (cc-switch may be running); retry shortly';
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+  // Keep the BUSY retry and READONLY escalation as independent one-shot budgets. Every open,
+  // PRAGMA and query attempt passes through the same classifier, so a real state transition such
+  // as BUSY (cc-switch was writing) → READONLY (it crashed and left a malformed journal) can use
+  // both recoveries in sequence instead of escaping through a nested retry catch.
+  let useRecoveryConnection = false;
+  let busyRetried = false;
+  while (true) {
+    let db = null;
+    let phase = 'open';
+    try {
+      db = useRecoveryConnection
+        ? new DatabaseSync(dbPath)
+        : new DatabaseSync(dbPath, { readOnly: true });
+      phase = 'query';
+      if (useRecoveryConnection) db.exec('PRAGMA query_only = ON');
+      return readProviders(db);
+    } catch (err) {
+      if (isBusyErr(err)) {
+        if (busyRetried) return { profiles: [], error: LOCKED_MSG };
+        busyRetried = true;
+        await sleep(200);
+        continue;
+      }
+      if (isReadonlyErr(err) && !useRecoveryConnection) {
+        useRecoveryConnection = true;
+        continue;
+      }
+      const prefix = phase === 'open' ? 'cannot open db' : 'query failed';
+      return { profiles: [], error: `${prefix}: ${err && err.message}` };
+    } finally {
+      try { db && db.close(); } catch { /* best effort */ }
+    }
   }
 }
 

package/server/lib/context-rules.js

@@ -27,6 +27,29 @@ export function parseContextSizeSuffix(modelName) {
   return m[2].toLowerCase() === 'm' ? num * 1000000 : num * 1000;
 }
 
+/**
+ * Resolve the model name to use for context-window classification (血条窗口判定专用).
+ *
+ * Precedence differs from getEffectiveModel (response-first) on one deliberate
+ * point: an EXPLICIT [Nk]/[Nm] suffix on the REQUEST model (`body.model`, which
+ * carries the user's hot-switch config / model selector intent) is authoritative
+ * and must NOT be overridden by the upstream response. Upstream APIs normalize
+ * the response `model` — e.g. hot-switching to `k3[1m]` makes Moonshot return
+ * `response.body.model: "k3"`, stripping the [1m] marker; a response-first read
+ * would then misclassify the window (bare k3 vs the configured 1M). So: request
+ * suffix wins; otherwise fall back to the response model, then the request name.
+ *
+ * @param {object|null|undefined} request log entry with body / response
+ * @returns {string|null}
+ */
+export function getCalibrationModel(request) {
+  const reqModel = request?.body?.model;
+  if (typeof reqModel === 'string' && parseContextSizeSuffix(reqModel) != null) return reqModel;
+  const respModel = request?.response?.body?.model;
+  if (typeof respModel === 'string' && respModel) return respModel;
+  return (typeof reqModel === 'string' && reqModel) ? reqModel : null;
+}
+
 // 模型家族 → 窗口档位表(有序,首条命中)。后缀解析在表外先行(见 getModelMaxTokens)。
 const MODEL_CONTEXT_SIZES = [
   // haiku 全系 200K,显式置于一切 1M 默认之前(claude-haiku-4-5 等)
@@ -48,6 +71,10 @@ const MODEL_CONTEXT_SIZES = [
   { match: /gpt-4o|o1|o3|o4/i, tokens: 128000 },
   { match: /gpt-4/i, tokens: 128000 },
   { match: /gpt-3/i, tokens: 16000 },
+  // Kimi 家族精确档:k2.x/k3 等带 kimi/moonshot 前缀的 → 256K;裸 'k3'(无前缀,
+  // 代理直连时的简写 model 名)→ 256K 精确档但 classifyContextWindow 不升 1M
+  // (见该函数的家族特判,裸 k3 归 200K 桶,超量由 adaptContextWindow 纠偏)。
+  { match: /kimi|moonshot|^k3$/i, tokens: 256000 },
   // deepseek-v4 defaults to 1M; placed before generic /deepseek/ so the
   // first-match-wins loop picks it up before falling through to 128K.
   { match: /deepseek-v4/i, tokens: 1000000 },
@@ -74,12 +101,19 @@ export function getModelMaxTokens(modelName) {
  * 不变量:只返回 1000000 或 200000(resolveCalibrationTokens 依赖此不变量)。
  * 裸 '1m' 子串(无方括号,如 deepseek-v3-1m)→ 1M 的宽松规则仅限本分类器,
  * 刻意不进 getModelMaxTokens(后者面向精确档位)。128K/16K 档归入 200K 桶。
+ * Kimi 家族特判:kimi/moonshot 前缀型号(k2.x/k3,真实窗口 256K)归 1M 桶 ——
+ * 避免会话中段从 200K 重标定到 256K/1M 的跳变;代价是相对真实 256K 上限
+ * 长期低估(约 4 倍刻度),可接受。裸 'k3' 同样归 1M:代理热切换到
+ * 'k3[1m]' 时上游会把响应 model 归一化成裸 'k3'(剥掉 [1m] 后缀),
+ * response-first 解析读到裸 'k3' 若归 200K 桶会与请求侧 1M 判定分裂,
+ * 血条分母错成 200K;且裸 'k3' 本就是 k3[1m] 的 1M 形态被剥后缀的产物。
  * @param {string} modelName
  * @returns {1000000|200000}
  */
 export function classifyContextWindow(modelName) {
   if (!modelName || typeof modelName !== 'string') return 200000;
   if (modelName.toLowerCase().includes('1m')) return 1000000;
+  if (/kimi|moonshot|^k3$/i.test(modelName)) return 1000000;
   return getModelMaxTokens(modelName) >= 1000000 ? 1000000 : 200000;
 }
 
@@ -88,7 +122,9 @@ export function classifyContextWindow(modelName) {
  * 一个真正的 200K 模型,其输入上下文(input + cache_creation + cache_read)物理上不可能
  * 超过 200K —— 超了 API 直接拒收。所以一旦真实输入用量越过 200K 还被判成 200K,必然是
  * model 名识别错了(误判),此时自动升到 1M,免得血条卡死在 100%、百分比与真实进度脱节。
- * 仅做 200K→1M 这一个方向的纠偏;其余判定(1M、各家 200K 真值等)一律原样返回。
+ * One-way upgrades only: 200K→1M and 256K→1M (the kimi exact tier used by the
+ * server-side SSE path); every other classification (1M, 128K/16K tiers, true
+ * 200K values) is returned unchanged — 128K is deliberately never promoted.
  * 注意:usedContextTokens 必须是"输入侧"用量(sumUsageInputTokens,不含 output_tokens),
  * 否则大输出会误触发。
  * @param {number} classifiedTokens classifyContextWindow / getModelMaxTokens 的结果
@@ -97,6 +133,7 @@ export function classifyContextWindow(modelName) {
  */
 export function adaptContextWindow(classifiedTokens, usedContextTokens) {
   if (classifiedTokens === 200000 && usedContextTokens > 200000) return 1000000;
+  if (classifiedTokens === 256000 && usedContextTokens > 256000) return 1000000;
   return classifiedTokens;
 }
 

package/server/lib/context-watcher.js

@@ -2,7 +2,7 @@ import { readFileSync, existsSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { getClaudeConfigDir } from '../../findcc.js';
-import { getModelMaxTokens, adaptContextWindow, sumUsageInputTokens, sumUsageContextTokens } from './context-rules.js';
+import { getModelMaxTokens, adaptContextWindow, sumUsageInputTokens, sumUsageContextTokens, getCalibrationModel } from './context-rules.js';
 
 export const CONTEXT_WINDOW_FILE = join(getClaudeConfigDir(), 'context-window.json');
 export const CLAUDE_SETTINGS_FILE = join(getClaudeConfigDir(), 'settings.json');
@@ -43,10 +43,25 @@ export function readModelContextSize() {
 /**
  * Get context size for a given API model name (e.g. 'claude-opus-4-6-20250514').
  * Uses startup cache to avoid re-reading the file.
- * @param {string} apiModelName - model name from req.body.model
+ * Accepts either a bare model-name string (legacy path) or a full log entry.
+ * Entry input resolves the model via getCalibrationModel (context-rules.js):
+ * an explicit [Nk]/[Nm] suffix on the REQUEST model wins (the user's hot-switch
+ * config intent, e.g. k3[1m]); otherwise the upstream response.body.model is
+ * authoritative. The startup cache is request-side static info, stale after a
+ * hot-switch, so entry resolution skips it and goes straight to the family
+ * rules table. String input keeps legacy cache-first behavior unchanged.
+ * @param {string|object} modelOrEntry - model name, or log entry with body/response
  * @returns {number} context window size in tokens
  */
-export function getContextSizeForModel(apiModelName) {
+export function getContextSizeForModel(modelOrEntry) {
+  const isEntry = modelOrEntry !== null && typeof modelOrEntry === 'object';
+  // Entry input: calibration-aware resolution (request [Nk]/[Nm] suffix wins,
+  // else response model). Authoritative over the stale startup cache.
+  if (isEntry) {
+    const model = getCalibrationModel(modelOrEntry);
+    return model ? getModelMaxTokens(model) : (_startupContextSize || 200000);
+  }
+  const apiModelName = modelOrEntry;
   if (!apiModelName) return _startupContextSize || 200000;
   const lower = apiModelName.toLowerCase();
   // Extract base: 'claude-opus-4-6-20250514' → 'opus-4-6'
@@ -56,7 +71,7 @@ export function getContextSizeForModel(apiModelName) {
     return _startupContextSize;
   }
   // 完整档位表见 server/lib/context-rules.js(与前端同源;含 haiku/旧 opus/3-opus 200K、
-  // deepseek-v4 1M、gpt/deepseek 等三方档位,默认 200K)
+  // deepseek-v4 1M、kimi/moonshot 256K、gpt/deepseek 等三方档位,默认 200K)
   return getModelMaxTokens(apiModelName);
 }
 

package/server/lib/log-watcher.js

@@ -156,7 +156,7 @@ export function processWatchedEntry(parsed, ctx) {
     if (cached) sendEventToClients(clients, 'kv_cache_content', cached);
     const usage = parsed.response?.body?.usage;
     if (usage) {
-      const contextSize = getContextSizeForModel(parsed.body?.model);
+      const contextSize = getContextSizeForModel(parsed);
       const cwData = buildContextWindowEvent(usage, contextSize);
       if (cwData) sendEventToClients(clients, 'context_window', cwData);
     }

package/server/lib/proxy-retry.js

@@ -17,6 +17,7 @@
 //   - race/stagger use AbortController; cancelled requests must be released correctly.
 import { resolveProfileModel } from './interceptor-core.js';
 import { readFileSync, existsSync } from 'node:fs';
+import { reportSwallowed } from './error-report.js';
 
 // ── Configuration ─────────────────────────────────────────────────
 
@@ -162,7 +163,11 @@ export function resolveRetryConfig(env = process.env, options = {}) {
         const fileRaw = JSON.parse(readFileSync(_retryConfigPath, 'utf-8'));
         Object.assign(cfg, validateRetryConfig(fileRaw));
       }
-    } catch { /* file missing/corrupt → use env only, don't block */ }
+    } catch (err) {
+      // retry-config.json written by the UI is corrupt/unreadable → fall back to env.
+      // Not fatal, but a silent swallow would hide a config the user believes is active.
+      reportSwallowed('proxyRetry.load-config-file', err);
+    }
   }
 
   return cfg;
@@ -219,7 +224,10 @@ export function isStreamResponse(response) {
   try {
     const ct = response?.headers?.get?.('content-type') || '';
     return typeof ct === 'string' && ct.toLowerCase().includes('text/event-stream');
-  } catch {
+  } catch (err) {
+    // A misbehaving header object would make us misclassify the response, which
+    // changes retry behavior (streaming 200 is never retried). Surface it.
+    reportSwallowed('proxyRetry.is-stream-response', err);
     return false;
   }
 }
@@ -233,7 +241,10 @@ export function extractModel(body) {
     const s = typeof body === 'string' ? body : body.toString('utf-8');
     const obj = JSON.parse(s);
     return typeof obj.model === 'string' ? obj.model : '';
-  } catch {
+  } catch (err) {
+    // Unparseable body → stats detail record loses the model field. Surface it
+    // so a regression in request-body handling isn't hidden behind empty models.
+    reportSwallowed('proxyRetry.extract-model', err);
     return '';
   }
 }
@@ -253,7 +264,11 @@ export function applyModelReplacement(body, profile) {
     if (!target) return body;
     obj.model = target;
     return JSON.stringify(obj);
-  } catch {
+  } catch (err) {
+    // JSON.parse failure means model replacement silently no-ops; the request
+    // still goes out with the original (un-replaced) model. Surface it so the
+    // mismatch between configured replacement and actual body isn't silent.
+    reportSwallowed('proxyRetry.apply-model-replacement', err);
     return body;
   }
 }
@@ -299,13 +314,67 @@ function computeWaitMs(status, retryAfterHeader, cfg) {
 
 // ── Single fetch wrapper ─────────────────────────────────────────
 
+/**
+ * Attaches a streaming-idle watchdog to a streaming response body.
+ *
+ * Why: connectTimeoutMs only bounds time-to-HEADERS; once headers arrive the
+ * connect timer is cleared and the retry loop breaks (streaming 200 is never
+ * retried — retry-before-first-byte strategy). If the upstream then stalls
+ * (200 headers but no body chunk ever arrives — a hung upstream), the piped
+ * response would hang indefinitely, pinning the client socket and the upstream
+ * socket until the client gives up. streamIdleTimeoutMs bounds the max gap
+ * between two chunks; exceeding it errors the body so proxy.js's pipeline
+ * surfaces the stall instead of hanging.
+ *
+ * Implemented as a TransformStream pass-through so response.body stays a valid
+ * ReadableStream (Readable.fromWeb in proxy.js keeps working): each enqueued
+ * chunk resets the timer; a stalled stream fires the timer, which calls
+ * controller.error(), aborting the fetch's underlying body and breaking the
+ * pipeline.
+ *
+ * @param {ReadableStream} body original streaming body
+ * @param {number} idleMs max gap between chunks (0 = disabled)
+ * @param {AbortSignal} signal external signal (race/stagger loser cancel + client disconnect)
+ * @returns {ReadableStream} watched body (same chunks, bounded idle)
+ */
+function applyStreamIdleWatchdog(body, idleMs, signal) {
+  if (!body || typeof body?.pipeThrough !== 'function') return body;
+  if (!idleMs || idleMs <= 0) return body;
+  let timer = null;
+  let aborted = false;
+  const arm = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      aborted = true;
+      controller.error(new Error(`proxy stream idle timeout (${idleMs}ms)`));
+    }, idleMs);
+  };
+  let controller;
+  const transform = new TransformStream({
+    start(ctl) { controller = ctl; arm(); if (signal) signal.addEventListener('abort', disarm, { once: true }); },
+    transform(chunk, ctl) {
+      if (aborted) return; // already errored — drop late chunks
+      ctl.enqueue(chunk);
+      arm(); // reset on each chunk
+    },
+    flush() { disarm(); },
+    cancel() { disarm(); },
+  });
+  function disarm() { if (timer) { clearTimeout(timer); timer = null; } }
+  // teeThrough keeps our transform in the path; pipeThrough returns the readable end.
+  // Only pass signal when present — pipeThrough rejects a null/undefined signal.
+  return signal
+    ? body.pipeThrough(transform, { signal })
+    : body.pipeThrough(transform);
+}
+
 /**
  * Executes a single fetch request with the x-cc-viewer-trace header + network proxy dispatcher.
  * Returns the raw Response. Does not throw (on network errors returns { __networkError: true, status: 0 }).
  *
  * @param {string} url full URL
  * @param {object} fetchOptions method/headers/body
- * @param {object} ctx { dispatcher, connectTimeoutMs, signal }
+ * @param {object} ctx { dispatcher, connectTimeoutMs, streamIdleTimeoutMs, signal }
  */
 async function singleFetch(url, fetchOptions, ctx) {
   const opts = {
@@ -342,10 +411,25 @@ async function singleFetch(url, fetchOptions, ctx) {
 
   try {
     const response = await fetch(url, opts);
+    // Streaming responses: attach the idle watchdog so a hung body (headers in,
+    // no chunks) breaks within streamIdleTimeoutMs instead of pinning sockets.
+    // connectTimeoutMs already cleared below can't help — it only bound headers.
+    if (response?.body && ctx.streamIdleTimeoutMs > 0 && isStreamResponse(response)) {
+      const watched = applyStreamIdleWatchdog(response.body, ctx.streamIdleTimeoutMs, ctx.signal);
+      return new Response(watched, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
     return response;
   } catch (err) {
     // Network error/timeout/cancellation → return a pseudo response; status=0 indicates an error
     const aborted = ctx.signal?.aborted || timeoutCtl?.signal.aborted;
+    // Aborts are expected (race loser cancellation, client disconnect, connect
+    // timeout) — not diagnostic. Only surface genuine network errors so a
+    // failing upstream isn't hidden behind status=0 pseudo-responses.
+    if (err && !aborted) reportSwallowed('proxyRetry.single-fetch', err);
     return {
       __networkError: true,
       __aborted: !!aborted,
@@ -416,7 +500,17 @@ export async function executeRequest({ url, fetchOptions, retryConfig, ctx }) {
   // headers well past 10s — so with retry disabled we must not introduce a new
   // failure mode. The timeout applies only when a retry mode is active.
   const effectiveConnectTimeoutMs = cfg.mode === 'off' ? 0 : cfg.connectTimeoutMs;
-  const commonCtx = { dispatcher, connectTimeoutMs: effectiveConnectTimeoutMs };
+  // streamIdleTimeoutMs is gated to retry modes only (NOT off), mirroring the
+  // connectTimeoutMs off-exclusion above. The watchdog wraps response.body in a
+  // TransformStream, but the interceptor (server/interceptor.js) already
+  // reconstructs response.body via getReader() + a new ReadableStream for
+  // logging/live-streaming; under concurrent load the watchdog's pipeThrough
+  // races that reconstruction and surfaces as a spurious `fetch failed` →
+  // status 0 → 502. off mode is the legacy pass-through path (no retry), so the
+  // watchdog's value (bound idle on a hung stream) is marginal here and the
+  // interceptor already observes the stream — serial/race/stagger keep the guard.
+  const effectiveStreamIdleMs = cfg.mode === 'off' ? 0 : (cfg.streamIdleTimeoutMs > 0 ? cfg.streamIdleTimeoutMs : 0);
+  const commonCtx = { dispatcher, connectTimeoutMs: effectiveConnectTimeoutMs, streamIdleTimeoutMs: effectiveStreamIdleMs };
 
   if (cfg.mode === 'off' || cfg.mode === 'serial') {
     // off / serial: serial retry. off = no retry (break on any status); serial = controlled by maxRetries (0=infinite, capped by deadline)

package/server/lib/stats-worker.js

@@ -177,11 +177,16 @@ function generateProjectStats(projectDir, projectName, onlyFile) {
   // Proxy retry shards (proxy_YYYY-MM-DD.jsonl) live at the project top level
   // and can exist without any v2 session (proxy-only usage) — only bail out
   // when BOTH are absent so aggregateProxyStats still runs for proxy-only dirs.
-  let proxyFiles = [];
+  // Existence-only check: the full sorted file list is read once inside
+  // aggregateProxyStats (called below), so here we just need to know whether
+  // ANY proxy shard exists — short-circuit avoids a redundant full readdir+filter.
+  let hasProxyFiles = false;
   try {
-    proxyFiles = readdirSync(projectDir).filter(f => f.startsWith('proxy_') && f.endsWith('.jsonl'));
+    for (const f of readdirSync(projectDir)) {
+      if (f.startsWith('proxy_') && f.endsWith('.jsonl')) { hasProxyFiles = true; break; }
+    }
   } catch { /* unreadable project dir → nothing to aggregate from it either */ }
-  if (sessionIds.length === 0 && proxyFiles.length === 0) return;
+  if (sessionIds.length === 0 && !hasProxyFiles) return;
 
   const filesStats = {};
   const topModels = {};
@@ -249,7 +254,7 @@ function generateProjectStats(projectDir, projectName, onlyFile) {
 
   // No parsable session yet (dirs without journals) — keep whatever exists,
   // unless proxy shards are present (they alone justify a stats write).
-  if (Object.keys(filesStats).length === 0 && proxyFiles.length === 0) return;
+  if (Object.keys(filesStats).length === 0 && !hasProxyFiles) return;
 
   // 计算全局汇总
   let totalRequests = 0;

package/server/lib/v2/migrate-prompt.js

@@ -12,6 +12,9 @@ import { listV1Files, listConvertibleProjects, readConvertState } from './conver
 /** Pending v1 files + bytes of ONE project dir. */
 function pendingOf(projectDir) {
   const state = readConvertState(projectDir);
+  // Migration already completed — don't re-prompt, even if v1 files grew
+  // (dual-write captures new entries in v2).
+  if (state && state.status === 'done') return { files: 0, totalBytes: 0 };
   const doneAtSize = new Map(
     (state && Array.isArray(state.files) ? state.files : [])
       .filter((f) => f && f.done)

package/server/routes/events.js

@@ -320,7 +320,7 @@ async function events(req, res, parsedUrl, isLocal, deps) {
       if (!latestContextWindow) {
         const usage = entry.response?.body?.usage;
         if (usage) {
-          const contextSize = getContextSizeForModel(entry.body?.model);
+          const contextSize = getContextSizeForModel(entry);
           const cw = buildContextWindowEvent(usage, contextSize);
           if (cw) latestContextWindow = cw;
         }

package/src/utils/effectiveModel.js

@@ -7,6 +7,10 @@
  * server-reported model in `response.body.model` (authoritative under proxy
  * hot-switch) over the client-supplied `body.model`. Returns null when both
  * are missing — callers should fall back to a sensible default.
+ *
+ * KEEP IN SYNC: server/lib/context-watcher.js getContextSizeForModel reuses
+ * this precedence for its entry path — changing the priority here must be
+ * mirrored there (and vice versa).
  */
 export function getEffectiveModel(request) {
   return request?.response?.body?.model || request?.body?.model || null;

package/src/utils/helpers.js

@@ -20,8 +20,9 @@ export {
   sumCacheCreationTokens,
   sumUsageInputTokens,
   sumUsageContextTokens,
+  getCalibrationModel,
 } from '../../server/lib/context-rules.js';
-import { classifyContextWindow, adaptContextWindow } from '../../server/lib/context-rules.js';
+import { classifyContextWindow, adaptContextWindow, getCalibrationModel } from '../../server/lib/context-rules.js';
 
 // getEffectiveModel moved to ./effectiveModel.js (pure, node-testable — sessionMerge/sessionManager
 // import it without helpers' Vite-only svg imports); re-exported here to keep import paths stable.
@@ -57,7 +58,9 @@ const CALIBRATION_TOKEN_MAP = {
 export function resolveCalibrationTokens(calibrationModel, lastMainAgent, projectModelHint = null) {
   const direct = CALIBRATION_TOKEN_MAP[calibrationModel];
   if (direct) return direct;
-  const lastModel = lastMainAgent ? getEffectiveModel(lastMainAgent) : null;
+  // 校准用 getCalibrationModel:请求名带显式 [Nk]/[Nm] 后缀时优先(用户热切换配置的
+  // 1M 意图),不被上游响应归一化(如 k3[1m]→裸 k3)覆盖;其余回退 response-first。
+  const lastModel = lastMainAgent ? getCalibrationModel(lastMainAgent) : null;
   // 优先用真实 mainAgent 信号；haiku 一律视为 init ping 噪声，跳过
   if (typeof lastModel === 'string' && lastModel && !/haiku/i.test(lastModel)) {
     return classifyContextWindow(lastModel);
@@ -334,7 +337,7 @@ const MODEL_PROVIDERS = [
     match: /kimi|moonshot|^k3$/i,
     name: 'Kimi',
     color: 'var(--bg-model-avatar)',
-    svg: '<svg t="1771495664798" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="6649" width="200" height="200"><path d="M731.062857 590.262857v318.317714h-148.589714V443.977143a146.285714 146.285714 0 0 1-146.285714 146.285714l-214.491429-0.036571v318.354285H73.142857V165.814857h148.553143v275.858286h180.882286l119.771428-275.858286h167.753143l-67.84 156.269714a255.524571 255.524571 0 0 1-106.678857 119.588572h66.925714a148.553143 148.553143 0 0 1 148.516572 148.589714z m120.758857-473.965714a99.035429 99.035429 0 0 1 0 198.070857h-99.035428V215.332571a99.035429 99.035429 0 0 1 99.035428-99.035428z" fill="currentColor" p-id="6650"></path></svg>',
+    svg: '<svg class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" width="200" height="200"><path d="M932.096 0a82.048 82.048 0 1 1 0 164.096h-72.352a9.568 9.568 0 0 1-9.664-9.632V82.016A82.048 82.048 0 0 1 932.096 0z" fill="#1783FF"></path><path d="M472.064 477.856l309.76-307.2c5.888-5.792 2.56-17.472-4.96-17.472h-166.72a7.008 7.008 0 0 0-5.056 2.112L271.456 486.24c-5.12 5.12-12.8 0.576-12.8-7.68V162.976c0-5.376-3.584-9.792-7.936-9.792H135.936c-4.352 0-7.936 4.416-7.936 9.792V843.52c0 5.44 3.584 9.824 7.936 9.824h114.784c4.352 0 7.936-4.288 7.936-9.824v-138.656c0-2.912 1.024-5.728 2.88-7.616l103.424-102.656a6.72 6.72 0 0 1 8.8-0.928l276.64 203.616a328.64 328.64 0 0 0 147.296 54.688c4.608 0.512 8.544-4 8.544-9.824V711.68c0-4.96-2.912-9.056-7.008-9.632a214.528 214.528 0 0 1-86.432-34.496l-239.456-173.472c-5.024-3.328-5.632-11.936-1.184-16.224h-0.096z" fill="currentColor"></path></svg>',
   },
   {
     match: /glm|chatglm/i,