cc-viewer 1.6.311 → 1.6.313

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-DqUPEFNT.js"></script>
+  <script type="module" crossorigin src="/assets/index-ByBJZi-l.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/package.json

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

package/server/lib/ansi-safe-slice.js

@@ -0,0 +1,131 @@
+/**
+ * ANSI 转义序列安全边界工具（纯函数、零依赖，乱码残片不变量的语义基准）。
+ * 两个导出：
+ *   findSafeSliceStart(buf, rawStart)  —— 缓冲区"掐头"裁剪的安全起点（锚点扫描）
+ *   splitTrailingIncomplete(buf)       —— 批边界"截尾"缓带：[安全前段, 半截序列尾巴]
+ * 共同保证：xterm 收到的字节流中，任何删除/分批的续点都是合法解析起点，
+ * 半截序列永不以字面渲染。端到端验证见 test/terminal-pipeline-oracle.test.js。
+ */
+
+/**
+ * findSafeSliceStart：在输出缓冲区从头部截断时，找到安全的截断起点，
+ * 避免切片落在 ANSI 转义序列中间——丢掉 ESC[ 前缀后剩余字节
+ * 会被 xterm.js 当普通文本渲染（表现为 `[9m`、`?2026l`、`6;136;136m` 类乱码）。
+ *
+ * 算法：从 rawStart 向后扫描，锚到下一个无歧义的解析重启点：
+ * - 硬锚点 ESC (0x1b)：从 ESC 起始永远是合法序列起点（CSI/SGR/OSC/DCS 通吃）；
+ *   最坏情况锚到 OSC 终止符 ST（ESC \）自身，ground state 下是无害 no-op。
+ * - 软锚点 LF (0x0a)：仅当窗口内无 ESC 时使用（纯文本流如 shell 日志），
+ *   返回 LF 之后的位置。不与 ESC 平级是因为 OSC payload 理论上可含 LF。
+ * - 都没有且窗口未覆盖尾部：返回 scanLimit（多丢 ≤scanWindow 字节，发生在
+ *   滚动缓冲头部，可忽略）。
+ * - 都没有且窗口覆盖尾部：回看一小窗判断 rawStart 是否落在某 CSI/OSC 内部
+ *   （前方无 ESC/LF 意味着该序列的终止符只能在 rawStart 之后）——是则前跳到
+ *   终止符之后，否则返回 rawStart——绝不清空保留数据（洪泛限流的 last-wins
+ *   语义依赖这一点）。fallback 起点若落在 UTF-16 低代理上则 +1，避免孤儿化
+ *   代理对（高代理起点配对仍完整，无需处理）。
+ *
+ * 注意：只保 ANSI 序列边界，不保 DEC 2026 同步标记的配对——头部截断只可能
+ * 孤儿化 END（?2026l，xterm 下无害 no-op），不可能产生无 END 的 BEGIN；
+ * 跨 2026 块截断的配平由调用方负责（见 pty-flood-coalescer.js 的标记剥离）。
+ */
+// 前向锚点扫描窗：TUI 流 ESC 密集（几十字节内必中锚点），上限只在纯文本流生效——
+// 多丢 ≤4KB 且发生在 ≥45KB 保留尾部的头部，不可感知。
+const DEFAULT_SCAN_WINDOW = 4096;
+// 回看判定窗：CSI 实际长度有界（最长常见真彩 SGR ≈20 字节），64 足以覆盖
+// "rawStart 是否落在某序列内部"的判定；OSC 超长场景由前向 ESC 锚兜住。
+const BACK_SCAN = 64;
+// 缓带上限：正常序列远小于此；超限视为畸形流（永不终结的 OSC/DCS），
+// 放弃缓带按原样发出，防半截尾巴无界滞留内存/延迟。
+const DEFAULT_MAX_CARRY = 4096;
+
+/**
+ * 把 buf 切成 [可安全发出的前段, 尾部未终结的半截转义序列]。
+ * 用途：flushBatch 给每批输出包裹 DEC 2026 SYNC 标记——若批边界劈开一条序列，
+ * 注入的标记会吃掉它的 ESC，让后半段以字面渲染（`[9m`/`8;2;102m` 类残片的总根源）。
+ * 半截尾巴缓带到下一批（PTY 续写必然补全）即可保证每个被包裹的批序列完整。
+ * 尾部孤立高代理同样缓带（不劈 emoji 码点）。超 maxCarry 的悬挂（畸形流如
+ * 永不终结的 OSC）放弃缓带按原样发出，防止无界延迟/内存。
+ */
+export function splitTrailingIncomplete(buf, maxCarry = DEFAULT_MAX_CARRY) {
+  if (!buf) return ['', ''];
+  const k = buf.lastIndexOf('\x1b');
+  if (k !== -1 && buf.length - k <= maxCarry) {
+    const intro = k + 1 < buf.length ? buf.charCodeAt(k + 1) : -1;
+    let complete;
+    if (intro === -1) {
+      complete = false;                       // 裸 ESC 收尾
+    } else if (intro === 0x5b) {              // CSI：任何 0x40-0x7e 终字节即终结
+      complete = false;
+      for (let j = k + 2; j < buf.length; j++) {
+        const c = buf.charCodeAt(j);
+        if (c >= 0x40 && c <= 0x7e) { complete = true; break; }
+      }
+    } else if (intro === 0x5d) {              // OSC：k 是最后一个 ESC → ST 不可能，只看 BEL
+      complete = buf.indexOf('\x07', k + 2) !== -1;
+    } else if (intro === 0x50) {              // DCS：ST 终结需要 ESC，而 k 已是最后一个
+      complete = false;
+    } else {                                  // 短转义：ESC + 中间字节(0x20-0x2f)* + 终字节
+      let j = k + 1;
+      while (j < buf.length && buf.charCodeAt(j) >= 0x20 && buf.charCodeAt(j) <= 0x2f) j++;
+      complete = j < buf.length;
+    }
+    if (!complete) return [buf.slice(0, k), buf.slice(k)];
+  }
+  // 尾部孤立高代理：配对的低代理还在路上
+  const last = buf.charCodeAt(buf.length - 1);
+  if (last >= 0xd800 && last <= 0xdbff) return [buf.slice(0, -1), buf.slice(-1)];
+  return [buf, ''];
+}
+
+export function findSafeSliceStart(buf, rawStart, scanWindow = DEFAULT_SCAN_WINDOW) {
+  if (rawStart <= 0) return 0;
+  if (rawStart >= buf.length) return buf.length;
+  const scanLimit = Math.min(rawStart + scanWindow, buf.length);
+  let afterLf = -1;
+  for (let i = rawStart; i < scanLimit; i++) {
+    const ch = buf.charCodeAt(i);
+    if (ch === 0x1b) return i;
+    if (ch === 0x0a && afterLf === -1) afterLf = i + 1;
+  }
+  if (afterLf !== -1) return afterLf;
+  const idx = scanLimit >= buf.length ? resolveInSequence(buf, rawStart) : scanLimit;
+  const c = buf.charCodeAt(idx);
+  return (c >= 0xdc00 && c <= 0xdfff) ? idx + 1 : idx;
+}
+
+// 前向无任何锚点时的兜底：回看 BACK_SCAN 字节找最近的 ESC，判断 rawStart 是否
+// 正落在它引导的 CSI/OSC 内部（引导符与 rawStart 之间无终止符），是则前跳过终止符。
+// 注意调用前提：rawStart 之后整个 buf 内都没有 ESC（前向扫描已覆盖到结尾），
+// 所以 OSC 只需考虑 BEL 终止形态（ESC\ 形态会被前向锚点拦下，到不了这里）。
+function resolveInSequence(buf, rawStart) {
+  const backStop = Math.max(0, rawStart - BACK_SCAN);
+  for (let k = rawStart - 1; k >= backStop; k--) {
+    if (buf.charCodeAt(k) !== 0x1b) continue;
+    const intro = buf.charCodeAt(k + 1);
+    if (intro === 0x5b) { // CSI：终止符为 0x40-0x7e（引导符之后起算）
+      for (let j = k + 2; j < rawStart; j++) {
+        const cj = buf.charCodeAt(j);
+        if (cj >= 0x40 && cj <= 0x7e) return rawStart; // 序列已终结，rawStart 在纯文本里
+      }
+      for (let j = Math.max(rawStart, k + 2); j < buf.length; j++) {
+        const cj = buf.charCodeAt(j);
+        if (cj >= 0x40 && cj <= 0x7e) return j + 1;
+      }
+      // 序列到结尾仍未终结（还在被 PTY 续写）：保留半截序列头，等续写补全；
+      // 若改为丢弃，下一 chunk 送来的序列尾会变成新的孤儿残片。
+      return k;
+    }
+    if (intro === 0x5d) { // OSC：BEL 终止
+      for (let j = k + 2; j < rawStart; j++) {
+        if (buf.charCodeAt(j) === 0x07) return rawStart;
+      }
+      for (let j = Math.max(rawStart, k + 2); j < buf.length; j++) {
+        if (buf.charCodeAt(j) === 0x07) return j + 1;
+      }
+      return k;
+    }
+    return rawStart; // 其他短转义（charset 切换等）≤3 字节，rawStart 已在其后
+  }
+  return rawStart; // 回看窗口内无 ESC：rawStart 在纯文本里
+}

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

