cc-viewer 1.6.302 → 1.6.303

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="/assets/index-DSz9bNGm.js"></script>
+  <script type="module" crossorigin src="/assets/index-BmKQfyia.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-Bur5ZxWE.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-Si44UqBp.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-Cco3AQJS.js">

package/findcc.js

@@ -201,6 +201,20 @@ export function resolveNpmClaudePath() {
   return null;
 }
 
+/**
+ * 从 which/where 的原始输出中挑出能直接 CreateProcess/exec 的候选行。
+ * Windows 的 `where` 会列出 PATH 中全部同名匹配——npm 全局安装时第一行往往是给
+ * git-bash 用的**无扩展名 sh shim**（#!/bin/sh 文本文件），其后是 .cmd/.ps1，都不是
+ * PE：node-pty/ConPTY 直接 spawn 会抛 "Cannot create process, error code: 193"
+ * (ERROR_BAD_EXE_FORMAT)。win32 只接受 .exe 行；POSIX 取第一行。
+ * 导出供单测；生产代码经 resolveNativePath 调用。
+ */
+export function pickSpawnableLookupResult(rawOut, platform = process.platform) {
+  const lines = String(rawOut || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  if (platform === 'win32') return lines.find((l) => l.toLowerCase().endsWith('.exe')) || null;
+  return lines[0] || null;
+}
+
 export function resolveNativePath() {
   const globalRoot = getGlobalNodeModulesDir();
 
@@ -220,7 +234,8 @@ export function resolveNativePath() {
   for (const cmd of lookupCmds) {
     try {
       const rawOut = execSync(cmd, { encoding: 'utf-8', shell: true, env: process.env, windowsHide: true });
-      const result = rawOut.split(/\r?\n/)[0].trim();
+      // win32 过滤掉 sh shim / .cmd / .ps1，只取 .exe（否则 ConPTY spawn 报 error 193）
+      const result = pickSpawnableLookupResult(rawOut);
       if (result && existsSync(result)) {
         // 只排除 .js 文件（老版本 npm 分发的 cli.js，需要 node 运行，
         // 由 resolveNpmClaudePath 处理）。Claude Code 2.x+ 的 npm 包内
@@ -249,6 +264,11 @@ export function resolveNativePath() {
     if (existsSync(p)) {
       return p;
     }
+    // Windows 原生安装器（install.ps1）落的是 claude.exe（如 ~/.local/bin/claude.exe），
+    // 无扩展名候选在 win32 上永远 miss，这里补查 .exe 变体。
+    if (process.platform === 'win32' && existsSync(p + '.exe')) {
+      return p + '.exe';
+    }
   }
 
   // 4. 兜底：wrapper 包的 bin/claude(.exe)（可能是 postinstall 后的真实二进制，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.302",
+  "version": "1.6.303",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",

package/server/lib/pty-flood-coalescer.js

@@ -7,9 +7,14 @@
  * （bufferedAmount > 1MB）介入，快 LAN 上洪泛字节全量到达前端，xterm 逐帧解析渲染
  * 稠密 SGR+CJK 重绘把主线程打满。本器在发送侧限流：
  *
- *   - 直通态：chunk 立即 send（零延迟，不起 timer）。字节率按固定 flushMs 桶统计，
- *     当前桶累计超 floodThresholdBytesPerWin → 进入限流态。打字回显 / 正常 token
- *     流远低于阈值（≈256KB/s），不受影响。
+ *   - 直通态：leading-edge 微合并——空窗期首 chunk 立即 send（回显零延迟）并开
+ *     ptCoalesceMs（默认 16ms）窗，同窗后续 chunk 并入 ptBuffer、到点合为一条 send
+ *     （上限 2 条/窗 = 1000ms÷16ms×2 ≈125 msg/s）。低于洪泛阈值的持续小 chunk 流（/plugins 菜单导航
+ *     等 ConPTY 重绘）每 chunk 单发会打出数百条 ws 消息/秒，客户端逐条 MessageEvent
+ *     分发 + JSON.parse + xterm 主线程解析，**消息数风暴**即可锁死页面——字节率
+ *     限流（下方限流态）封不住这个维度。字节率仍按固定 flushMs 桶统计，
+ *     当前桶累计超 floodThresholdBytesPerWin → 进入限流态（ptBuffer 按序折入 pending）。
+ *     打字回显 / 正常 token 流是稀疏 chunk，每条都走 leading 立即发，不受影响。
  *   - 限流态：chunk 剥掉自带的 DEC 2026 标记后追加进 pending（pending 内部因此
  *     **绝无 2026 标记**，截断永不切坏配对）；每 flushMs 把 pending 用单对
  *     SYNC_BEGIN/END 重新包裹成**一条** send 发出并清空（无论下游是否跳发，
@@ -37,10 +42,23 @@ const SYNC_END = '\x1b[?2026l';
 const SYNC_MARKS_RE = /\x1b\[\?2026[hl]/g;
 
 // 默认常量可经 CCV_FLOOD_* 环境变量覆盖（仿 CCV_FORCE_POLL 先例），便于 Windows
-// 实机排障时调参而不改源码。非法/非正整数值回落默认。
-function envInt(name, fallback) {
-  const v = parseInt(process.env[name], 10);
-  return Number.isFinite(v) && v > 0 ? v : fallback;
+// 实机排障时调参而不改源码。严格十进制白名单：parseInt 遇非数字字符即截停——
+// '1e9' 解析成 1、'0x10' 解析成 0，静默生效远比回落默认值危险，非纯数字一律回落。
+// 位数上限 15（< Number.MAX_SAFE_INTEGER）：超长数字串 parseInt 溢出为 Infinity 会
+// 穿透 v>0 判断，setTimeout(fn, Infinity) 被 Node 钳到 1ms——33ms 桶宽静默变 1ms。
+// 导出供 server.js 等复用（knob 解析逻辑收敛在此，不再各处内联）。
+export function envInt(name, fallback) {
+  const s = (process.env[name] ?? '').trim();
+  if (!/^\d{1,15}$/.test(s)) return fallback;
+  const v = parseInt(s, 10);
+  return v > 0 ? v : fallback;
+}
+
+// 同 envInt 但接受 0（0 = 关闭该功能的逃生口，envInt 的 v>0 会把 0 误回落默认值）。
+export function envIntAllowZero(name, fallback) {
+  const s = (process.env[name] ?? '').trim();
+  if (!/^\d{1,15}$/.test(s)) return fallback;
+  return parseInt(s, 10);
 }
 
 const DEFAULT_FLUSH_MS = envInt('CCV_FLOOD_FLUSH_MS', 33);                       // 限流态合并窗口 = 字节率统计桶宽
@@ -50,6 +68,12 @@ const DEFAULT_PENDING_CAP = envInt('CCV_FLOOD_PENDING_CAP', 256 * 1024);
 const DEFAULT_TRIM_TO = envInt('CCV_FLOOD_TRIM_TO', 128 * 1024);                 // pendingCap 截断后保留的尾部量
 // 单次 flush 发送预算 = 真速率上限：64KB / 33ms ≈ 1.9MB/s，与前端 32KB/帧消化速率同量级
 const DEFAULT_FLUSH_BUDGET = envInt('CCV_FLOOD_FLUSH_BUDGET', 64 * 1024);
+// 直通态微合并窗口：低于洪泛阈值的持续小 chunk 流（如 /plugins 菜单导航的 ConPTY 重绘）
+// 每 chunk 单发会打出每秒数百条 ws 消息——客户端每条都付 MessageEvent 分发 + JSON.parse +
+// xterm 主线程同步解析，**消息数风暴**（非字节率）即可锁死页面（xterm.js#3368）。
+// leading-edge 立即发（回显零延迟）+ 同窗后续合并 trailing 一条
+// → 上限 2 条/窗 ≈125 msg/s（1000ms ÷ 16ms × 2 条）。0 = 禁用。
+const DEFAULT_PT_COALESCE_MS = envIntAllowZero('CCV_FLOOD_PT_COALESCE_MS', 16);
 
 /**
  * @param {object} opts
@@ -63,6 +87,7 @@ const DEFAULT_FLUSH_BUDGET = envInt('CCV_FLOOD_FLUSH_BUDGET', 64 * 1024);
  * @param {number} [opts.pendingCap]
  * @param {number} [opts.trimTo]
  * @param {number} [opts.flushBudgetBytes]
+ * @param {number} [opts.ptCoalesceMs] - 直通态微合并窗口（0 = 禁用，每 chunk 单发）
  * @param {(fn: Function, ms: number) => any} [opts.setTimer] - 测试注入
  * @param {(t: any) => void} [opts.clearTimer] - 测试注入
  * @returns {{ offer: (chunk: string) => void, reset: () => void, dispose: () => void, isFlooding: () => boolean }}
@@ -78,6 +103,7 @@ export function createFloodCoalescer({
   pendingCap = DEFAULT_PENDING_CAP,
   trimTo = DEFAULT_TRIM_TO,
   flushBudgetBytes = DEFAULT_FLUSH_BUDGET,
+  ptCoalesceMs = DEFAULT_PT_COALESCE_MS,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
 }) {
@@ -86,6 +112,8 @@ export function createFloodCoalescer({
   let winBytes = 0;       // 当前桶累计字节（直通态由 offer 累计，限流态由 flush 结算）
   let calmWins = 0;       // 连续低于阈值的桶数
   let flushTimer = null;  // 限流态周期 flush；直通态下亦作为桶边界 timer（见 offer）
+  let ptBuffer = '';      // 直通态微合并缓冲（窗口开启期间到达的后续 chunk）
+  let ptTimer = null;     // 直通态微合并窗口 timer（16ms），与 flushTimer（33ms 字节桶）并存、职责正交
   let disposed = false;
 
   const stopTimer = () => {
@@ -95,6 +123,24 @@ export function createFloodCoalescer({
     }
   };
 
+  const stopPtTimer = () => {
+    if (ptTimer) {
+      clearTimer(ptTimer);
+      ptTimer = null;
+    }
+  };
+
+  // 微合并窗口到点：缓冲非空则一条发出，窗口关闭（不自动续约——下一 chunk 重新 leading 立即发）。
+  // ptBuffer 不剥 SYNC 标记：terminal 路径每 chunk 经 pty-manager flushBatch 已自配平（拼接守恒），
+  // scratch 路径 chunk 本就无标记（拼接平凡守恒）；只有洪泛路径（有截断）才需要剥。
+  const onPtFlush = () => {
+    ptTimer = null;
+    if (disposed || flooding || !ptBuffer) return;
+    const out = ptBuffer;
+    ptBuffer = '';
+    try { send(out); } catch { }
+  };
+
   // 直通态的桶边界：到点清零计数。无流量时 timer 不存在，零常驻开销。
   const armPassthroughWindow = () => {
     if (flushTimer) return;
@@ -143,21 +189,35 @@ export function createFloodCoalescer({
     /** 每条 PTY chunk 调用。直通态立即 send；限流态进 pending 等周期 flush。 */
     offer(chunk) {
       if (disposed || !chunk) return;
-      winBytes += chunk.length;
+      winBytes += chunk.length;   // 缓冲与直发都全量计账：微合并不致盲洪泛判定
       if (!flooding) {
         if (winBytes > floodThresholdBytesPerWin) {
-          // 进入限流态：当前 chunk 是压垮桶的那条，一并纳入 pending（含它之前
-          // 本桶已直通的部分不回收——它们已发出，量级在阈值内）。
+          // 进入限流态：当前 chunk 是压垮桶的那条，连同微合并缓冲中未发的旧 chunk
+          // 按序一并纳入 pending（已 leading 发出的部分不回收——量级在阈值内）。
+          // 注意 stopTimer 只清 flushTimer，ptTimer 须显式清，否则残留窗口会在洪泛
+          // 期间触发 onPtFlush（虽有 flooding 守卫兜底，仍以显式清为准）。
           flooding = true;
           calmWins = 0;
           stopTimer();
-          pending = chunk.replace(SYNC_MARKS_RE, '');
+          stopPtTimer();
+          pending = (ptBuffer + chunk).replace(SYNC_MARKS_RE, '');
+          ptBuffer = '';
           flushTimer = setTimer(onFloodTick, flushMs);
           flushTimer.unref?.();
           try { onFloodStart?.(winBytes); } catch { }
           return;
         }
         armPassthroughWindow();
+        if (ptCoalesceMs > 0) {
+          // 微合并：窗口开启（ptTimer 在跑）→ 追加缓冲不发；窗口关闭 → leading 立即发
+          // （单次回显零延迟）并开窗。上限 2 条/窗（leading + trailing flush）。
+          if (ptTimer) {
+            ptBuffer += chunk;
+            return;
+          }
+          ptTimer = setTimer(onPtFlush, ptCoalesceMs);
+          ptTimer.unref?.();
+        }
         try { send(chunk); } catch { }
         return;
       }
@@ -170,10 +230,12 @@ export function createFloodCoalescer({
         pending = pending.slice(safeStart);
       }
     },
-    /** bpGate onBehind/onResume 时调用：resync 快照是唯一真相源，清掉旧 pending 防回灌。 */
+    /** bpGate onBehind/onResume 时调用：resync 快照是唯一真相源，清掉旧 pending/ptBuffer 防回灌。 */
     reset() {
       stopTimer();
+      stopPtTimer();
       pending = '';
+      ptBuffer = '';
       winBytes = 0;
       calmWins = 0;
       flooding = false;
@@ -185,7 +247,9 @@ export function createFloodCoalescer({
     dispose() {
       disposed = true;
       stopTimer();
+      stopPtTimer();
       pending = '';
+      ptBuffer = '';
     },
   };
 }

package/server/lib/resync-nudge-gate.js

@@ -0,0 +1,33 @@
+/**
+ * resync 重绘 nudge 冷却门（防 behind→resume 死循环的退避器）。
+ *
+ * 背景：ws-backpressure onResume 在发 data-resync 快照后会做一次重绘 nudge
+ * （POSIX SIGWINCH / Windows resize 抖动），让 claude TUI 全屏重绘以免画面停在
+ * 快照静止态。但 nudge 本身让 ConPTY 再吐 1~2 次全屏重绘 = 新洪泛燃料：客户端
+ * 仍慢 → bufferedAmount 再越线 → behind → resume → 再 nudge → 死循环，客户端
+ * 每轮 terminal.reset + 重放快照，表现为永久冻结。
+ *
+ * 语义：快照每次 resume 仍无条件发（修复 behind 期间被跳发的数据，不能省）；
+ * 只有 nudge 走冷却——紧循环中 PTY 输出仍在流动，"画面停在快照"的风险不存在，
+ * 该风险只在 resume 稀疏时成立，而稀疏 resume 必然过冷却期、照常 nudge。
+ *
+ * 纯逻辑、时钟可注入（now），便于单测。仿 pty-flood-coalescer.js 惯例。
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.cooldownMs=3000] - 两次 nudge 最小间隔；0 = 不冷却（恒放行，逃生口）
+ * @param {() => number} [opts.now=Date.now] - 测试注入
+ * @returns {{ shouldNudge: () => boolean }}
+ */
+export function createResyncNudgeGate({ cooldownMs = 3000, now = Date.now } = {}) {
+  let lastNudgeAt = -Infinity;   // 首次必放行
+  return {
+    /** resume 时调用：放行则记账并返回 true，冷却期内返回 false（调用方跳过 nudge）。 */
+    shouldNudge() {
+      if (cooldownMs <= 0) return true;
+      const t = now();
+      if (t - lastNudgeAt < cooldownMs) return false;
+      lastNudgeAt = t;
+      return true;
+    },
+  };
+}

package/server/routes/files-content.js

@@ -7,6 +7,21 @@ import { discoverClaudeMdCandidates, readCandidateById } from '../lib/claude-md-
 import { getClaudeConfigDir } from '../../findcc.js';
 import { _projectName } from '../interceptor.js';
 
+// file-raw 扩展名 → MIME 映射。图片走 <img> 预览;html 走 iframe 预览(带下方 CSP sandbox);
+// 其余为 HTML 预览的同目录子资源(c8/nyc/lcov-genhtml 等静态报告):CSP sandbox 使文档
+// 处于 opaque origin,对一切子资源都是跨源——跨源样式表受浏览器严格 MIME 校验,
+// octet-stream 的 CSS 会被直接拒用(报告渲染成裸 HTML)。js 虽为 classic script 不受
+// MIME 门禁,配正确类型属卫生项 + 为未来 nosniff 铺路。
+// 注意:值不带 charset 后缀——fileRaw 内 CSP 判等依赖 mime === 'text/html'。
+const FILE_RAW_MIME = {
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif', '.svg': 'image/svg+xml', '.ico': 'image/x-icon',
+  '.webp': 'image/webp', '.html': 'text/html', '.htm': 'text/html',
+  '.css': 'text/css', '.js': 'text/javascript', '.mjs': 'text/javascript',
+  '.json': 'application/json', '.map': 'application/json', '.txt': 'text/plain',
+  '.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf',
+};
+
 function planFile(req, res, parsedUrl) {
   try {
     const raw = parsedUrl.searchParams.get('path') || '';
@@ -290,13 +305,8 @@ function fileRaw(req, res, parsedUrl) {
       res.end(JSON.stringify({ error: 'File too large' }));
       return;
     }
-    const extMime = {
-      '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-      '.gif': 'image/gif', '.svg': 'image/svg+xml', '.ico': 'image/x-icon',
-      '.webp': 'image/webp', '.html': 'text/html', '.htm': 'text/html',
-    };
     const ext = (targetFile.match(/\.[^.]+$/) || [''])[0].toLowerCase();
-    const mime = extMime[ext] || 'application/octet-stream';
+    const mime = FILE_RAW_MIME[ext] || 'application/octet-stream';
     const data = method === 'HEAD' ? null : readFileSync(targetFile);
     const size = method === 'HEAD' ? stat.size : data.length;
     const headers = { 'Content-Type': mime, 'Content-Length': size };

package/server/server.js

@@ -81,7 +81,8 @@ import { backupConfigs } from './lib/config-backup.js';
 import { normalizeBasePath, validateBasePath, stripBasePath } from './lib/base-path.js';
 import { createHardenedCleanup } from './lib/term-signals.js';
 import { createBackpressureGate } from './lib/ws-backpressure.js';
-import { createFloodCoalescer } from './lib/pty-flood-coalescer.js';
+import { createFloodCoalescer, envIntAllowZero } from './lib/pty-flood-coalescer.js';
+import { createResyncNudgeGate } from './lib/resync-nudge-gate.js';
 
 
 // 动态获取 getPrefsFile()（LOG_DIR 可能在运行时被 setLogDir 修改）
@@ -1121,20 +1122,30 @@ async function setupTerminalWebSocket(httpServer) {
 
     // 反压状态转换日志（observability：线上排"页面卡"时可直接判断是否触发过反压、几次、积压量）。
     // behind/resume 在持续洪泛下以亚秒级周期振荡，5s 节流防刷屏；timeout 是终态必记。
+    // resyncTotal/nudgeSkipped 判别 resync 循环：resync 涨 + skipped 同涨 = nudge 冷却在救；
+    // resync 涨 + skipped≈0 = resume 间隔超过冷却期的慢振荡，需更激进策略（如洪泛期禁 nudge）。
     const makeBpLogger = (label, ws) => {
       let behindCount = 0;
+      let resyncCount = 0;
+      let nudgeSkipped = 0;
       let lastLogAt = 0;
       return (event, buffered) => {
         if (event === 'behind') behindCount++;
+        if (event === 'resume') resyncCount++;
+        if (event === 'nudge-skip') { nudgeSkipped++; return; }   // 只计数，随下一条节流日志带出
         const now = Date.now();
         if (event !== 'timeout' && now - lastLogAt < 5000) return;
         lastLogAt = now;
-        console.warn(`[${label}] ws backpressure ${event}: client=${ws._socket?.remoteAddress || '?'} bufferedAmount=${buffered} behindTotal=${behindCount}`);
+        console.warn(`[${label}] ws backpressure ${event}: client=${ws._socket?.remoteAddress || '?'} bufferedAmount=${buffered} behindTotal=${behindCount} resyncTotal=${resyncCount} nudgeSkipped=${nudgeSkipped}`);
       };
     };
 
+    // resync nudge 冷却（CCV_RESYNC_NUDGE_COOLDOWN_MS，0 = 不冷却；详见 lib/resync-nudge-gate.js）
+    const RESYNC_NUDGE_COOLDOWN_MS = envIntAllowZero('CCV_RESYNC_NUDGE_COOLDOWN_MS', 3000);
+
     // 洪泛限流器状态日志（与 makeBpLogger 同款 5s 节流，独立实例不共享计数）。
     // Windows 实机排"切主题/大流量卡死"时据此确认 ConPTY 洪泛是否触发、几次、量级。
+    // 'rate' 事件 = 直通态 ws 消息率告警（msgsPerSec，计数在 send 闭包），判别消息数风暴。
     const makeFloodLogger = (label, ws) => {
       let floodCount = 0;
       let lastLogAt = 0;
@@ -1143,7 +1154,23 @@ async function setupTerminalWebSocket(httpServer) {
         const now = Date.now();
         if (now - lastLogAt < 5000) return;
         lastLogAt = now;
-        console.warn(`[${label}] pty flood ${event}: client=${ws._socket?.remoteAddress || '?'} winBytes=${bytes} floodTotal=${floodCount}`);
+        const metric = event === 'rate' ? 'msgsPerSec' : 'winBytes';
+        console.warn(`[${label}] pty flood ${event}: client=${ws._socket?.remoteAddress || '?'} ${metric}=${bytes} floodTotal=${floodCount}`);
+      };
+    };
+
+    // 直通态消息率计数器工厂：1s 整数桶，桶滚动时超过阈值经 floodLog('rate') 告警（5s 节流兜底）。
+    const makeMsgRateCounter = (floodLog, warnAbove = 60) => {
+      let count = 0;
+      let winStart = 0;
+      return () => {
+        const now = Date.now();
+        if (now - winStart >= 1000) {
+          if (count > warnAbove) floodLog('rate', count);
+          count = 0;
+          winStart = now;
+        }
+        count++;
       };
     };
 
@@ -1196,10 +1223,12 @@ async function setupTerminalWebSocket(httpServer) {
       // 洪泛限流器：字节率超阈值时按窗口合并 + last-wins 截断（ConPTY 全屏重绘洪泛防卡死，
       // 与 bpGate 互补——bpGate 管慢网络写缓冲，floodGate 管快 LAN 字节率，详见 lib/pty-flood-coalescer.js）
       const _floodLog = makeFloodLogger('scratch-ws', ws);
+      const _countMsg = makeMsgRateCounter(_floodLog);
       floodGate = createFloodCoalescer({
         send: (data) => {
           if (ws.readyState === 1 && bpGate.offer()) {
             try { ws.send(JSON.stringify({ type: 'data', data })); } catch {}
+            _countMsg();
           }
         },
         findSafeSliceStart,
@@ -1293,6 +1322,10 @@ async function setupTerminalWebSocket(httpServer) {
       // floodGate 前向引用（构造顺序同 scratch 路径）：onBehind/onResume 必清 coalescer
       // pending——resync 快照是唯一真相源，旧 pending 回灌会导致画面回退。
       let floodGate = null;
+      // nudge 冷却门：快照每次 resume 无条件发（修复 behind 期间跳发的数据），但重绘 nudge
+      // 走冷却——nudge 让 ConPTY 再吐全屏重绘 = 新洪泛燃料，紧 behind→resume 循环里反复
+      // nudge 会自我维持（客户端每轮 reset+重放快照 = 永久冻结表象）。详见 lib/resync-nudge-gate.js。
+      const nudgeGate = createResyncNudgeGate({ cooldownMs: RESYNC_NUDGE_COOLDOWN_MS });
       const bpGate = createBackpressureGate({
         getBufferedAmount: () => ws.bufferedAmount,
         onBehind: (buffered) => {
@@ -1304,6 +1337,7 @@ async function setupTerminalWebSocket(httpServer) {
           floodGate?.reset();
           if (ws.readyState !== 1) return;
           try { ws.send(JSON.stringify({ type: 'data-resync', data: getOutputBuffer() })); } catch {}
+          if (!nudgeGate.shouldNudge()) { _bpLog('nudge-skip', buffered); return; }
           try {
             if (process.platform !== 'win32') {
               // POSIX：与下方 _needRedrawBootstrap 同款 SIGWINCH 兜底
@@ -1333,10 +1367,12 @@ async function setupTerminalWebSocket(httpServer) {
       // 洪泛限流器：字节率超阈值时按窗口合并 + last-wins 截断（ConPTY 全屏重绘洪泛防卡死，
       // 与 bpGate 互补——bpGate 管慢网络写缓冲，floodGate 管快 LAN 字节率，详见 lib/pty-flood-coalescer.js）
       const _floodLog = makeFloodLogger('terminal-ws', ws);
+      const _countMsg = makeMsgRateCounter(_floodLog);
       floodGate = createFloodCoalescer({
         send: (data) => {
           if (ws.readyState === 1 && bpGate.offer()) {
             try { ws.send(JSON.stringify({ type: 'data', data })); } catch {}
+            _countMsg();
           }
         },
         findSafeSliceStart,