dsh-dupguard 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 本文件遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循 [SemVer](https://semver.org/lang/zh-CN/)。
 
+## [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
+
+- 设置页写入在 DSH 0.1.2 上完全失效：0.1.2 的客户端 `connection` 服务不再暴露
+  `api`（wire 面改为 `ctx.remote.<namespace>`），此前的直连 RPC 写法在 0.1.2 上
+  同步抛错——表现为点击「添加」后列表乐观更新、底部停在「保存中…」，写入从未落盘、
+  关闭重开不显示、白名单也不生效。现改为经 `settingsScope` 控制器写
+  （`set` / `unset`：自动携带最新 revision、串行化并发写、把宿主应答折叠回共享镜像），
+  写完回读快照校验后显示「已保存」或失败原因；该控制器接口在 0.1.1 与 0.1.2 一致，
+  因此同时兼容两版。
+
+### Added
+
+- `tests/client.test.js`：用最小 React / DSH 客户端桩直接驱动设置页组件，覆盖写路径
+  （控制器 `set`/`unset`）、「保存中…→已保存」回显、重开显示持久化白名单，并断言组件
+  不再依赖 `connection.api`；`npm test` 与 CI 改为同时运行两个测试文件。
+
 ## [1.2.0] - 2026-09-02
 
 ### Added

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 表格分隔行（连字符与竖线）不参与重复统计 / whitelist of characters ignored during detection, so Markdown table separators don't count |
 | `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.
 
 ---
 
@@ -197,6 +212,7 @@ default), Markdown table separator rows and horizontal rules (whitelisted by def
 │   └── 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
 ├── cordis.patch.yml            # bundle 补丁层（dsh.bundle.patch：插入宿主行）
@@ -209,13 +225,17 @@ default), Markdown table separator rows and horizontal rules (whitelisted by def
 ## 测试 / Tests
 
 ```bash
-node tests/detector.test.js   # 或 npm test
+npm test                      # 两个测试文件
+node tests/detector.test.js   # 检测端到端（48 项）
+node tests/client.test.js     # 设置页组件（6 项）
 ```
 
 同一套 15 项用例分别驱动两个入口（`plugin/host.js` 经 `new Function` 求值、`lib/index.js` 经
 `require` 加载），覆盖：透传完整性、各类复读形态、阈值边界、协议闭合、上游 `return()` 调用、
-默认不检测 reasoning/工具参数、未闭合工具调用块的闭合、多次调用状态隔离等。CI 在 Node 20/22/24
-上运行（与 DSH 一致，不支持 Node 18）。
+默认不检测 reasoning/工具参数、未闭合工具调用块的闭合、多次调用状态隔离等。`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).

package/lib/client.js

@@ -2,7 +2,7 @@
  * dupguard 浏览器端 bundle（单文件，经 window.__ModuleLoader__ 加载）。
  *
  * 在 DSH 设置面板注册一个与「通用设置 / 模型 / 插件 / Agent 预设」并列的
- * 分节「重复守卫」：白名单（检测时忽略的字符）的可视化编辑界面。
+ * 分节「重复守卫」：白名单（检测时忽略的字符）与全部检测参数的可视化编辑界面。
  * 数据经 settingsScope 绑定宿主 settings 服务的 "dsh-dupguard" 命名空间，
  * 修改即时生效并持久化（settings.yaml）。
  *
@@ -23,29 +23,73 @@ window.__ModuleLoader__.load({
     const zh = {
       nav: '重复守卫',
       title: '重复输出守卫',
-      intro: '模型输出中同一字符串连续重复 10 次以上时会自动截停。此处配置检测时忽略的字符（白名单）：这些字符不参与重复统计，例如 Markdown 表格分隔行会大量使用连字符与竖线。',
-      list: '当前白名单',
+      intro: '模型输出中同一字符串连续重复达到阈值次数时自动截停。以下参数修改后即时生效并持久化（settings.yaml）。',
+      list: '忽略字符（白名单）',
       empty: '白名单为空：所有字符都参与重复统计。',
       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}）。',
+      windowWarn: '⚠ 检测窗口长度需要提高：至少 {need}（当前 {current} = 阈值 {threshold} × 最大单元 {maxUnit}）。当前窗口下超过 {effective} 字符的重复单元无法识别。',
       loading: '加载中…',
-      note: '修改即时生效；「恢复默认」回到连字符与竖线。',
-      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)',
       empty: 'Whitelist is empty: every character counts.',
       addPlaceholder: 'Character to ignore',
       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}).',
+      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.',
-      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.',
     }
 
