dsh-repeat-guard 0.1.3 → 0.1.4

package/README.md

@@ -7,7 +7,7 @@
 | 类型 | dsh bundle，含宿主侧插件与客户端设置页 |
 | 监听 | `llm/stream`、`agent/turn-stopping` |
 | 入口 | `lib/index.js`（`src/index.ts`）、`lib/client.js`（`src/client.tsx`） |
-| 可调项 | 拦截短句表、连续命中阈值（设置 → 复读打断） |
+| 可调项 | 拦截短句表、连续命中阈值、行内重复检测、续跑指令与折叠摘要（设置 → 复读打断） |
 | 分发 | npm 包 `dsh-repeat-guard` |
 
 ---
@@ -51,6 +51,14 @@
 
 表项**连标点一起写**（`'好的。'` 对应思考里的 `好的。`），英文条目一律写小写。分割单位是单个换行，空行会把连续计数打断。
 
+### 行内重复检测（默认关）
+
+上面那条规则只认"独占一行的整句"，所以 `好。好。好。` 这种挤在一行里的重复看不见——对 DeepSeek 够用，但有些模型是单行循环的，所以留了这个开关。
+
+打开之后多一条判据：**整行由一个或多个表项首尾相接拼成**，也算命中（`好。好。好。`、`好。ok.好。`）。它仍然不会误杀——`我觉得可以。好。` 的前面那截不是表项、整行拼不出来，放行；`好的，好的` 也放行（表项是带句号的 `好的。`，这里是逗号）。
+
+计数单位同时从"行"变成"表项"：整行全等算一次，行内每一段各算一次。所以阈值 2 配上它时，`好。好。` 这种一行两段的也会被拦。
+
 **表可以在设置里改**（见下面「可调项」）；`src/config.ts` 的 `DEFAULT_FRAGMENTS` 是出厂默认值。
 
 已知边界：判据只看"有没有这样一行"，不看上下文。所以"用户想让我改代码。\n好的。"这种**前面有实质内容、结尾又跟一句空话**的思考也会被拦。这是"按行判定"的直接结果。
@@ -116,20 +124,28 @@ if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读收件箱
 
 | 项 | 含义 |
 |---|---|
+| 累计拦截 | 自本次启动或上次清零以来掐断过多少次（只读，旁边有清零按钮） |
 | 拦截短句 | 判为复读的空话短句表，一行一句，连标点一起写 |
-| 连续命中次数 | 连着几行命中才拦；默认 1 = 发现即拦 |
+| 连续命中次数 | 连着几次命中才拦；默认 1 = 发现即拦 |
+| 行内重复检测 | 打开后"好。好。好。"这种挤在一行里的重复也算命中；默认关 |
+| 续跑指令 | 截断后推给模型的指令正文，整段照发 |
+| 折叠行摘要 | 那条注入消息在会话里的折叠行摘要 |
+
+配置存在 dsh 的 settings 服务里（命名空间 `repeat-guard`），落盘在 `~/.dsh/settings.yaml` 的 `repeat-guard:` 节下。
 
-配置存在 dsh 的 settings 服务里（命名空间 `repeat-guard`），落盘位置由 dsh 决定。
+**累计计数也寄在这个命名空间里**——宿主侧每掐断一次写一次，客户端读同一个值，清零就是把它写成 0。这样不用另开 host↔client 通道，代价是它跟着配置一起落盘；插件加载时会先把它归零，所以口径是"自本次启动或上次清零以来"。计数只在**真的掐断**时 +1，命中却落在思考段末尾（未拦截）的那种不计。
 
 ## 续跑时推给模型的输入
 
+默认正文（可在设置里改）：
+
 ```
 [复读拦截]
 你上一段思考退化成了碎片复读（反复输出"好。"一类的空话），已被系统截断。
 请直接继续执行下一步，不要再输出任何确认语、寒暄或空话。
 ```
 
