dsh-dupguard 1.0.2 → 1.1.0

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 本文件遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循 [SemVer](https://semver.org/lang/zh-CN/)。
 
+## [1.1.0] - 2026-08-30
+
+### Added
+
+- 图形化设置页（npm 常驻版）：新增 `lib/client.js`（`dsh.client` 浏览器端入口），在 DSH
+  设置面板注册与「通用设置 / 模型 / 插件 / Agent 预设」并列的「重复守卫」分节，可视化
+  编辑白名单（增删字符、恢复默认），样式使用 `--dsw-*` 主题变量与原有设置页一致；
+- 设置持久化与热更新：host 端通过 settings 服务注册 `dsh-dupguard` 命名空间
+  （`ignoredChars` 字段，schemastery schema，新增 `@deepseek-ai/schemastery` 依赖），
+  设置变更即时热生效（动态版保持零依赖，白名单固定取常量）；
+- 测试新增 settings 集成套件（默认 base、热更新、清空、恢复默认），共 48 项。
+
+## [1.0.3] - 2026-08-30
+
+### Fixed
+
+- 思考（reasoning）复读守卫：`monitorReasoning` 默认改为开启，思考中同一字符串连续重复
+  10 次以上即截停；修复开启后暴露的 reasoning 文本双重累积缺陷（`b.text` 与 `feedText`
+  各加一次，导致闭合块文本翻倍）；新增"关闭开关"变体套件验证 `monitorReasoning: false`
+  时仍全量透传。测试套件双入口各 21 项，加变体共 44 项。
+
 ## [1.0.2] - 2026-08-27
 
 ### Fixed

package/README.md

@@ -19,11 +19,14 @@ When triggered, the already-generated text is committed as a normal assistant me
 
 - **实时检测**：逐 token（`text-delta`）检测，复读出现即停，延迟为单个增量。
 - **多种复读形态**：单字符循环、词语循环、带空格/换行分隔的复读均能识别（默认去空白后检测）。
+- **思考守卫**：默认同时检测 reasoning（思考）文本，思考中的复读同样会被截停（可通过 `monitorReasoning` 关闭）。
 - **真正的服务端停止**：提前关闭流迭代 → 适配器 `consumer.abort()` → 中断 HTTP 连接，模型在服务端停止生成。
 - **安全停止**：绝不 `abort()` agent 步骤信号；补发协议合规的 `block-end` + `finish(stop)`，消息正常提交。
-- **Markdown 表格友好**：默认忽略连字符与竖线（`ignoredChars` 白名单，可配置），表格分隔行与长分隔线不会被误判为复读。
-- **零依赖 / 零配置**：纯 JavaScript，无运行时依赖；默认配置开箱即用。
-- **双入口交付**：动态插件（`plugin/host.js`）+ npm 组合挂载（`lib/index.js`），行为一致、CI 防漂移。
+- **Markdown 表格友好**：默认忽略连字符与竖线（`ignoredChars` 白名单），表格分隔行与长分隔线不会被误判为复读。
+- **图形化设置页**（npm 常驻版）：在 DSH 设置面板注册与「通用设置 / 模型 / 插件 / Agent 预设」并列的
+  「重复守卫」分节，可视化编辑白名单并持久化（`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 多代并存冲突（见下文"已知限制"）。
 
@@ -105,8 +108,8 @@ Edit the `CONFIG` block at the top of `plugin/host.js` / `lib/index.js` (both en
 | `maxUnitLength` | `80` | 最大重复单元长度 / maximum repeating-unit length |
 | `detectionWindow` | `8192` | 检测滚动窗口（字符，去空白后）/ rolling detection window in chars (after whitespace removal) |
 | `stripWhitespace` | `true` | 检测前移除空白/换行，识别带分隔符的复读 / strip whitespace so `"x x x"` and `"x\nx\nx"` are caught |
-| `ignoredChars` | `['-', '\|']` | 检测时忽略的字符白名单：Markdown 表格分隔行（连字符与竖线）不参与重复统计；需更严格检测时置 `[]` / whitelist of characters ignored during detection: Markdown table separators don't count as repetition; set `[]` for stricter detection |
-| `monitorReasoning` | `false` | 是否检测思考文本 / also guard reasoning (thinking) text — off by default, high false-positive risk |
+| `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) |
+| `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 |
 
@@ -160,11 +163,12 @@ agent-loop commits the partial text as a normal assistant message.
 | 带空格复读 / space-separated | `hello hello hello ...` ×10 |
 | 逐行复读 / line repeats | `抱歉，我无法完成。` ×10 行 |
 | 前缀后循环 / loop after prefix | `好的，下面开始回答：` + `循环` ×10 |
+| 思考复读 / reasoning loop | 思考中 `想` ×10（默认截停） |
 
 **不会触发 / Won't trigger**：正常文本中的高频词（检测只针对**连续**重复）、重复 9 次及以下、
-reasoning 与工具参数（默认关闭）、Markdown 表格分隔行与长分隔线（连字符与竖线在白名单中，默认忽略）。
-/ high-frequency words in normal prose (consecutive runs only), ≤9 repeats, reasoning and tool args
-(off by default), Markdown table separator rows and horizontal rules (whitelisted by default).
+工具参数（默认关闭）、Markdown 表格分隔行与长分隔线（连字符与竖线在白名单中，默认忽略）。
+/ high-frequency words in normal prose (consecutive runs only), ≤9 repeats, tool args (off by
+default), Markdown table separator rows and horizontal rules (whitelisted by default).
 
 ---
 
@@ -175,9 +179,10 @@ reasoning 与工具参数（默认关闭）、Markdown 表格分隔行与长分
 ├── plugin/
 │   └── host.js                 # 动态插件形式（cordis_define 的 code.host）
 ├── lib/
-│   └── index.js                # npm/组合常驻形式（package.json main 入口）
+│   ├── index.js                # npm/组合常驻形式（package.json main 入口，含设置集成）
+│   └── client.js               # 浏览器端设置页（ModuleLoader 格式，dsh.client 入口）
 ├── tests/
-│   ├── detector.test.js        # 端到端测试：15 项 × 2 入口（防漂移）
+│   ├── detector.test.js        # 端到端测试：双入口防漂移 + reasoning 开关 + settings 集成
 │   └── experiment-cancel.mjs   # 诊断实验（不进 CI）：验证截停不阻塞于底层流取消
 ├── .github/workflows/ci.yml    # GitHub Actions：Node 18/20/22
 ├── package.json

package/lib/client.js

@@ -0,0 +1,162 @@
+/**
+ * dupguard 浏览器端 bundle（单文件，经 window.__ModuleLoader__ 加载）。
+ *
+ * 在 DSH 设置面板注册一个与「通用设置 / 模型 / 插件 / Agent 预设」并列的
+ * 分节「重复守卫」：白名单（检测时忽略的字符）的可视化编辑界面。
+ * 数据经 settingsScope 绑定宿主 settings 服务的 "dsh-dupguard" 命名空间，
+ * 修改即时生效并持久化（settings.yaml）。
+ *
+ * 样式全部使用 --dsw-* 主题变量，跟随全局亮/暗主题，与原有设置页风格一致。
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-dupguard',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const React = require('react')
+
+    const NS = 'dsh-dupguard'
+    const SETTINGS_NS = 'dsh-dupguard'
+
+    const zh = {
+      nav: '重复守卫',
+      title: '重复输出守卫',
+      intro: '模型输出中同一字符串连续重复 10 次以上时会自动截停。此处配置检测时忽略的字符（白名单）：这些字符不参与重复统计，例如 Markdown 表格分隔行会大量使用连字符与竖线。',
+      list: '当前白名单',
+      empty: '白名单为空：所有字符都参与重复统计。',
+      addPlaceholder: '输入要忽略的字符',
+      add: '添加',
+      reset: '恢复默认',
+      loading: '加载中…',
+      note: '修改即时生效；「恢复默认」回到连字符与竖线。',
+    }
+    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',
+      empty: 'Whitelist is empty: every character counts.',
+      addPlaceholder: 'Character to ignore',
+      add: 'Add',
+      reset: 'Reset to defaults',
+      loading: 'Loading…',
+      note: 'Changes take effect immediately; "Reset to defaults" restores hyphen and pipe.',
+    }
+
+    const css = [
+      '.dg-section{display:flex;flex-direction:column;gap:14px;padding:4px 2px 24px;font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary)}',
+      '.dg-title{font-size:15px;font-weight:600;line-height:24px;margin:0}',
+      '.dg-intro{color:var(--dsw-alias-label-secondary);margin:0}',
+      '.dg-chips{display:flex;flex-wrap:wrap;gap:8px}',
+      '.dg-chip{display:inline-flex;align-items:center;gap:6px;height:28px;padding:0 6px 0 10px;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;background:var(--dsw-alias-bg-layer-1);font-size:12px;color:var(--dsw-alias-label-primary)}',
+      '.dg-chip-remove{display:inline-flex;align-items:center;justify-content:center;width:18px;height:18px;border:none;border-radius:5px;background:none;color:var(--dsw-alias-label-tertiary);cursor:pointer;font-size:13px;line-height:1;padding:0}',
+      '.dg-chip-remove:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}',
+      '.dg-add{display:flex;gap:8px}',
+      '.dg-input{flex:1;max-width:240px;height:32px;padding:0 12px;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;outline:none;font-family:inherit}',
+      '.dg-input:focus{border-color:var(--dsw-alias-brand-primary)}',
+      '.dg-btn{height:32px;padding:0 14px;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font-size:13px;cursor:pointer;font-family:inherit}',
+      '.dg-btn:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.dg-btn-primary{background:var(--dsw-alias-brand-primary);border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-brand-on-primary,#fff)}',
+      '.dg-btn-primary:hover{background:var(--dsw-alias-brand-primary)}',
+      '.dg-note{color:var(--dsw-alias-label-tertiary);font-size:12px;margin:0}',
+      '.dg-empty{color:var(--dsw-alias-label-tertiary);margin:0}',
+    ].join('\n')
+
+    if (typeof document !== 'undefined') {
+      const tag = document.createElement('style')
+      tag.dataset.plugin = 'dsh-dupguard'
+      tag.dataset.pluginCss = 'dsh-dupguard/client.css'
+      tag.textContent = css
+      document.head.appendChild(tag)
+    }
+
+    const inject = ['slots', 'locale', 'connection', 'settingsScope']
+
+    function DupguardSection(props) {
+      const controller = props.controller
+      const t = props.t
+      const snap = React.useSyncExternalStore(
+        (cb) => controller.subscribe(cb),
+        () => controller.getSnapshot(),
+      )
+      const [draft, setDraft] = React.useState('')
+
+      if (snap.status !== 'ready') {
+        return React.createElement('div', { className: 'dg-section' },
+          React.createElement('p', { className: 'dg-empty' }, t('loading')))
+      }
+      const list = Array.isArray(snap.value && snap.value.ignoredChars) ? snap.value.ignoredChars : []
+
+      const remove = (ch) => {
+        controller.set('ignoredChars', list.filter((item) => item !== ch))
+      }
+      const add = () => {
+        const ch = draft.trim()
+        if (ch.length === 0) return
+        if (list.indexOf(ch) !== -1) {
+          setDraft('')
+          return
+        }
+        controller.set('ignoredChars', [...list, ch])
+        setDraft('')
+      }
+      const reset = () => {
+        controller.unset('ignoredChars')
+      }
+      const onKey = (e) => {
+        if (e.key === 'Enter') add()
+      }
+
+      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')),
+        list.length === 0
+          ? React.createElement('p', { className: 'dg-empty' }, t('empty'))
+          : React.createElement('div', { className: 'dg-chips' },
+            list.map((ch) => React.createElement('span', { className: 'dg-chip', key: ch },
+              ch,
+              React.createElement('button', {
+                className: 'dg-chip-remove',
+                onClick: () => remove(ch),
+                'aria-label': 'remove',
+              }, '\u00d7')))),
+        React.createElement('div', { className: 'dg-add' },
+          React.createElement('input', {
+            className: 'dg-input',
+            placeholder: t('addPlaceholder'),
+            value: draft,
+            onChange: (e) => setDraft(e.target.value),
+            onKeyDown: onKey,
+          }),
+          React.createElement('button', { className: 'dg-btn dg-btn-primary', onClick: add }, t('add')),
+          React.createElement('button', { className: 'dg-btn', onClick: reset }, t('reset')),
+        ),
+        React.createElement('p', { className: 'dg-note' }, t('note')),
+      )
+    }
+
+    function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dupguard: dictionaries')
+      const t = ctx.locale.bind(NS)
+      const controller = ctx.settingsScope.bind({ namespace: SETTINGS_NS })
+      ctx.effect(() => () => {
+        controller.dispose()
+      }, 'dupguard: settings scope')
+      const injected = () => ({ controller, t })
+      ctx.slots.inject('settings.section', () => ctx.slots.register({
+        name: 'settings.section',
+        id: 'dupguard',
+        order: 25,
+        label: () => t('nav'),
+        inject: injected,
+      }, DupguardSection))
+    }
+
+    exports.apply = apply
+    exports.inject = inject
+    return module.exports
+  },
+})

package/lib/index.js

@@ -10,10 +10,24 @@
 // { name, apply }，供 DSH 组合（cordis.yml / preset）挂载；
 // 与 plugin/host.js（动态 cordis_define 形式）行为完全一致，
 // tests/detector.test.js 会对两者同时跑同一套用例，防止两份代码漂移。
+//
+// 设置集成（仅本常驻版）：通过 DSH 的 settings 服务注册命名空间
+// "dsh-dupguard"，白名单（ignoredChars）可在 Web 设置页修改并持久化
+// （见 lib/client.js），修改即时热生效。
 // ============================================================================
 
+const z = require('@deepseek-ai/schemastery')
+
 const name = 'dupguard'
 
+/** 设置命名空间：小写 kebab-case（dsh-settings 的命名规范）。 */
+const SETTINGS_NS = 'dsh-dupguard'
+
+/** 设置 schema：白名单字符数组（其余检测参数保持代码常量）。 */
+const SETTINGS_SCHEMA = z.object({
+  ignoredChars: z.array(z.string()).default(['-', '|']),
+})
+
 const CONFIG = {
   // 触发阈值：同一字符串连续重复次数达到该值时停止输出（用户需求：重复十次以上）。
   // 语义为「>= threshold」，即第 10 次重复出现时就触发。
@@ -32,9 +46,10 @@ const CONFIG = {
   // （如 "|---|---|"），正常表格输出会大量连续出现，不应视为复读。
   // 默认忽略连字符与竖线；需要更严格的检测时可改为空数组 []。
   ignoredChars: ['-', '|'],
-  // 是否同时检测思考（reasoning）文本。默认关闭：思考内容不可见，且正常思考文本
-  // 更可能出现连续重复片段，误伤风险高。
-  monitorReasoning: false,
+  // 是否同时检测思考（reasoning）文本。默认开启：思考中的复读同样消耗 token，
+  // 应立即截停。注意：正常思考中若连续重复同一字符串 10 次以上（如"等等等等"），
+  // 也会被截停，属预期行为；需要只检测可见输出时可置为 false。
+  monitorReasoning: true,
   // 是否同时检测工具调用参数（JSON 片段）。默认关闭：JSON / base64 中重复字符很常见。
   monitorToolArguments: false,
   // DSH ≤ 0.1.1-rc.1 兼容补丁（默认开启；实测 0.1.1-rc.1 仍未修复）：preset 的 standing mount
@@ -102,8 +117,10 @@ function sanitizeDelta(delta, config) {
 /**
  * 为一次 llm/stream 调用创建守卫。
  * 每次模型调用都会新建一份状态，互不干扰。
+ * @param options - llm/stream 的 GenerateOptions。
+ * @param runtime - 运行时配置（ignoredChars 可被设置页热更新）。
  */
-function createStreamGuard(options) {
+function createStreamGuard(options, runtime) {
   // index -> 块状态。用 Map 按块索引累积，避免多个文本块交替输出时互相打断检测。
   const blocks = new Map()
   let stopped = null
@@ -130,9 +147,9 @@ function createStreamGuard(options) {
   /** 把一段文本增量喂给检测缓冲，返回命中结果（null 表示未命中）。 */
   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 piece = sanitizeDelta(delta, runtime)
+    b.stripped = (b.stripped + piece).slice(-runtime.detectionWindow)
+    return findRepeatedTail(b.stripped, runtime.threshold, runtime.minUnitLength, runtime.maxUnitLength)
   }
 
   /** 依据 StreamChunk 协议累积状态；命中时置 stopped。 */
@@ -150,10 +167,12 @@ function createStreamGuard(options) {
       }
       case 'reasoning-delta': {
         const b = ensure(chunk.index, 'reasoning')
-        b.text += chunk.text // 始终累积：停止时需要完整内容闭合块
-        if (CONFIG.monitorReasoning) {
+        if (runtime.monitorReasoning) {
+          // feedText 内部负责累积完整文本与检测缓冲，这里不得重复 +=
           const hit = feedText(b, chunk.text)
           if (hit !== null) stopped = hit
+        } else {
+          b.text += chunk.text // 不检测时仍须累积完整内容以便停止时闭合块
         }
         return
       }
@@ -162,10 +181,10 @@ function createStreamGuard(options) {
         if (chunk.id !== undefined) b.toolCallId = chunk.id
         if (chunk.name !== undefined) b.toolCallName = chunk.name
         b.toolCallArguments += chunk.argumentsDelta
-        if (CONFIG.monitorToolArguments) {
-          const piece = sanitizeDelta(chunk.argumentsDelta, CONFIG)
-          b.stripped = (b.stripped + piece).slice(-CONFIG.detectionWindow)
-          const hit = findRepeatedTail(b.stripped, CONFIG.threshold, CONFIG.minUnitLength, CONFIG.maxUnitLength)
+        if (runtime.monitorToolArguments) {
+          const piece = sanitizeDelta(chunk.argumentsDelta, runtime)
+          b.stripped = (b.stripped + piece).slice(-runtime.detectionWindow)
+          const hit = findRepeatedTail(b.stripped, runtime.threshold, runtime.minUnitLength, runtime.maxUnitLength)
           if (hit !== null) stopped = hit
         }
         return
@@ -268,12 +287,44 @@ function installStandingMountPatch(ctx) {
   console.log('[dupguard] cordisInspect.register 已幂等化（DSH standing-mount 多代并存兼容补丁）')
 }
 
+/**
+ * 把 CONFIG 拷贝为运行时配置：ignoredChars 会被设置页热更新，
+ * 其余字段保持代码常量（设置页只暴露白名单）。
+ */
+function createRuntime() {
+  return {
+    ...CONFIG,
+    ignoredChars: [...CONFIG.ignoredChars],
+  }
+}
+
+/**
+ * 从 DSH 的 settings 服务注册白名单设置（仅常驻版）。
+ * 返回注销器；settings 服务缺失（无头环境）时不做任何事。
+ */
+function installSettings(ctx, runtime) {
+  const settings = ctx.get('settings')
+  if (settings === undefined || typeof settings.register !== 'function') return
+  const scope = settings.register(SETTINGS_NS, SETTINGS_SCHEMA, {
+    base: { ignoredChars: CONFIG.ignoredChars },
+  })
+  const sync = () => {
+    runtime.ignoredChars = [...scope.get().ignoredChars]
+  }
+  sync()
+  const stop = scope.watch(sync)
+  ctx.effect(() => () => stop(), 'dupguard: settings watch')
+  console.log('[dupguard] 已注册设置命名空间 ' + SETTINGS_NS + '（白名单可在设置页修改）')
+}
+
 function apply(ctx) {
   if (CONFIG.fixStandingMountConflict) installStandingMountPatch(ctx)
+  const runtime = createRuntime()
+  installSettings(ctx, runtime)
   // llm/stream：包裹每次流式模型调用的瀑布事件。
   // 监听器返回包装后的 AsyncIterable，即成为本次调用对消费方可见的流。
   // （与 @deepseek-ai/dsh-llm 的 invariant、dsh-session-checkpoint-policy 同款接入方式）
-  ctx.on('llm/stream', (options, next) => createStreamGuard(options)(next()))
+  ctx.on('llm/stream', (options, next) => createStreamGuard(options, runtime)(next()))
 }
 
 module.exports = { name, apply }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-dupguard",
-  "version": "1.0.2",
+  "version": "1.1.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",
@@ -11,13 +11,21 @@
     "anti-repetition",
     "output-guard",
     "llm",
+    "client-plugin",
     "防复读",
     "重复检测"
   ],
   "license": "MIT",
   "main": "lib/index.js",
   "exports": {
-    ".": "./lib/index.js"
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web"
+    }
   },
   "files": [
     "lib",
@@ -36,6 +44,9 @@
     "access": "public"
   },
   "sideEffects": false,
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zqh260619/dsh-dupguard.git"

package/plugin/host.js

@@ -9,6 +9,11 @@
 // 需要随 DSH 常驻时，请改用 npm/组合形式 lib/index.js（与本文件行为一致，
 // tests/detector.test.js 会对两个入口跑同一套用例防止漂移）。
 // 安装/运行步骤与配置说明见仓库根目录的 README.md。
+//
+// 说明：动态插件代码体不能 require 依赖，因此本版本不集成 settings 服务，
+// 白名单固定取 CONFIG.ignoredChars。npm 常驻版（lib/index.js）会注册
+// "dsh-dupguard" 设置命名空间并提供 Web 设置页（lib/client.js），
+// 白名单可在设置中修改并持久化。
 // ============================================================================
 
 const CONFIG = {
@@ -29,9 +34,10 @@ const CONFIG = {
   // （如 "|---|---|"），正常表格输出会大量连续出现，不应视为复读。
   // 默认忽略连字符与竖线；需要更严格的检测时可改为空数组 []。
   ignoredChars: ['-', '|'],
-  // 是否同时检测思考（reasoning）文本。默认关闭：思考内容不可见，且正常思考文本
-  // 更可能出现连续重复片段，误伤风险高。
-  monitorReasoning: false,
+  // 是否同时检测思考（reasoning）文本。默认开启：思考中的复读同样消耗 token，
+  // 应立即截停。注意：正常思考中若连续重复同一字符串 10 次以上（如"等等等等"），
+  // 也会被截停，属预期行为；需要只检测可见输出时可置为 false。
+  monitorReasoning: true,
   // 是否同时检测工具调用参数（JSON 片段）。默认关闭：JSON / base64 中重复字符很常见。
   monitorToolArguments: false,
   // DSH ≤ 0.1.1-rc.1 兼容补丁（默认开启；实测 0.1.1-rc.1 仍未修复）：preset 的 standing mount
@@ -147,10 +153,12 @@ function createStreamGuard(options) {
       }
       case 'reasoning-delta': {
         const b = ensure(chunk.index, 'reasoning')
-        b.text += chunk.text // 始终累积：停止时需要完整内容闭合块
         if (CONFIG.monitorReasoning) {
+          // feedText 内部负责累积完整文本与检测缓冲，这里不得重复 +=
           const hit = feedText(b, chunk.text)
           if (hit !== null) stopped = hit
+        } else {
+          b.text += chunk.text // 不检测时仍须累积完整内容以便停止时闭合块
         }
         return
       }