dsh-dupguard 1.2.1 → 1.3.1

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 本文件遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循 [SemVer](https://semver.org/lang/zh-CN/)。
 
+## [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
+
+- 全部检测参数可在设置页动态调整（此前仅白名单可改）：`threshold`、`minUnitLength`、
+  `maxUnitLength`、`detectionWindow`、`stripWhitespace`、`monitorReasoning`、
+  `monitorToolArguments` 均注册进 `dsh-dupguard` 设置 schema（含上下界与非整数拒绝），
+  改动即时热生效并持久化到 `settings.yaml`；
+- 设置页参数表单：数值输入（失焦或回车提交、范围与整数校验、跨字段校验）与原生风格开关，
+  写入仍走 `settingsScope` 控制器并回读快照校验；
+- **窗口缺口提示**：`detectionWindow < threshold × maxUnitLength` 时，设置页显示
+  「⚠ 检测窗口长度需要提高：至少 N（当前 M = 阈值 × 最大单元），超过 K 字符的重复单元无法识别」，
+  宿主日志同时打印一条同义告警（只提示不拒绝写入）；
+- 「恢复默认」改为清空本页全部用户设置（逐字段 unset），回到代码默认值。
+
+### Changed
+
+- 宿主 `settings.register` 增加 `validate` 跨字段约束（最大单元长度不得小于最小单元长度），
+  违规写入被拒绝而非静默存入；
+- 运行时设置同步改为逐字段归一化（类型/范围兜底，绝不抛错），非法外部编辑回落到代码默认值；
+- 客户端组件改为全部 hook 前置，消除「加载中 → 就绪」状态切换时的 hook 数量变化风险。
+
 ## [1.2.1] - 2026-09-02
 
 ### Fixed

package/README.md

@@ -24,11 +24,13 @@ When triggered, the already-generated text is committed as a normal assistant me
 - **安全停止**：绝不 `abort()` agent 步骤信号；补发协议合规的 `block-end` + `finish(stop)`，消息正常提交。
 - **Markdown 表格友好**：默认忽略连字符与竖线（`ignoredChars` 白名单），表格分隔行与长分隔线不会被误判为复读。
 - **图形化设置页**（npm 常驻版）：在 DSH 设置面板注册与「通用设置 / 模型 / 插件 / Agent 预设」并列的
-  「重复守卫」分节，可视化编辑白名单并持久化（`dsh-dupguard` 设置命名空间），修改即时生效。
-- **零配置开箱即用**：默认配置即可用；仅白名单可通过设置页调整。
+  「重复守卫」分节，可视化编辑白名单与全部检测参数（阈值、最小/最大单元长度、检测窗口、空白与
+  reasoning、工具参数开关）并持久化（`dsh-dupguard` 设置命名空间），修改即时生效；窗口小于
+  阈值 × 最大单元长度时给出「窗口长度需要提高」提示。
+- **零配置开箱即用**：默认配置即可用；全部检测参数均可在设置页按需调整。
 - **双入口交付**：动态插件（`plugin/host.js`）+ npm 组合挂载（`lib/index.js` + `lib/client.js`），行为一致、CI 防漂移。
 - **内置 DSH 兼容补丁**（`fixStandingMountConflict`，默认开启）：幂等化 `cordisInspect.register`，
-  修复 DSH ≤ 0.1.1-rc.1 的 preset standing-mount 多代并存冲突（见下文"已知限制"）。
+  修复 DSH ≤ 0.1.2-rc.1 的 preset standing-mount 多代并存冲突（见下文"已知限制"）。
 
 ---
 
@@ -111,21 +113,34 @@ loader's `unwrapExports`, no build step).
 
 ## 配置 / Configuration
 
-修改 `plugin/host.js` 或 `lib/index.js` 顶部 `CONFIG` 常量（两个入口需保持同步，CI 会校验一致性）：
+检测参数的默认值定义在 `plugin/host.js` 与 `lib/index.js` 顶部的 `CONFIG`（两个入口需保持同步，
+CI 会校验行为一致性）。**npm 常驻版**：下表参数除 `fixStandingMountConflict` 外全部可在设置页
+「重复守卫」分节中动态调整并持久化到 `settings.yaml`，改动即时生效（动态版固定取常量）。
 
-Edit the `CONFIG` block at the top of `plugin/host.js` / `lib/index.js` (both entries must stay in sync; CI verifies behavioral parity).
+Defaults live in the `CONFIG` block of both entries (CI verifies behavioral parity). In the npm build
+every option below except `fixStandingMountConflict` is editable from the "Dupguard" settings section
+and persisted to `settings.yaml`; the dynamic build uses the constants.
 
 | 配置项 / Option | 默认 / Default | 说明 / Description |
 | --- | --- | --- |
 | `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) |
+| `detectionWindow` | `8192` | 检测滚动窗口（字符，去空白后），需 ≥ 阈值 × 最大单元长度 / rolling detection window in chars (after whitespace removal); must be ≥ threshold × max unit length |
 | `stripWhitespace` | `true` | 检测前移除空白/换行，识别带分隔符的复读 / strip whitespace so `"x x x"` and `"x\nx\nx"` are caught |
-| `ignoredChars` | `['-', '\|']` | 检测时忽略的字符白名单（默认值）：Markdown 表格分隔行（连字符与竖线）不参与重复统计；npm 常驻版可在设置页「重复守卫」分节中可视化修改并持久化（动态版固定取此常量）/ whitelist of characters ignored during detection (default): Markdown table separators don't count as repetition; the npm build exposes it in the settings page "Dupguard" with persistence (the dynamic build uses this constant) |
+| `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.1-rc.1 兼容补丁：幂等化 `cordisInspect.register`，修复 preset standing-mount 多代并存冲突 / idempotent `cordisInspect.register` patch for the DSH ≤ 0.1.1-rc.1 standing-mount conflict |
+| `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) |
+
+**窗口约束 / Window constraint**：`detectionWindow` 必须 ≥ `threshold × maxUnitLength`；否则长度超过
+`floor(detectionWindow / threshold)` 的重复单元凑不满重复次数，无法被识别（例如窗口 80、阈值 10 时，
+超过 8 字符的单元不再触发）。设置页在该约束被违反时显示
+「⚠ 检测窗口长度需要提高：至少 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.
 
 ---
 
@@ -232,6 +247,11 @@ Node 20/22/24 (matching DSH; Node 18 is not supported).
 - 停止时若恰有未闭合的工具调用块（顺序输出块的适配器几乎不可能），该块会按已累积参数闭合并可能被执行。
 - 服务端停止依赖适配器在流关闭时中止底层请求的语义（已验证 `dsh-llm-deepseek`；自定义适配器需自查）。
 - 阈值语义为 `>= threshold`：第 10 次重复出现时即停止。
+- 检测窗口上限 1,048,576 字符：窗口越大，每个增量都要重写一次缓冲（实测 1Mi 窗口约 0.13 ms/增量），
+  极端长输出下会有可感知的额外开销；默认 8192 无此问题。
+- 若手工编辑 `settings.yaml` 写入非法值（如 `minUnitLength > maxUnitLength`），DSH 会在注册时拒绝该
+  命名空间，本插件捕获后仅打印错误日志并整体回落到代码默认值（检测功能不受影响，设置页显示默认值）。
+- 协议新增 `ContentBlock` 类型时，截停收尾对未知块类型只能按 tool-call 兜底并打印一次性告警。
 
 ### DSH 运行期间编辑 preset 后的 standing-mount 冲突（DSH ≤ 0.1.2-rc.1 缺陷，本插件已内置补丁）
 

package/lib/client.js

@@ -2,7 +2,7 @@
  * dupguard 浏览器端 bundle（单文件，经 window.__ModuleLoader__ 加载）。
  *
  * 在 DSH 设置面板注册一个与「通用设置 / 模型 / 插件 / Agent 预设」并列的
- * 分节「重复守卫」：白名单（检测时忽略的字符）的可视化编辑界面。
+ * 分节「重复守卫」：白名单（检测时忽略的字符）与全部检测参数的可视化编辑界面。
  * 数据经 settingsScope 绑定宿主 settings 服务的 "dsh-dupguard" 命名空间，
  * 修改即时生效并持久化（settings.yaml）。
  *
@@ -23,31 +23,75 @@ window.__ModuleLoader__.load({
     const zh = {
       nav: '重复守卫',
       title: '重复输出守卫',
-      intro: '模型输出中同一字符串连续重复 10 次以上时会自动截停。此处配置检测时忽略的字符（白名单）：这些字符不参与重复统计，例如 Markdown 表格分隔行会大量使用连字符与竖线。',
-      list: '当前白名单',
+      intro: '模型输出中同一字符串连续重复达到阈值次数时自动截停。以下参数修改后即时生效并持久化（settings.yaml）。',
+      list: '忽略字符（白名单，按单个字符匹配）',
       empty: '白名单为空：所有字符都参与重复统计。',
-      addPlaceholder: '输入要忽略的字符',
+      addPlaceholder: '输入要忽略的字符（可多个）',
       add: '添加',
+      params: '检测参数',
+      threshold: '触发阈值（连续重复次数）',
+      thresholdHint: '同一字符串连续重复达到该次数即截停（≥ 语义）。范围 {min}–{max}。',
+      minUnitLength: '最小重复单元长度',
+      minUnitLengthHint: '参与检测的重复单元最小字符数。范围 {min}–{max}；设为 1 可捕获单字符循环。',
+      maxUnitLength: '最大重复单元长度',
+      maxUnitLengthHint: '可识别的最长重复单元（清洗后字符数，空白与白名单字符不计）。范围 {min}–{max}。',
+      detectionWindow: '检测窗口（字符）',
+      detectionWindowHint: '检测缓冲保留的字符数。范围 {min}–{max}；需 ≥ 阈值 × 最大单元长度，否则长单元凑不满重复次数。',
+      stripWhitespace: '忽略空白字符',
+      stripWhitespaceHint: '检测前移除所有空白（含换行），使「重复 重复」「重复\\n重复」这类带分隔的复读也能识别。',
+      monitorReasoning: '检测思考内容（reasoning）',
+      monitorReasoningHint: '思考中的复读同样消耗 token，默认一并检测。',
+      monitorToolArguments: '检测工具调用参数',
+      monitorToolArgumentsHint: '默认关闭：JSON / base64 参数中重复字符很常见。',
       reset: '恢复默认',
+      note: '「恢复默认」清空本页全部用户设置，回到代码默认值。',
+      saving: '保存中…',
+      saved: '已保存',
+      saveFailed: '保存失败：宿主未接受该值，请检查取值或查看 DSH 宿主日志。',
+      errInteger: '请输入整数。',
+      errRange: '取值范围 {min}–{max}。',
+      errCross: '不能小于最小重复单元长度（当前 {min}）。',
+      errCrossMin: '不能大于最大重复单元长度（当前 {max}）。',
+      windowWarn: '⚠ 检测窗口长度需要提高：至少 {need}（当前 {current} = 阈值 {threshold} × 最大单元 {maxUnit}）。当前窗口下超过 {effective} 字符的重复单元无法识别。',
       loading: '加载中…',
-      note: '修改即时生效；「恢复默认」回到连字符与竖线。',
-      saveFailed: '保存失败：宿主未接受该值，请查看 DSH 宿主日志。',
-      remoteHint: '设置修改仅支持本机连接：请通过本机地址（127.0.0.1）打开 DSH 页面后重试。远程访问时 DSH 的设置通道被禁用，白名单将使用默认值（连字符与竖线）。',
+      remoteHint: '设置修改仅支持本机连接：请通过本机地址（127.0.0.1）打开 DSH 页面后重试。远程访问时 DSH 的设置通道被禁用，检测参数将使用默认值。',
       unavailable: '设置服务不可用：未读取到「重复守卫」的设置数据。请确认 DSH 为 npm 常驻版挂载（宿主日志应包含「已注册设置命名空间 dsh-dupguard」），并刷新页面重试。',
     }
     const en = {
       nav: 'Dupguard',
       title: 'Repetition Guard',
-      intro: 'Generation stops when the same string repeats 10 or more times in a row. Configure the whitelisted characters that are ignored during detection, e.g. Markdown table separators use many hyphens and pipes.',
-      list: 'Whitelist',
+      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, 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)',
+      thresholdHint: 'Stop once a string repeats this many times in a row (>= semantics). Range {min}–{max}.',
+      minUnitLength: 'Minimum repeating-unit length',
+      minUnitLengthHint: 'Shortest repeating unit considered, in characters. Range {min}–{max}; 1 catches single-character loops.',
+      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.',
+      stripWhitespace: 'Ignore whitespace',
+      stripWhitespaceHint: 'Remove all whitespace (newlines included) before detection, so separated repeats are still recognized.',
+      monitorReasoning: 'Monitor reasoning text',
+      monitorReasoningHint: 'Repeats inside reasoning burn tokens too, so they are monitored by default.',
+      monitorToolArguments: 'Monitor tool-call arguments',
+      monitorToolArgumentsHint: 'Off by default: repeated characters are common in JSON / base64 arguments.',
       reset: 'Reset to defaults',
+      note: '"Reset to defaults" clears every user setting on this page and restores the code defaults.',
+      saving: 'Saving…',
+      saved: 'Saved',
+      saveFailed: 'Save failed: the host did not accept the value; check the input or the DSH host log.',
+      errInteger: 'Enter an integer.',
+      errRange: 'Allowed range {min}–{max}.',
+      errCross: 'Must not be smaller than the minimum unit length (currently {min}).',
+      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 max unit {maxUnit}). Units longer than {effective} characters cannot be detected with the current window.',
       loading: 'Loading…',
-      note: 'Changes take effect immediately; "Reset to defaults" restores hyphen and pipe.',
-      saveFailed: 'Save failed: the host did not accept the value; check the DSH host log.',
-      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 the whitelist stays at its defaults (hyphen and pipe).',
+      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.',
     }
 
@@ -66,6 +110,21 @@ window.__ModuleLoader__.load({
       '.dg-btn:hover{background:var(--dsw-alias-interactive-bg-hover)}',
       '.dg-note{color:var(--dsw-alias-label-tertiary);font-size:12px;margin:0}',
       '.dg-empty{color:var(--dsw-alias-label-tertiary);margin:0}',
+      '.dg-fields{display:flex;flex-direction:column;gap:12px}',
+      '.dg-field{display:flex;flex-direction:column;gap:4px}',
+      '.dg-field-head{display:flex;align-items:center;justify-content:space-between;gap:12px}',
+      '.dg-field-label{color:var(--dsw-alias-label-primary);font-size:13px}',
+      '.dg-field-hint{color:var(--dsw-alias-label-tertiary);font-size:12px;margin:0}',
+      '.dg-field-error{color:var(--dsw-alias-state-error-primary);font-size:12px;margin:0}',
+      '.dg-num{box-sizing:border-box;width:110px;height:32px;padding:0 10px;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font-size:13px;font-family:inherit;text-align:right;outline:none}',
+      '.dg-num:focus{border-color:var(--dsw-alias-brand-primary)}',
+      '.dg-switch{box-sizing:border-box;width:36px;height:20px;flex:none;padding:2px;border:0;border-radius:10px;background:var(--dsw-alias-border-l2);cursor:pointer}',
+      '.dg-switch-on{background:var(--dsw-alias-brand-primary)}',
+      '.dg-switch-thumb{display:block;width:16px;height:16px;border-radius:50%;background:var(--dsw-alias-label-primary-foreground);transition:transform .12s}',
+      '.dg-switch-on .dg-switch-thumb{transform:translateX(16px)}',
+      '.dg-warn{color:var(--dsw-alias-state-warn-primary);font-size:12px;margin:0}',
+      '.dg-error{color:var(--dsw-alias-state-error-primary)}',
+      '.dg-footer{display:flex;align-items:center;gap:12px;flex-wrap:wrap}',
     ].join('\n')
 
     if (typeof document !== 'undefined') {
@@ -78,18 +137,117 @@ window.__ModuleLoader__.load({
 
     const inject = ['slots', 'locale', 'connection', 'settingsScope']
 
+    // ---------------------------------------------------------------------
+    // 字段元数据：与宿主 lib/index.js 的 LIMITS / CONFIG 必须保持一致。
+    // ---------------------------------------------------------------------
+    const NUMERIC_FIELDS = [
+      { key: 'threshold', min: 2, max: 1000 },
+      { 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 DEFAULTS = {
+      ignoredChars: ['-', '|'],
+      threshold: 10,
+      minUnitLength: 1,
+      maxUnitLength: 80,
+      detectionWindow: 8192,
+      stripWhitespace: true,
+      monitorReasoning: true,
+      monitorToolArguments: false,
+    }
+    const ALL_FIELDS = ['ignoredChars'].concat(NUMERIC_FIELDS.map((field) => field.key), BOOL_FIELDS)
+
+    /** 模板占位符替换：{name} → vars.name。 */
+    const fmt = (text, vars) =>
+      String(text).replace(/\{(\w+)\}/g, (match, key) => (vars[key] === undefined ? match : String(vars[key])))
+
+    /**
+     * 把宿主设置值归一化为完整形态：缺失或越界的字段回落默认，
+     * 保证任何异常形状到达视图时仍是 ready 且可渲染。
+     */
+    function normalizeValue(raw) {
+      const out = { ignoredChars: [...DEFAULTS.ignoredChars] }
+      for (const field of NUMERIC_FIELDS) out[field.key] = DEFAULTS[field.key]
+      for (const key of BOOL_FIELDS) out[key] = DEFAULTS[key]
+      try {
+        if (raw !== null && typeof raw === 'object' && !Array.isArray(raw)) {
+          if (Array.isArray(raw.ignoredChars)) {
+            out.ignoredChars = raw.ignoredChars.filter((ch) => typeof ch === 'string')
+          }
+          for (const field of NUMERIC_FIELDS) {
+            const value = raw[field.key]
+            if (Number.isSafeInteger(value) && value >= field.min && value <= field.max) out[field.key] = value
+          }
+          for (const key of BOOL_FIELDS) {
+            if (typeof raw[key] === 'boolean') out[key] = raw[key]
+          }
+        }
+      } catch (_normalizeError) {}
+      return out
+    }
+
+    /** 归一化值为编辑表单：数值字段存字符串，便于输入中途的状态。 */
+    function toForm(value) {
+      const normalized = normalizeValue(value)
+      const form = { ignoredChars: normalized.ignoredChars }
+      for (const field of NUMERIC_FIELDS) form[field.key] = String(normalized[field.key])
+      for (const key of BOOL_FIELDS) form[key] = normalized[key]
+      return form
+    }
+
+    /** 从输入文本解析整数（仅接受纯整数，避免 1e3 / 3.5 这类写法）。 */
+    function parseInt10(text) {
+      const value = typeof text === 'string' ? text.trim() : String(text)
+      return /^-?\d+$/.test(value) ? Number(value) : NaN
+    }
+
     function DupguardSection(props) {
       const controller = props.controller
       const t = props.t
+
+      // 全部 hook 在早退之前调用，保证 loading → ready 的状态切换不改变 hook 数量。
       const snap = React.useSyncExternalStore(
         (cb) => controller.subscribe(cb),
         () => controller.getSnapshot(),
       )
-      const [draft, setDraft] = React.useState('')
       const mirrorSnap = React.useSyncExternalStore(
         (cb) => props.mirror.subscribe(cb),
         () => props.mirror.getSnapshot(),
       )
+      const [draft, setDraft] = React.useState('')
+      const [form, setForm] = React.useState(null)
+      const [writeState, setWriteState] = React.useState(null)
+      const [errors, setErrors] = React.useState({})
+      const dirty = React.useRef({})
+      const lastRemote = React.useRef(null)
+
+      // 每次打开本页都强制重拉镜像：保证显示的是宿主持久化的最新值。
+      React.useEffect(() => {
+        if (props.mirror && typeof props.mirror.load === 'function') {
+          props.mirror.load()
+        }
+      }, [])
+
+      // 同步模型：手动修改过的字段本地自治（免疫旧值回传），其余字段跟随镜像快照。
+      const ready = snap.status === 'ready' && snap.value !== undefined
+      const remoteForm = ready ? toForm(snap.value) : null
+      if (ready) {
+        const signature = JSON.stringify(remoteForm)
+        if (form === null) {
+          lastRemote.current = signature
+          setForm(remoteForm)
+        } else if (lastRemote.current !== signature) {
+          lastRemote.current = signature
+          const next = {}
+          for (const key of ALL_FIELDS) {
+            next[key] = dirty.current[key] === true ? form[key] : remoteForm[key]
+          }
+          setForm(next)
+        }
+      }
+      const shown = form === null ? remoteForm : form
 
       if (props.isLoopback === false) {
         return React.createElement('div', { className: 'dg-section' },
@@ -101,7 +259,7 @@ window.__ModuleLoader__.load({
           React.createElement('h2', { className: 'dg-title' }, t('title')),
           React.createElement('p', { className: 'dg-intro' }, t('unavailable')))
       }
-      if (snap.status !== 'ready') {
+      if (!ready || shown === null) {
         const mirrorError = mirrorSnap && mirrorSnap.error ? String(mirrorSnap.error) : null
         const mirrorStatus = mirrorSnap ? String(mirrorSnap.status) : 'unknown'
         return React.createElement('div', { className: 'dg-section' },
@@ -110,92 +268,172 @@ window.__ModuleLoader__.load({
             'mirror=' + mirrorStatus + (mirrorError === null ? '' : ' error=' + mirrorError)))
       }
 
-      // UI 同步模型：手动修改前跟随镜像快照（含本页挂载时的强制重拉），
-      // 手动修改后本地自治（镜像回传不再覆盖，避免旧值回滚）。
-      const remoteList = Array.isArray(snap.value && snap.value.ignoredChars) ? snap.value.ignoredChars : []
-      const [list, setList] = React.useState(null)
-      const touched = React.useRef(false)
-      const lastRemote = React.useRef(remoteList)
-      if (list === null || (!touched.current && lastRemote.current !== remoteList)) {
-        lastRemote.current = remoteList
-        setList(remoteList)
+      // ---- 取值校验：逐字段范围 + 跨字段（最大单元 ≥ 最小单元） ----
+      const parsed = {}
+      let numericValid = true
+      for (const field of NUMERIC_FIELDS) {
+        const value = parseInt10(shown[field.key])
+        parsed[field.key] = value
+        if (!Number.isInteger(value) || value < field.min || value > field.max) numericValid = false
       }
-      const shown = list === null ? remoteList : list
-      const [writeState, setWriteState] = React.useState(null)
+      const crossInvalid = Number.isInteger(parsed.minUnitLength) && Number.isInteger(parsed.maxUnitLength) &&
+        parsed.maxUnitLength < parsed.minUnitLength
 
-      // 每次打开本页都强制重拉镜像：保证显示的是宿主持久化的最新值。
-      React.useEffect(() => {
-        if (props.mirror && typeof props.mirror.load === 'function') {
-          props.mirror.load()
-        }
-      }, [])
+      const fieldError = (field) => {
+        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 (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
+        ? {
+            need: parsed.threshold * parsed.maxUnitLength,
+            current: parsed.detectionWindow,
+            threshold: parsed.threshold,
+            maxUnit: parsed.maxUnitLength,
+            effective: Math.floor(parsed.detectionWindow / parsed.threshold),
+          }
+        : null
 
-      // 写路径走 settingsScope 控制器（DSH 自己的设置写通道）：自动携带最新
-      // revision、串行化并发写，并把宿主应答折叠回共享镜像。
-      // 注意：DSH 0.1.2 起客户端不再暴露 connection.api（改为 ctx.remote.<ns>），
-      // 直接调 wire 面会在 0.1.2 上抛错并卡在「保存中…」；控制器接口两版一致。
-      const finishWrite = (expected) => {
-        // 写入结果由控制器折叠进镜像，回读快照校验是否真的落盘。
-        const snapNow = props.controller.getSnapshot()
-        const applied = snapNow !== undefined && snapNow.value !== undefined && Array.isArray(snapNow.value.ignoredChars)
-          ? snapNow.value.ignoredChars
-          : null
-        const same = applied !== null && applied.length === expected.length &&
-          applied.every((ch, index) => ch === expected[index])
-        setWriteState(same ? 'saved' : 'error:' + t('saveFailed'))
+      // ---- 写路径：settingsScope 控制器（DSH 自己的设置写通道，自动携带 revision、
+      // 串行化并发写、把宿主应答折叠回镜像）。DSH 0.1.2 起客户端不再暴露
+      // connection.api，控制器接口自 0.1.1 起稳定，故不直接触碰 wire 面。 ----
+      const snapshotValue = () => {
+        const current = controller.getSnapshot()
+        return current !== undefined && current.value !== undefined ? current.value : {}
       }
-      const runWrite = (operation, expected) => {
+      const sameList = (a, b) => Array.isArray(a) && Array.isArray(b) &&
+        a.length === b.length && a.every((item, index) => item === b[index])
+      const currentForm = () => (form === null ? remoteForm : form)
+      const runWrite = (operation, verify) => {
         setWriteState('saving')
         Promise.resolve()
           .then(() => operation())
-          .then(() => finishWrite(expected), (error) => {
+          .then(() => setWriteState(verify() ? 'saved' : 'error:' + t('saveFailed')), (error) => {
             setWriteState('error:' + String((error && error.message) || error))
           })
       }
-      const persist = (next) => {
-        runWrite(() => props.controller.set('ignoredChars', next), next)
+      const commitList = (next) => {
+        dirty.current.ignoredChars = true
+        setForm({ ...currentForm(), ignoredChars: next })
+        runWrite(() => controller.set('ignoredChars', next), () => sameList(snapshotValue().ignoredChars, next))
       }
-      const persistUnset = () => {
-        // unset 后解析值回到 schema 默认（宿主 base）白名单。
-        runWrite(() => props.controller.unset('ignoredChars'), ['-', '|'])
+      const commitNumber = (field) => {
+        const message = fieldError(field)
+        if (message !== null) {
+          setErrors((prev) => ({ ...prev, [field.key]: message }))
+          return
+        }
+        const value = parsed[field.key]
+        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)
       }
-
-      const remove = (ch) => {
-        const next = shown.filter((item) => item !== ch)
-        touched.current = true
-        setList(next)
-        persist(next)
+      const commitBool = (key) => {
+        const value = shown[key] !== true
+        dirty.current[key] = true
+        setForm({ ...currentForm(), [key]: value })
+        runWrite(() => controller.set(key, value), () => snapshotValue()[key] === value)
+      }
+      const resetAll = () => {
+        dirty.current = {}
+        setErrors({})
+        runWrite(
+          () => Promise.all(ALL_FIELDS.map((key) => controller.unset(key))),
+          () => {
+            setForm(toForm(snapshotValue()))
+            const current = controller.getSnapshot()
+            const user = current !== undefined ? current.user : undefined
+            if (user === undefined || user === null) return true
+            return ALL_FIELDS.every((key) => user[key] === undefined)
+          },
+        )
       }
+
       const add = () => {
-        const ch = draft.trim()
-        if (ch.length === 0) return
-        if (shown.indexOf(ch) !== -1) {
-          setDraft('')
-          return
-        }
-        const next = [...shown, ch]
-        touched.current = true
-        setList(next)
-        persist(next)
+        const text = draft.trim()
+        if (text.length === 0) return
         setDraft('')
+        // 白名单按单个字符匹配：一次输入多个字符时逐个加入（忽略输入中的空白），
+        // 否则整串会被当成一个条目，永远不会命中。
+        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 reset = () => {
-        touched.current = true
-        setList(['-', '|'])
-        persistUnset()
-      }
-      const onKey = (e) => {
-        if (e.key === 'Enter') add()
+      const remove = (ch) => commitList(shown.ignoredChars.filter((item) => item !== ch))
+
+      const fieldRow = (field) => {
+        const message = errors[field.key] !== undefined && errors[field.key] !== null
+          ? errors[field.key]
+          : fieldError(field)
+        return React.createElement('div', { className: 'dg-field', key: field.key },
+          React.createElement('div', { className: 'dg-field-head' },
+            React.createElement('label', { className: 'dg-field-label', htmlFor: 'dg-' + field.key }, t(field.key)),
+            React.createElement('input', {
+              id: 'dg-' + field.key,
+              className: 'dg-num',
+              type: 'number',
+              min: field.min,
+              max: field.max,
+              step: 1,
+              value: shown[field.key],
+              onChange: (event) => {
+                const value = event.target.value
+                setForm({ ...currentForm(), [field.key]: value })
+                setErrors((prev) => ({ ...prev, [field.key]: null }))
+              },
+              onBlur: () => commitNumber(field),
+              onKeyDown: (event) => {
+                if (event.key === 'Enter') commitNumber(field)
+              },
+            })),
+          React.createElement('p', { className: 'dg-field-hint' },
+            fmt(t(field.key + 'Hint'), { min: field.min, max: field.max })),
+          message === null ? null : React.createElement('p', { className: 'dg-field-error' }, message),
+        )
       }
+      const switchRow = (key) => React.createElement('div', { className: 'dg-field', key: key },
+        React.createElement('div', { className: 'dg-field-head' },
+          React.createElement('span', { className: 'dg-field-label' }, t(key)),
+          React.createElement('button', {
+            className: 'dg-switch' + (shown[key] === true ? ' dg-switch-on' : ''),
+            type: 'button',
+            role: 'switch',
+            'aria-checked': shown[key] === true,
+            onClick: () => commitBool(key),
+          }, React.createElement('span', { className: 'dg-switch-thumb' }))),
+        React.createElement('p', { className: 'dg-field-hint' }, t(key + 'Hint')),
+      )
 
       return React.createElement('div', { className: 'dg-section' },
         React.createElement('h2', { className: 'dg-title' }, t('title')),
         React.createElement('p', { className: 'dg-intro' }, t('intro')),
+
         React.createElement('p', { className: 'dg-note' }, t('list')),
-        shown.length === 0
+        shown.ignoredChars.length === 0
           ? React.createElement('p', { className: 'dg-empty' }, t('empty'))
           : React.createElement('div', { className: 'dg-chips' },
-            shown.map((ch) => React.createElement('span', { className: 'dg-chip', key: ch },
+            shown.ignoredChars.map((ch) => React.createElement('span', { className: 'dg-chip', key: ch },
               ch,
               React.createElement('button', {
                 className: 'dg-chip-remove',
@@ -208,19 +446,31 @@ window.__ModuleLoader__.load({
             className: 'dg-input',
             placeholder: t('addPlaceholder'),
             value: draft,
-            onChange: (e) => setDraft(e.target.value),
-            onKeyDown: onKey,
+            onChange: (event) => setDraft(event.target.value),
+            onKeyDown: (event) => {
+              if (event.key === 'Enter') add()
+            },
           }),
           React.createElement('button', { className: 'dg-btn', type: 'button', onClick: add }, t('add')),
-          React.createElement('button', { className: 'dg-btn', type: 'button', onClick: reset }, t('reset')),
         ),
-        writeState === null
-          ? React.createElement('p', { className: 'dg-note' }, t('note'))
-          : writeState === 'saving'
-            ? React.createElement('p', { className: 'dg-note' }, '保存中…')
-            : writeState === 'saved'
-              ? React.createElement('p', { className: 'dg-note' }, '已保存')
-              : React.createElement('p', { className: 'dg-note', style: { color: 'var(--dsw-alias-state-error-primary)' } }, writeState),
+
+        React.createElement('p', { className: 'dg-note' }, t('params')),
+        React.createElement('div', { className: 'dg-fields' },
+          NUMERIC_FIELDS.map((field) => fieldRow(field)),
+          BOOL_FIELDS.map((key) => switchRow(key)),
+        ),
+        shortfall === null ? null : React.createElement('p', { className: 'dg-warn' }, fmt(t('windowWarn'), shortfall)),
+
+        React.createElement('div', { className: 'dg-footer' },
+          React.createElement('button', { className: 'dg-btn', type: 'button', onClick: resetAll }, t('reset')),
+          writeState === null
+            ? React.createElement('p', { className: 'dg-note' }, t('note'))
+            : writeState === 'saving'
+              ? React.createElement('p', { className: 'dg-note' }, t('saving'))
+              : writeState === 'saved'
+                ? React.createElement('p', { className: 'dg-note' }, t('saved'))
+                : React.createElement('p', { className: 'dg-note dg-error' }, writeState),
+        ),
       )
     }
 
@@ -231,22 +481,10 @@ window.__ModuleLoader__.load({
       const isLoopback = connection !== undefined && connection.isLoopback === true
       // 自定义 decode：绕开客户端 schema 复水化与校验。DSH 的 SettingsScopeController
       // 以 spec.decode(view.value) 调用，即直接传入本命名空间的设置值
-      // （{ignoredChars: [...]}），而非 wire 视图。直接解读该值的 ignoredChars 字段。
+      // （{ignoredChars, threshold, ...}），而非 wire 视图。
       const controller = ctx.settingsScope.bind({
         namespace: SETTINGS_NS,
-        decode: (value) => {
-          // 尽力解读；任何异常形状回退到默认白名单，保证视图到达即进入 ready。
-          try {
-            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-              const list = value.ignoredChars
-              if (Array.isArray(list)) {
-                const strings = list.filter((ch) => typeof ch === 'string')
-                return { ignoredChars: strings }
-              }
-            }
-          } catch (_decodeError) {}
-          return { ignoredChars: ['-', '|'] }
-        },
+        decode: (value) => normalizeValue(value),
       })
       const mirror = ctx.settingsScope.describe()
       ctx.effect(() => () => {

package/lib/index.js

@@ -21,6 +21,18 @@ const name = 'dupguard'
 /** 设置命名空间：小写 kebab-case（dsh-settings 的命名规范）。 */
 const SETTINGS_NS = 'dsh-dupguard'
 
+/**
+ * 可在设置页动态调整的数值参数及其边界。
+ * 客户端 UI 会镜像这些边界与默认值（lib/client.js 的 NUMERIC_FIELDS / DEFAULTS），
+ * 两处必须保持一致；范围外的写入由 schema 直接拒绝。
+ */
+const LIMITS = {
+  threshold: { min: 2, max: 1000 },
+  minUnitLength: { min: 1, max: 4096 },
+  maxUnitLength: { min: 1, max: 8192 },
+  detectionWindow: { min: 64, max: 1048576 },
+}
+
 /**
  * 惰性加载 schemastery 并构建设置 schema。
  *
@@ -33,9 +45,16 @@ let settingsSchemaPromise
 function loadSettingsSchema() {
   if (settingsSchemaPromise === undefined) {
     settingsSchemaPromise = import('@deepseek-ai/schemastery').then(({ default: z }) =>
-      // 设置 schema：白名单字符数组（其余检测参数保持代码常量）。
+      // 设置 schema：全部检测参数均可在设置页动态调整（默认值取自 CONFIG）。
       z.object({
-        ignoredChars: z.array(z.string()).default(['-', '|']),
+        ignoredChars: z.array(z.string()).default([...CONFIG.ignoredChars]),
+        threshold: z.number().min(LIMITS.threshold.min).max(LIMITS.threshold.max).step(1).default(CONFIG.threshold),
+        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),
+        stripWhitespace: z.boolean().default(CONFIG.stripWhitespace),
+        monitorReasoning: z.boolean().default(CONFIG.monitorReasoning),
+        monitorToolArguments: z.boolean().default(CONFIG.monitorToolArguments),
       })
     )
   }
@@ -59,6 +78,8 @@ const CONFIG = {
   // 检测时忽略的字符（白名单）：Markdown 表格的分隔行由连字符与竖线组成
   // （如 "|---|---|"），正常表格输出会大量连续出现，不应视为复读。
   // 默认忽略连字符与竖线；需要更严格的检测时可改为空数组 []。
+  // 条目必须是单个字符（按 Unicode 码点匹配，emoji 也算一个）；
+  // 多字符条目永远不会命中，运行时会丢弃并告警。
   ignoredChars: ['-', '|'],
   // 是否同时检测思考（reasoning）文本。默认开启：思考中的复读同样消耗 token，
   // 应立即截停。注意：正常思考中若连续重复同一字符串 10 次以上（如"等等等等"），
@@ -110,12 +131,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
@@ -128,6 +148,46 @@ function sanitizeDelta(delta, config) {
   return piece
 }
 
+/**
+ * 未知块类型只会在 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 调用创建守卫。
  * 每次模型调用都会新建一份状态，互不干扰。
@@ -222,6 +282,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,
@@ -302,18 +363,84 @@ function installStandingMountPatch(ctx) {
 }
 
 /**
- * 把 CONFIG 拷贝为运行时配置：ignoredChars 会被设置页热更新，
- * 其余字段保持代码常量（设置页只暴露白名单）。
+ * 组合层默认值（= 代码 CONFIG）。设置页的用户层被清空（unset）时回落到这里，
+ * 因此「恢复默认」等价于回到 CONFIG。
  */
-function createRuntime() {
+function settingsBase() {
   return {
-    ...CONFIG,
     ignoredChars: [...CONFIG.ignoredChars],
+    threshold: CONFIG.threshold,
+    minUnitLength: CONFIG.minUnitLength,
+    maxUnitLength: CONFIG.maxUnitLength,
+    detectionWindow: CONFIG.detectionWindow,
+    stripWhitespace: CONFIG.stripWhitespace,
+    monitorReasoning: CONFIG.monitorReasoning,
+    monitorToolArguments: CONFIG.monitorToolArguments,
   }
 }
 
+/** 每次模型调用使用的运行时配置副本（字段均可被设置页热更新）。 */
+function createRuntime() {
+  return settingsBase()
+}
+
 /**
- * 从 DSH 的 settings 服务注册白名单设置（仅常驻版）。
+ * 检测窗口是否小于「阈值 × 最大单元长度」。
+ *
+ * 窗口是清洗后保留的字符数：一个长度 p 的单元需要 p × threshold 个字符才可能
+ * 凑满阈值，因此 p 超过 floor(窗口 / 阈值) 的重复单元无法被识别。返回缺口描述
+ * （含所需窗口）或 null。
+ */
+function windowShortfall(runtime) {
+  const needed = runtime.threshold * runtime.maxUnitLength
+  if (runtime.detectionWindow >= needed) return null
+  return {
+    needed: needed,
+    current: runtime.detectionWindow,
+    effectiveMaxUnit: Math.floor(runtime.detectionWindow / runtime.threshold),
+  }
+}
+
+/** 窗口偏小时打一条宿主日志（设置页另有同样的提示）。 */
+function warnShortWindow(runtime) {
+  const short = windowShortfall(runtime)
+  if (short === null) return
+  console.warn(
+    '[dupguard] 检测窗口长度需要提高：至少 ' + String(short.needed) +
+    '（= 阈值 ' + String(runtime.threshold) + ' × 最大单元长度 ' + String(runtime.maxUnitLength) +
+    '），当前 ' + String(short.current) + '；超过 ' + String(short.effectiveMaxUnit) +
+    ' 字符的重复单元将无法识别。请在设置页提高「检测窗口」，或降低阈值/最大单元长度。'
+  )
+}
+
+/**
+ * 把设置值归一化进 runtime。外部编辑的设置文档可能带来非法值（schema 校验失败
+ * 会保留上一份好值，但归一化仍以防万一），因此逐字段做类型与范围兜底，且绝不抛出：
+ * 该方法运行在每次设置提交与插件注册路径上，不能影响检测主体。
+ */
+function applySettingsToRuntime(runtime, value) {
+  const fallback = settingsBase()
+  const source = value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {}
+  const pickInt = (key) => {
+    const raw = source[key]
+    const limit = LIMITS[key]
+    if (Number.isSafeInteger(raw) && raw >= limit.min && raw <= limit.max) return raw
+    return fallback[key]
+  }
+  const pickBool = (key) => (typeof source[key] === 'boolean' ? source[key] : fallback[key])
+  runtime.ignoredChars = normalizeIgnoredChars(source.ignoredChars, fallback.ignoredChars)
+  runtime.threshold = pickInt('threshold')
+  runtime.minUnitLength = pickInt('minUnitLength')
+  runtime.maxUnitLength = pickInt('maxUnitLength')
+  runtime.detectionWindow = pickInt('detectionWindow')
+  runtime.stripWhitespace = pickBool('stripWhitespace')
+  runtime.monitorReasoning = pickBool('monitorReasoning')
+  runtime.monitorToolArguments = pickBool('monitorToolArguments')
+  warnShortWindow(runtime)
+}
+
+/**
+ * 从 DSH 的 settings 服务注册检测参数（仅常驻版）；设置页可动态调整全部字段。
  * 返回注销器；settings 服务缺失（无头环境）时不做任何事。
  */
 async function installSettings(ctx, runtime) {
@@ -322,18 +449,28 @@ async function installSettings(ctx, runtime) {
   try {
     const schema = await loadSettingsSchema()
     const scope = settings.register(SETTINGS_NS, schema, {
-      base: { ignoredChars: CONFIG.ignoredChars },
+      base: settingsBase(),
+      // schema 表达不了的跨字段约束：maxUnitLength 不得小于 minUnitLength，
+      // 违规的写入在此被拒绝（调用方收到错误），不会存入文档。
+      validate: (value) => {
+        if (value.maxUnitLength < value.minUnitLength) {
+          throw new TypeError(
+            '最大重复单元长度（' + String(value.maxUnitLength) +
+            '）不能小于最小重复单元长度（' + String(value.minUnitLength) + '）'
+          )
+        }
+      },
     })
     const sync = () => {
-      runtime.ignoredChars = [...scope.get().ignoredChars]
+      applySettingsToRuntime(runtime, scope.get())
     }
     sync()
     const stop = scope.watch(sync)
     ctx.effect(() => () => stop(), 'dupguard: settings watch')
-    console.log('[dupguard] 已注册设置命名空间 ' + SETTINGS_NS + '（白名单可在设置页修改）')
+    console.log('[dupguard] 已注册设置命名空间 ' + SETTINGS_NS + '（检测参数可在设置页动态调整）')
   } catch (error) {
-    // 设置注册失败不得破坏检测主体：白名单保持代码常量，仅损失设置页能力。
-    console.error('[dupguard] 设置命名空间注册失败（白名单将使用默认值）：' + (error && error.message ? error.message : String(error)))
+    // 设置注册失败不得破坏检测主体：参数保持代码常量，仅损失设置页能力。
+    console.error('[dupguard] 设置命名空间注册失败（检测参数将使用代码默认值）：' + (error && error.message ? error.message : String(error)))
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-dupguard",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "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",

package/plugin/host.js

@@ -11,9 +11,10 @@
 // 安装/运行步骤与配置说明见仓库根目录的 README.md。
 //
 // 说明：动态插件代码体不能 require 依赖，因此本版本不集成 settings 服务，
-// 白名单固定取 CONFIG.ignoredChars。npm 常驻版（lib/index.js）会注册
+// 全部检测参数固定取本文件顶部的 CONFIG。npm 常驻版（lib/index.js）会注册
 // "dsh-dupguard" 设置命名空间并提供 Web 设置页（lib/client.js），
-// 白名单可在设置中修改并持久化。
+// 白名单与检测参数（阈值/单元长度/窗口/空白与 reasoning、工具参数开关）
+// 均可在设置中动态调整并持久化；两版默认值保持一致。
 // ============================================================================
 
 const CONFIG = {