-这条消息带 `source.kind = 'plugin'`，客户端会渲染成折叠的 context 行，不是用户气泡。
+这条消息带 `source.kind = 'plugin'`，客户端按 `source.summary`（同样可配置）渲染成折叠的 context 行，不是用户气泡。
 
 ## 构建
 

package/lib/client.js

@@ -36,6 +36,7 @@ var __dshClientBundle = (() => {
   var SETTINGS_NS = "repeat-guard";
   var THRESHOLD_MIN = 1;
   var THRESHOLD_MAX = 9;
+  var FIELD = `height:36px;box-sizing:border-box;padding:0 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:transparent;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:14px;line-height:22px`;
   var CSS = `
 .rg-root{display:flex;flex-direction:column;width:100%}
 .rg-head{display:flex;align-items:center;gap:12px;padding:2px 0 14px}
@@ -57,6 +58,11 @@ var __dshClientBundle = (() => {
 .rg-arrow{display:inline-flex;justify-content:center;align-items:center;width:17px;height:12px;padding:0;border:none;border-radius:3px;cursor:pointer;color:var(--dsw-alias-label-primary);background:color-mix(in srgb, var(--dsw-alias-bg-layer-1) 75%, transparent)}
 .rg-arrow:hover:not(:disabled){background:var(--dsw-alias-bg-layer-1)}
 .rg-arrow:disabled{color:var(--dsw-alias-label-caption);cursor:default}
+.rg-switch{position:relative;flex:none;width:40px;height:24px;padding:0;border:none;border-radius:12px;cursor:pointer;background:var(--dsw-alias-bg-module-platform);transition:background .15s ease}
+.rg-switch::after{content:"";position:absolute;top:3px;left:3px;width:18px;height:18px;border-radius:50%;background:var(--dsw-alias-label-primary-foreground);transition:transform .15s ease}
+.rg-switch[aria-checked="true"]{background:var(--dsw-alias-brand-primary)}
+.rg-switch[aria-checked="true"]::after{transform:translateX(16px)}
+.rg-count{display:inline-flex;align-items:center;justify-content:center;min-width:72px;height:36px;padding:0 14px;box-sizing:border-box;border-radius:18px;background:var(--dsw-alias-bg-module-platform);color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px;font-variant-numeric:tabular-nums}
 .rg-list{display:flex;flex-direction:column;gap:2px;width:100%;max-height:300px;overflow-y:auto;padding:4px;border-radius:12px;background:var(--dsw-alias-bg-module-platform);box-sizing:border-box}
 .rg-item{display:flex;align-items:center;gap:8px;padding:5px 6px 5px 12px;border-radius:8px;font-size:14px;line-height:22px;color:var(--dsw-alias-label-primary)}
 .rg-item:hover{background:var(--dsw-alias-interactive-bg-hover)}
@@ -65,8 +71,10 @@ var __dshClientBundle = (() => {
 .rg-remove:hover{background:var(--dsw-alias-interactive-bg-hover-danger);color:var(--dsw-alias-state-error-primary)}
 .rg-empty{padding:10px 12px;color:var(--dsw-alias-label-caption);font-size:13px;line-height:20px}
 .rg-addRow{display:flex;align-items:center;gap:8px;width:100%}
-.rg-input{flex:1;min-width:0;height:36px;box-sizing:border-box;padding:0 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:transparent;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:14px;line-height:22px}
-.rg-input:focus{outline:none;border-color:var(--dsw-alias-border-l4)}
+.rg-input{flex:1;min-width:0;${FIELD}}
+.rg-summaryInput{flex:none;width:260px;${FIELD}}
+.rg-textarea{width:100%;min-height:84px;box-sizing:border-box;padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:transparent;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:14px;line-height:22px;resize:vertical}
+.rg-input:focus,.rg-summaryInput:focus,.rg-textarea:focus{outline:none;border-color:var(--dsw-alias-border-l4)}
 .rg-button{cursor:pointer;flex:none;height:32px;padding:0 14px;border:none;border-radius:16px;background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary);font-family:inherit;font-size:14px;line-height:22px}
 .rg-button:hover{background:var(--dsw-alias-interactive-bg-active)}
 `;
@@ -137,6 +145,21 @@ var __dshClientBundle = (() => {
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "rg-stepperUnit", children: unit })
     ] });
   }
