dsh-repeat-guard 0.1.1 → 0.1.2

package/README.md

@@ -4,11 +4,10 @@
 
 | 项 | 说明 |
 |---|---|
-| 类型 | dsh host 侧插件（函数式） |
+| 类型 | dsh bundle，含宿主侧插件与客户端设置页 |
 | 监听 | `llm/stream`、`agent/turn-stopping` |
-| 运行时依赖 | **无**，不产生任何运行时 import |
-| 构建期依赖 | 仅 TypeScript |
-| 入口 | `lib/index.js`（由 `src/index.ts` 编译得到） |
+| 入口 | `lib/index.js`（`src/index.ts`）、`lib/client.js`（`src/client.tsx`） |
+| 可调项 | 拦截短句表、连续命中阈值（设置 → 复读打断） |
 | 分发 | npm 包 `dsh-repeat-guard` |
 
 ---
@@ -50,10 +49,32 @@
 | `好？` `好！` `好` `OK` | 不拦（表外） |
 | `我需要检查实现。\n然后重新编译。` | 不拦（各行都在表外） |
 
-**表在 `src/detect.ts` 的 `FRAGMENTS` 数组里**，增删词条改它即可。表项**连标点一起写**（`'好的。'` 对应思考里的 `好的。`），英文条目一律写小写。
+表项**连标点一起写**（`'好的。'` 对应思考里的 `好的。`），英文条目一律写小写。分割单位是单个换行，空行会把连续计数打断。
+
+**表可以在设置里改**（见下面「可调项」）；`src/config.ts` 的 `DEFAULT_FRAGMENTS` 是出厂默认值。
 
 已知边界：判据只看"有没有这样一行"，不看上下文。所以"用户想让我改代码。\n好的。"这种**前面有实质内容、结尾又跟一句空话**的思考也会被拦。这是"按行判定"的直接结果。
 
+## 连续命中阈值
+
+阈值 `threshold` 是"连着几行命中才拦"：
+
+| 值 | 行为 |
+|---|---|
+| 1（默认） | 任意一行命中即拦 |
+| n | 连着 n 行都是表项（**句子可以各不相同**）才拦；中间夹一行不命中的就重新计数 |
+
+阈值只在**同一次生成内**计数，不跨轮次。
+
+## 命中在思考段末尾时不拦
+
+命中之后，插件再往下探一格：
+
+- 后面还是 `reasoning-delta` → 思考确实在继续复读，**拦**；
+- 后面换成正文、工具调用，或直接收尾（`block-end` / `usage` / `finish` / 流结束）→ 说明命中行本来就是这段思考的最后一句，**不拦**，原样透传。
+
+判据是**思考段是否还在往下写**，不是整个响应是否结束——思考以一句"好。"收尾、接着写正文，属正常收尾。
+
 ## 工作原理
 
 1. 包一层 `llm/stream`（模型调用的流式 waterfall），逐 chunk 观察 `reasoning-delta`，累积本次响应已产出的思考文本。
@@ -63,10 +84,12 @@
 
 辅助调用（上下文压缩、会话标题等带 `purpose` 的调用）不参与检测。
 
-每次拦截都会把**命中的那一行原文**写进 journal，便于事后核对误杀：
+三种结局各有日志，便于事后核对误杀：
 
 ```
-[repeat-guard] 检出思考段复读，已掐断本次生成 | 命中行="好的。"
+[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=… | 命中行="好的。"
+[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=… | 命中行="好的。"
+[repeat-guard] turn-stopping：会话 … 续跑一步
 ```
 
 ## 掐断之后怎么让本轮继续
