dsh-repeat-guard 0.1.3 → 0.1.5

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 {};

package/lib/stream-guard.js

@@ -18,9 +18,10 @@ import { findDegenerateLine } from './detect.js';
  * @param sessionId - 当前会话 id；有值才登记待续跑标记。
  * @param state - 跨监听保留的拦截状态。
  * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
+ * @param countHit - 记一次拦截；只在真的掐断时调用。
  * @returns 包好的流。
  */
-async function* guardStream(downstream, sessionId, state, readConfig) {
+async function* guardStream(downstream, sessionId, state, readConfig, countHit) {
     const iterator = downstream[Symbol.asyncIterator]();
     let accumulated = '';
     try {
@@ -33,10 +34,11 @@ async function* guardStream(downstream, sessionId, state, readConfig) {
             if (chunk.type === 'reasoning-delta') {
                 accumulated += chunk.text;
                 const config = readConfig();
-                const hit = findDegenerateLine(accumulated, config.fragments, config.threshold);
+                const hit = findDegenerateLine(accumulated, config.fragments, config.threshold, config.inlineRepeat);
                 if (hit !== null) {
                     const probe = await iterator.next();
                     if (!probe.done && probe.value.type === 'reasoning-delta') {
+                        countHit();
                         if (sessionId !== undefined) {
                             state.pending.add(sessionId);
                         }
@@ -73,14 +75,15 @@ async function* guardStream(downstream, sessionId, state, readConfig) {
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
  * @param readConfig - 取当前配置。
+ * @param countHit - 记一次拦截。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export function createStreamGuard(state, readConfig) {
+export function createStreamGuard(state, readConfig, countHit) {
     return (options, next) => {
         // 辅助调用（上下文压缩、会话标题）不参与检测。
         if (options.purpose !== undefined) {
             return next();
         }
-        return guardStream(next(), options.sessionId, state, readConfig);
+        return guardStream(next(), options.sessionId, state, readConfig, countHit);
     };
 }

package/lib/turn-stopping-guard.d.ts

@@ -5,12 +5,14 @@
  * `agent.steer(...)`，见 resume.ts 的说明。
  */
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ConfigSource } from './config.js';
 import type { GuardState } from './types.js';
 /**
  * 造一个 `agent/turn-stopping` 监听器。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
  * @returns 监听器；只在有待续跑标记时推一条输入。
  */
-export declare function createTurnStoppingGuard(state: GuardState): (payload: {
+export declare function createTurnStoppingGuard(state: GuardState, readConfig: ConfigSource): (payload: {
     agent: Agent;
 }) => void;

package/lib/turn-stopping-guard.js

@@ -8,10 +8,11 @@ import { reviveTurn } from './resume.js';
 /**
  * 造一个 `agent/turn-stopping` 监听器。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
  * @returns 监听器；只在有待续跑标记时推一条输入。
  */
-export function createTurnStoppingGuard(state) {
+export function createTurnStoppingGuard(state, readConfig) {
     return (payload) => {
-        reviveTurn(state, payload.agent);
+        reviveTurn(state, payload.agent, readConfig());
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-repeat-guard",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "流式输出退化拦截：检测碎片复读，掐断本次生成并提醒模型直接执行工具调用",
   "type": "module",
   "main": "lib/index.js",
@@ -40,11 +40,11 @@
   "author": "yuqing",
   "peerDependencies": {
     "@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/dsh-agent": ">=0.1.0-rc.8 <0.1.1-0 || >=0.1.1-0 <0.1.2-0 || >=0.1.2-0 <0.1.3-0 || >=0.1.3-0 <0.1.4-0 || >=0.1.4-0 <0.1.5-0 || >=0.1.5-0 <0.1.6-0 || >=0.1.6-0 <0.1.7-0",
+    "@deepseek-ai/dsh-client-ui-renderer": ">=0.1.0-rc.8 <0.1.1-0 || >=0.1.1-0 <0.1.2-0 || >=0.1.2-0 <0.1.3-0 || >=0.1.3-0 <0.1.4-0 || >=0.1.4-0 <0.1.5-0 || >=0.1.5-0 <0.1.6-0 || >=0.1.6-0 <0.1.7-0",
+    "@deepseek-ai/dsh-client-ui-settings": ">=0.1.0-rc.8 <0.1.1-0 || >=0.1.1-0 <0.1.2-0 || >=0.1.2-0 <0.1.3-0 || >=0.1.3-0 <0.1.4-0 || >=0.1.4-0 <0.1.5-0 || >=0.1.5-0 <0.1.6-0 || >=0.1.6-0 <0.1.7-0",
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.8 <0.1.1-0 || >=0.1.1-0 <0.1.2-0 || >=0.1.2-0 <0.1.3-0 || >=0.1.3-0 <0.1.4-0 || >=0.1.4-0 <0.1.5-0 || >=0.1.5-0 <0.1.6-0 || >=0.1.6-0 <0.1.7-0",
+    "@deepseek-ai/dsh-settings": ">=0.1.0-rc.8 <0.1.1-0 || >=0.1.1-0 <0.1.2-0 || >=0.1.2-0 <0.1.3-0 || >=0.1.3-0 <0.1.4-0 || >=0.1.4-0 <0.1.5-0 || >=0.1.5-0 <0.1.6-0 || >=0.1.6-0 <0.1.7-0",
     "@deepseek-ai/schemastery": "^3.18.2",
     "react": "^18.2.0"
   },