@@ -64,6 +108,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') {
@@ -76,18 +135,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' },
@@ -99,7 +257,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' },
@@ -108,108 +266,153 @@ 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 (field.key === 'maxUnitLength' && crossInvalid) return fmt(t('errCross'), { min: parsed.minUnitLength })
+        return null
+      }
 
-      // 直接经设置 RPC 写（models 页同款），可观察到真实错误；
-      // 乐观更新保证界面即时反映，写入结果异步回填状态。
-      const persist = (next) => {
-        setWriteState('saving')
-        const revision = snap.revision === undefined ? undefined : snap.revision
-        props.api.settings.mutate({
-          ns: SETTINGS_NS,
-          ops: [{ op: 'set', path: ['ignoredChars'], value: next }],
-          ...(revision === undefined ? {} : { expectedRevision: revision }),
-        }).then((response) => {
-          if (!response || !response.result || !response.result.ok) {
-            const message = response && response.result && response.result.error ? response.result.error.message : 'unknown'
-            setWriteState('error:' + message)
-          } else {
-            setWriteState('saved')
-            // 写成功后重拉 describe 刷新镜像，保证重开设置页显示持久化值。
-            if (props.mirror && typeof props.mirror.load === 'function') {
-              props.mirror.load()
-            }
+      // 窗口缺口提示：窗口 < 阈值 × 最大单元长度时，更长的单元无法凑满重复次数。
+      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),
           }
-        }, (error) => {
-          setWriteState('error:' + String(error && error.message || error))
-        })
+        : null
+
+      // ---- 写路径：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 persistUnset = () => {
+      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')
-        const revision = snap.revision === undefined ? undefined : snap.revision
-        props.api.settings.mutate({
-          ns: SETTINGS_NS,
-          ops: [{ op: 'unset', path: ['ignoredChars'] }],
-          ...(revision === undefined ? {} : { expectedRevision: revision }),
-        }).then((response) => {
-          if (!response || !response.result || !response.result.ok) {
-            const message = response && response.result && response.result.error ? response.result.error.message : 'unknown'
-            setWriteState('error:' + message)
-          } else {
-            setWriteState('saved')
-            if (props.mirror && typeof props.mirror.load === 'function') {
-              props.mirror.load()
-            }
-          }
-        }, (error) => {
-          setWriteState('error:' + String(error && error.message || error))
-        })
+        Promise.resolve()
+          .then(() => operation())
+          .then(() => setWriteState(verify() ? 'saved' : 'error:' + t('saveFailed')), (error) => {
+            setWriteState('error:' + String((error && error.message) || error))
+          })
       }
-
-      const remove = (ch) => {
-        const next = shown.filter((item) => item !== ch)
-        touched.current = true
-        setList(next)
-        persist(next)
+      const commitList = (next) => {
+        dirty.current.ignoredChars = true
+        setForm({ ...currentForm(), ignoredChars: next })
+        runWrite(() => controller.set('ignoredChars', next), () => sameList(snapshotValue().ignoredChars, next))
+      }
+      const commitNumber = (field) => {
+        const message = fieldError(field)
+        if (message !== null) {
+          setErrors((prev) => ({ ...prev, [field.key]: message }))
+          return
+        }
+        const value = parsed[field.key]
+        dirty.current[field.key] = true
+        setErrors((prev) => ({ ...prev, [field.key]: null }))
+        setForm({ ...currentForm(), [field.key]: String(value) })
+        runWrite(() => controller.set(field.key, value), () => snapshotValue()[field.key] === value)
+      }
+      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)
         setDraft('')
+        if (shown.ignoredChars.indexOf(ch) !== -1) return
+        commitList([...shown.ignoredChars, ch])
       }
-      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',
@@ -222,19 +425,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),
+        ),
       )
     }
 
@@ -245,28 +460,16 @@ 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(() => () => {
         controller.dispose()
       }, 'dupguard: settings scope')
-      const injected = () => ({ controller, t, isLoopback, mirror, api: connection.api })
+      const injected = () => ({ controller, t, isLoopback, mirror })
       ctx.slots.inject('settings.section', () => ctx.slots.register({
         name: 'settings.section',
         id: 'dupguard',

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),
       })
     )
   }
@@ -302,18 +321,86 @@ 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 = Array.isArray(source.ignoredChars)
+    ? source.ignoredChars.filter((ch) => typeof ch === 'string')
+    : [...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 +409,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.0",
+  "version": "1.3.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,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/detector.test.js"
+    "test": "node tests/detector.test.js && node tests/client.test.js"
   },
   "publishConfig": {
     "access": "public"

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 = {