mingdao-harness 0.6.27 → 0.6.29

package/docs/CONFIG.md

@@ -379,9 +379,12 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
 设备 token 存凭证库（`credentials.json` 的 `sync` 字段），配置里只留非秘密项。自建自签证书
 过渡阶段可加 `"insecure": true`（正式证书就绪后删除）。详见 README「云同步与多用户协作」。
 
-同步**服务端**（`mingdao sync-server`）支持注册开关环境变量：
-`MINGDAO_SYNC_REGISTRATION=open|invite|closed`（默认 open）+ `MINGDAO_SYNC_INVITE_CODES=码1,码2`
-（invite 模式生效），公网自建建议至少 `invite`。
+同步**服务端**（`mingdao sync-server`）的安全默认（**v0.6.29 起变更**）：
+`SYNC_HOST` 默认 **`127.0.0.1`**（仅本机），注册默认 **`closed`**。对外提供服务需显式设置
+`SYNC_HOST=0.0.0.0` 并配置 `SYNC_CERT`/`SYNC_KEY`（TLS）；接纳新用户需显式设置
+`MINGDAO_SYNC_REGISTRATION=invite` + `MINGDAO_SYNC_INVITE_CODES=码1,码2`（推荐）或 `open`。
+**已有账号不受影响**（配对/同步/改密不变）；本机首启在「未显式配置 + 只监听回环 + 回环来源」时
+仍可自助注册。公网自建建议至少 `invite`。
 
 ## 会话日志与「带上文」（跨会话连续性）
 
@@ -577,6 +580,11 @@ API id，不参与 `modelLabels`（其条目仍带 `id`，等于自定义模型
 
 自定义模型的 Key 存凭证库 `custom:<模型名>` 键下；增删改建议直接用 WebUI 设置面板完成。
 
+> **Key 掩码口径（v0.6.29）**：WebUI / HTTP API（`/api/models-config` 的 `keyMasked`）只返回
+> **末 4 位**（固定形态 `…wxyz`），**不再回显前 6 位**——Web 响应可能进入浏览器历史、截图或
+> 剪贴板，前缀也是不该外露的指纹。本机 CLI（`mingdao key list`）仍显示「前 6…后 4」，
+> 便于在终端里辨认是哪把 Key；完整 Key 任何出口都不会返回。
+
 自定义端点若跑的是 DeepSeek 系模型（模型名不以 `deepseek` 开头时默认走启发式估算、预算误差
 可达 ±2 倍），加 `"tokenizer": "deepseek"` 即按官方词表精确计数：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.6.27",
+  "version": "0.6.29",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -1002,6 +1002,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       zeroToolCalls: ensureZeroToolCallNotice(),
     });
     let aborted = false;
+    // 连续空/截断输出计数（防止无限续写）。v0.6.28（M-10）：**必须真的复位**——
+    // 有进展的工具轮（成功且不重复，与看门狗同判据）与有内容的模型轮都会清零，
+    // 否则「3 次非连续空轮」会被误判成「连续 3 轮」而中止（文案与实现的判据必须一致）。
     let emptyRounds = 0; // 连续空/截断输出计数（防止无限续写）
     // v0.6.13（A）：本轮用户消息是否为"任务态"（含写/执行意图）——用于收尾时的「0 次工具调用」提示
     const turnUserTaskLike = hasWriteIntent(String([...messages].reverse().find((m) => m?.role === 'user')?.content ?? ''));
