dsh-dupguard 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 本文件遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循 [SemVer](https://semver.org/lang/zh-CN/)。
 
+## [1.4.0] - 2026-09-23
+
+### Added
+
+- **围栏代码块内放宽检测**（`skipCodeBlocks` 默认开启 + `codeBlockMultiplier` 默认 `3`，均可在设置页调整）：
+  代码块内的重复串（生成的测试夹具、表格、ASCII 图、内嵌数据）改用「阈值 × 倍数」判定，
+  不再被误判为复读；块内的失控复读仍会被兜住（默认连续 30 次即截停）。倍数范围 1–100，
+  设为 1 等价于不放宽；关闭开关则块内与块外同样严格；
+- 围栏识别按 CommonMark：起始行为行首 ≤3 个空格 + 连续 ≥3 个 `` ` `` 或 `~`（其后为 info string），
+  结束行需同字符且不短于起始长度、其后仅空白；未闭合围栏延续到该块结束；
+  围栏标记被切进多个增量（如 `"``"` + ``"`js"``）时仍能识别；行内代码与缩进代码块不受影响；
+- 截停日志新增 `code-block=true（放宽阈值命中）` 标记，便于区分命中来源。
+
+### Changed
+
+- 窗口缺口提示与宿主告警改为按「阈值 × 代码块倍数 × 最大单元长度」计算（关闭放宽时倍数按 1 计），
+  设置页提示文本同步显示倍数。
+
+### Fixed
+
+- 长围栏不再被短围栏提前关闭：围栏长度取起始行的**完整** run，```` ```` ```` 开启的代码块不会被
+  内部的 ``` 行关闭（此前一见 3 个反引号就进入并记长度为 3）。
+
+## [1.3.1] - 2026-09-05
+
+### Fixed
+
+- **白名单按「单个字符」匹配的语义两端不一致**：设置页会把整串输入（如 `ab`）当成一个条目，
+  而检测按单个字符比对，该条目永远不会生效。现在设置页把一次输入拆成单个字符逐个加入
+  （忽略其中的空白），宿主对存量或手改的多字符、空、非字符串条目在运行时丢弃并打印告警；
+  白名单比对同时改为按 Unicode 码点进行，emoji 等代理对字符可作为单个条目正常生效。
+- **未改动的数值输入在失焦时也会写入**，把默认值写进用户层（`settings.yaml` 里因此出现
+  `threshold: 10`、`maxUnitLength: 80`、`detectionWindow: 8192` 这类无意义条目）。现在值与
+  宿主一致时跳过写入。
+- **跨字段约束只在「最大单元」一行提示**：从「最小单元」一侧提交违规值时只能拿到宿主拒绝后的
+  泛化「保存失败」。现在两行都给出具体错误并在本地拦截写入。
+- 截停收尾遇到未知块类型（协议新增 `ContentBlock` 类型）时会静默按 tool-call 兜底，
+  现补充一次性宿主告警，便于定位协议漂移。
+
 ## [1.3.0] - 2026-09-05
 
 ### Added

package/README.md

@@ -9,6 +9,17 @@
 [![CI](https://github.com/zqh260619/dsh-dupguard/actions/workflows/ci.yml/badge.svg)](https://github.com/zqh260619/dsh-dupguard/actions/workflows/ci.yml)
 [![dsh-plugin](https://img.shields.io/badge/topic-dsh--plugin-0969da)](https://github.com/topics/dsh-plugin)
 
+**兼容性 / Compatibility**
+
+- **DSH**：宿主 API 自 `0.1.1-rc.1` 起可用；当前版本在 **0.1.5-rc.2 / 0.1.6-alpha.2** 上实测通过，
+  更早版本在 `0.1.1-rc.1` / `0.1.2-rc.1` 上实测通过。下面「一条命令的 bundle 安装」需要
+  **DSH ≥ 0.1.2-rc.1**（bundle 自动纳管与 `dsh.bundle` 约定从该版本起提供）。
+- **Node**：≥ 20（与 DSH 一致，不支持 Node 18）。
+
+Host APIs work since DSH `0.1.1-rc.1`; the current version is verified on **0.1.5-rc.2 / 0.1.6-alpha.2**
+(earlier releases were verified on `0.1.1-rc.1` / `0.1.2-rc.1`). The one-command bundle install below
+needs **DSH ≥ 0.1.2-rc.1**. Node ≥ 20 (matching DSH; Node 18 is unsupported).
+
 触发后，已生成的内容会**正常提交为助手消息**，本轮对话干净结束——不会报错、不会丢弃输出、不会污染会话日志。
 
 When triggered, the already-generated text is committed as a normal assistant message and the turn ends cleanly — no errors, no lost output, no session-log pollution.
@@ -27,10 +38,12 @@ When triggered, the already-generated text is committed as a normal assistant me
   「重复守卫」分节，可视化编辑白名单与全部检测参数（阈值、最小/最大单元长度、检测窗口、空白与
   reasoning、工具参数开关）并持久化（`dsh-dupguard` 设置命名空间），修改即时生效；窗口小于
   阈值 × 最大单元长度时给出「窗口长度需要提高」提示。
+- **代码块内放宽**：围栏代码块（``` / ~~~）内改用「阈值 × 倍数」（默认 3×）判定，生成的代码、
+  测试夹具、表格、ASCII 图不会被误判为复读；块内的失控复读仍会被兜住（默认连续 30 次即截停）。
 - **零配置开箱即用**：默认配置即可用；全部检测参数均可在设置页按需调整。
 - **双入口交付**：动态插件（`plugin/host.js`）+ npm 组合挂载（`lib/index.js` + `lib/client.js`），行为一致、CI 防漂移。
 - **内置 DSH 兼容补丁**（`fixStandingMountConflict`，默认开启）：幂等化 `cordisInspect.register`，
-  修复 DSH ≤ 0.1.2-rc.1 的 preset standing-mount 多代并存冲突（见下文"已知限制"）。
+  修复 DSH ≤ 0.1.6-alpha.2 仍未修复的 preset standing-mount 多代并存冲突（见下文"已知限制"）。
 
 ---
 
@@ -63,7 +76,9 @@ dsh plugin --profile web add dsh-dupguard
 `{ id: dupguard, name: dsh-dupguard }`。**无需手改任何 YAML。**
 
 - 验证：`dsh --profile web --dump-config` 末尾应出现 `dupguard` 行；loader 日志出现
-  `apply plugin dupguard`。
+  `apply plugin dupguard`；宿主日志另有本插件的自检行
+  `[dupguard] 常驻插件 apply 开始` 与 `[dupguard] 已注册设置命名空间 dsh-dupguard（检测参数可在设置页动态调整）`，
+  出现后设置面板的「重复守卫」分节即可编辑白名单与全部参数。
 - 升级：`dsh plugin --profile web update dsh-dupguard`；
   卸载：`dsh plugin --profile web remove dsh-dupguard`（依赖与 bundles 层一并移除）。
 
@@ -83,6 +98,42 @@ dsh plugin --profile web add dsh-dupguard
 ⚠️ 两种方式**不要同时使用**：loader 对重复 entry id 直接抛
 `duplicate loader entry id: dupguard`。从手工方式切换到 bundle 方式时，请删除手工 `insert` 项。
 
+**3. 临时禁用（不卸载）**：在 profile 的用户补丁层里按 id 关掉该行即可：
+
+```yaml
+# $DSH_HOME/profiles/web/cordis.patch.yml
+- id: dupguard
+  name: dsh-dupguard
+  disabled: true
+```
+
+用户补丁层在 bundle 层之后应用，profile 的 `patchReload` 默认为 `live`——**保存即卸载该插件行，无需重启**；
+改回 `disabled: false`（或删除该条）即恢复。这条 id 定位的补丁对两种安装方式都适用（bundle 层插入的行、
+或你自己 insert 的行都会被它覆盖）。禁用后宿主半边（截停与 `dsh-dupguard` 设置命名空间）一并卸载，
+全部检测参数回落到代码默认值（含白名单；`settings.yaml` 中的取值保留），重复输出不再被截停；由于 DSH 的
+客户端模块图按**活动 loader 行**生成，**刷新页面**后设置面板里的「重复守卫」分节会消失。注意进程内的
+standing-mount 兼容补丁不会随禁用撤销，要彻底干净需重启 DSH。彻底卸载请用上面的
+`dsh plugin --profile web remove dsh-dupguard`（依赖与 bundles 条目一并移除）。
+
+**Temporarily disable (without uninstalling)**: turn the row off by id in the profile's user patch layer:
+
+```yaml
+# $DSH_HOME/profiles/web/cordis.patch.yml
+- id: dupguard
+  name: dsh-dupguard
+  disabled: true
+```
+
+The user layer applies after every bundle layer and the profile's `patchReload` defaults to `live`, so
+saving unloads the row **without a restart**; set it back to `false` (or delete the entry) to re-enable.
+The id-targeted patch works for both install styles (a row inserted by the bundle layer or by your own
+`insert` entry). The host half (guard + the `dsh-dupguard` settings namespace) unloads with it — every
+detection parameter falls back to the code default (whitelist included) while `settings.yaml` keeps your
+values, and nothing is stopped any more. DSH builds its Client module graph from **live loader rows**, so
+the "Dupguard" settings section disappears after a page refresh. The process-resident standing-mount
+patch is not undone by disabling; restart DSH if you need a completely clean process. To remove it
+entirely, use `dsh plugin --profile web remove dsh-dupguard`.
+
 **本地开发**：未发布/调试时，`name` 也可直接用 `file:` URL 指向仓库内的
 [`lib/index.js`](lib/index.js)（CJS 导出 `{ name, apply }`，与 loader 的
 `unwrapExports` 兼容，零构建）。
@@ -126,21 +177,23 @@ and persisted to `settings.yaml`; the dynamic build uses the constants.
 | `threshold` | `10` | 触发阈值：同一字符串连续重复 ≥ 该值时停止 / stop when the same string repeats ≥ this many times |
 | `minUnitLength` | `1` | 最小重复单元长度 / minimum repeating-unit length (`1` also catches single-char loops like `aaaaaaaaaa`) |
 | `maxUnitLength` | `80` | 最大重复单元长度 / maximum repeating-unit length |
-| `detectionWindow` | `8192` | 检测滚动窗口（字符，去空白后），需 ≥ 阈值 × 最大单元长度 / rolling detection window in chars (after whitespace removal); must be ≥ threshold × max unit length |
+| `detectionWindow` | `8192` | 检测滚动窗口（字符，去空白后），需 ≥ 阈值 × 代码块倍数 × 最大单元长度 / rolling detection window in chars (after whitespace removal); must be ≥ threshold × code-block multiplier × max unit length |
+| `skipCodeBlocks` | `true` | 围栏代码块（``` / ~~~）内放宽检测：块内改用「阈值 × 代码块倍数」判定，避免生成的代码/夹具/表格被误杀；置 `false` 则块内与块外同样严格 / relax detection inside fenced code blocks; set `false` to apply the normal threshold inside them too |
+| `codeBlockMultiplier` | `3` | 代码块内的阈值倍数，范围 1–100；越大越少误杀正常代码，但也越晚兜住代码块里的失控复读（1 = 不放宽）/ threshold multiplier inside code blocks, range 1–100 (1 = no relaxation) |
 | `stripWhitespace` | `true` | 检测前移除空白/换行，识别带分隔符的复读 / strip whitespace so `"x x x"` and `"x\nx\nx"` are caught |
-| `ignoredChars` | `['-', '\|']` | 检测时忽略的字符白名单：Markdown 表格分隔行（连字符与竖线）不参与重复统计 / whitelist of characters ignored during detection, so Markdown table separators don't count |
+| `ignoredChars` | `['-', '\|']` | 检测时忽略的字符白名单：Markdown 表格分隔行（连字符与竖线）不参与重复统计。条目必须**是单个字符**（按 Unicode 码点匹配，emoji 也算一个）；设置页一次输入多个字符会逐个加入，多字符/空条目在运行时被丢弃并告警 / whitelist of characters ignored during detection, so Markdown table separators don't count. Entries must be a **single character** (matched per Unicode code point); the settings page splits multi-character input into individual entries, and invalid entries are dropped at runtime with a warning |
 | `monitorReasoning` | `true` | 是否检测思考文本（思考中的复读同样消耗 token，默认截停；只检测可见输出时置 `false`）/ also guard reasoning (thinking) text — on by default; set `false` to guard visible output only |
 | `monitorToolArguments` | `false` | 是否检测工具调用参数 / also guard tool-call JSON args — off by default (base64/JSON repeats are common) |
-| `fixStandingMountConflict` | `true` | DSH ≤ 0.1.2-rc.1 兼容补丁：幂等化 `cordisInspect.register`，修复 preset standing-mount 多代并存冲突（仅代码常量）/ idempotent `cordisInspect.register` patch for the DSH ≤ 0.1.2-rc.1 standing-mount conflict (code constant only) |
+| `fixStandingMountConflict` | `true` | DSH ≤ 0.1.6-alpha.2 兼容补丁：幂等化 `cordisInspect.register`，修复 preset standing-mount 多代并存冲突（仅代码常量）/ idempotent `cordisInspect.register` patch for the DSH ≤ 0.1.6-alpha.2 standing-mount conflict (code constant only) |
 
-**窗口约束 / Window constraint**：`detectionWindow` 必须 ≥ `threshold × maxUnitLength`；否则长度超过
-`floor(detectionWindow / threshold)` 的重复单元凑不满重复次数，无法被识别（例如窗口 80、阈值 10 时，
-超过 8 字符的单元不再触发）。设置页在该约束被违反时显示
-「⚠ 检测窗口长度需要提高：至少 N（当前 M = 阈值 × 最大单元）」的提示，宿主日志同时打印一条告警；
-该约束**只提示不拒绝写入**，便于按需权衡内存占用与可识别单元长度。
+**窗口约束 / Window constraint**：`detectionWindow` 必须 ≥ `threshold × codeBlockMultiplier × maxUnitLength`
+（关闭代码块放宽时倍数按 1 计）；否则长度超过 `floor(detectionWindow / 最严格阈值)` 的重复单元凑不满重复
+次数，无法被识别（例如窗口 80、阈值 10、倍数 3 时，超过 2 字符的单元不再触发）。设置页在该约束被违反时
+显示「⚠ 检测窗口长度需要提高：至少 N（当前 M = 阈值 × 倍数 × 最大单元）」的提示，宿主日志同时打印一条
+告警；该约束**只提示不拒绝写入**，便于按需权衡内存占用与可识别单元长度。
 
 The settings page shows a "detection window is too small" hint (and the host logs a matching warning)
-whenever `detectionWindow < threshold × maxUnitLength`; the write is still accepted.
+whenever `detectionWindow < threshold × codeBlockMultiplier × maxUnitLength`; the write is still accepted.
 
 ---
 
@@ -156,9 +209,9 @@ Listens to the `llm/stream` waterfall (wraps every streaming model call) and ret
 ### 2. 检测算法 / Detection
 
 - 按块索引（`chunk.index`）分别累积文本，多块交替输出互不干扰；
-- 去空白后做**尾部连续重复检测**：文本以某个单元（长度 1..80）连续重复 ≥ 阈值结尾即触发。
-  模型一旦复读，重复必然在尾部，因此尾部检测即可实时捕获所有循环，同时避免全窗口词频的误报
-  （如正常中文里高频的"的"）。
+- 去空白后做**尾部连续重复检测**：文本以某个单元（长度 `minUnitLength`..`maxUnitLength`，默认 1..80）
+  连续重复 ≥ `threshold` 次结尾即触发。模型一旦复读，重复必然在尾部，因此尾部检测即可实时捕获所有
+  循环，同时避免全窗口词频的误报（如正常中文里高频的"的"）。
 
 Tails-only consecutive-run detection on the whitespace-stripped buffer: catches every loop in real time
 without the false positives of whole-window frequency counting.
@@ -211,10 +264,15 @@ default), Markdown table separator rows and horizontal rules (whitelisted by def
 │   ├── index.js                # npm/组合常驻形式（package.json main 入口，含设置集成）
 │   └── client.js               # 浏览器端设置页（ModuleLoader 格式，dsh.client 入口）
 ├── tests/
-│   ├── detector.test.js        # 端到端测试：双入口防漂移 + reasoning 开关 + settings 集成
-│   ├── client.test.js          # 设置页组件测试：最小 React/DSH 桩驱动写路径
-│   └── experiment-cancel.mjs   # 诊断实验（不进 CI）：验证截停不阻塞于底层流取消
-├── .github/workflows/ci.yml    # GitHub Actions：Node 20/22/24
+│   ├── detector.test.js        # 端到端测试：双入口防漂移 + reasoning 开关 + settings 集成（74 项）
+│   ├── client.test.js          # 设置页组件测试：最小 React/DSH 桩驱动写路径（16 项）
+│   ├── stress-host-adversarial.js  # 压力：边界/协议交错/热更新 churn/畸形输入
+│   ├── stress-host-throughput.js   # 压力：吞吐/内存/200 路并发/参数极值（METRIC 指标）
+│   ├── stress-client-ui.js         # 压力：设置页高频交互、乱序应答、挂载泄漏
+│   ├── stress-real-invariant.mjs   # 压力：真实 DSH llm-invariant + BlockAssembler 端到端校验
+│   ├── experiment-cancel.mjs       # 诊断实验（不进 CI）：验证截停不阻塞于底层流取消
+│   └── experiment-inspect-patch.mjs # 诊断实验：standing-mount 补丁的多代并存行为
+├── .github/workflows/          # ci.yml（Node 20/22/24 跑 npm test）+ publish.yml（v* 标签发布 npm）
 ├── cordis.patch.yml            # bundle 补丁层（dsh.bundle.patch：插入宿主行）
 ├── package.json
 ├── CHANGELOG.md
@@ -225,20 +283,49 @@ default), Markdown table separator rows and horizontal rules (whitelisted by def
 ## 测试 / Tests
 
 ```bash
-npm test                      # 两个测试文件
-node tests/detector.test.js   # 检测端到端（48 项）
-node tests/client.test.js     # 设置页组件（6 项）
+npm test                      # 功能测试（两个文件）
+node tests/detector.test.js   # 检测端到端（74 项）
+node tests/client.test.js     # 设置页组件（16 项）
 ```
 
-同一套 15 项用例分别驱动两个入口（`plugin/host.js` 经 `new Function` 求值、`lib/index.js` 经
+同一套用例分别驱动两个入口（`plugin/host.js` 经 `new Function` 求值、`lib/index.js` 经
 `require` 加载），覆盖：透传完整性、各类复读形态、阈值边界、协议闭合、上游 `return()` 调用、
-默认不检测 reasoning/工具参数、未闭合工具调用块的闭合、多次调用状态隔离等。`client.test.js`
-用最小 React 与 DSH 客户端桩驱动设置页组件，断言写入走 `settingsScope` 控制器
+默认不检测 reasoning/工具参数、未闭合工具调用块的闭合、多次调用状态隔离、设置 schema 与热更新等。
+`client.test.js` 用最小 React 与 DSH 客户端桩驱动设置页组件，断言写入走 `settingsScope` 控制器
 （`set`/`unset`）而非已移除的 `connection.api`。CI 在 Node 20/22/24 上运行
 （与 DSH 一致，不支持 Node 18）。
 
-The same 15-test suite drives both entries, guarding against drift between the two forms. CI runs on
-Node 20/22/24 (matching DSH; Node 18 is not supported).
+### 压力测试 / Stress suites
+
+```bash
+npm run stress                          # 依次运行下列四套
+node tests/stress-host-adversarial.js   # 边界/周期重叠/分块不变性/协议交错/围栏代码块/设置 churn/畸形输入
+node tests/stress-host-throughput.js    # 吞吐、最坏情况扫描、命中延迟、内存、200 路并发、参数极值
+node tests/stress-client-ui.js          # 设置页 500 条白名单、1000 次混合操作、写应答乱序、churn、挂载泄漏
+node tests/stress-real-invariant.mjs    # 用真实 DSH 的 llm-invariant 与 BlockAssembler 校验截停收尾
+```
+
+后一套使用本机安装的 `@deepseek-ai/dsh-llm`（依次探测 `$DSH_LLM_DIR`、`$DSH_INSTALL`、
+`$DSH_HOME`、全局 npm 安装），找不到时打印 SKIP 并跳过，因此可安全地在任意环境运行。
+
+实测参考（Windows / Node 24，默认参数除注明外）：
+
+| 指标 | 实测 |
+| --- | --- |
+| 增量吞吐（窗口 8192） | 1 字符增量 1.9 µs/增量（533 chars/ms）；1KB 增量 11 µs/增量（92k chars/ms） |
+| 增量吞吐（窗口 1 MiB） | 4 字符增量 33 µs/增量（118 chars/ms）——每增量重写整个窗口，大窗口显著变慢 |
+| 最坏情况扫描（近失配周期文本） | 2.7 µs/增量 |
+| 命中延迟 | 阈值 10 时消费 12 字符即截停（尾部即时判定） |
+| 5,000,000 字符长流 | 堆增长约 32 MB（完整文本 + 检测窗口），无额外无界增长 |
+| 200 路并发 | 136 ms；1 路复读被截停，其余 199 路完整透传 |
+| 设置页 500 条白名单 | 渲染 0.3 ms；逐个删除 500 次 = 500 次写入 |
+| 设置页 1000 次混合操作 | 24 ms、887 次写入，终态与控制器快照一致 |
+| 500 次挂载/卸载 | subscribe 1000 / dispose 999（余 1 为当前挂载），无监听器泄漏 |
+
+The same suite drives both entries. Stress suites cover host throughput/memory/concurrency, adversarial
+protocol interleavings, client UI churn, and an end-to-end check against the installed DSH
+`llm-invariant` validator plus the real `BlockAssembler`; `tests/stress-real-invariant.mjs` skips itself
+when DSH is not installed. CI runs on Node 20/22/24 (matching DSH; Node 18 is not supported).
 
 ---
 
@@ -247,8 +334,17 @@ Node 20/22/24 (matching DSH; Node 18 is not supported).
 - 停止时若恰有未闭合的工具调用块（顺序输出块的适配器几乎不可能），该块会按已累积参数闭合并可能被执行。
 - 服务端停止依赖适配器在流关闭时中止底层请求的语义（已验证 `dsh-llm-deepseek`；自定义适配器需自查）。
 - 阈值语义为 `>= threshold`：第 10 次重复出现时即停止。
-
-### DSH 运行期间编辑 preset 后的 standing-mount 冲突（DSH ≤ 0.1.2-rc.1 缺陷，本插件已内置补丁）
+- **代码块放宽只覆盖围栏代码块**：行内代码（`` `x` ``）与缩进代码块（4 空格）仍按普通阈值判定；
+  模型忘记闭合围栏时，其后内容一律按代码块（放宽）处理，且**代码块内的失控复读要到「阈值 × 倍数」
+  才会被截停**（默认 30 次），这是「避免误杀生成的代码」的代价——把倍数调小可获得更早的兜底。
+- 检测窗口上限 1,048,576 字符：每个增量都要重写一次缓冲，成本随窗口线性增长——缓冲填满后
+  1 MiB 窗口约 0.13 ms/增量，实测 4 字符增量的平均值为 33 µs/增量（含缓冲填充期）。默认 8192 无感
+  （1.9 µs/增量，模型侧毫秒级的 token 间隔下可忽略）。
+- 若手工编辑 `settings.yaml` 写入非法值（如 `minUnitLength > maxUnitLength`），DSH 会在注册时拒绝该
+  命名空间，本插件捕获后仅打印错误日志并整体回落到代码默认值（检测功能不受影响，设置页显示默认值）。
+- 协议新增 `ContentBlock` 类型时，截停收尾对未知块类型只能按 tool-call 兜底并打印一次性告警。
+
+### DSH 运行期间编辑 preset 后的 standing-mount 冲突（DSH ≤ 0.1.6-alpha.2 缺陷，本插件已内置补丁）
 
 **现象**：对某个会话执行模型选择等操作时报
 `resume failed ... preset ... failed to mount ... Host Cordis inspect provider "Service" is already registered`，
@@ -264,8 +360,8 @@ while the process lives"）。`tool-cordis` 在每次挂载时向**进程全局*
 **本插件的修复（默认开启）**：`apply` 时把 `cordisInspect.register` **幂等化**——同 id 已有注册时
 共享既有注册并返回 no-op disposer，多代并存不再冲突。补丁进程内常驻（卸载本插件后仍生效，
 重启后由本插件重新安装；HMR 重载不会叠加）。依赖 `cordisInspect.providers` 为可读 Map
-（rc.6 / rc.7 / 0.1.1-rc.1 / 0.1.2-rc.1 实测如此）；0.1.2-rc.1 上游仍留有
-"reclaim the superseded generation" 的 TODO，缺陷未修复，故默认开启。
+（rc.6 / rc.7 / 0.1.1-rc.1 / 0.1.2-rc.1 / 0.1.5-rc.2 / 0.1.6-alpha.2 实测如此）；0.1.6-alpha.2 上游
+仍留有 "reclaim the superseded generation" 的 TODO，缺陷未修复，故默认开启。
 DSH 升级修复后可将 `CONFIG.fixStandingMountConflict` 置为 `false` 关闭。
 
 **仍建议的操作纪律**：运行期间编辑已挂载 preset 后重启 DSH（补丁消除的是报错，旧代残留的
@@ -279,7 +375,7 @@ its process-global Host inspect providers (`Service` …) twice and every retry
 patches it by default**: `cordisInspect.register` is made idempotent (a same-id registration shares
 the existing one and gets a no-op disposer), so coexisting generations no longer collide. The patch
 is process-resident (survives plugin unload, reinstalled on restart; HMR reload does not stack it);
-set `CONFIG.fixStandingMountConflict` to `false` once a fixed DSH ships. Still open in 0.1.2-rc.1:
+set `CONFIG.fixStandingMountConflict` to `false` once a fixed DSH ships. Still open in 0.1.6-alpha.2:
 upstream carries a TODO to reclaim superseded generations.
 
 ## License

package/lib/client.js

@@ -24,9 +24,9 @@ window.__ModuleLoader__.load({
       nav: '重复守卫',
       title: '重复输出守卫',
       intro: '模型输出中同一字符串连续重复达到阈值次数时自动截停。以下参数修改后即时生效并持久化（settings.yaml）。',
-      list: '忽略字符（白名单）',
+      list: '忽略字符（白名单，按单个字符匹配）',
       empty: '白名单为空：所有字符都参与重复统计。',
-      addPlaceholder: '输入要忽略的字符',
+      addPlaceholder: '输入要忽略的字符（可多个）',
       add: '添加',
       params: '检测参数',
       threshold: '触发阈值（连续重复次数）',
@@ -36,9 +36,13 @@ window.__ModuleLoader__.load({
       maxUnitLength: '最大重复单元长度',
       maxUnitLengthHint: '可识别的最长重复单元（清洗后字符数，空白与白名单字符不计）。范围 {min}–{max}。',
       detectionWindow: '检测窗口（字符）',
-      detectionWindowHint: '检测缓冲保留的字符数。范围 {min}–{max}；需 ≥ 阈值 × 最大单元长度，否则长单元凑不满重复次数。',
+      detectionWindowHint: '检测缓冲保留的字符数。范围 {min}–{max}；需 ≥ 阈值 × 代码块倍数 × 最大单元长度，否则长单元凑不满重复次数。',
+      codeBlockMultiplier: '代码块内阈值倍数',
+      codeBlockMultiplierHint: '围栏代码块（``` / ~~~）内的重复按「阈值 × 本倍数」判定。范围 {min}–{max}；越大越不容易误杀正常代码，但也越晚兜住代码块里的失控复读（1 = 不放宽）。',
       stripWhitespace: '忽略空白字符',
       stripWhitespaceHint: '检测前移除所有空白（含换行），使「重复 重复」「重复\\n重复」这类带分隔的复读也能识别。',
+      skipCodeBlocks: '放宽代码块内的检测',
+      skipCodeBlocksHint: '开启后围栏代码块（``` / ~~~）内改用放宽阈值，避免生成的代码、测试夹具、表格、ASCII 图被误判为复读；行内代码与缩进代码块不受影响。',
       monitorReasoning: '检测思考内容（reasoning）',
       monitorReasoningHint: '思考中的复读同样消耗 token，默认一并检测。',
       monitorToolArguments: '检测工具调用参数',
@@ -51,7 +55,8 @@ window.__ModuleLoader__.load({
       errInteger: '请输入整数。',
       errRange: '取值范围 {min}–{max}。',
       errCross: '不能小于最小重复单元长度（当前 {min}）。',
-      windowWarn: '⚠ 检测窗口长度需要提高：至少 {need}（当前 {current} = 阈值 {threshold} × 最大单元 {maxUnit}）。当前窗口下超过 {effective} 字符的重复单元无法识别。',
+      errCrossMin: '不能大于最大重复单元长度（当前 {max}）。',
+      windowWarn: '⚠ 检测窗口长度需要提高：至少 {need}（当前 {current} = 阈值 {threshold} × 代码块倍数 {multiplier} × 最大单元 {maxUnit}）。当前窗口下超过 {effective} 字符的重复单元无法识别。',
       loading: '加载中…',
       remoteHint: '设置修改仅支持本机连接：请通过本机地址（127.0.0.1）打开 DSH 页面后重试。远程访问时 DSH 的设置通道被禁用，检测参数将使用默认值。',
       unavailable: '设置服务不可用：未读取到「重复守卫」的设置数据。请确认 DSH 为 npm 常驻版挂载（宿主日志应包含「已注册设置命名空间 dsh-dupguard」），并刷新页面重试。',
@@ -60,9 +65,9 @@ window.__ModuleLoader__.load({
       nav: 'Dupguard',
       title: 'Repetition Guard',
       intro: 'Generation stops when the same string repeats consecutively up to the threshold. Changes below take effect immediately and persist to settings.yaml.',
-      list: 'Ignored characters (whitelist)',
+      list: 'Ignored characters (whitelist, matched per character)',
       empty: 'Whitelist is empty: every character counts.',
-      addPlaceholder: 'Character to ignore',
+      addPlaceholder: 'Characters to ignore (one or more)',
       add: 'Add',
       params: 'Detection parameters',
       threshold: 'Threshold (consecutive repeats)',
@@ -72,9 +77,13 @@ window.__ModuleLoader__.load({
       maxUnitLength: 'Maximum repeating-unit length',
       maxUnitLengthHint: 'Longest repeating unit recognized, in characters after cleaning (whitespace and whitelisted characters are removed). Range {min}–{max}.',
       detectionWindow: 'Detection window (characters)',
-      detectionWindowHint: 'Characters retained in the detection buffer. Range {min}–{max}; must be >= threshold x max unit length, otherwise long units never reach the repeat count.',
+      detectionWindowHint: 'Characters retained in the detection buffer. Range {min}–{max}; must be >= threshold x code-block multiplier x max unit length, otherwise long units never reach the repeat count.',
+      codeBlockMultiplier: 'Code-block threshold multiplier',
+      codeBlockMultiplierHint: 'Inside fenced code blocks (``` / ~~~) a repeat must reach threshold x this multiplier. Range {min}–{max}; higher means fewer false stops on generated code, but runaway loops inside code are caught later (1 = no relaxation).',
       stripWhitespace: 'Ignore whitespace',
       stripWhitespaceHint: 'Remove all whitespace (newlines included) before detection, so separated repeats are still recognized.',
+      skipCodeBlocks: 'Relax detection inside code blocks',
+      skipCodeBlocksHint: 'With this on, fenced code blocks (``` / ~~~) use the relaxed threshold, so generated code, fixtures, tables and ASCII art are not mistaken for repetition loops. Inline code and indented code blocks are unaffected.',
       monitorReasoning: 'Monitor reasoning text',
       monitorReasoningHint: 'Repeats inside reasoning burn tokens too, so they are monitored by default.',
       monitorToolArguments: 'Monitor tool-call arguments',
@@ -87,7 +96,8 @@ window.__ModuleLoader__.load({
       errInteger: 'Enter an integer.',
       errRange: 'Allowed range {min}–{max}.',
       errCross: 'Must not be smaller than the minimum unit length (currently {min}).',
-      windowWarn: '⚠ Detection window is too small: needs at least {need} (currently {current} = threshold {threshold} x max unit {maxUnit}). Units longer than {effective} characters cannot be detected with the current window.',
+      errCrossMin: 'Must not be larger than the maximum unit length (currently {max}).',
+      windowWarn: '⚠ Detection window is too small: needs at least {need} (currently {current} = threshold {threshold} x code-block multiplier {multiplier} x max unit {maxUnit}). Units longer than {effective} characters cannot be detected with the current window.',
       loading: 'Loading…',
       remoteHint: 'Settings editing requires a local connection: open the DSH page through the local address (127.0.0.1) and retry. Remote browsers have the settings channel disabled and detection keeps its defaults.',
       unavailable: 'Settings unavailable: no data for the Dupguard section was received. Verify the npm build is mounted (the host log should contain "已注册设置命名空间 dsh-dupguard") and refresh the page.',
@@ -140,18 +150,21 @@ window.__ModuleLoader__.load({
     // ---------------------------------------------------------------------
     const NUMERIC_FIELDS = [
       { key: 'threshold', min: 2, max: 1000 },
+      { key: 'codeBlockMultiplier', min: 1, max: 100 },
       { key: 'minUnitLength', min: 1, max: 4096 },
       { key: 'maxUnitLength', min: 1, max: 8192 },
       { key: 'detectionWindow', min: 64, max: 1048576 },
     ]
-    const BOOL_FIELDS = ['stripWhitespace', 'monitorReasoning', 'monitorToolArguments']
+    const BOOL_FIELDS = ['stripWhitespace', 'skipCodeBlocks', 'monitorReasoning', 'monitorToolArguments']
     const DEFAULTS = {
       ignoredChars: ['-', '|'],
       threshold: 10,
+      codeBlockMultiplier: 3,
       minUnitLength: 1,
       maxUnitLength: 80,
       detectionWindow: 8192,
       stripWhitespace: true,
+      skipCodeBlocks: true,
       monitorReasoning: true,
       monitorToolArguments: false,
     }
@@ -281,18 +294,26 @@ window.__ModuleLoader__.load({
         const value = parsed[field.key]
         if (!Number.isInteger(value)) return t('errInteger')
         if (value < field.min || value > field.max) return fmt(t('errRange'), { min: field.min, max: field.max })
-        if (field.key === 'maxUnitLength' && crossInvalid) return fmt(t('errCross'), { min: parsed.minUnitLength })
+        // 跨字段约束在两侧都提示：否则从「最小单元」一侧提交违规值时，
+        // 只能拿到宿主拒绝后的泛化「保存失败」。
+        if (crossInvalid && field.key === 'maxUnitLength') return fmt(t('errCross'), { min: parsed.minUnitLength })
+        if (crossInvalid && field.key === 'minUnitLength') return fmt(t('errCrossMin'), { max: parsed.maxUnitLength })
         return null
       }
 
-      // 窗口缺口提示：窗口 < 阈值 × 最大单元长度时，更长的单元无法凑满重复次数。
-      const shortfall = numericValid && !crossInvalid && parsed.detectionWindow < parsed.threshold * parsed.maxUnitLength
+      // 窗口缺口提示：窗口 < 最严格阈值 × 最大单元长度时，更长的单元无法凑满重复次数。
+      // 代码块内使用放宽阈值（阈值 × 倍数），因此窗口需按更严格的一侧计算。
+      const strictThreshold = shown.skipCodeBlocks === true
+        ? parsed.threshold * parsed.codeBlockMultiplier
+        : parsed.threshold
+      const shortfall = numericValid && !crossInvalid && parsed.detectionWindow < strictThreshold * parsed.maxUnitLength
         ? {
-            need: parsed.threshold * parsed.maxUnitLength,
+            need: strictThreshold * parsed.maxUnitLength,
             current: parsed.detectionWindow,
             threshold: parsed.threshold,
+            multiplier: shown.skipCodeBlocks === true ? parsed.codeBlockMultiplier : 1,
             maxUnit: parsed.maxUnitLength,
-            effective: Math.floor(parsed.detectionWindow / parsed.threshold),
+            effective: Math.floor(parsed.detectionWindow / strictThreshold),
           }
         : null
 
@@ -326,8 +347,15 @@ window.__ModuleLoader__.load({
           return
         }
         const value = parsed[field.key]
-        dirty.current[field.key] = true
         setErrors((prev) => ({ ...prev, [field.key]: null }))
+        // 值未变化时不写入：避免仅仅聚焦/失焦就把默认值写进用户层，
+        // 污染 settings.yaml 并让「恢复默认」失去意义。
+        if (snapshotValue()[field.key] === value) {
+          dirty.current[field.key] = false
+          setForm({ ...currentForm(), [field.key]: String(value) })
+          return
+        }
+        dirty.current[field.key] = true
         setForm({ ...currentForm(), [field.key]: String(value) })
         runWrite(() => controller.set(field.key, value), () => snapshotValue()[field.key] === value)
       }
@@ -353,11 +381,20 @@ window.__ModuleLoader__.load({
       }
 
       const add = () => {
-        const ch = draft.trim()
-        if (ch.length === 0) return
+        const text = draft.trim()
+        if (text.length === 0) return
         setDraft('')
-        if (shown.ignoredChars.indexOf(ch) !== -1) return
-        commitList([...shown.ignoredChars, ch])
+        // 白名单按单个字符匹配：一次输入多个字符时逐个加入（忽略输入中的空白），
+        // 否则整串会被当成一个条目，永远不会命中。
+        const next = [...shown.ignoredChars]
+        let changed = false
+        for (const ch of text) {
+          if (/\s/.test(ch)) continue
+          if (next.indexOf(ch) !== -1) continue
+          next.push(ch)
+          changed = true
+        }
+        if (changed) commitList(next)
       }
       const remove = (ch) => commitList(shown.ignoredChars.filter((item) => item !== ch))
 

package/lib/index.js

@@ -31,6 +31,7 @@ const LIMITS = {
   minUnitLength: { min: 1, max: 4096 },
   maxUnitLength: { min: 1, max: 8192 },
   detectionWindow: { min: 64, max: 1048576 },
+  codeBlockMultiplier: { min: 1, max: 100 },
 }
 
 /**
@@ -52,7 +53,9 @@ function loadSettingsSchema() {
         minUnitLength: z.number().min(LIMITS.minUnitLength.min).max(LIMITS.minUnitLength.max).step(1).default(CONFIG.minUnitLength),
         maxUnitLength: z.number().min(LIMITS.maxUnitLength.min).max(LIMITS.maxUnitLength.max).step(1).default(CONFIG.maxUnitLength),
         detectionWindow: z.number().min(LIMITS.detectionWindow.min).max(LIMITS.detectionWindow.max).step(1).default(CONFIG.detectionWindow),
+        codeBlockMultiplier: z.number().min(LIMITS.codeBlockMultiplier.min).max(LIMITS.codeBlockMultiplier.max).step(1).default(CONFIG.codeBlockMultiplier),
         stripWhitespace: z.boolean().default(CONFIG.stripWhitespace),
+        skipCodeBlocks: z.boolean().default(CONFIG.skipCodeBlocks),
         monitorReasoning: z.boolean().default(CONFIG.monitorReasoning),
         monitorToolArguments: z.boolean().default(CONFIG.monitorToolArguments),
       })
@@ -78,7 +81,17 @@ const CONFIG = {
   // 检测时忽略的字符（白名单）：Markdown 表格的分隔行由连字符与竖线组成
   // （如 "|---|---|"），正常表格输出会大量连续出现，不应视为复读。
   // 默认忽略连字符与竖线；需要更严格的检测时可改为空数组 []。
+  // 条目必须是单个字符（按 Unicode 码点匹配，emoji 也算一个）；
+  // 多字符条目永远不会命中，运行时会丢弃并告警。
   ignoredChars: ['-', '|'],
+  // 围栏代码块（``` / ~~~）内的重复检测放宽：代码里的重复串（生成的测试夹具、表格、
+  // ASCII 图、内嵌数据等）大多属于正常内容，按普通阈值会误杀。开启后块内改用
+  // threshold × codeBlockMultiplier 判定：既能放过正常代码，又能兜住真正的失控复读。
+  // 置 false 则关闭该行为（块内与块外同样严格）；倍数置 1 等价于不放宽。
+  // 局限：只识别围栏代码块，行内代码（`x`）与缩进代码块（4 空格）仍按普通阈值判定；
+  // 模型忘记闭合围栏时，其后内容都按代码块（放宽）处理。
+  skipCodeBlocks: true,
+  codeBlockMultiplier: 3,
   // 是否同时检测思考（reasoning）文本。默认开启：思考中的复读同样消耗 token，
   // 应立即截停。注意：正常思考中若连续重复同一字符串 10 次以上（如"等等等等"），
   // 也会被截停，属预期行为；需要只检测可见输出时可置为 false。
@@ -129,12 +142,11 @@ function stripWhitespace(text) {
   return text.replace(/\s+/g, '')
 }
 
-/** 移除白名单字符（与 CONFIG.ignoredChars 配合）。 */
+/** 移除白名单字符（与 CONFIG.ignoredChars 配合）。按 Unicode 码点逐个比对。 */
 function stripIgnoredChars(text, ignored) {
   if (ignored.length === 0) return text
   let out = ''
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i]
+  for (const ch of text) {
     if (ignored.indexOf(ch) === -1) out += ch
   }
   return out
@@ -147,6 +159,194 @@ function sanitizeDelta(delta, config) {
   return piece
 }
 
+/**
+ * 流式围栏代码块过滤器（每个文本块一份状态）。
+ *
+ * 目标：把增量切成「普通文本 / 代码块内文本」两段，供检测按不同阈值判定——
+ * 代码块内的重复大多是正常内容（生成的测试夹具、表格、ASCII 图、内嵌数据），
+ * 按普通阈值会误杀，故块内使用放宽阈值。
+ *
+ * 规则按 CommonMark 的围栏代码块：
+ *   - 起始行：行首最多 3 个空格 + 连续 ≥3 个 ` 或 ~（其后为 info string）；
+ *   - 结束行：行首最多 3 个空格 + 同字符且不短于起始长度的连续 run，其后仅允许空白；
+ *   - 未闭合的围栏一直延续到该块结束。
+ * 增量切分安全：围栏标记被切进多个 delta（如 "``" + "`js"）时靠行首缓冲继续判定。
+ * 局限：不识别行内代码（`x`）与缩进代码块（4 空格），它们按普通文本处理。
+ */
+function createFenceFilter() {
+  // 围栏字符 run 的长度上限：超过即按上限记录并进入代码块，避免无界缓冲。
+  const MAX_FENCE_RUN = 64
+  let atLineStart = true
+  let head = '' // 行首缓冲：最多 3 个空格 + 可能的围栏字符 run
+  let headSpaces = 0
+  let headChar = ''
+  let fence = null // { char, len }：已进入代码块
+  let closeLine = '' // 代码块内当前行（用于判定结束行）
+  let closeTooLong = false
+
+  const runLength = () => head.length - headSpaces
+  const resetHead = () => {
+    head = ''
+    headSpaces = 0
+    headChar = ''
+  }
+
+  /** 当前行是否为结束行（同字符、不短于起始长度、其后仅空白）。 */
+  function isClosingLine(line) {
+    const body = line.replace(/[ \t]+$/, '')
+    const indent = body.length - body.replace(/^ {0,3}/, '').length
+    const run = body.slice(indent)
+    if (run.length < fence.len) return false
+    for (let i = 0; i < run.length; i++) {
+      if (run[i] !== fence.char) return false
+    }
+    return true
+  }
+
+  return {
+    /** 当前是否处于围栏代码块内（诊断/测试用）。 */
+    inside: () => fence !== null,
+    /**
+     * 消费一个增量，返回按「是否位于代码块内」切分的片段序列。
+     * 片段按原始顺序首尾相接即为完整增量，调用方据此分别用普通/放宽阈值检测。
+     * @param delta - 文本增量。
+     * @returns {Array<{ text: string, code: boolean }>} 片段序列（可能为空数组）。
+     */
+    push(delta) {
+      // 快路径：不含围栏字符与换行的增量不可能改变围栏状态。
+      if (fence !== null && delta.indexOf(fence.char) === -1 && delta.indexOf('\n') === -1) {
+        return [{ text: delta, code: true }]
+      }
+      if (fence === null && !atLineStart &&
+        delta.indexOf('`') === -1 && delta.indexOf('~') === -1 && delta.indexOf('\n') === -1) {
+        return [{ text: delta, code: false }]
+      }
+      const runs = []
+      let buffer = ''
+      let bufferCode = fence !== null
+      const emit = (text, code) => {
+        if (text.length === 0) return
+        if (buffer.length > 0 && code !== bufferCode) {
+          runs.push({ text: buffer, code: bufferCode })
+          buffer = ''
+        }
+        bufferCode = code
+        buffer += text
+      }
+      for (let i = 0; i < delta.length; i++) {
+        const ch = delta[i]
+        if (fence !== null) {
+          // 代码块内：只判定结束行，内容整体按代码发射。
+          if (ch === '\n') {
+            const closing = isClosingLine(closeLine)
+            emit(ch, true)
+            closeLine = ''
+            closeTooLong = false
+            if (closing) {
+              fence = null
+              atLineStart = true
+              resetHead()
+              bufferCode = false
+            }
+            continue
+          }
+          if (!closeTooLong) {
+            closeLine += ch
+            if (closeLine.length > fence.len + 8) closeTooLong = true
+          }
+          emit(ch, true)
+          continue
+        }
+        if (atLineStart) {
+          if (ch === ' ' && headChar === '' && headSpaces < 3) {
+            head += ch
+            headSpaces++
+            continue
+          }
+          if ((ch === '`' || ch === '~') && (headChar === '' || headChar === ch)) {
+            headChar = ch
+            head += ch
+            // 不能一见 3 个就进入：起始行的完整 run 才是围栏长度（```` 不能被 ``` 关闭）。
+            if (runLength() >= MAX_FENCE_RUN) {
+              emit(head, true)
+              fence = { char: ch, len: runLength() }
+              closeLine = ''
+              closeTooLong = false
+              atLineStart = false
+              resetHead()
+            }
+            continue
+          }
+          if (headChar !== '' && runLength() >= 3) {
+            // 起始行（含行首空格与围栏符）整体属于代码块，长度取完整 run。
+            emit(head, true)
+            fence = { char: headChar, len: runLength() }
+            closeLine = ''
+            closeTooLong = false
+            atLineStart = false
+            resetHead()
+            emit(ch, true)
+            continue
+          }
+          // 判定不是围栏起始：行首缓冲按普通文本交还。
+          emit(head, false)
+          resetHead()
+          atLineStart = ch === '\n'
+          emit(ch, false)
+          continue
+        }
+        emit(ch, false)
+        if (ch === '\n') {
+          atLineStart = true
+          resetHead()
+        }
+      }
+      if (buffer.length > 0) runs.push({ text: buffer, code: bufferCode })
+      return runs
+    },
+  }
+}
+
+/**
+ * 未知块类型只会在 DSH 协议新增 ContentBlock 类型时出现：此时没有合法的合成
+ * block-end，只能按 tool-call 兜底并告警一次，便于定位协议漂移。
+ */
+let warnedUnknownBlockType = false
+function warnUnknownBlockType(blockType) {
+  if (warnedUnknownBlockType) return
+  warnedUnknownBlockType = true
+  console.warn(
+    '[dupguard] 遇到未知块类型 ' + JSON.stringify(blockType) +
+    '：截停收尾只能按 tool-call 兜底，请升级插件以匹配新的 DSH 协议。'
+  )
+}
+
+/**
+ * 白名单按「单个字符」（Unicode 码点）匹配：多字符或空条目永远不会命中，
+ * 属于无效配置。此处丢弃并告警，避免设置页显示了一个永远不生效的条目。
+ */
+function normalizeIgnoredChars(raw, fallback) {
+  if (!Array.isArray(raw)) return [...fallback]
+  const kept = []
+  const dropped = []
+  for (const entry of raw) {
+    if (typeof entry !== 'string') {
+      dropped.push(String(entry))
+      continue
+    }
+    // [...entry] 按码点拆分：emoji 等代理对字符算一个字符。
+    if ([...entry].length === 1) kept.push(entry)
+    else dropped.push(entry)
+  }
+  if (dropped.length > 0) {
+    console.warn(
+      '[dupguard] 白名单条目必须是单个字符，已忽略无效条目：' + JSON.stringify(dropped) +
+      '（白名单按字符匹配，多字符条目不会生效）。'
+    )
+  }
+  return kept
+}
+
 /**
  * 为一次 llm/stream 调用创建守卫。
  * 每次模型调用都会新建一份状态，互不干扰。
@@ -168,6 +368,7 @@ function createStreamGuard(options, runtime) {
         blockType,
         text: '',            // 完整文本：停止时需要用它闭合块，不能只保留窗口
         stripped: '',        // 去空白后的滚动窗口：仅用于检测
+        fence: createFenceFilter(), // 围栏代码块状态（skipCodeBlocks 开启时使用）
         toolCallId: undefined,
         toolCallName: undefined,
         toolCallArguments: '',
@@ -177,12 +378,25 @@ function createStreamGuard(options, runtime) {
     return b
   }
 
-  /** 把一段文本增量喂给检测缓冲，返回命中结果（null 表示未命中）。 */
+  /**
+   * 把一段文本增量喂给检测缓冲，返回命中结果（null 表示未命中）。
+   *
+   * 增量会先按围栏代码块切成片段：块外按 threshold 判定，块内按
+   * threshold × codeBlockMultiplier 判定（放宽，避免误杀正常代码）。
+   */
   function feedText(b, delta) {
     b.text += delta
-    const piece = sanitizeDelta(delta, runtime)
-    b.stripped = (b.stripped + piece).slice(-runtime.detectionWindow)
-    return findRepeatedTail(b.stripped, runtime.threshold, runtime.minUnitLength, runtime.maxUnitLength)
+    const codeThreshold = Math.max(runtime.threshold, runtime.threshold * runtime.codeBlockMultiplier)
+    const runs = runtime.skipCodeBlocks ? b.fence.push(delta) : [{ text: delta, code: false }]
+    for (const run of runs) {
+      const piece = sanitizeDelta(run.text, runtime)
+      if (piece.length === 0) continue
+      b.stripped = (b.stripped + piece).slice(-runtime.detectionWindow)
+      const threshold = run.code ? codeThreshold : runtime.threshold
+      const hit = findRepeatedTail(b.stripped, threshold, runtime.minUnitLength, runtime.maxUnitLength)
+      if (hit !== null) return { unit: hit.unit, count: hit.count, span: hit.span, code: run.code }
+    }
+    return null
   }
 
   /** 依据 StreamChunk 协议累积状态；命中时置 stopped。 */
@@ -241,6 +455,7 @@ function createStreamGuard(options, runtime) {
     } else if (b.blockType === 'reasoning') {
       block = { type: 'reasoning', text: b.text }
     } else {
+      if (b.blockType !== 'tool-call') warnUnknownBlockType(b.blockType)
       block = {
         type: 'tool-call',
         id: b.toolCallId !== undefined ? b.toolCallId : 'call-' + index,
@@ -273,7 +488,8 @@ function createStreamGuard(options, runtime) {
           '[dupguard] 检测到重复输出，已停止生成：provider=' + provider + ' model=' + model +
           ' unit=' + JSON.stringify(stopped.unit) +
           ' repeat>=' + String(stopped.count) +
-          ' span=' + String(stopped.span) + 'chars'
+          ' span=' + String(stopped.span) + 'chars' +
+          (stopped.code === true ? ' code-block=true（放宽阈值命中）' : '')
         )
         yield* closingChunks()
         // 提前 return：for-await 会调用上游 iterator.return()，
@@ -331,7 +547,9 @@ function settingsBase() {
     minUnitLength: CONFIG.minUnitLength,
     maxUnitLength: CONFIG.maxUnitLength,
     detectionWindow: CONFIG.detectionWindow,
+    codeBlockMultiplier: CONFIG.codeBlockMultiplier,
     stripWhitespace: CONFIG.stripWhitespace,
+    skipCodeBlocks: CONFIG.skipCodeBlocks,
     monitorReasoning: CONFIG.monitorReasoning,
     monitorToolArguments: CONFIG.monitorToolArguments,
   }
@@ -342,20 +560,29 @@ function createRuntime() {
   return settingsBase()
 }
 
+/** 代码块内实际使用的最严格阈值（未开启代码块放宽时等于 threshold）。 */
+function effectiveCodeThreshold(runtime) {
+  if (runtime.skipCodeBlocks !== true) return runtime.threshold
+  return runtime.threshold * runtime.codeBlockMultiplier
+}
+
 /**
- * 检测窗口是否小于「阈值 × 最大单元长度」。
+ * 检测窗口是否小于「最严格阈值 × 最大单元长度」。
  *
  * 窗口是清洗后保留的字符数：一个长度 p 的单元需要 p × threshold 个字符才可能
- * 凑满阈值，因此 p 超过 floor(窗口 / 阈值) 的重复单元无法被识别。返回缺口描述
- * （含所需窗口）或 null。
+ * 凑满阈值，因此 p 超过 floor(窗口 / 阈值) 的重复单元无法被识别。代码块内使用
+ * 放宽阈值（threshold × codeBlockMultiplier），窗口需按该更严格的一侧计算。
+ * 返回缺口描述（含所需窗口）或 null。
  */
 function windowShortfall(runtime) {
-  const needed = runtime.threshold * runtime.maxUnitLength
+  const threshold = Math.max(runtime.threshold, effectiveCodeThreshold(runtime))
+  const needed = threshold * runtime.maxUnitLength
   if (runtime.detectionWindow >= needed) return null
   return {
     needed: needed,
     current: runtime.detectionWindow,
-    effectiveMaxUnit: Math.floor(runtime.detectionWindow / runtime.threshold),
+    threshold: threshold,
+    effectiveMaxUnit: Math.floor(runtime.detectionWindow / threshold),
   }
 }
 
@@ -363,11 +590,14 @@ function windowShortfall(runtime) {
 function warnShortWindow(runtime) {
   const short = windowShortfall(runtime)
   if (short === null) return
+  const relaxed = short.threshold !== runtime.threshold
   console.warn(
     '[dupguard] 检测窗口长度需要提高：至少 ' + String(short.needed) +
-    '（= 阈值 ' + String(runtime.threshold) + ' × 最大单元长度 ' + String(runtime.maxUnitLength) +
+    '（= 阈值 ' + String(runtime.threshold) +
+    (relaxed ? ' × 代码块倍数 ' + String(runtime.codeBlockMultiplier) : '') +
+    ' × 最大单元长度 ' + String(runtime.maxUnitLength) +
     '），当前 ' + String(short.current) + '；超过 ' + String(short.effectiveMaxUnit) +
-    ' 字符的重复单元将无法识别。请在设置页提高「检测窗口」，或降低阈值/最大单元长度。'
+    ' 字符的重复单元将无法识别。请在设置页提高「检测窗口」，或降低阈值/代码块倍数/最大单元长度。'
   )
 }
 
@@ -386,14 +616,14 @@ function applySettingsToRuntime(runtime, value) {
     return fallback[key]
   }
   const pickBool = (key) => (typeof source[key] === 'boolean' ? source[key] : fallback[key])
-  runtime.ignoredChars = Array.isArray(source.ignoredChars)
-    ? source.ignoredChars.filter((ch) => typeof ch === 'string')
-    : [...fallback.ignoredChars]
+  runtime.ignoredChars = normalizeIgnoredChars(source.ignoredChars, fallback.ignoredChars)
   runtime.threshold = pickInt('threshold')
   runtime.minUnitLength = pickInt('minUnitLength')
   runtime.maxUnitLength = pickInt('maxUnitLength')
   runtime.detectionWindow = pickInt('detectionWindow')
+  runtime.codeBlockMultiplier = pickInt('codeBlockMultiplier')
   runtime.stripWhitespace = pickBool('stripWhitespace')
+  runtime.skipCodeBlocks = pickBool('skipCodeBlocks')
   runtime.monitorReasoning = pickBool('monitorReasoning')
   runtime.monitorToolArguments = pickBool('monitorToolArguments')
   warnShortWindow(runtime)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-dupguard",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Real-time repetition guard for DeepSeek Harness (DSH): stops model generation when the same string repeats >=10 times in the streamed output. 实时检测 DSH 大模型流式输出中的重复内容，同一字符串重复十次以上立即停止生成。",
   "keywords": [
     "dsh-plugin",
@@ -45,7 +45,8 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/detector.test.js && node tests/client.test.js"
+    "test": "node tests/detector.test.js && node tests/client.test.js",
+    "stress": "node tests/stress-host-adversarial.js && node tests/stress-host-throughput.js && node tests/stress-client-ui.js && node tests/stress-real-invariant.mjs"
   },
   "publishConfig": {
     "access": "public"

package/plugin/host.js

@@ -35,6 +35,15 @@ const CONFIG = {
   // （如 "|---|---|"），正常表格输出会大量连续出现，不应视为复读。
   // 默认忽略连字符与竖线；需要更严格的检测时可改为空数组 []。
   ignoredChars: ['-', '|'],
+  // 围栏代码块（``` / ~~~）内的重复检测放宽：代码里的重复串（生成的测试夹具、表格、
+  // ASCII 图、内嵌数据等）大多属于正常内容，按普通阈值会误杀。开启后块内改用
+  // threshold × codeBlockMultiplier 判定：既能放过正常代码，又能兜住真正的失控复读。
+  // 置 false 则关闭该行为（块内与块外同样严格）；倍数置 1 等价于不放宽。
+  // 局限：只识别围栏代码块，行内代码（`x`）与缩进代码块（4 空格）仍按普通阈值判定；
+  // 模型忘记闭合围栏时，其后内容都按代码块（放宽）处理。
+  // 动态版无设置页，此处为代码常量；npm 常驻版可在设置页动态调整同名参数。
+  skipCodeBlocks: true,
+  codeBlockMultiplier: 3,
   // 是否同时检测思考（reasoning）文本。默认开启：思考中的复读同样消耗 token，
   // 应立即截停。注意：正常思考中若连续重复同一字符串 10 次以上（如"等等等等"），
   // 也会被截停，属预期行为；需要只检测可见输出时可置为 false。
@@ -103,6 +112,156 @@ function sanitizeDelta(delta, config) {
   return piece
 }
 
+/**
+ * 流式围栏代码块过滤器（每个文本块一份状态）。
+ *
+ * 目标：把增量切成「普通文本 / 代码块内文本」两段，供检测按不同阈值判定——
+ * 代码块内的重复大多是正常内容（生成的测试夹具、表格、ASCII 图、内嵌数据），
+ * 按普通阈值会误杀，故块内使用放宽阈值。
+ *
+ * 规则按 CommonMark 的围栏代码块：
+ *   - 起始行：行首最多 3 个空格 + 连续 ≥3 个 ` 或 ~（其后为 info string）；
+ *   - 结束行：行首最多 3 个空格 + 同字符且不短于起始长度的连续 run，其后仅允许空白；
+ *   - 未闭合的围栏一直延续到该块结束。
+ * 增量切分安全：围栏标记被切进多个 delta（如 "``" + "`js"）时靠行首缓冲继续判定。
+ * 局限：不识别行内代码（`x`）与缩进代码块（4 空格），它们按普通文本处理。
+ *
+ * 与 lib/index.js 中的同名实现保持一致（两个入口行为必须相同）。
+ */
+function createFenceFilter() {
+  // 围栏字符 run 的长度上限：超过即按上限记录并进入代码块，避免无界缓冲。
+  const MAX_FENCE_RUN = 64
+  let atLineStart = true
+  let head = '' // 行首缓冲：最多 3 个空格 + 可能的围栏字符 run
+  let headSpaces = 0
+  let headChar = ''
+  let fence = null // { char, len }：已进入代码块
+  let closeLine = '' // 代码块内当前行（用于判定结束行）
+  let closeTooLong = false
+
+  const runLength = () => head.length - headSpaces
+  const resetHead = () => {
+    head = ''
+    headSpaces = 0
+    headChar = ''
+  }
+
+  /** 当前行是否为结束行（同字符、不短于起始长度、其后仅空白）。 */
+  function isClosingLine(line) {
+    const body = line.replace(/[ \t]+$/, '')
+    const indent = body.length - body.replace(/^ {0,3}/, '').length
+    const run = body.slice(indent)
+    if (run.length < fence.len) return false
+    for (let i = 0; i < run.length; i++) {
+      if (run[i] !== fence.char) return false
+    }
+    return true
+  }
+
+  return {
+    /** 当前是否处于围栏代码块内（诊断/测试用）。 */
+    inside: () => fence !== null,
+    /**
+     * 消费一个增量，返回按「是否位于代码块内」切分的片段序列。
+     * 片段按原始顺序首尾相接即为完整增量，调用方据此分别用普通/放宽阈值检测。
+     * @param delta - 文本增量。
+     * @returns {Array<{ text: string, code: boolean }>} 片段序列（可能为空数组）。
+     */
+    push(delta) {
+      // 快路径：不含围栏字符与换行的增量不可能改变围栏状态。
+      if (fence !== null && delta.indexOf(fence.char) === -1 && delta.indexOf('\n') === -1) {
+        return [{ text: delta, code: true }]
+      }
+      if (fence === null && !atLineStart &&
+        delta.indexOf('`') === -1 && delta.indexOf('~') === -1 && delta.indexOf('\n') === -1) {
+        return [{ text: delta, code: false }]
+      }
+      const runs = []
+      let buffer = ''
+      let bufferCode = fence !== null
+      const emit = (text, code) => {
+        if (text.length === 0) return
+        if (buffer.length > 0 && code !== bufferCode) {
+          runs.push({ text: buffer, code: bufferCode })
+          buffer = ''
+        }
+        bufferCode = code
+        buffer += text
+      }
+      for (let i = 0; i < delta.length; i++) {
+        const ch = delta[i]
+        if (fence !== null) {
+          // 代码块内：只判定结束行，内容整体按代码发射。
+          if (ch === '\n') {
+            const closing = isClosingLine(closeLine)
+            emit(ch, true)
+            closeLine = ''
+            closeTooLong = false
+            if (closing) {
+              fence = null
+              atLineStart = true
+              resetHead()
+              bufferCode = false
+            }
+            continue
+          }
+          if (!closeTooLong) {
+            closeLine += ch
+            if (closeLine.length > fence.len + 8) closeTooLong = true
+          }
+          emit(ch, true)
+          continue
+        }
+        if (atLineStart) {
+          if (ch === ' ' && headChar === '' && headSpaces < 3) {
+            head += ch
+            headSpaces++
+            continue
+          }
+          if ((ch === '`' || ch === '~') && (headChar === '' || headChar === ch)) {
+            headChar = ch
+            head += ch
+            // 不能一见 3 个就进入：起始行的完整 run 才是围栏长度（```` 不能被 ``` 关闭）。
+            if (runLength() >= MAX_FENCE_RUN) {
+              emit(head, true)
+              fence = { char: ch, len: runLength() }
+              closeLine = ''
+              closeTooLong = false
+              atLineStart = false
+              resetHead()
+            }
+            continue
+          }
+          if (headChar !== '' && runLength() >= 3) {
+            // 起始行（含行首空格与围栏符）整体属于代码块，长度取完整 run。
+            emit(head, true)
+            fence = { char: headChar, len: runLength() }
+            closeLine = ''
+            closeTooLong = false
+            atLineStart = false
+            resetHead()
+            emit(ch, true)
+            continue
+          }
+          // 判定不是围栏起始：行首缓冲按普通文本交还。
+          emit(head, false)
+          resetHead()
+          atLineStart = ch === '\n'
+          emit(ch, false)
+          continue
+        }
+        emit(ch, false)
+        if (ch === '\n') {
+          atLineStart = true
+          resetHead()
+        }
+      }
+      if (buffer.length > 0) runs.push({ text: buffer, code: bufferCode })
+      return runs
+    },
+  }
+}
+
 /**
  * 为一次 llm/stream 调用创建守卫。
  * 每次模型调用都会新建一份状态，互不干扰。
@@ -122,6 +281,7 @@ function createStreamGuard(options) {
         blockType,
         text: '',            // 完整文本：停止时需要用它闭合块，不能只保留窗口
         stripped: '',        // 去空白后的滚动窗口：仅用于检测
+        fence: createFenceFilter(), // 围栏代码块状态（skipCodeBlocks 开启时使用）
         toolCallId: undefined,
         toolCallName: undefined,
         toolCallArguments: '',
@@ -131,12 +291,25 @@ function createStreamGuard(options) {
     return b
   }
 
-  /** 把一段文本增量喂给检测缓冲，返回命中结果（null 表示未命中）。 */
+  /**
+   * 把一段文本增量喂给检测缓冲，返回命中结果（null 表示未命中）。
+   *
+   * 增量会先按围栏代码块切成片段：块外按 CONFIG.threshold 判定，块内按
+   * CONFIG.threshold × CONFIG.codeBlockMultiplier 判定（放宽，避免误杀正常代码）。
+   */
   function feedText(b, delta) {
     b.text += delta
-    const piece = sanitizeDelta(delta, CONFIG)
-    b.stripped = (b.stripped + piece).slice(-CONFIG.detectionWindow)
-    return findRepeatedTail(b.stripped, CONFIG.threshold, CONFIG.minUnitLength, CONFIG.maxUnitLength)
+    const codeThreshold = Math.max(CONFIG.threshold, CONFIG.threshold * CONFIG.codeBlockMultiplier)
+    const runs = CONFIG.skipCodeBlocks ? b.fence.push(delta) : [{ text: delta, code: false }]
+    for (const run of runs) {
+      const piece = sanitizeDelta(run.text, CONFIG)
+      if (piece.length === 0) continue
+      b.stripped = (b.stripped + piece).slice(-CONFIG.detectionWindow)
+      const threshold = run.code ? codeThreshold : CONFIG.threshold
+      const hit = findRepeatedTail(b.stripped, threshold, CONFIG.minUnitLength, CONFIG.maxUnitLength)
+      if (hit !== null) return { unit: hit.unit, count: hit.count, span: hit.span, code: run.code }
+    }
+    return null
   }
 
   /** 依据 StreamChunk 协议累积状态；命中时置 stopped。 */
@@ -227,7 +400,8 @@ function createStreamGuard(options) {
           '[dupguard] 检测到重复输出，已停止生成：provider=' + provider + ' model=' + model +
           ' unit=' + JSON.stringify(stopped.unit) +
           ' repeat>=' + String(stopped.count) +
-          ' span=' + String(stopped.span) + 'chars'
+          ' span=' + String(stopped.span) + 'chars' +
+          (stopped.code === true ? ' code-block=true（放宽阈值命中）' : '')
         )
         yield* closingChunks()
         // 提前 return：for-await 会调用上游 iterator.return()，