@@ -81,6 +81,12 @@ const DEFAULT_PT_COALESCE_MS = envIntAllowZero('CCV_FLOOD_PT_COALESCE_MS', 16);
  * @param {(buf: string, rawStart: number) => number} opts.findSafeSliceStart - ANSI 安全截断（pty-manager 导出）
  * @param {(buffered: number) => void} [opts.onFloodStart] - 进入限流态（observability 埋点）
  * @param {() => void} [opts.onFloodEnd] - 回落直通态
+ * @param {(droppedChars: number) => void} [opts.onTruncate] - 本轮洪泛**实际丢过字节**且已回落直通时触发
+ *   （紧随 onFloodEnd 之后，每轮洪泛至多一次，携带累计丢弃量）。安全切片只保证残片不上屏，
+ *   被截掉的中段对增量 TUI 流（macOS/Linux forkpty）不会自愈——调用方应在此用权威快照
+ *   （getOutputBuffer → data-resync）对齐客户端画面。洪泛进行中不触发：中途 resync 快照
+ *   立刻过期且加重负载，回落时一次终态对齐即可。reset()/dispose() 清零累计（resync 路径
+ *   自身就是快照对齐，无需重复触发）。
  * @param {number} [opts.flushMs]
  * @param {number} [opts.floodThresholdBytesPerWin]
  * @param {number} [opts.fallbackWins]