@@ -80,19 +103,23 @@ if (turnEnds && this.inbox.nextStep.length === 0) {
 if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读收件箱
 ```
 
-`agent/turn-stopping` 在 `break` 之前被 `await`，之后收件箱会被**重新读一次**。所以只要监听器往 `inbox.nextStep` 里推入东西，本轮就不 break，而是再跑一步。官方对该事件的说明也写明了这个用法，先例见 `dsh-hooks-claude-code/lib/index.js:292`。
+`agent/turn-stopping` 在 `break` 之前被 `await`，之后收件箱会被**重新读一次**。所以只要监听器往 `inbox.nextStep` 里推入东西，本轮就不 break，而是再跑一步。官方对该事件的说明也写明了这个用法，先例见 `dsh-hooks-claude-code/lib/index.js:300`。
 
 注意：
 
 - **做不到"这一步当作没发生"。** 被截断的 assistant 消息在 `step()` 里已经 `session.append` 落盘，dsh 没有回滚一步的机制；`step()` 唯一返回 `null`（循环继续）的出口要求本步真的产生了 tool-call，插件够不着。所以这里的语义是"接着再跑一步"，会话里会留下被截断的思考记录。
+- **续跑没有次数配额。** 有标记就推，同一轮里反复退化就反复续跑。
 
 ## 可调项
 
-判定本身没有阈值，只有 `src/detect.ts` 里的 `FRAGMENTS` 表。改完需要重新构建。
+在 **设置 → 复读打断** 里改，保存后宿主侧立即按新配置判定，不用重启。
+
+| 项 | 含义 |
+|---|---|
+| 拦截短句 | 判为复读的空话短句表，一行一句，连标点一起写 |
+| 连续命中次数 | 连着几行命中才拦；默认 1 = 发现即拦 |
 
-| 项 | 位置 | 含义 |
-|---|---|---|
-| `FRAGMENTS` | `src/detect.ts` | 会被判为复读的空话短句表，增删词条改它 |
+配置存在 dsh 的 settings 服务里（命名空间 `repeat-guard`），落盘位置由 dsh 决定。
 
 ## 续跑时推给模型的输入
 
@@ -108,9 +135,20 @@ if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读收件箱
 
 ```bash
 npm install
-npm run build        # 等价于 tsc，产出 lib/
+npm run build        # tsc 产出 lib/*.js，再用 esbuild 打 lib/client.js
 ```
 
+两步各有各的产物：
+
+- `tsc` 编译 `src/*.ts` → `lib/*.js`，宿主侧入口就是 `lib/index.js`（真正被 dsh import 的部分）。
+- `scripts/build-client.mjs` 用 esbuild 把 `src/client.tsx` 打成**单文件** `lib/client.js`，外面套一层 dsh 客户端模块系统要求的包装：
+
+  ```js
+  window.__ModuleLoader__.load({ id: "dsh-repeat-guard", factory: function (require) { … } });
+  ```
+
+  `id` 必须是包名，`factory` 的返回值就是该包的客户端模块导出。`react` 等平台基座模块由模块系统提供，构建时设为 external，运行时从 `factory` 的 `require` 参数取。
+
 `lib/` **不进版本库**：`npm publish` 前由 `prepack` 钩子现构建，随包发布（`files` 字段已含 `lib`）。这样"改了 `src/` 忘了 build"不会让旧产物静默跟着提交——代价是构建失败时发不出去，这是有意的。
 
 ## 发布
@@ -122,7 +160,7 @@ npm publish --registry=https://registry.npmjs.org
 
 **两条命令都别省 `--registry`。** npm 的凭据是**按源绑定**的：`npm login` 登的是哪个源，`~/.npmrc` 里就只在那个源下记一条 `//registry.npmjs.org/:_authToken`。所以 `npm config get registry` 一旦被切到 npmmirror 这类只读镜像（它本身也发不上去），不带参数的 `npm publish` 会直接报 `need auth`。
 
-发布前不必手动构建，`prepack` 会跑一次 `npm run build`；tsc 报错则发布中止。
+发布前不必手动构建，`prepack` 会跑一次 `npm run build`；tsc 或 esbuild 报错则发布中止。
 
 ## 安装到 dsh
 
@@ -130,7 +168,7 @@ npm publish --registry=https://registry.npmjs.org
 dsh plugin --profile web add dsh-repeat-guard
 ```
 
-本插件是一个 **dsh bundle**——包根带 `cordis.patch.yml`，由 `package.json` 的 `dsh.bundle.patch` 声明。装进 profile 时它会自动进入 `dsh.profile.bundles` 分层栈，**不需要改 profile 自己的 `cordis.patch.yml`**。
+本插件是一个 **dsh bundle**——包根带 `cordis.patch.yml`，由 `package.json` 的 `dsh.bundle.patch` 声明。装进 profile 时它会自动进入 `dsh.profile.bundles` 分层栈，**不需要改 profile 自己的 `cordis.patch.yml`**。客户端半靠 `package.json` 的 `dsh.client` 声明被自动发现，同样不用改 profile。
 
 装完**必须重启 dsh 进程**。`patchReload: live` 只重载已有的层，不会加载新增的层——实测编辑后运行中的进程既不加载也不报错。
 
@@ -151,12 +189,15 @@ journalctl --user -u dsh-web --no-pager | grep -a repeat-guard
 
 dsh 会把 bundle 声明的 `dependencies` 与 `peerDependencies` 从安装目录软链进 profile（`dsh-app-boot` 的 `healProfileModuleFallback`，依赖名取自 `profileDependencyNames(manifest)`，注释原文是 "dependency names that may be imported by a loader-visible plugin"）。软链落在 `~/.dsh/profiles/node_modules/`，Node 按常规向上查找即可解析到。
 
+dsh 的 profile 同时带一份 `.npmrc`，写着 `auto-install-peers=false`（注释：core packages come from the CLI dependency tree; a profile must never resolve its own copy）——所以声明 `peerDependencies` 不会让 profile 自己再装一份宿主包。
+
 所以：
 
-- **宿主提供的包写 `peerDependencies`**：`@deepseek-ai/cordis`、`@deepseek-ai/dsh-llm`、`@deepseek-ai/dsh-agent`。它们不在 profile 里重复安装，用 dsh 自带的那份。
-- **类型一律从官方引**，不在本地重抄。`Context`、`StreamChunk`、`GenerateOptions`、`Agent`、`UserMessage` 都是 dsh 导出的；本地抄一份只会在 dsh 升级后于运行时暴露字段对不上，官方声明则会在 `tsc` 阶段直接报错。
+- **宿主提供的包写 `peerDependencies`**：`@deepseek-ai/cordis`、`dsh-llm`、`dsh-agent`、`dsh-settings`、`schemastery`、`dsh-client-ui-renderer`、`dsh-client-ui-settings`，以及客户端侧由平台基座提供的 `react`。它们不在 profile 里重复安装，用 dsh 自带的那份。
+- **类型一律从官方引**，不在本地重抄。`Context`、`StreamChunk`、`GenerateOptions`、`Agent`、`SettingsScope` 都是 dsh 导出的；本地抄一份只会在 dsh 升级后于运行时暴露字段对不上，官方声明则会在 `tsc` 阶段直接报错。
 - `src/types.ts` 只放本插件自有的类型（当前是 `GuardState`）。
-- 仍然只用 TypeScript 写源码，由 `tsc` 产出 `lib/` 供 dsh 加载。dsh 的 loader 是原生 ESM import，**没有转译层**，运行时读到的永远是编译产物——改完 `src/` 必须重新构建。`lib/` 只随 npm 包发布，不进版本库。
+- 部分 dsh 包的类型只通过 module augmentation 生效（如 `Context.settings`、`Context.slots`、`Context.settingsScope`），要显式 `import type {} from '…'` 触发加载，否则 `tsc` 会报"属性不存在"。
+- dsh 的 loader 是原生 ESM import，**没有转译层**，运行时读到的永远是编译产物——改完 `src/` 必须重新构建。`lib/` 只随 npm 包发布，不进版本库。
 
 ## 代码约定
 
@@ -165,7 +206,7 @@ dsh 会把 bundle 声明的 `dependencies` 与 `peerDependencies` 从安装目
 | 缩进 / 引号 / 分号 | 2 空格、单引号、语句末分号 |
 | 行宽 | 目标 100 字符，上限 120（中英混排按字符数计） |
 | 控制语句 | **一律带花括号**，单行 `if`、`continue`、`break` 也不例外，不写 `if (x) return;` |
-| 文件 | 一个文件只干一件事：类型声明 / 判定 / 续跑 / 单个监听器 / 装配，各占一个文件 |
+| 文件 | 一个文件只干一件事：类型声明 / 配置 / 判定 / 续跑 / 单个监听器 / 装配，各占一个文件 |
 | 函数 | 不超过 50 行；超了就先看能不能按职责拆开 |
 | 注释 | 一律中文；导出函数与判定函数配 `@param` / `@returns`，文件内小工具函数用单行注释即可 |
 
@@ -176,18 +217,22 @@ dsh 会把 bundle 声明的 `dependencies` 与 `peerDependencies` 从安装目
 ```
 .
 ├── src/
-│   ├── index.ts                 插件入口：装配状态，注册两个监听器（只做装配）
+│   ├── index.ts                 宿主侧入口：装配状态，注册两个监听器（只做装配）
 │   ├── types.ts                 本插件自有的类型（dsh 的接口一律从 @deepseek-ai/* 引）
-│   ├── detect.ts                复读判定：FRAGMENTS 表 + 查表纯函数，不碰会话状态
+│   ├── config.ts                配置：settings 命名空间、默认值、schema、取当前值
+│   ├── detect.ts                复读判定：查表 + 连续计数，不碰会话状态
 │   ├── resume.ts                续跑：注入文案、消息构造、推送
 │   ├── stream-guard.ts          llm/stream 监听器：思考段检测与掐断
-│   └── turn-stopping-guard.ts   agent/turn-stopping 监听器：让本轮继续
-├── lib/                         tsc 产物（已 gitignore），dsh 实际加载 lib/index.js
+│   ├── turn-stopping-guard.ts   agent/turn-stopping 监听器：让本轮继续
+│   └── client.tsx               客户端设置页：注册 settings.section
+├── scripts/
+│   └── build-client.mjs         esbuild 打包客户端半 → lib/client.js
+├── lib/                         构建产物（已 gitignore），dsh 加载 lib/index.js 与 lib/client.js
+├── cordis.patch.yml             bundle 层声明：把本插件挂进 profile 树
 ├── package.json
 └── tsconfig.json
 ```
 
-
 ## 许可
 
 MIT，见 `LICENSE`。

package/lib/client.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 客户端设置页：在设置窗口左侧加一项"复读打断"。
+ *
+ * 面板里编辑两样东西——拦截短句表（一行一句）与连续命中阈值，两者都写宿主侧
+ * 注册的 settings 命名空间，保存后宿主侧立即按新配置判定。
+ *
+ * 本文件由 scripts/build-client.mjs 用 esbuild 单独打包成单文件 bundle
+ * （`lib/client.js`），不走 tsc 的 lib 输出。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** 注册设置页需要的服务；这两个是 cordis 服务名，不是包名。 */
+export declare const inject: string[];
+/**
+ * 客户端插件入口。
+ * @param ctx - 浏览器侧 cordis 上下文。
+ */
+export declare function apply(ctx: Context): void;

package/lib/client.js

@@ -0,0 +1,113 @@
+window.__ModuleLoader__.load({ id: "dsh-repeat-guard", factory: function (require) {
+"use strict";
+var __dshClientBundle = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/client.tsx
+  var client_exports = {};
+  __export(client_exports, {
+    apply: () => apply,
+    inject: () => inject
+  });
+  var import_react = __require("react");
+  var import_jsx_runtime = __require("react/jsx-runtime");
+  var SETTINGS_NS = "repeat-guard";
+  var inject = ["slots", "settingsScope"];
+  function apply(ctx) {
+    const scope = ctx.settingsScope.bind({ namespace: SETTINGS_NS });
+    function Form({ initial }) {
+      const [fragments, setFragments] = (0, import_react.useState)(() => (initial.fragments ?? []).join("\n"));
+      const [threshold, setThreshold] = (0, import_react.useState)(() => String(initial.threshold ?? 1));
+      const [message, setMessage] = (0, import_react.useState)("");
+      function save() {
+        const list = fragments.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+        const count = Number(threshold);
+        setMessage("\u4FDD\u5B58\u4E2D\u2026");
+        scope.set("fragments", list).then(() => scope.set("threshold", count)).then(() => {
+          setMessage("\u5DF2\u4FDD\u5B58");
+        }).catch((error) => {
+          setMessage(`\u4FDD\u5B58\u5931\u8D25\uFF1A${String(error)}`);
+        });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", flexDirection: "column", gap: "12px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "\u8FDE\u7EED\u547D\u4E2D\u6B21\u6570" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "input",
+            {
+              type: "number",
+              value: threshold,
+              onChange: (event) => {
+                setThreshold(event.target.value);
+              }
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "\u586B 1 \u8868\u793A\u547D\u4E2D\u5373\u62E6\uFF1B\u586B n \u8868\u793A\u8FDE\u7740 n \u884C\u90FD\u547D\u4E2D\u624D\u62E6\u3002" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "\u62E6\u622A\u77ED\u53E5\uFF08\u4E00\u884C\u4E00\u53E5\uFF0C\u8FDE\u6807\u70B9\u4E00\u8D77\u5199\uFF09" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "textarea",
+            {
+              rows: 16,
+              style: { width: "100%", fontFamily: "monospace" },
+              value: fragments,
+              onChange: (event) => {
+                setFragments(event.target.value);
+              }
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", onClick: save, children: "\u4FDD\u5B58" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: message })
+        ] })
+      ] });
+    }
+    function Panel() {
+      const [snapshot, setSnapshot] = (0, import_react.useState)(() => scope.getSnapshot());
+      (0, import_react.useEffect)(
+        () => scope.subscribe(() => {
+          setSnapshot(scope.getSnapshot());
+        }),
+        []
+      );
+      const value = snapshot.value;
+      if (snapshot.status !== "ready" || value === void 0) {
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: `\u914D\u7F6E\u5C1A\u672A\u5C31\u7EEA\uFF08${snapshot.status}\uFF09` });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Form, { initial: value });
+    }
+    ctx.slots.inject(
+      "settings.section",
+      () => ctx.slots.register(
+        { name: "settings.section", id: "repeat-guard", order: 100, label: "\u590D\u8BFB\u6253\u65AD" },
+        Panel
+      )
+    );
+  }
+  return __toCommonJS(client_exports);
+})();
+return __dshClientBundle; } });