+  function Switch({ checked, label, onChange }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "button",
+      {
+        type: "button",
+        role: "switch",
+        "aria-checked": checked,
+        "aria-label": label,
+        className: "rg-switch",
+        onClick: () => {
+          onChange(!checked);
+        }
+      }
+    );
+  }
   function FragmentList({ items, draft, onDraft, onAdd, onRemove }) {
     function handleKey(event) {
       if (event.key === "Enter") {
@@ -189,9 +212,12 @@ var __dshClientBundle = (() => {
       ] })
     ] });
   }
-  function Form({ initial, onSave }) {
-    const [items, setItems] = (0, import_react.useState)(() => initial.fragments ?? []);
-    const [count, setCount] = (0, import_react.useState)(() => initial.threshold ?? 1);
+  function Form({ initial, count, onReset, onSave }) {
+    const [items, setItems] = (0, import_react.useState)(initial.fragments);
+    const [limit, setLimit] = (0, import_react.useState)(initial.threshold);
+    const [inlineRepeat, setInlineRepeat] = (0, import_react.useState)(initial.inlineRepeat);
+    const [resumeText, setResumeText] = (0, import_react.useState)(initial.resumeText);
+    const [resumeSummary, setResumeSummary] = (0, import_react.useState)(initial.resumeSummary);
     const [draft, setDraft] = (0, import_react.useState)("");
     const [note, setNote] = (0, import_react.useState)("");
     function add() {
@@ -209,33 +235,77 @@ var __dshClientBundle = (() => {
     }
     function save() {
       setNote("\u4FDD\u5B58\u4E2D\u2026");
-      onSave(items, count).then(() => {
+      onSave({
+        fragments: [...items],
+        threshold: limit,
+        inlineRepeat,
+        resumeText,
+        resumeSummary,
+        count
+      }).then(() => {
         setNote("\u5DF2\u4FDD\u5B58");
       }).catch((error) => {
         setNote(`\u4FDD\u5B58\u5931\u8D25\uFF1A${String(error)}`);
       });
     }
+    function reset() {
+      onReset().then(() => {
+        setNote("\u8BA1\u6570\u5DF2\u6E05\u96F6");
+      }).catch((error) => {
+        setNote(`\u6E05\u96F6\u5931\u8D25\uFF1A${String(error)}`);
+      });
+    }
     return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-root", children: [
       /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-head", children: [
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "rg-headTitle", children: "\u590D\u8BFB\u6253\u65AD" }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "rg-headNote", children: note }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "rg-save", onClick: save, children: "\u4FDD\u5B58" })
       ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-row", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-rowText", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowTitle", children: "\u7D2F\u8BA1\u62E6\u622A" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u91CD\u590D\u6253\u65AD\u8BA1\u6570" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "rg-control", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "rg-count", children: [
+            count,
+            " \u6B21"
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "rg-button", onClick: reset, children: "\u6E05\u96F6" })
+        ] })
+      ] }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-row", children: [
         /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-rowText", children: [
           /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowTitle", children: "\u8FDE\u7EED\u547D\u4E2D\u6B21\u6570" }),
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u8FDE\u7740\u51E0\u4E2A\u77ED\u53E5\u884C\u547D\u4E2D\u624D\u62E6\u622A\uFF1B\u586B 1 \u8868\u793A\u53D1\u73B0\u5373\u62E6" })
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u5FAA\u73AF\u6B21\u6570\u4E0A\u9650\uFF1B\u586B 1 \u8868\u793A\u53D1\u73B0\u5373\u62E6" })
         ] }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
           Stepper,
           {
-            value: count,
+            value: limit,
             min: THRESHOLD_MIN,
             max: THRESHOLD_MAX,
             unit: "\u6B21",
             label: "\u8FDE\u7EED\u547D\u4E2D\u6B21\u6570",
             onChange: (next) => {
-              setCount(next);
+              setLimit(next);
+              setNote("");
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-row", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-rowText", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowTitle", children: "\u884C\u5185\u91CD\u590D\u68C0\u6D4B" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: '\u62E6\u622A\u7C7B\u4F3C"\u597D\u3002\u597D\u3002\u597D\u3002"\u7684\u884C\u5185\u5FAA\u73AF\uFF1B\u5173\u95ED\u65F6\u53EA\u68C0\u6D4B\u72EC\u7ACB\u6BB5\u843D\u3002' })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          Switch,
+          {
+            checked: inlineRepeat,
+            label: "\u884C\u5185\u91CD\u590D\u68C0\u6D4B",
+            onChange: (next) => {
+              setInlineRepeat(next);
               setNote("");
             }
           }
@@ -244,7 +314,7 @@ var __dshClientBundle = (() => {
       /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-row rg-row--stack", children: [
         /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-rowText", children: [
           /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowTitle", children: "\u62E6\u622A\u77ED\u53E5" }),
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u4E00\u884C\u4E00\u53E5\uFF0C\u8FDE\u6807\u70B9\u4E00\u8D77\u5199\uFF1B\u53EA\u7B97\u72EC\u5360\u4E00\u884C\u7684\u6574\u884C\u5339\u914D" })
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u6807\u70B9\u4E0D\u53EF\u7701\u7565" })
         ] }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
           FragmentList,
@@ -256,6 +326,40 @@ var __dshClientBundle = (() => {
             onRemove: remove
           }
         )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-row rg-row--stack", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-rowText", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowTitle", children: "\u62E6\u622A\u63D0\u793A\u8BCD" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u622A\u65AD\u540E\u4E0A\u4E0B\u6587\u6CE8\u5165\u7684\u63D0\u793A\u8BCD" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "textarea",
+          {
+            className: "rg-textarea",
+            value: resumeText,
+            onChange: (event) => {
+              setResumeText(event.target.value);
+              setNote("");
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-row", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rg-rowText", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowTitle", children: "\u62E6\u622A\u6458\u8981" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "rg-rowDesc", children: "\u4E0A\u4E0B\u6587\u6CE8\u5165\u7684\u7B80\u4ECB\u4FE1\u606F\uFF0C\u4EC5\u7528\u6237\u53EF\u89C1" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "input",
+          {
+            className: "rg-summaryInput",
+            value: resumeSummary,
+            onChange: (event) => {
+              setResumeSummary(event.target.value);
+              setNote("");
+            }
+          }
+        )
       ] })
     ] });
   }