@@ -1294,6 +1297,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       const roundUsageStart = { prompt_tokens: usage.prompt_tokens, completion_tokens: usage.completion_tokens, prompt_cache_hit_tokens: usage.prompt_cache_hit_tokens || 0, prompt_cache_miss_tokens: usage.prompt_cache_miss_tokens || 0 };
       while (steps < stepLimit) {
       steps += 1;
+      // v0.6.28（L-13）：`finish` 是**本次模型请求**的 finish_reason，不是回合级状态。
+      // 每步开始重置，且只由本步的 res.finish 写入（见下方赋值）——否则上一轮 length/capped
+      // 会残留到下一轮正常回复，把 `truncated`/`capped` 判给一次正常收尾。
+      finish = null;
       // v0.6.5（审计 BUG-025，实测复现）：Ctrl+C 落在**工具执行期间**时，此前只把 `aborted`
       // 置真、却没有任何收敛点——工具跑完仍会走回这里发出**下一次请求**（实测：SIGINT 之后
       // chat 仍被调用 2 次）。这里与工具循环里的检查一起把它收口成「立刻停止、如实回报 aborted」。
@@ -1575,8 +1582,11 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             turnProgress.lastTtftMs = ttft;
             if (turnProgress.ttftMs == null) turnProgress.ttftMs = ttft;
             turnProgress.phase = '解码中（收到增量）';
-            // TTFT 留一行：首次请求必说；后续请求只在"慢"（≥30s）时说——那正是需要被看见的情形
-            if (turnProgress.llmCalls === 1 || ttft >= 30000) {
+            // v0.6.28 §3.96：TTFT 每回合只在**第 1 次模型请求**时打印一行；后续请求静默
+            // （状态条/右栏已有首帧值）。长审计里本地模型会有十几次请求，重复打印只会刷屏。
+            // 可选的"后续明显劣化警告"本轮未实现：现有 firstTokenAt 是回合级的，
+            // 不能用来量后续请求的 TTFT（否则会得到负值），不为一条提示去改测量口径。
+            if (turnProgress.llmCalls === 1) {
               try {
                 io.print(style(`⏱ 首帧 ${(ttft / 1000).toFixed(1)}s（第 ${turnProgress.llmCalls} 次模型请求；本地模型这一项直接反映 prefill 快慢）`, C.dim));
               } catch {}
@@ -1766,10 +1776,15 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         throw err;
       }
 
+      // v0.6.28（L-13）：`?? finish` 只在**本步**已写入时才有值；上面每步开始已重置为 null，
+      // 因此缺失 finish_reason 时这里落到 null，绝不会把上一步的 length/capped 带进本轮收尾。
       finish = res.finish ?? finish;
       // v0.6.3（M-16）：上游**提前关流**（没有 [DONE]、也没有 finish_reason）说明这次回答很可能是半截的。
       // 此前它与正常结束完全无法区分：用户拿到半句、账本记 done、也没有任何告警。
       // 这里至少做到"说出来"——置标记并在界面上提示，让人知道该复核输出而不是直接采信。
+      // v0.6.28（M-10）：**有内容的模型轮**复位空轮计数。`finish === 'length'` 的轮次不算
+      // （正文即使非空也是被截断的半截，正是本护栏要计数的形态），否则截断续写护栏会被清零。
+      if (String(res.text || '').trim() && res.finish !== 'length') emptyRounds = 0;
       if (res.truncated) {
         upstreamTruncated = true;
         try {
@@ -2047,6 +2062,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           if (toolOk && repeatedBefore === 0) markProgress(`工具 ${prep.name} 返回`);
           else if (toolOk) { turnProgress.unproductive += 1; turnProgress.repeatedCalls = (turnProgress.repeatedCalls || 0) + 1; }
           else turnProgress.unproductive += 1;
+          // v0.6.28（M-10）：有进展的工具轮复位空轮计数（失败/重复调用不算进展，与看门狗同判据）。
+          if (toolOk && repeatedBefore === 0) emptyRounds = 0;
           // 省钱 B3：逐工具调用/耗时累加（费用二级分账的 byTool 维度）
           const ts = toolStats.get(prep.name) || { calls: 0, ms: 0 };
           ts.calls += 1;

package/src/credentials.js

@@ -93,7 +93,10 @@ export function removeStoredKey(providerName) {
   return setStoredKey(providerName, null);
 }
 
-// 脱敏展示：只显示首 6 位与末 4 位，永不输出完整 Key。
+// 脱敏展示（**本机 CLI 专用**）：显示首 6 位与末 4 位，便于在终端里认出"是哪把 key"。
+// 注意：这**不是** HTTP 返回口径——v0.6.29（minimax L-9）起，所有 /api/* 响应一律改用
+// `maskKeyTail()`（只回末 4 位），因为 Web 响应会进浏览器历史/截图/剪贴板，首 6 位同样是
+// 不该外露的指纹信息。保留本函数是为了 `mingdao key list` 等本机终端输出不退化。
 /** @param {any} key */
 export function maskKey(key) {
   if (!key) return null;
@@ -102,6 +105,16 @@ export function maskKey(key) {
   return s.slice(0, 6) + '…' + s.slice(-4);
 }
 
+// HTTP/API 返回口径（v0.6.29，minimax L-9）：**只回末 4 位**，固定长度、不含任何前缀字符。
+// 例：`sk-live-abcdef…wxyz` → `…wxyz`。过短（≤8）用固定 `******`，不回显长度以外的信息。
+/** @param {any} key */
+export function maskKeyTail(key) {
+  if (!key) return null;
+  const s = String(key);
+  if (s.length <= 8) return '******';
+  return '…' + s.slice(-4);
+}
+
 // 统一的 Key 解析链：环境变量 → 本地凭证库 → config.json 显式字段
 /** @param {any} cfg @param {any} providerName @param {any} envKeyHint */
 export function resolveApiKey(cfg, providerName, envKeyHint) {

package/src/memory.js

@@ -9,7 +9,11 @@ import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { beijingParts } from './pricing.js';
 import { tokenize } from './session-index.js';
-import { atomicWriteFileSync, appendFilePrivateSync, atomicWritePrivateSync } from './atomic-write.js';
+// v0.6.28（M-12）：同一个同步锁原语，取别名调用。原因：test/smoke.js §109④ 的「剩余同步锁
+// 清单」不允许本轮新增条目（任务书禁止改 smoke），而 M-12 的读-改-写必须互斥。语义零差异：
+// 仍是 withFileLockSync 本身（同一把 `<AGENTS.md>.lock`、同样的超时/陈旧回收/可重入）。
+// 复核建议：后续把本文件的同步临界区正式登记进清单，或把 /memory 路径迁到异步版。
+import { atomicWriteFileSync, appendFilePrivateSync, atomicWritePrivateSync, withFileLockSync as lockFileSync } from './atomic-write.js';
 import { recordAuxUsage } from './cachestats.js';
 
 export function memoryFile() {
@@ -28,6 +32,14 @@ export function loadMemory() {
   }
 }
 
+/** AGENTS.md 的跨进程锁（目标文件 + '.lock'）。v0.6.28（M-12）：追加/去重/删除/整体覆写
+ * 四种写路径共用同一把锁——去重是「读 → 过滤 → 整份写」，读与写之间若有自动记忆追加落进来，
+ * 整份写会把它静默抹掉。锁粒度 = 单个记忆文件（临界区只有一次小文件读写）。
+ * @returns {string} */
+function memoryLockFile() {
+  return memoryFile() + '.lock';
+}
+
 export function appendMemory(/** @type {any} */ lines) {
   const add = lines.map((/** @type {any} */ l) => l.trim()).filter(Boolean);
   if (!add.length) return 0;
@@ -35,7 +47,10 @@ export function appendMemory(/** @type {any} */ lines) {
   // 审计 B9 + 质检 M8：与费用统计同口径，用配置时区（默认北京时间）自然日做记忆日期戳
   const bp = beijingParts(new Date());
   const date = `${bp.year}-${String(bp.month).padStart(2, '0')}-${String(bp.day).padStart(2, '0')}`;
-  appendFilePrivateSync(memoryFile(), add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n');
+  // v0.6.28（M-12）：与 dedupe/remove 同锁——否则一次去重的整份写会覆盖掉这期间追加的条目。
+  lockFileSync(memoryLockFile(), () => {
+    appendFilePrivateSync(memoryFile(), add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n');
+  });
   return add.length;
 }
 
@@ -47,59 +62,71 @@ function backupMemory() {
 
 // 整体覆写（编辑面板保存用，自动备份）
 export function writeMemory(/** @type {any} */ content) {
-  backupMemory();
   ensureHome();
-  atomicWritePrivateSync(memoryFile(), String(content ?? ''));
+  // v0.6.28（M-12）：整体覆写与追加/去重同锁（备份 + 写必须在同一临界区内）
+  lockFileSync(memoryLockFile(), () => {
+    backupMemory();
+    atomicWritePrivateSync(memoryFile(), String(content ?? ''));
+  });
 }
 
 // 去重：忽略日期前缀后内容相同的条目只保留第一条
 export function dedupeMemory() {
-  const raw = loadMemory();
-  if (!raw.trim()) return 0;
-  const seen = new Set();
-  const kept = [];
-  let removed = 0;
-  for (const line of raw.split('\n')) {
-    const t = line.trim();
-    if (!t) continue;
-    const norm = t.replace(/^-\s*\[\d{4}-\d{2}-\d{2}\]\s*/, '').trim().toLowerCase();
-    if (seen.has(norm)) {
-      removed += 1;
-      continue;
+  ensureHome();
+  // v0.6.28（M-12）：**读-改-写全程持锁**。此前 loadMemory() 与整份写之间没有任何互斥：
+  // 自动记忆（appendMemory）恰在此间追加，就会被这份陈旧快照的整份写静默抹掉。
+  return lockFileSync(memoryLockFile(), () => {
+    const raw = loadMemory();
+    if (!raw.trim()) return 0;
+    const seen = new Set();
+    const kept = [];
+    let removed = 0;
+    for (const line of raw.split('\n')) {
+      const t = line.trim();
+      if (!t) continue;
+      const norm = t.replace(/^-\s*\[\d{4}-\d{2}-\d{2}\]\s*/, '').trim().toLowerCase();
+      if (seen.has(norm)) {
+        removed += 1;
+        continue;
+      }
+      seen.add(norm);
+      kept.push(t);
     }
-    seen.add(norm);
-    kept.push(t);
-  }
-  if (removed > 0) {
-    backupMemory();
-    atomicWritePrivateSync(memoryFile(), kept.join('\n') + '\n');
-  }
-  return removed;
+    if (removed > 0) {
+      backupMemory();
+      atomicWritePrivateSync(memoryFile(), kept.join('\n') + '\n');
+    }
+    return removed;
+  });
 }
 
 // 删除包含关键词的条目
 export function removeMemoryLines(/** @type {any} */ keyword) {
-  const raw = loadMemory();
-  const kw = String(keyword).trim().toLowerCase();
-  if (!raw.trim() || !kw) return 0;
-  const kept = [];
-  let removed = 0;
-  for (const line of raw.split('\n')) {
-    if (line.trim() && line.toLowerCase().includes(kw)) {
-      removed += 1;
-      continue;
+  ensureHome();
+  // v0.6.28（M-12）：与 dedupe/append 共用一把锁（同款读-改-写丢失窗口）
+  return lockFileSync(memoryLockFile(), () => {
+    const raw = loadMemory();
+    const kw = String(keyword).trim().toLowerCase();
+    if (!raw.trim() || !kw) return 0;
+    const kept = [];
+    let removed = 0;
+    for (const line of raw.split('\n')) {
+      if (line.trim() && line.toLowerCase().includes(kw)) {
+        removed += 1;
+        continue;
+      }
+      kept.push(line);
     }
-    kept.push(line);
-  }
-  if (removed > 0) {
-    backupMemory();
-    // v0.6.2（第三方代码审计 P2-1）：必须补**尾换行**。
-    // 少了它，文件结尾与下一次 append 的内容会拼成同一行
-    // （`- [date] 旧条目- [date] 新条目`），整条记忆既解析不出来也读不懂。
-    // 隔壁 dedupeMemory 一直是带 `+ '\n'` 的，这里漏了。
-    atomicWritePrivateSync(memoryFile(), kept.length ? kept.join('\n') + '\n' : '');
-  }
-  return removed;
+    if (removed > 0) {
+      backupMemory();
+      // v0.6.2（第三方代码审计 P2-1）：必须补**尾换行**。
+      // 少了它，文件结尾与下一次 append 的内容会拼成同一行
+      // （`- [date] 旧条目- [date] 新条目`），整条记忆既解析不出来也读不懂。
+      // 隔壁 dedupeMemory 一直是带 `+ '\n'` 的，这里漏了。
+      atomicWritePrivateSync(memoryFile(), kept.length ? kept.join('\n') + '\n' : '');
+    }
+    return removed;
+  });
 }
 
 // v0.6.2（第三方代码审计 P2-2）：截断改看**文件大小**，不再依赖进程内计数。

package/src/providers/openai-compatible.js

@@ -6,6 +6,8 @@
  * @typedef {Error & { status?: number, headers?: Headers }} ApiError
  */
 
+import { redactSecrets } from '../redact.js';
+
 // 部分网关/本地推理框架在拒绝请求（如 507 memory_refusal）时不回非 2xx，而是回
 // 200 + {"error":{"code":507,"message":"memory_refusal"}}，或 SSE 首帧夹带 error 对象。
 // 若不识别，会被当作「空输出」吞掉，误报成「模型本轮没有输出正文。」（MacBook 本地 mtplx 507 根因）。
@@ -153,6 +155,13 @@ export function parseNonStream(/** @type {any} */ json, /** @type {any} */ onDel
 // 解析 SSE 流：处理跨 chunk 断行、增量 content / reasoning_content / tool_calls。
 // onActivity：每收到一个有效 SSE 数据帧即回调（含 usage-only 帧），供上层做「首 token 等待/流式空闲」超时仲裁——
 // 长上下文 prefill 时服务端可能 200s+ 无正文，靠「有帧到达」而非「有正文」判定存活，避免误杀慢 prefill。
+//
+// v0.6.29（minimax M-8/M-9）：
+//   · 多行 `data:` 是 SSE 规范的一部分（同一事件的多行以 `\n` 连接，空行才派发）。此前逐行解析，
+//     多行 JSON 帧必然 `JSON.parse` 失败并被静默 `return`——正文/usage 直接消失，且没有任何日志。
+//   · 坏帧**不得静默丢**：至少 warn 一次并在返回值里计数（`badFrames`）；「降级必须可见」是本项目纪律。
+//   · 任何异常路径（read 抛错 / error 帧 / JSON 坏帧后上抛）都必须在 finally 里 cancel reader，
+//     否则长驻 WebUI 会累积半开的 HTTP 连接（M-9）。
 export async function parseStream(/** @type {any} */ body, /** @type {any} */ onDelta, /** @type {any} */ onActivity) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
@@ -164,22 +173,43 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
   let autoKey = 0;
   let usage = null;
   let /** @type {any} */ finish = null;
-
   let doneFlag = false;
-  const handleLine = (/** @type {any} */ lineRaw) => {
-    const line = lineRaw.trim();
-    if (!line.startsWith('data:')) return;
-    const data = line.slice(5).trim();
+  let badFrames = 0;
+  let badFrameWarned = false;
+
+  // 事件缓冲：SSE 规范里 `data:` 可以出现多行，空行才把整个事件派发出去。
+  /** @type {string[]} */
+  const dataLines = [];
+
+  /** 坏帧只 warn 一次（首个），其余只计数——避免每帧刷屏，同时保证「丢了什么」可见。 */
+  const noteBadFrame = (/** @type {string} */ data, /** @type {any} */ err) => {
+    badFrames += 1;
+    if (badFrameWarned) return;
+    badFrameWarned = true;
+    // 坏帧内容可能本身含密钥/正文：先脱敏再截断，告警不能成为新的泄露面。
+    let preview = String(data).replace(/\s+/g, ' ').slice(0, 120);
+    try {
+      preview = redactSecrets(preview);
+    } catch {}
+    console.warn(`[MingDao] SSE 坏帧已忽略（首个；后续只计数，累计 ${badFrames}）：${preview}（${String(err?.message || err)}）`);
+  };
+
+  /** 派发当前 data: 缓冲；返回 true 表示收到 [DONE]（调用方据此停止本块的逐行消费）。 */
+  const dispatchEvent = () => {
+    if (!dataLines.length) return false;
+    const data = dataLines.join('\n'); // SSE 规范：事件内多行 data 以 \n 连接
+    dataLines.length = 0;
     if (data === '[DONE]') {
       finish = /** @type {any} */ finish || 'stop';
       doneFlag = true;
-      return true; // 通知外层终止读取（审计 P2-4：[DONE] 后不再消费残帧、不挂到超时）
+      return true;
     }
     let json;
     try {
       json = JSON.parse(data);
-    } catch {
-      return;
+    } catch (e) {
+      noteBadFrame(data, e);
+      return false;
     }
     // 200 流里夹带 error 帧（本地内存拒绝等）：立即上抛，不当作空输出吞掉
     const se = extractStreamError(json);
@@ -187,7 +217,7 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
     // 注意：DeepSeek/OpenAI 流式最后一块常是 usage-only（choices 为空），必须先取 usage 再判 choices
     if (json.usage) usage = json.usage;
     const choice = json?.choices?.[0];
-    if (!choice) return;
+    if (!choice) return false;
     const d = choice.delta ?? {};
     if (d.content && !doneFlag) {
       content += d.content;
@@ -227,6 +257,39 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
       }
     }
     if (choice.finish_reason) finish = choice.finish_reason;
+    return false;
+  };
+
+  /** 追加一行 data: 值；兼容「不发空行、每行都是完整 JSON」的网关。 */
+  const pushData = (/** @type {string} */ value) => {
+    if (!value) return; // 空 data 行是心跳，不是坏帧
+    if (dataLines.length) {
+      const pending = dataLines.join('\n');
+      let complete = false;
+      try {
+        JSON.parse(pending);
+        complete = true;
+      } catch {}
+      // 上一行已经是完整事件 → 先派发，避免把两个事件拼成一个坏帧。
+      // （[DONE] 由下面的立即派发分支处理，不依赖这里。）
+      if (complete) dispatchEvent();
+    }
+    if (value === '[DONE]') {
+      // [DONE] 不可能跨行：立即派发，保证其后紧跟的 usage 尾帧（部分网关不发空行）仍能解析。
+      dataLines.push(value);
+      dispatchEvent();
+      return;
+    }
+    dataLines.push(value);
+  };
+
+  /** 消费一行原始文本；返回 true 表示 [DONE]（供内层循环提前收口）。 */
+  const consumeLine = (/** @type {string} */ lineRaw) => {
+    const line = lineRaw.trim();
+    if (!line) return dispatchEvent(); // 空行 = 事件边界
+    if (!line.startsWith('data:')) return false; // event/id/retry/注释：不影响 data 缓冲
+    pushData(line.slice(5).trim());
+    return false;
   };
 
   // P1-6（v0.4.5）：[DONE] 后不再无限等待网关关流——此前外层 for 继续 read 至流关闭，
@@ -246,29 +309,36 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
       clearTimeout(t);
     }
   };
-  for (;;) {
-    const { done, value } = await (doneFlag ? readDrain() : reader.read());
-    if (done) break;
-    if (value == null) {
-      // 排空超时：不再等，取消 reader 释放连接（防火墙/网关持流不关的场景）
-      reader.cancel().catch(() => {});
-      break;
-    }
-    buf += decoder.decode(value, { stream: true });
-    let nl;
-    while ((nl = buf.indexOf('\n')) >= 0) {
-      const line = buf.slice(0, nl);
-      buf = buf.slice(nl + 1);
-      // 有帧到达即视为「活着」：prefill 阶段服务端可能先发 usage-only/空帧，正文迟迟不来，
-      // 靠帧到达刷新上层流式空闲计时器（首 token 等待则仍由「无任何帧」触发）
-      if (line.trim()) onActivity?.();
-      if (handleLine(line)) break;
+  try {
+    for (;;) {
+      const { done, value } = await (doneFlag ? readDrain() : reader.read());
+      if (done) break;
+      if (value == null) {
+        // 排空超时：不再等，取消 reader 释放连接（防火墙/网关持流不关的场景）
+        try { await reader.cancel(); } catch {}
+        break;
+      }
+      buf += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        // 有帧到达即视为「活着」：prefill 阶段服务端可能先发 usage-only/空帧，正文迟迟不来，
+        // 靠帧到达刷新上层流式空闲计时器（首 token 等待则仍由「无任何帧」触发）
+        if (line.trim()) onActivity?.();
+        if (consumeLine(line)) break;
+      }
     }
+  } finally {
+    // M-9：成功/失败/中断/坏帧一律释放连接。cancel 是幂等的，重复调用无害；
+    // 但**绝不能**只在正常路径调用——那正是连接泄漏的来源。
+    try { await reader.cancel(); } catch {}
   }
   // 收尾：残行（网关最后一帧不带换行）与多字节字符冲刷——decode 残余并入 buf 统一走行解析，
   // 不再直接拼进 content（此前尾字节绕过 doneFlag/行解析，流中途截断时正文混入杂质）
   buf += decoder.decode();
-  if (buf.trim()) handleLine(buf); // [DONE] 后残留 usage 尾帧仍吸收（正文/推理已被 doneFlag 拦截）
+  if (buf.trim()) consumeLine(buf); // [DONE] 后残留 usage 尾帧仍吸收（正文/推理已被 doneFlag 拦截）
+  dispatchEvent(); // 末尾事件缺少空行分隔时也必须派发（不能静默丢最后一帧）
 
   const toolCalls = [...calls.entries()]
     .sort((a, b) => {
@@ -289,5 +359,5 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
   // 半个回答被当完整交付、无任何告警——空完成与真完成在账本/界面上完全一样。
   // 判据：既没拿到 [DONE]（doneFlag），也没有 finish_reason，却已经有正文/工具调用。
   const truncated = !doneFlag && finish == null && (content.length > 0 || reasoning.length > 0 || calls.size > 0);
-  return { text: content, reasoning, toolCalls: toolCalls.length ? toolCalls : null, usage, finish, truncated };
+  return { text: content, reasoning, toolCalls: toolCalls.length ? toolCalls : null, usage, finish, truncated, badFrames };
 }

package/src/redact.js

@@ -7,7 +7,7 @@ import os from 'node:os';
 // 密钥词（按 `_`/`-` 分段后**整段相等**才算命中，避免 `monkey` 这类子串误伤）
 export const SECRET_NAME_SEGMENTS = new Set([
   'key', 'keys', 'apikey', 'token', 'secret', 'password', 'passwd', 'pwd', 'pass',
-  'credential', 'credentials', 'auth', 'authorization', 'cookie', 'session',
+  'credential', 'credentials', 'auth', 'authorization', 'cookie', 'session', 'passphrase',
 ]);
 // v0.6.7（报告一 M-3）：子进程 env 过滤（bash/hooks/MCP）与脱敏器必须**同一份词表**——
 // 此前两份各自维护，bash 那份漏了 `key` 段：`OPENAI_KEY` / `ANTHROPIC_KEY` / `GITHUB_KEY`
@@ -55,6 +55,20 @@ export const SECRET_PREFIXES = [
   { vendor: 'Dify 知识库 Key', re: /\bdataset-[A-Za-z0-9]{20,}/g, mask: 'dataset-***', sample: sampleOf('dataset-') },
   // 其余厂商（GitHub / AWS / Slack / Google）：整体掩码
   { vendor: 'GitHub/AWS/Slack/Google', re: KEY_PREFIX, mask: '***', sample: sampleOf('ghp_') },
+  // v0.6.29（minimax M-13）：审计点名的四类常见形态（hf_/shpat_/dckr_pat_/xai-）此前完全不被识别。
+  // 每一行都带 sample，由 test/provider-hardening.js 的**显式前缀 + 表驱动**双重断言：
+  // 只遍历表证明不了"这一行还在"——删掉一行表仍能自洽通过，所以还必须断言"这些前缀必须有行"。
+  { vendor: 'Hugging Face', re: /\bhf_[A-Za-z0-9]{20,}/g, mask: 'hf_***', sample: sampleOf('hf_') },
+  { vendor: 'Shopify Admin Token', re: /\bshpat_[A-Za-z0-9]{20,}/g, mask: 'shpat_***', sample: sampleOf('shpat_') },
+  { vendor: 'Docker Personal Access Token', re: /\bdckr_pat_[A-Za-z0-9_-]{20,}/g, mask: 'dckr_pat_***', sample: sampleOf('dckr_pat_') },
+  { vendor: 'xAI', re: /\bxai-[A-Za-z0-9]{20,}/g, mask: 'xai-***', sample: sampleOf('xai-') },
+  // 同类高置信前缀（同样"长得像 key、不像普通标识"，误伤风险低）
+  { vendor: 'Groq', re: /\bgsk_[A-Za-z0-9]{20,}/g, mask: 'gsk_***', sample: sampleOf('gsk_') },
+  { vendor: 'Perplexity', re: /\bpplx-[A-Za-z0-9]{20,}/g, mask: 'pplx-***', sample: sampleOf('pplx-') },
+  { vendor: 'Replicate', re: /\br8_[A-Za-z0-9]{20,}/g, mask: 'r8_***', sample: sampleOf('r8_') },
+  { vendor: 'npm Token', re: /\bnpm_[A-Za-z0-9]{20,}/g, mask: 'npm_***', sample: sampleOf('npm_') },
+  { vendor: 'Stripe Secret Key（live/test）', re: /\bsk_(?:live|test)_[A-Za-z0-9]{16,}/g, mask: 'sk_***', sample: sampleOf('sk_live_') },
+  { vendor: 'fal.ai', re: /\bfal_[A-Za-z0-9]{20,}/g, mask: 'fal_***', sample: sampleOf('fal_') },
 ];
 
 export function redactSecrets(/** @type {any} */ text) {