package/lib/config.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 插件配置：拦截短句表与连续命中阈值。
+ *
+ * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
+ * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** settings 命名空间。客户端设置页必须写同一个值。 */
+export declare const SETTINGS_NS = "repeat-guard";
+/** 默认的拦截短句表，标点照原样写。 */
+export declare const DEFAULT_FRAGMENTS: readonly string[];
+/** 默认阈值：1 表示发现即拦。 */
+export declare const DEFAULT_THRESHOLD = 1;
+/** 一份生效中的配置，已编译成判定时直接可用的形式。 */
+export interface RepeatGuardConfig {
+    /** 短句表，已全部小写化。 */
+    readonly fragments: ReadonlySet<string>;
+    /** 连续命中多少行才拦。 */
+    readonly threshold: number;
+}
+/** 取当前配置。 */
+export type ConfigSource = () => RepeatGuardConfig;
+/**
+ * 注册配置命名空间，并返回取当前配置的函数。
+ * @param ctx - 宿主 cordis 上下文。
+ * @returns 每次调用都返回最新配置。
+ */
+export declare function createConfigSource(ctx: Context): ConfigSource;

package/lib/config.js

@@ -0,0 +1,73 @@
+/**
+ * 插件配置：拦截短句表与连续命中阈值。
+ *
+ * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
+ * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ */
+import z from '@deepseek-ai/schemastery';
+/** settings 命名空间。客户端设置页必须写同一个值。 */
+export const SETTINGS_NS = 'repeat-guard';
+/** 默认的拦截短句表，标点照原样写。 */
+export const DEFAULT_FRAGMENTS = [
+    '好。',
+    '好的。',
+    '好嘞。',
+    '对。',
+    '对的。',
+    '是。',
+    '是的。',
+    '行。',
+    '嗯。',
+    '可以。',
+    '明白。',
+    '收到。',
+    '了解。',
+    '执行。',
+    '继续。',
+    '确认。',
+    '完成。',
+    '搞定。',
+    '写。',
+    '查。',
+    '看。',
+    'ok.',
+    'okay.',
+    'sure.',
+    'alright.',
+    'right.',
+    'yes.',
+    'done.',
+    'got it.',
+    'let me go.',
+    'let me do it.',
+    'check it.',
+];
+/** 默认阈值：1 表示发现即拦。 */
+export const DEFAULT_THRESHOLD = 1;
+const SCHEMA = z.object({
+    fragments: z.array(z.string()).default([...DEFAULT_FRAGMENTS]),
+    threshold: z.number().default(DEFAULT_THRESHOLD),
+});
+function compile(value) {
+    return {
+        fragments: new Set(value.fragments.map((fragment) => fragment.toLowerCase())),
+        threshold: value.threshold,
+    };
+}
+/**
+ * 注册配置命名空间，并返回取当前配置的函数。
+ * @param ctx - 宿主 cordis 上下文。
+ * @returns 每次调用都返回最新配置。
+ */
+export function createConfigSource(ctx) {
+    let current = compile({ fragments: DEFAULT_FRAGMENTS, threshold: DEFAULT_THRESHOLD });
+    ctx.inject(['settings'], (settingsCtx) => {
+        const scope = settingsCtx.settings.register(SETTINGS_NS, SCHEMA);
+        const sync = () => {
+            current = compile(scope.get());
+        };
+        sync();
+        scope.watch(sync);
+    });
+    return () => current;
+}