@@ -279,9 +383,16 @@ var __dshClientBundle = (() => {
         Form,
         {
           initial: value,
-          onSave: async (fragments, threshold) => {
-            await scope.set("fragments", [...fragments]);
-            await scope.set("threshold", threshold);
+          count: value.count,
+          onReset: async () => {
+            await scope.set("count", 0);
+          },
+          onSave: async (next) => {
+            await scope.set("fragments", next.fragments);
+            await scope.set("threshold", next.threshold);
+            await scope.set("inlineRepeat", next.inlineRepeat);
+            await scope.set("resumeText", next.resumeText);
+            await scope.set("resumeSummary", next.resumeSummary);
           }
         }
       );

package/lib/config.d.ts

@@ -1,8 +1,12 @@
 /**
- * 插件配置：拦截短句表与连续命中阈值。
+ * 插件配置：拦截短句表、连续命中阈值、行内重复检测、续跑注入的正文与摘要，
+ * 外加一个运行时计数。
  *
  * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
- * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ * schema，客户端设置页写同一个命名空间。判定与续跑时现取，改完立即生效，不用重启。
+ *
+ * 计数也寄在同一个命名空间里：宿主侧每次掐断写一次，客户端读同一个值、清零就是
+ * 把它写成 0。插件加载时先把它归零，所以口径是"自本次启动或上次清零以来"。
  */
 import type { Context } from '@deepseek-ai/cordis';
 /** settings 命名空间。客户端设置页必须写同一个值。 */
@@ -11,18 +15,37 @@ export declare const SETTINGS_NS = "repeat-guard";
 export declare const DEFAULT_FRAGMENTS: readonly string[];
 /** 默认阈值：1 表示发现即拦。 */
 export declare const DEFAULT_THRESHOLD = 1;
-/** 一份生效中的配置，已编译成判定时直接可用的形式。 */
+/** 默认关闭行内重复检测：只认独占一行的整句。 */
+export declare const DEFAULT_INLINE_REPEAT = false;
+/** 默认的续跑指令正文，截断后推给模型。 */
+export declare const DEFAULT_RESUME_TEXT: string;
+/** 默认的折叠行摘要；客户端拿它渲染折叠的 context 行，不是用户气泡。 */
+export declare const DEFAULT_RESUME_SUMMARY = "\u590D\u8BFB\u5DF2\u622A\u65AD\uFF1A\u8BF7\u7EE7\u7EED\u6267\u884C";
+/** 判定与续跑用得上的一份配置。 */
 export interface RepeatGuardConfig {
     /** 短句表，已全部小写化。 */
     readonly fragments: ReadonlySet<string>;
-    /** 连续命中多少行才拦。 */
+    /** 连续命中多少次才拦。 */
     readonly threshold: number;
+    /** 是否把"整行由多个表项拼成"也算命中。 */
+    readonly inlineRepeat: boolean;
+    /** 截断后推给模型的指令正文。 */
+    readonly resumeText: string;
+    /** 注入消息的折叠行摘要。 */
+    readonly resumeSummary: string;
 }
 /** 取当前配置。 */
 export type ConfigSource = () => RepeatGuardConfig;
+/** 宿主侧要用到的两件事：取配置、记一次拦截。 */
+export interface GuardRuntime {
+    /** 取当前配置。 */
+    readonly read: ConfigSource;
+    /** 记一次拦截，把计数写回 settings。 */
+    readonly countHit: () => void;
+}
 /**
- * 注册配置命名空间，并返回取当前配置的函数。
+ * 注册配置命名空间，返回宿主侧要用的运行时句柄。
  * @param ctx - 宿主 cordis 上下文。
- * @returns 每次调用都返回最新配置。
+ * @returns 取配置与记数两个入口。
  */
-export declare function createConfigSource(ctx: Context): ConfigSource;
+export declare function createRuntime(ctx: Context): GuardRuntime;

package/lib/config.js

@@ -1,8 +1,12 @@
 /**
- * 插件配置：拦截短句表与连续命中阈值。
+ * 插件配置：拦截短句表、连续命中阈值、行内重复检测、续跑注入的正文与摘要，
+ * 外加一个运行时计数。
  *
  * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
- * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ * schema，客户端设置页写同一个命名空间。判定与续跑时现取，改完立即生效，不用重启。
+ *
+ * 计数也寄在同一个命名空间里：宿主侧每次掐断写一次，客户端读同一个值、清零就是
+ * 把它写成 0。插件加载时先把它归零，所以口径是"自本次启动或上次清零以来"。
  */
 import z from '@deepseek-ai/schemastery';
 /** settings 命名空间。客户端设置页必须写同一个值。 */
@@ -44,30 +48,69 @@ export const DEFAULT_FRAGMENTS = [
 ];
 /** 默认阈值：1 表示发现即拦。 */
 export const DEFAULT_THRESHOLD = 1;
+/** 默认关闭行内重复检测：只认独占一行的整句。 */
+export const DEFAULT_INLINE_REPEAT = false;
+/** 默认的续跑指令正文，截断后推给模型。 */
+export const DEFAULT_RESUME_TEXT = [
+    '[复读拦截]',
+    '你上一段思考退化成了碎片复读（反复输出"好。"一类的空话），已被系统截断。',
+    '请直接继续执行下一步，不要再输出任何确认语、寒暄或空话。',
+].join('\n');
+/** 默认的折叠行摘要；客户端拿它渲染折叠的 context 行，不是用户气泡。 */
+export const DEFAULT_RESUME_SUMMARY = '复读已截断：请继续执行';
 const SCHEMA = z.object({
     fragments: z.array(z.string()).default([...DEFAULT_FRAGMENTS]),
     threshold: z.number().default(DEFAULT_THRESHOLD),
+    inlineRepeat: z.boolean().default(DEFAULT_INLINE_REPEAT),
+    resumeText: z.string().default(DEFAULT_RESUME_TEXT),
+    resumeSummary: z.string().default(DEFAULT_RESUME_SUMMARY),
+    count: z.number().default(0),
 });
 function compile(value) {
     return {
         fragments: new Set(value.fragments.map((fragment) => fragment.toLowerCase())),
         threshold: value.threshold,
+        inlineRepeat: value.inlineRepeat,
+        resumeText: value.resumeText,
+        resumeSummary: value.resumeSummary,
     };
 }
 /**
- * 注册配置命名空间，并返回取当前配置的函数。
+ * 注册配置命名空间，返回宿主侧要用的运行时句柄。
  * @param ctx - 宿主 cordis 上下文。
- * @returns 每次调用都返回最新配置。
+ * @returns 取配置与记数两个入口。
  */
-export function createConfigSource(ctx) {
-    let current = compile({ fragments: DEFAULT_FRAGMENTS, threshold: DEFAULT_THRESHOLD });
+export function createRuntime(ctx) {
+    let current = compile({
+        fragments: DEFAULT_FRAGMENTS,
+        threshold: DEFAULT_THRESHOLD,
+        inlineRepeat: DEFAULT_INLINE_REPEAT,
+        resumeText: DEFAULT_RESUME_TEXT,
+        resumeSummary: DEFAULT_RESUME_SUMMARY,
+    });
+    let bump;
     ctx.inject(['settings'], (settingsCtx) => {
         const scope = settingsCtx.settings.register(SETTINGS_NS, SCHEMA);
         const sync = () => {
             current = compile(scope.get());
         };
+        const write = (patch) => {
+            scope.update(patch).catch((error) => {
+                console.log(`[repeat-guard] 写设置失败：${String(error)}`);
+            });
+        };
         sync();
         scope.watch(sync);
+        // 计数口径是"自本次启动或上次清零以来"。
+        write({ count: 0 });
+        bump = () => {
+            write({ count: scope.get().count + 1 });
+        };
     });
-    return () => current;
+    return {
+        read: () => current,
+        countHit: () => {
+            bump?.();
+        },
+    };
 }

package/lib/detect.d.ts

@@ -2,16 +2,20 @@
  * 复读退化判定：查表。
  *
  * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
- * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
+ * 基本判据是"整行与表项全等"，不拆解行的内部。
  *
- * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
- * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
+ * 行内重复检测（可开关，默认关）打开时，"整行由多个表项首尾相接拼成"也算命中，
+ * 用来兜住把短句连成一串写在同一行里的模型（如"好。好。好。"）。
+ *
+ * 阈值是"连续命中多少次才拦"：默认 1 表示发现即拦。计数单位是表项——整行全等算一次，
+ * 开了行内检测后行内每一段各算一次；中间夹一行不命中的就重新计数。
  */
 /**
  * 找出退化的碎片行。
  * @param text - 已生成的思考文本。
  * @param fragments - 小写化的短句表。
- * @param threshold - 连续命中多少行才判定为复读。
+ * @param threshold - 连续命中多少次才判定为复读。
+ * @param inlineRepeat - 是否启用行内重复检测。
  * @returns 计数成立时返回那一行的原文，否则返回 null。
  */
-export declare function findDegenerateLine(text: string, fragments: ReadonlySet<string>, threshold: number): string | null;
+export declare function findDegenerateLine(text: string, fragments: ReadonlySet<string>, threshold: number, inlineRepeat: boolean): string | null;

package/lib/detect.js

@@ -2,30 +2,76 @@
  * 复读退化判定：查表。
  *
  * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
- * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
+ * 基本判据是"整行与表项全等"，不拆解行的内部。
  *
- * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
- * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
+ * 行内重复检测（可开关，默认关）打开时，"整行由多个表项首尾相接拼成"也算命中，
+ * 用来兜住把短句连成一串写在同一行里的模型（如"好。好。好。"）。
+ *
+ * 阈值是"连续命中多少次才拦"：默认 1 表示发现即拦。计数单位是表项——整行全等算一次，
+ * 开了行内检测后行内每一段各算一次；中间夹一行不命中的就重新计数。
  */
+/**
+ * 在 line 的 at 处能匹配到的最长表项长度。
+ * @param line - 已小写化的行。
+ * @param at - 起始下标。
+ * @param fragments - 小写化的短句表。
+ * @returns 匹配到的长度，0 表示这个位置没有表项。
+ */
+function longestFragmentAt(line, at, fragments) {
+    let size = 0;
+    for (const fragment of fragments) {
+        if (fragment.length > size && line.startsWith(fragment, at)) {
+            size = fragment.length;
+        }
+    }
+    return size;
+}
+/**
+ * 这一行算几次命中。
+ * @param line - 已 trim 并小写化的行。
+ * @param fragments - 小写化的短句表。
+ * @param inlineRepeat - 是否把"整行由多个表项拼成"也算命中。
+ * @returns 0 表示不是命中行，其余为这一行贡献的次数。
+ */
+function countHits(line, fragments, inlineRepeat) {
+    if (fragments.has(line)) {
+        return 1;
+    }
+    if (!inlineRepeat) {
+        return 0;
+    }
+    let at = 0;
+    let parts = 0;
+    while (at < line.length) {
+        const size = longestFragmentAt(line, at, fragments);
+        if (size === 0) {
+            return 0;
+        }
+        at += size;
+        parts += 1;
+    }
+    return parts > 1 ? parts : 0;
+}
 /**
  * 找出退化的碎片行。
  * @param text - 已生成的思考文本。
  * @param fragments - 小写化的短句表。
- * @param threshold - 连续命中多少行才判定为复读。
+ * @param threshold - 连续命中多少次才判定为复读。
+ * @param inlineRepeat - 是否启用行内重复检测。
  * @returns 计数成立时返回那一行的原文，否则返回 null。
  */
-export function findDegenerateLine(text, fragments, threshold) {
+export function findDegenerateLine(text, fragments, threshold, inlineRepeat) {
     let run = 0;
     for (const raw of text.split('\n')) {
         const line = raw.trim();
-        if (line !== '' && fragments.has(line.toLowerCase())) {
-            run += 1;
-            if (run >= threshold) {
-                return line;
-            }
-        }
-        else {
+        const hits = line === '' ? 0 : countHits(line.toLowerCase(), fragments, inlineRepeat);
+        if (hits === 0) {
             run = 0;
+            continue;
+        }
+        run += hits;
+        if (run >= threshold) {
+            return line;
         }
     }
     return null;

package/lib/index.js

@@ -20,7 +20,7 @@
 // `@deepseek-ai/*`——它们声明在 peerDependencies 里，由宿主提供。
 //
 // 本文件只做装配，具体逻辑在各自的模块里。
-import { createConfigSource } from './config.js';
+import { createRuntime } from './config.js';
 import { createStreamGuard } from './stream-guard.js';
 import { createTurnStoppingGuard } from './turn-stopping-guard.js';
 /**
@@ -31,7 +31,7 @@ export default function repeatGuard(ctx) {
     // 直接写 stdout：dsh 把插件的 stdout 收进 journal，便于确认插件确实被加载。
     console.log('[repeat-guard] 已加载，复读拦截生效');
     const state = { pending: new Set() };
-    const readConfig = createConfigSource(ctx);
-    ctx.on('llm/stream', createStreamGuard(state, readConfig), { global: true });
-    ctx.on('agent/turn-stopping', createTurnStoppingGuard(state));
+    const runtime = createRuntime(ctx);
+    ctx.on('llm/stream', createStreamGuard(state, runtime.read, runtime.countHit), { global: true });
+    ctx.on('agent/turn-stopping', createTurnStoppingGuard(state, runtime.read));
 }

package/lib/resume.d.ts

@@ -11,12 +11,16 @@
  *
  * 所以在监听器里调 `agent.steer(...)` 推入一条输入，本轮就会再跑一步，而不是停下来等
  * 用户输入。dsh 自己的 dsh-hooks-claude-code/lib/index.js:300 就是这么用的。
+ *
+ * 推什么内容由配置决定（见 config.ts 的 resumeText / resumeSummary）。
  */
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { RepeatGuardConfig } from './config.js';
 import type { GuardState } from './types.js';
 /**
  * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
  * @param state - 跨监听保留的拦截状态。
  * @param agent - 本轮所属的 agent 句柄。
+ * @param config - 当前配置，正文与摘要都从这里取。
  */
-export declare function reviveTurn(state: GuardState, agent: Agent): void;
+export declare function reviveTurn(state: GuardState, agent: Agent, config: RepeatGuardConfig): void;

package/lib/resume.js

@@ -11,31 +11,17 @@
  *
  * 所以在监听器里调 `agent.steer(...)` 推入一条输入，本轮就会再跑一步，而不是停下来等
  * 用户输入。dsh 自己的 dsh-hooks-claude-code/lib/index.js:300 就是这么用的。
+ *
+ * 推什么内容由配置决定（见 config.ts 的 resumeText / resumeSummary）。
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
-/** 续跑时推给模型的指令正文。 */
-const RESUME_TEXT = [
-    '[复读拦截]',
-    '你上一段思考退化成了碎片复读（反复输出"好。"一类的空话），已被系统截断。',
-    '请直接继续执行下一步，不要再输出任何确认语、寒暄或空话。',
-].join('\n');
-/**
- * 这条注入消息的来源标记。
- * `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
- * 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
- */
-const PLUGIN_SOURCE = {
-    kind: 'plugin',
-    plugin: 'repeat-guard',
-    form: 'notice',
-    summary: '复读已截断：请继续执行',
-};
 /**
  * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
  * @param state - 跨监听保留的拦截状态。
  * @param agent - 本轮所属的 agent 句柄。
+ * @param config - 当前配置，正文与摘要都从这里取。
  */
-export function reviveTurn(state, agent) {
+export function reviveTurn(state, agent, config) {
     const sessionId = agent.session.id;
     if (!state.pending.has(sessionId)) {
         return;
@@ -43,7 +29,14 @@ export function reviveTurn(state, agent) {
     state.pending.delete(sessionId);
     console.log(`[repeat-guard] turn-stopping：会话 ${sessionId} 续跑一步`);
     agent.steer(createUserMessage({
-        content: [{ type: 'text', text: RESUME_TEXT }],
-        source: PLUGIN_SOURCE,
+        content: [{ type: 'text', text: config.resumeText }],
+        // `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
+        // 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
+        source: {
+            kind: 'plugin',
+            plugin: 'repeat-guard',
+            form: 'notice',
+            summary: config.resumeSummary,
+        },
     }));
 }

package/lib/stream-guard.d.ts

@@ -12,7 +12,8 @@ type StreamListener = (options: GenerateOptions, next: () => AsyncIterable<Strea
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
  * @param readConfig - 取当前配置。
+ * @param countHit - 记一次拦截。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export declare function createStreamGuard(state: GuardState, readConfig: ConfigSource): StreamListener;
+export declare function createStreamGuard(state: GuardState, readConfig: ConfigSource, countHit: () => void): StreamListener;
 export {};