@@ -97,6 +103,7 @@ export function createFloodCoalescer({
   findSafeSliceStart,
   onFloodStart,
   onFloodEnd,
+  onTruncate,
   flushMs = DEFAULT_FLUSH_MS,
   floodThresholdBytesPerWin = DEFAULT_FLOOD_THRESHOLD,
   fallbackWins = DEFAULT_FALLBACK_WINS,
@@ -111,6 +118,7 @@ export function createFloodCoalescer({
   let pending = '';
   let winBytes = 0;       // 当前桶累计字节（直通态由 offer 累计，限流态由 flush 结算）
   let calmWins = 0;       // 连续低于阈值的桶数
+  let droppedChars = 0;   // 本轮洪泛累计实际丢弃的字符数（>0 时回落触发 onTruncate）
   let flushTimer = null;  // 限流态周期 flush；直通态下亦作为桶边界 timer（见 offer）
   let ptBuffer = '';      // 直通态微合并缓冲（窗口开启期间到达的后续 chunk）
   let ptTimer = null;     // 直通态微合并窗口 timer（16ms），与 flushTimer（33ms 字节桶）并存、职责正交
@@ -157,7 +165,9 @@ export function createFloodCoalescer({
     // 保证洪泛期送达客户端的字节率 ≤ flushBudgetBytes/flushMs，与前端消化速率同量级。
     if (pending.length > flushBudgetBytes) {
       const rawStart = pending.length - flushBudgetBytes;
-      pending = pending.slice(findSafeSliceStart(pending, rawStart));
+      const safeStart = findSafeSliceStart(pending, rawStart);
+      droppedChars += safeStart;
+      pending = pending.slice(safeStart);
     }
     const merged = SYNC_BEGIN + pending + SYNC_END;
     pending = '';
@@ -179,6 +189,13 @@ export function createFloodCoalescer({
       flooding = false;
       calmWins = 0;
       try { onFloodEnd?.(); } catch { }
+      // 本轮洪泛丢过字节 → 回落后通知一次终态对齐（见 opts.onTruncate doc）。
+      // 置零在调用**前**：回调内若同步 reset()/re-offer 不会重复触发。
+      if (droppedChars > 0) {
+        const dropped = droppedChars;
+        droppedChars = 0;
+        try { onTruncate?.(dropped); } catch { }
+      }
       return; // 不再续约 timer，回直通
     }
     flushTimer = setTimer(onFloodTick, flushMs);
@@ -227,6 +244,7 @@ export function createFloodCoalescer({
       if (pending.length > pendingCap) {
         const rawStart = pending.length - trimTo;
         const safeStart = findSafeSliceStart(pending, rawStart);
+        droppedChars += safeStart;
         pending = pending.slice(safeStart);
       }
     },
@@ -239,6 +257,7 @@ export function createFloodCoalescer({
       winBytes = 0;
       calmWins = 0;
       flooding = false;
+      droppedChars = 0; // resync 路径调用本方法，快照即对齐，不再补发 onTruncate
     },
     isFlooding() {
       return flooding;
@@ -250,6 +269,7 @@ export function createFloodCoalescer({
       stopPtTimer();
       pending = '';
       ptBuffer = '';
+      droppedChars = 0;
     },
   };
 }

package/server/pty-manager.js

@@ -6,6 +6,7 @@ import { platform, arch, homedir } from 'node:os';
 import { createRequire } from 'node:module';
 import { prepareEmbeddedShellSpawn, stripClaudeNoFlickerUnlessOptedIn } from './lib/terminal-env.js';
 import { killPtyTree } from './lib/term-signals.js';
+import { findSafeSliceStart, splitTrailingIncomplete } from './lib/ansi-safe-slice.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -35,6 +36,9 @@ let _spawnInflight = null;
 const PTY_COLS_MIN = 2, PTY_COLS_MAX = 1000;
 const PTY_ROWS_MIN = 1, PTY_ROWS_MAX = 1000;
 const MAX_BUFFER = 200000;
+// 裁剪滞回：超 MAX_BUFFER 触发后一次裁到 TRIM_TO，而非每个 chunk 都裁到 MAX_BUFFER——
+// 把 ~200KB slice 重分配的频率从每 chunk 一次降到每 ~20KB 新输出一次。
+const BUFFER_TRIM_TO = 180000;
 let batchBuffer = '';
 let batchScheduled = false;
 let _ptyImportForTests = null;
@@ -51,47 +55,9 @@ async function getPty() {
   return ptyMod.default || ptyMod;
 }
 
-/**
- * 在 outputBuffer 截断时，找到安全的截断位置，
- * 避免从 ANSI 转义序列中间开始导致终端状态紊乱。
- * 策略：从截断点向后扫描，跳过可能被截断的不完整转义序列。
- * 注意：只保 ANSI 序列边界，不保 DEC 2026 同步标记的配对——
- * 跨 2026 块截断的配平由调用方负责（见 lib/pty-flood-coalescer.js）。
- * export 供洪泛限流器复用同一截断语义。
- */
-export function findSafeSliceStart(buf, rawStart) {
-  // 从 rawStart 开始，向后最多扫描 64 字节寻找安全起点
-  const scanLimit = Math.min(rawStart + 64, buf.length);
-  let i = rawStart;
-  while (i < scanLimit) {
-    const ch = buf.charCodeAt(i);
-    // 如果当前字符是 ESC (0x1b)，可能是新转义序列的开头，
-    // 但也可能是被截断的序列的中间部分，跳过整个序列
-    if (ch === 0x1b) {
-      // 找到 ESC，向后寻找序列结束符（字母字符）
-      let j = i + 1;
-      while (j < scanLimit && !((buf.charCodeAt(j) >= 0x40 && buf.charCodeAt(j) <= 0x7e) && j > i + 1)) {
-        j++;
-      }
-      if (j < scanLimit) {
-        // 找到完整序列末尾，从下一个字符开始是安全的
-        return j + 1;
-      }
-      // 序列不完整，继续扫描
-      i = j;
-      continue;
-    }
-    // 如果字符是 CSI 参数字符 (0x30-0x3f) 或中间字符 (0x20-0x2f)，
-    // 说明我们在转义序列中间，继续向后
-    if ((ch >= 0x20 && ch <= 0x3f)) {
-      i++;
-      continue;
-    }
-    // 普通可见字符或控制字符（非转义相关），这是安全位置
-    break;
-  }
-  return i < buf.length ? i : rawStart;
-}
+// ANSI 安全截断起点：实现迁至 lib/ansi-safe-slice.js（锚点扫描算法，见该文件 doc）。
+// 保持从本模块 export——server.js 解构注入洪泛限流器、单测均从这里导入。
+export { findSafeSliceStart };
 
 // DEC Private Mode 2026 (Synchronized Output) markers.
 // xterm.js 6.0+ 原生支持：收到 BEGIN 后缓存所有写入，收到 END 后一次性渲染，
@@ -99,11 +65,18 @@ export function findSafeSliceStart(buf, rawStart) {
 const SYNC_BEGIN = '\x1b[?2026h';
 const SYNC_END   = '\x1b[?2026l';
 
-function flushBatch() {
+function flushBatch(force = false) {
   batchScheduled = false;
   if (!batchBuffer) return;
-  const chunk = SYNC_BEGIN + batchBuffer + SYNC_END;
-  batchBuffer = '';
+  // 批边界半截序列缓带：每批都包 SYNC 标记，若批边界劈开一条转义序列，注入的标记
+  // 会吃掉它的 ESC、让后半段以字面渲染（`[9m`/`8;2;102m` 类残片的总根源）。半截尾巴
+  // 留到下一批（PTY 续写必然补全）；force=true（进程退出）时不缓带，冲洗全部残余。
+  let safe = batchBuffer;
+  let carry = '';
+  if (!force) [safe, carry] = splitTrailingIncomplete(batchBuffer);
+  batchBuffer = carry;
+  if (!safe) return;
+  const chunk = SYNC_BEGIN + safe + SYNC_END;
   for (const cb of dataListeners) {
     try { cb(chunk); } catch { }
   }
@@ -297,7 +270,7 @@ async function _spawnClaudeImpl(proxyPort, cwd, extraArgs = [], claudePath = nul
   ptyProcess.onData((data) => {
     outputBuffer += data;
     if (outputBuffer.length > MAX_BUFFER) {
-      const rawStart = outputBuffer.length - MAX_BUFFER;
+      const rawStart = outputBuffer.length - BUFFER_TRIM_TO;
       const safeStart = findSafeSliceStart(outputBuffer, rawStart);
       outputBuffer = outputBuffer.slice(safeStart);
     }
@@ -309,7 +282,7 @@ async function _spawnClaudeImpl(proxyPort, cwd, extraArgs = [], claudePath = nul
   });
 
   ptyProcess.onExit(({ exitCode }) => {
-    flushBatch();
+    flushBatch(true);
     lastExitCode = exitCode;
     ptyProcess = null;
     ptyKind = null;
@@ -477,7 +450,7 @@ async function _spawnShellImpl() {
   ptyProcess.onData((data) => {
     outputBuffer += data;
     if (outputBuffer.length > MAX_BUFFER) {
-      const rawStart = outputBuffer.length - MAX_BUFFER;
+      const rawStart = outputBuffer.length - BUFFER_TRIM_TO;
       const safeStart = findSafeSliceStart(outputBuffer, rawStart);
       outputBuffer = outputBuffer.slice(safeStart);
     }
@@ -489,7 +462,7 @@ async function _spawnShellImpl() {
   });
 
   ptyProcess.onExit(({ exitCode }) => {
-    flushBatch();
+    flushBatch(true);
     lastExitCode = exitCode;
     ptyProcess = null;
     ptyKind = null;
@@ -522,7 +495,7 @@ export function resizePty(cols, rows) {
 
 export function killPty() {
   if (ptyProcess) {
-    flushBatch();
+    flushBatch(true);
     batchBuffer = '';
     batchScheduled = false;
     // Windows：node-pty 的 ConPTY kill 有已知同步挂起问题（microsoft/node-pty#454），

package/server/scratch-pty-manager.js

@@ -5,6 +5,7 @@ import { platform, arch, homedir } from 'node:os';
 import { createRequire } from 'node:module';
 import { prepareEmbeddedShellSpawn } from './lib/terminal-env.js';
 import { killPtyTree } from './lib/term-signals.js';
+import { findSafeSliceStart, splitTrailingIncomplete } from './lib/ansi-safe-slice.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -21,6 +22,8 @@ const STARTUP_CWD = (() => {
 })();
 
 const MAX_BUFFER = 50000;
+// 裁剪滞回：超 MAX_BUFFER 后一次裁到 TRIM_TO，降低每 chunk slice 重分配频率（同 pty-manager.js）
+const BUFFER_TRIM_TO = 45000;
 
 // id -> { ptyProcess, dataListeners, exitListeners, lastExitCode, outputBuffer, lastCols, lastRows, batchBuffer, batchScheduled }
 const ptys = new Map();
@@ -71,31 +74,17 @@ function maybeReap(id, s) {
   }
 }
 
-function findSafeSliceStart(buf, rawStart) {
-  const scanLimit = Math.min(rawStart + 64, buf.length);
-  let i = rawStart;
-  while (i < scanLimit) {
-    const ch = buf.charCodeAt(i);
-    if (ch === 0x1b) {
-      let j = i + 1;
-      while (j < scanLimit && !((buf.charCodeAt(j) >= 0x40 && buf.charCodeAt(j) <= 0x7e) && j > i + 1)) {
-        j++;
-      }
-      if (j < scanLimit) return j + 1;
-      i = j;
-      continue;
-    }
-    if (ch >= 0x20 && ch <= 0x3f) { i++; continue; }
-    break;
-  }
-  return i < buf.length ? i : rawStart;
-}
-
-function flushBatch(s) {
+function flushBatch(s, force = false) {
   s.batchScheduled = false;
   if (!s.batchBuffer) return;
-  const chunk = s.batchBuffer;
-  s.batchBuffer = '';
+  // 批边界半截序列缓带（同 pty-manager.flushBatch）：scratch chunk 本身不包 SYNC 标记，
+  // 但洪泛限流器会按 flush 包裹——chunk 尾部序列完整才能保证 flush 边界不撕裂。
+  // force=true（进程退出）时不缓带，冲洗全部残余。
+  let chunk = s.batchBuffer;
+  let carry = '';
+  if (!force) [chunk, carry] = splitTrailingIncomplete(s.batchBuffer);
+  s.batchBuffer = carry;
+  if (!chunk) return;
   // snapshot 防 listener 在迭代中卸载产生跳号
   for (const cb of [...s.dataListeners]) {
     try { cb(chunk); } catch { }
@@ -164,7 +153,7 @@ export async function spawnScratch(id) {
     s.ptyProcess.onData((data) => {
       s.outputBuffer += data;
       if (s.outputBuffer.length > MAX_BUFFER) {
-        const rawStart = s.outputBuffer.length - MAX_BUFFER;
+        const rawStart = s.outputBuffer.length - BUFFER_TRIM_TO;
         const safeStart = findSafeSliceStart(s.outputBuffer, rawStart);
         s.outputBuffer = s.outputBuffer.slice(safeStart);
       }
@@ -176,7 +165,7 @@ export async function spawnScratch(id) {
     });
 
     s.ptyProcess.onExit(({ exitCode }) => {
-      flushBatch(s);
+      flushBatch(s, true);
       s.lastExitCode = exitCode;
       s.ptyProcess = null;
       for (const cb of [...s.exitListeners]) {
@@ -225,7 +214,7 @@ export function killScratch(id) {
   const s = ptys.get(id);
   if (!s) return;
   if (s.ptyProcess) {
-    flushBatch(s);
+    flushBatch(s, true);
     s.batchBuffer = '';
     s.batchScheduled = false;
     // 与 pty-manager.killPty 同款：win32 用 taskkill /T 收割 ConPTY 树，