package/lib/detect.d.ts

@@ -1,14 +1,17 @@
 /**
  * 复读退化判定：查表。
  *
- * 表里是已知会被模型复读的空话短句，**连标点一起写**。判定就是"思考里有没有
- * 独占一行的表项"，整行与表项全等，不拆解行的内部。
+ * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
+ * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
  *
- * 增删条目直接改下面的 FRAGMENTS 即可，改完重新构建。
+ * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
+ * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
  */
 /**
  * 找出退化的碎片行。
  * @param text - 已生成的思考文本。
- * @returns 命中返回该行的原文，未命中返回 null。
+ * @param fragments - 小写化的短句表。
+ * @param threshold - 连续命中多少行才判定为复读。
+ * @returns 计数成立时返回那一行的原文，否则返回 null。
  */
-export declare function findDegenerateLine(text: string): string | null;
+export declare function findDegenerateLine(text: string, fragments: ReadonlySet<string>, threshold: number): string | null;

package/lib/detect.js

@@ -1,64 +1,31 @@
 /**
  * 复读退化判定：查表。
  *
- * 表里是已知会被模型复读的空话短句，**连标点一起写**。判定就是"思考里有没有
- * 独占一行的表项"，整行与表项全等，不拆解行的内部。
+ * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
+ * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
  *
- * 增删条目直接改下面的 FRAGMENTS 即可，改完重新构建。
+ * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
+ * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
  */
-/**
- * 会被复读的空话短句表，标点照原样写。
- *
- * 英文条目一律写小写，判定时会把整行转成小写再比。
- */
-const FRAGMENTS = [
-    // 中文
-    '好。',
-    '好的。',
-    '好嘞。',
-    '对。',
-    '对的。',
-    '是。',
-    '是的。',
-    '行。',
-    '嗯。',
-    '可以。',
-    '明白。',
-    '收到。',
-    '了解。',
-    '执行。',
-    '继续。',
-    '确认。',
-    '完成。',
-    '搞定。',
-    '写。',
-    '查。',
-    '看。',
-    // 英文
-    'ok.',
-    'okay.',
-    'sure.',
-    'alright.',
-    'right.',
-    'yes.',
-    'done.',
-    'got it.',
-    'let me go.',
-    'let me do it.',
-    'check it.',
-];
-/** 查表用的集合。 */
-const FRAGMENT_SET = new Set(FRAGMENTS);
 /**
  * 找出退化的碎片行。
  * @param text - 已生成的思考文本。
- * @returns 命中返回该行的原文，未命中返回 null。
+ * @param fragments - 小写化的短句表。
+ * @param threshold - 连续命中多少行才判定为复读。
+ * @returns 计数成立时返回那一行的原文，否则返回 null。
  */
-export function findDegenerateLine(text) {
+export function findDegenerateLine(text, fragments, threshold) {
+    let run = 0;
     for (const raw of text.split('\n')) {
         const line = raw.trim();
-        if (line !== '' && FRAGMENT_SET.has(line.toLowerCase())) {
-            return line;
+        if (line !== '' && fragments.has(line.toLowerCase())) {
+            run += 1;
+            if (run >= threshold) {
+                return line;
+            }
+        }
+        else {
+            run = 0;
         }
     }
     return null;

package/lib/index.js

@@ -9,7 +9,7 @@
 // 开始产出；等正文也碎掉再掐，思考段已经白烧了一遍。
 //
 // 判定做什么：思考段里出现独占一行的表项（如"好。""执行。""Let me go."）就掐断，
-// 表在 detect.ts 的 FRAGMENTS 里。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
+// 短句表与阈值都可配置，见 config.ts。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
 // 具体、可增删、可审计的。
 //
 // 掐断之后要让本轮继续，而不是停下来等用户输入：挂在 `agent/turn-stopping` 上，在本轮
@@ -20,6 +20,7 @@
 // `@deepseek-ai/*`——它们声明在 peerDependencies 里，由宿主提供。
 //
 // 本文件只做装配，具体逻辑在各自的模块里。
+import { createConfigSource } from './config.js';
 import { createStreamGuard } from './stream-guard.js';
 import { createTurnStoppingGuard } from './turn-stopping-guard.js';
 /**
@@ -30,6 +31,7 @@ export default function repeatGuard(ctx) {
     // 直接写 stdout：dsh 把插件的 stdout 收进 journal，便于确认插件确实被加载。
     console.log('[repeat-guard] 已加载，复读拦截生效');
     const state = { pending: new Set() };
-    ctx.on('llm/stream', createStreamGuard(state), { global: true });
+    const readConfig = createConfigSource(ctx);
+    ctx.on('llm/stream', createStreamGuard(state, readConfig), { global: true });
     ctx.on('agent/turn-stopping', createTurnStoppingGuard(state));
 }

package/lib/stream-guard.d.ts

@@ -4,13 +4,15 @@
  * 只检测 reasoning-delta（思考段）。正文 text-delta 不参与判定，原样透传。
  */
 import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ConfigSource } from './config.js';
 import type { GuardState } from './types.js';
 /** `llm/stream` 的监听器签名。 */
 type StreamListener = (options: GenerateOptions, next: () => AsyncIterable<StreamChunk>) => AsyncIterable<StreamChunk>;
 /**
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export declare function createStreamGuard(state: GuardState): StreamListener;
+export declare function createStreamGuard(state: GuardState, readConfig: ConfigSource): StreamListener;
 export {};

package/lib/stream-guard.js

@@ -10,12 +10,17 @@ import { findDegenerateLine } from './detect.js';
  * 适配器只开一个 reasoning 块（dsh-llm-deepseek: `reasoningBlock` 是单个变量），
  * 所以累积文本用一个字符串即可，不需要按 index 分开存。
  *
+ * 命中之后先往下探一格，判"思考段是不是就到这儿了"：再往下若还是 reasoning-delta，
+ * 说明思考在继续复读，该拦；若换成正文、工具调用，或直接收尾，说明命中行本来就是
+ * 这段思考的最后一句，属正常收尾，不拦。
+ *
  * @param downstream - 上游模型的流。
  * @param sessionId - 当前会话 id；有值才登记待续跑标记。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
  * @returns 包好的流。
  */
-async function* guardStream(downstream, sessionId, state) {
+async function* guardStream(downstream, sessionId, state, readConfig) {
     const iterator = downstream[Symbol.asyncIterator]();
     let accumulated = '';
     try {
@@ -27,17 +32,27 @@ async function* guardStream(downstream, sessionId, state) {
             const chunk = step.value;
             if (chunk.type === 'reasoning-delta') {
                 accumulated += chunk.text;
-                const hit = findDegenerateLine(accumulated);
+                const config = readConfig();
+                const hit = findDegenerateLine(accumulated, config.fragments, config.threshold);
                 if (hit !== null) {
-                    if (sessionId !== undefined) {
-                        state.pending.add(sessionId);
+                    const probe = await iterator.next();
+                    if (!probe.done && probe.value.type === 'reasoning-delta') {
+                        if (sessionId !== undefined) {
+                            state.pending.add(sessionId);
+                        }
+                        console.log(`[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`);
+                        // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
+                        yield chunk;
+                        yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
+                        yield { type: 'finish', reason: { kind: 'stop' } };
+                        return;
                     }
-                    console.log(`[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`);
-                    // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
+                    console.log(`[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`);
                     yield chunk;
-                    yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
-                    yield { type: 'finish', reason: { kind: 'stop' } };
-                    return;
+                    if (!probe.done) {
+                        yield probe.value;
+                    }
+                    continue;
                 }
             }
             yield chunk;
@@ -57,14 +72,15 @@ async function* guardStream(downstream, sessionId, state) {
 /**
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export function createStreamGuard(state) {
+export function createStreamGuard(state, readConfig) {
     return (options, next) => {
         // 辅助调用（上下文压缩、会话标题）不参与检测。
         if (options.purpose !== undefined) {
             return next();
         }
-        return guardStream(next(), options.sessionId, state);
+        return guardStream(next(), options.sessionId, state, readConfig);
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-repeat-guard",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "流式输出退化拦截：检测碎片复读，掐断本次生成并提醒模型直接执行工具调用",
   "type": "module",
   "main": "lib/index.js",
@@ -10,6 +10,9 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./client": {
+      "default": "./lib/client.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -20,10 +23,17 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/build-client.mjs",
     "prepack": "npm run build"
   },
   "license": "MIT",
@@ -31,13 +41,24 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-agent": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2"
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.5-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "react": "^18.2.0"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
     "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-client-ui-settings": "0.1.5-rc.2",
     "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.5-rc.2",
+    "@deepseek-ai/schemastery": "3.18.2",
     "@types/node": "^22.0.0",
+    "@types/react": "^19.3.0",
+    "esbuild": "^0.28.2",
     "typescript": "^7.0.2"
   }
 }

package/src/client.tsx

@@ -0,0 +1,118 @@
+/**
+ * 客户端设置页：在设置窗口左侧加一项"复读打断"。
+ *
+ * 面板里编辑两样东西——拦截短句表（一行一句）与连续命中阈值，两者都写宿主侧
+ * 注册的 settings 命名空间，保存后宿主侧立即按新配置判定。
+ *
+ * 本文件由 scripts/build-client.mjs 用 esbuild 单独打包成单文件 bundle
+ * （`lib/client.js`），不走 tsc 的 lib 输出。
+ */
+
+import type { Context } from '@deepseek-ai/cordis';
+// 空导入：只为加载这两处的 declaration merging（往 cordis 的 Context 上补
+// slots 与 settingsScope 两个客户端服务）。
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client';
+import type {} from '@deepseek-ai/dsh-client-ui-settings/client';
+import { useEffect, useState, type ReactElement } from 'react';
+
+/** settings 命名空间，必须与宿主侧 config.ts 的 SETTINGS_NS 逐字一致。 */
+const SETTINGS_NS = 'repeat-guard';
+
+/** 本插件配置节选。 */
+interface RepeatGuardSettings {
+  /** 拦截短句表。 */
+  fragments?: string[];
+  /** 连续命中多少行才拦。 */
+  threshold?: number;
+}
+
+/** 注册设置页需要的服务；这两个是 cordis 服务名，不是包名。 */
+export const inject = ['slots', 'settingsScope'];
+
+/**
+ * 客户端插件入口。
+ * @param ctx - 浏览器侧 cordis 上下文。
+ */
+export function apply(ctx: Context): void {
+  const scope = ctx.settingsScope.bind<RepeatGuardSettings>({ namespace: SETTINGS_NS });
+
+  function Form({ initial }: { initial: RepeatGuardSettings }): ReactElement {
+    const [fragments, setFragments] = useState(() => (initial.fragments ?? []).join('\n'));
+    const [threshold, setThreshold] = useState(() => String(initial.threshold ?? 1));
+    const [message, setMessage] = useState('');
+
+    function save(): void {
+      const list = fragments
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '');
+      const count = Number(threshold);
+      setMessage('保存中…');
+      scope
+        .set('fragments', list)
+        .then(() => scope.set('threshold', count))
+        .then(() => {
+          setMessage('已保存');
+        })
+        .catch((error: unknown) => {
+          setMessage(`保存失败：${String(error)}`);
+        });
+    }
+
+    return (
+      <div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
+        <label>
+          <span>连续命中次数</span>
+          <input
+            type="number"
+            value={threshold}
+            onChange={(event) => {
+              setThreshold(event.target.value);
+            }}
+          />
+          <span>填 1 表示命中即拦；填 n 表示连着 n 行都命中才拦。</span>
+        </label>
+        <label>
+          <span>拦截短句（一行一句，连标点一起写）</span>
+          <textarea
+            rows={16}
+            style={{ width: '100%', fontFamily: 'monospace' }}
+            value={fragments}
+            onChange={(event) => {
+              setFragments(event.target.value);
+            }}
+          />
+        </label>
+        <div>
+          <button type="button" onClick={save}>
+            保存
+          </button>
+          <span>{message}</span>
+        </div>
+      </div>
+    );
+  }
+
+  function Panel(): ReactElement {
+    const [snapshot, setSnapshot] = useState(() => scope.getSnapshot());
+    useEffect(
+      () =>
+        scope.subscribe(() => {
+          setSnapshot(scope.getSnapshot());
+        }),
+      [],
+    );
+    const value = snapshot.value;
+    if (snapshot.status !== 'ready' || value === undefined) {
+      return <p>{`配置尚未就绪（${snapshot.status}）`}</p>;
+    }
+    return <Form initial={value} />;
+  }
+
+  ctx.slots.inject('settings.section', () =>
+    ctx.slots.register(
+      { name: 'settings.section', id: 'repeat-guard', order: 100, label: '复读打断' },
+      Panel,
+    ),
+  );
+}

package/src/config.ts

@@ -0,0 +1,94 @@
+/**
+ * 插件配置：拦截短句表与连续命中阈值。
+ *
+ * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
+ * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ */
+
+import type { Context } from '@deepseek-ai/cordis';
+// 空导入：只为加载它的 declaration merging（往 cordis 的 Context 上补 settings 服务）。
+import type {} from '@deepseek-ai/dsh-settings';
+import z from '@deepseek-ai/schemastery';
+
+/** settings 命名空间。客户端设置页必须写同一个值。 */
+export const SETTINGS_NS = 'repeat-guard';
+
+/** 默认的拦截短句表，标点照原样写。 */
+export const DEFAULT_FRAGMENTS: readonly string[] = [
+  '好。',
+  '好的。',
+  '好嘞。',
+  '对。',
+  '对的。',
+  '是。',
+  '是的。',
+  '行。',
+  '嗯。',
+  '可以。',
+  '明白。',
+  '收到。',
+  '了解。',
+  '执行。',
+  '继续。',
+  '确认。',
+  '完成。',
+  '搞定。',
+  '写。',
+  '查。',
+  '看。',
+  'ok.',
+  'okay.',
+  'sure.',
+  'alright.',
+  'right.',
+  'yes.',
+  'done.',
+  'got it.',
+  'let me go.',
+  'let me do it.',
+  'check it.',
+];
+
+/** 默认阈值：1 表示发现即拦。 */
+export const DEFAULT_THRESHOLD = 1;
+
+const SCHEMA = z.object({
+  fragments: z.array(z.string()).default([...DEFAULT_FRAGMENTS]),
+  threshold: z.number().default(DEFAULT_THRESHOLD),
+});
+
+/** 一份生效中的配置，已编译成判定时直接可用的形式。 */
+export interface RepeatGuardConfig {
+  /** 短句表，已全部小写化。 */
+  readonly fragments: ReadonlySet<string>;
+  /** 连续命中多少行才拦。 */
+  readonly threshold: number;
+}
+
+/** 取当前配置。 */
+export type ConfigSource = () => RepeatGuardConfig;
+
+function compile(value: { fragments: readonly string[]; threshold: number }): RepeatGuardConfig {
+  return {
+    fragments: new Set(value.fragments.map((fragment) => fragment.toLowerCase())),
+    threshold: value.threshold,
+  };
+}
+
+/**
+ * 注册配置命名空间，并返回取当前配置的函数。
+ * @param ctx - 宿主 cordis 上下文。
+ * @returns 每次调用都返回最新配置。
+ */
+export function createConfigSource(ctx: Context): ConfigSource {
+  let current = compile({ fragments: DEFAULT_FRAGMENTS, threshold: DEFAULT_THRESHOLD });
+  ctx.inject(['settings'], (settingsCtx) => {
+    const scope = settingsCtx.settings.register(SETTINGS_NS, SCHEMA);
+    const sync = (): void => {
+      current = compile(scope.get());
+    };
+    sync();
+    scope.watch(sync);
+  });
+  return () => current;
+}

package/src/detect.ts

@@ -1,67 +1,35 @@
 /**
  * 复读退化判定：查表。
  *
- * 表里是已知会被模型复读的空话短句，**连标点一起写**。判定就是"思考里有没有
- * 独占一行的表项"，整行与表项全等，不拆解行的内部。
+ * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
+ * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
  *
- * 增删条目直接改下面的 FRAGMENTS 即可，改完重新构建。
+ * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
+ * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
  */
 
-/**
- * 会被复读的空话短句表，标点照原样写。
- *
- * 英文条目一律写小写，判定时会把整行转成小写再比。
- */
-const FRAGMENTS: readonly string[] = [
-  // 中文
-  '好。',
-  '好的。',
-  '好嘞。',
-  '对。',
-  '对的。',
-  '是。',
-  '是的。',
-  '行。',
-  '嗯。',
-  '可以。',
-  '明白。',
-  '收到。',
-  '了解。',
-  '执行。',
-  '继续。',
-  '确认。',
-  '完成。',
-  '搞定。',
-  '写。',
-  '查。',
-  '看。',
-  // 英文
-  'ok.',
-  'okay.',
-  'sure.',
-  'alright.',
-  'right.',
-  'yes.',
-  'done.',
-  'got it.',
-  'let me go.',
-  'let me do it.',
-  'check it.',
-];
-
-/** 查表用的集合。 */
-const FRAGMENT_SET = new Set(FRAGMENTS);
-
 /**
  * 找出退化的碎片行。
  * @param text - 已生成的思考文本。
- * @returns 命中返回该行的原文，未命中返回 null。
+ * @param fragments - 小写化的短句表。
+ * @param threshold - 连续命中多少行才判定为复读。
+ * @returns 计数成立时返回那一行的原文，否则返回 null。
  */
-export function findDegenerateLine(text: string): string | null {
+export function findDegenerateLine(
+  text: string,
+  fragments: ReadonlySet<string>,
+  threshold: number,
+): string | null {
+  let run = 0;
   for (const raw of text.split('\n')) {
     const line = raw.trim();
-    if (line !== '' && FRAGMENT_SET.has(line.toLowerCase())) {
-      return line;
+    if (line !== '' && fragments.has(line.toLowerCase())) {
+      run += 1;
+      if (run >= threshold) {
+        return line;
+      }
+    } else {
+      run = 0;
     }
   }
   return null;

package/src/index.ts

@@ -9,7 +9,7 @@
 // 开始产出；等正文也碎掉再掐，思考段已经白烧了一遍。
 //
 // 判定做什么：思考段里出现独占一行的表项（如"好。""执行。""Let me go."）就掐断，
-// 表在 detect.ts 的 FRAGMENTS 里。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
+// 短句表与阈值都可配置，见 config.ts。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
 // 具体、可增删、可审计的。
 //
 // 掐断之后要让本轮继续，而不是停下来等用户输入：挂在 `agent/turn-stopping` 上，在本轮
@@ -22,6 +22,7 @@
 // 本文件只做装配，具体逻辑在各自的模块里。
 
 import type { Context } from '@deepseek-ai/cordis';
+import { createConfigSource } from './config.js';
 import { createStreamGuard } from './stream-guard.js';
 import { createTurnStoppingGuard } from './turn-stopping-guard.js';
 import type { GuardState } from './types.js';
@@ -34,6 +35,7 @@ export default function repeatGuard(ctx: Context): void {
   // 直接写 stdout：dsh 把插件的 stdout 收进 journal，便于确认插件确实被加载。
   console.log('[repeat-guard] 已加载，复读拦截生效');
   const state: GuardState = { pending: new Set() };
-  ctx.on('llm/stream', createStreamGuard(state), { global: true });
+  const readConfig = createConfigSource(ctx);
+  ctx.on('llm/stream', createStreamGuard(state, readConfig), { global: true });
   ctx.on('agent/turn-stopping', createTurnStoppingGuard(state));
 }

package/src/stream-guard.ts

@@ -5,6 +5,7 @@
  */
 
 import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ConfigSource } from './config.js';
 import { findDegenerateLine } from './detect.js';
 import type { GuardState } from './types.js';
 
@@ -20,15 +21,21 @@ type StreamListener = (
  * 适配器只开一个 reasoning 块（dsh-llm-deepseek: `reasoningBlock` 是单个变量），
  * 所以累积文本用一个字符串即可，不需要按 index 分开存。
  *
+ * 命中之后先往下探一格，判"思考段是不是就到这儿了"：再往下若还是 reasoning-delta，
+ * 说明思考在继续复读，该拦；若换成正文、工具调用，或直接收尾，说明命中行本来就是
+ * 这段思考的最后一句，属正常收尾，不拦。
+ *
  * @param downstream - 上游模型的流。
  * @param sessionId - 当前会话 id；有值才登记待续跑标记。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
  * @returns 包好的流。
  */
 async function* guardStream(
   downstream: AsyncIterable<StreamChunk>,
   sessionId: GenerateOptions['sessionId'],
   state: GuardState,
+  readConfig: ConfigSource,
 ): AsyncGenerator<StreamChunk> {
   const iterator = downstream[Symbol.asyncIterator]();
   let accumulated = '';
@@ -41,19 +48,31 @@ async function* guardStream(
       const chunk = step.value;
       if (chunk.type === 'reasoning-delta') {
         accumulated += chunk.text;
-        const hit = findDegenerateLine(accumulated);
+        const config = readConfig();
+        const hit = findDegenerateLine(accumulated, config.fragments, config.threshold);
         if (hit !== null) {
-          if (sessionId !== undefined) {
-            state.pending.add(sessionId);
+          const probe = await iterator.next();
+          if (!probe.done && probe.value.type === 'reasoning-delta') {
+            if (sessionId !== undefined) {
+              state.pending.add(sessionId);
+            }
+            console.log(
+              `[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
+            );
+            // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
+            yield chunk;
+            yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
+            yield { type: 'finish', reason: { kind: 'stop' } };
+            return;
           }
           console.log(
-            `[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
+            `[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
           );
-          // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
           yield chunk;
-          yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
-          yield { type: 'finish', reason: { kind: 'stop' } };
-          return;
+          if (!probe.done) {
+            yield probe.value;
+          }
+          continue;
         }
       }
       yield chunk;
@@ -72,14 +91,15 @@ async function* guardStream(
 /**
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export function createStreamGuard(state: GuardState): StreamListener {
+export function createStreamGuard(state: GuardState, readConfig: ConfigSource): StreamListener {
   return (options, next) => {
     // 辅助调用（上下文压缩、会话标题）不参与检测。
     if (options.purpose !== undefined) {
       return next();
     }
-    return guardStream(next(), options.sessionId, state);
+    return guardStream(next(), options.sessionId, state, readConfig);
   };
 }