dsh-repeat-guard 0.1.3 → 0.1.5

package/src/client.tsx

@@ -23,14 +23,25 @@ const SETTINGS_NS = 'repeat-guard';
 const THRESHOLD_MIN = 1;
 const THRESHOLD_MAX = 9;
 
-/** 本插件配置节选。 */
+/** 宿主侧注册的配置。字段都带 schema 默认值，所以在这里是必有的。 */
 interface RepeatGuardSettings {
   /** 拦截短句表。 */
-  fragments?: string[];
-  /** 连续命中多少行才拦。 */
-  threshold?: number;
+  fragments: string[];
+  /** 连续命中多少次才拦。 */
+  threshold: number;
+  /** 是否把"整行由多个表项拼成"也算命中。 */
+  inlineRepeat: boolean;
+  /** 截断后推给模型的指令正文。 */
+  resumeText: string;
+  /** 注入消息的折叠行摘要。 */
+  resumeSummary: string;
+  /** 累计拦截次数，由宿主侧维护。 */
+  count: number;
 }
 
+/** 输入框与文本域的公共外观。 */
+const 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`;
+
 /** 样式。令牌名取自 dsh 前端已发布的设计令牌表。 */
 const CSS = `
 .rg-root{display:flex;flex-direction:column;width:100%}
@@ -53,6 +64,11 @@ const CSS = `
 .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)}
@@ -61,8 +77,10 @@ const CSS = `
 .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)}
 `;
@@ -144,6 +162,28 @@ function Stepper({ value, min, max, unit, label, onChange }: StepperProps): Reac
   );
 }
 
+interface SwitchProps {
+  checked: boolean;
+  label: string;
+  onChange: (next: boolean) => void;
+}
+
+/** 开关。 */
+function Switch({ checked, label, onChange }: SwitchProps): ReactElement {
+  return (
+    <button
+      type="button"
+      role="switch"
+      aria-checked={checked}
+      aria-label={label}
+      className="rg-switch"
+      onClick={() => {
+        onChange(!checked);
+      }}
+    />
+  );
+}
+
 interface FragmentListProps {
   items: readonly string[];
   draft: string;
@@ -209,13 +249,19 @@ function FragmentList({ items, draft, onDraft, onAdd, onRemove }: FragmentListPr
 
 interface FormProps {
   initial: RepeatGuardSettings;
-  onSave: (fragments: readonly string[], threshold: number) => Promise<void>;
+  /** 宿主侧实时计数；由外层订阅刷新，不参与本地编辑。 */
+  count: number;
+  onReset: () => Promise<void>;
+  onSave: (next: RepeatGuardSettings) => Promise<void>;
 }
 
-/** 设置表单：标题行 + 阈值行 + 短句表行；改动先留在本地，点保存才写。 */
-function Form({ initial, onSave }: FormProps): ReactElement {
-  const [items, setItems] = useState<readonly string[]>(() => initial.fragments ?? []);
-  const [count, setCount] = useState(() => initial.threshold ?? 1);
+/** 设置表单：标题行 + 五行设置；改动先留在本地，点保存才写。 */
+function Form({ initial, count, onReset, onSave }: FormProps): ReactElement {
+  const [items, setItems] = useState<readonly string[]>(initial.fragments);
+  const [limit, setLimit] = useState(initial.threshold);
+  const [inlineRepeat, setInlineRepeat] = useState(initial.inlineRepeat);
+  const [resumeText, setResumeText] = useState(initial.resumeText);
+  const [resumeSummary, setResumeSummary] = useState(initial.resumeSummary);
   const [draft, setDraft] = useState('');
   const [note, setNote] = useState('');
 
@@ -236,7 +282,14 @@ function Form({ initial, onSave }: FormProps): ReactElement {
 
   function save(): void {
     setNote('保存中…');
-    onSave(items, count)
+    onSave({
+      fragments: [...items],
+      threshold: limit,
+      inlineRepeat,
+      resumeText,
+      resumeSummary,
+      count,
+    })
       .then(() => {
         setNote('已保存');
       })
@@ -245,6 +298,16 @@ function Form({ initial, onSave }: FormProps): ReactElement {
       });
   }
 
+  function reset(): void {
+    onReset()
+      .then(() => {
+        setNote('计数已清零');
+      })
+      .catch((error: unknown) => {
+        setNote(`清零失败：${String(error)}`);
+      });
+  }
+
   return (
     <div className="rg-root">
       <div className="rg-head">
@@ -254,19 +317,47 @@ function Form({ initial, onSave }: FormProps): ReactElement {
           保存
         </button>
       </div>
+      <div className="rg-row">
+        <div className="rg-rowText">
+          <div className="rg-rowTitle">累计拦截</div>
+          <div className="rg-rowDesc">重复打断计数</div>
+        </div>
+        <span className="rg-control">
+          <span className="rg-count">{count} 次</span>
+          <button type="button" className="rg-button" onClick={reset}>
+            清零
+          </button>
+        </span>
+      </div>
       <div className="rg-row">
         <div className="rg-rowText">
           <div className="rg-rowTitle">连续命中次数</div>
-          <div className="rg-rowDesc">连着几个短句行命中才拦截；填 1 表示发现即拦</div>
+          <div className="rg-rowDesc">循环次数上限；填 1 表示发现即拦</div>
         </div>
         <Stepper
-          value={count}
+          value={limit}
           min={THRESHOLD_MIN}
           max={THRESHOLD_MAX}
           unit="次"
           label="连续命中次数"
           onChange={(next) => {
-            setCount(next);
+            setLimit(next);
+            setNote('');
+          }}
+        />
+      </div>
+      <div className="rg-row">
+        <div className="rg-rowText">
+          <div className="rg-rowTitle">行内重复检测</div>
+          <div className="rg-rowDesc">
+            拦截类似"好。好。好。"的行内循环；关闭时只检测独立段落。
+          </div>
+        </div>
+        <Switch
+          checked={inlineRepeat}
+          label="行内重复检测"
+          onChange={(next) => {
+            setInlineRepeat(next);
             setNote('');
           }}
         />
@@ -274,7 +365,7 @@ function Form({ initial, onSave }: FormProps): ReactElement {
       <div className="rg-row rg-row--stack">
         <div className="rg-rowText">
           <div className="rg-rowTitle">拦截短句</div>
-          <div className="rg-rowDesc">一行一句，连标点一起写；只算独占一行的整行匹配</div>
+          <div className="rg-rowDesc">标点不可省略</div>
         </div>
         <FragmentList
           items={items}
@@ -284,6 +375,34 @@ function Form({ initial, onSave }: FormProps): ReactElement {
           onRemove={remove}
         />
       </div>
+      <div className="rg-row rg-row--stack">
+        <div className="rg-rowText">
+          <div className="rg-rowTitle">拦截提示词</div>
+          <div className="rg-rowDesc">截断后上下文注入的提示词</div>
+        </div>
+        <textarea
+          className="rg-textarea"
+          value={resumeText}
+          onChange={(event) => {
+            setResumeText(event.target.value);
+            setNote('');
+          }}
+        />
+      </div>
+      <div className="rg-row">
+        <div className="rg-rowText">
+          <div className="rg-rowTitle">拦截摘要</div>
+          <div className="rg-rowDesc">上下文注入的简介信息，仅用户可见</div>
+        </div>
+        <input
+          className="rg-summaryInput"
+          value={resumeSummary}
+          onChange={(event) => {
+            setResumeSummary(event.target.value);
+            setNote('');
+          }}
+        />
+      </div>
     </div>
   );
 }
@@ -315,9 +434,16 @@ export function apply(ctx: Context): void {
     return (
       <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/src/config.ts

@@ -1,8 +1,12 @@
 /**
- * 插件配置：拦截短句表与连续命中阈值。
+ * 插件配置：拦截短句表、连续命中阈值、行内重复检测、续跑注入的正文与摘要，
+ * 外加一个运行时计数。
  *
  * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
- * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ * schema，客户端设置页写同一个命名空间。判定与续跑时现取，改完立即生效，不用重启。
+ *
+ * 计数也寄在同一个命名空间里：宿主侧每次掐断写一次，客户端读同一个值、清零就是
+ * 把它写成 0。插件加载时先把它归零，所以口径是"自本次启动或上次清零以来"。
  */
 
 import type { Context } from '@deepseek-ai/cordis';
@@ -52,43 +56,107 @@ export const DEFAULT_FRAGMENTS: readonly string[] = [
 /** 默认阈值：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),
 });
 
-/** 一份生效中的配置，已编译成判定时直接可用的形式。 */
+/** 判定与续跑用得上的一份配置。 */
 export interface RepeatGuardConfig {
   /** 短句表，已全部小写化。 */
   readonly fragments: ReadonlySet<string>;
-  /** 连续命中多少行才拦。 */
+  /** 连续命中多少次才拦。 */
   readonly threshold: number;
+  /** 是否把"整行由多个表项拼成"也算命中。 */
+  readonly inlineRepeat: boolean;
+  /** 截断后推给模型的指令正文。 */
+  readonly resumeText: string;
+  /** 注入消息的折叠行摘要。 */
+  readonly resumeSummary: string;
 }
 
 /** 取当前配置。 */
 export type ConfigSource = () => RepeatGuardConfig;
 
-function compile(value: { fragments: readonly string[]; threshold: number }): RepeatGuardConfig {
+/** 宿主侧要用到的两件事：取配置、记一次拦截。 */
+export interface GuardRuntime {
+  /** 取当前配置。 */
+  readonly read: ConfigSource;
+  /** 记一次拦截，把计数写回 settings。 */
+  readonly countHit: () => void;
+}
+
+function compile(value: {
+  fragments: readonly string[];
+  threshold: number;
+  inlineRepeat: boolean;
+  resumeText: string;
+  resumeSummary: string;
+}): RepeatGuardConfig {
   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: Context): ConfigSource {
-  let current = compile({ fragments: DEFAULT_FRAGMENTS, threshold: DEFAULT_THRESHOLD });
+export function createRuntime(ctx: Context): GuardRuntime {
+  let current = compile({
+    fragments: DEFAULT_FRAGMENTS,
+    threshold: DEFAULT_THRESHOLD,
+    inlineRepeat: DEFAULT_INLINE_REPEAT,
+    resumeText: DEFAULT_RESUME_TEXT,
+    resumeSummary: DEFAULT_RESUME_SUMMARY,
+  });
+  let bump: (() => void) | undefined;
+
   ctx.inject(['settings'], (settingsCtx) => {
     const scope = settingsCtx.settings.register(SETTINGS_NS, SCHEMA);
     const sync = (): void => {
       current = compile(scope.get());
     };
+    const write = (patch: object): void => {
+      scope.update(patch).catch((error: unknown) => {
+        console.log(`[repeat-guard] 写设置失败：${String(error)}`);
+      });
+    };
     sync();
     scope.watch(sync);
+    // 计数口径是"自本次启动或上次清零以来"。
+    write({ count: 0 });
+    bump = (): void => {
+      write({ count: scope.get().count + 1 });
+    };
   });
-  return () => current;
+
+  return {
+    read: () => current,
+    countHit: () => {
+      bump?.();
+    },
+  };
 }

package/src/detect.ts

@@ -2,34 +2,84 @@
  * 复读退化判定：查表。
  *
  * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
- * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
+ * 基本判据是"整行与表项全等"，不拆解行的内部。
  *
- * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
- * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
+ * 行内重复检测（可开关，默认关）打开时，"整行由多个表项首尾相接拼成"也算命中，
+ * 用来兜住把短句连成一串写在同一行里的模型（如"好。好。好。"）。
+ *
+ * 阈值是"连续命中多少次才拦"：默认 1 表示发现即拦。计数单位是表项——整行全等算一次，
+ * 开了行内检测后行内每一段各算一次；中间夹一行不命中的就重新计数。
+ */
+
+/**
+ * 在 line 的 at 处能匹配到的最长表项长度。
+ * @param line - 已小写化的行。
+ * @param at - 起始下标。
+ * @param fragments - 小写化的短句表。
+ * @returns 匹配到的长度，0 表示这个位置没有表项。
+ */
+function longestFragmentAt(line: string, at: number, fragments: ReadonlySet<string>): number {
+  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: string, fragments: ReadonlySet<string>, inlineRepeat: boolean): number {
+  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: string,
   fragments: ReadonlySet<string>,
   threshold: number,
+  inlineRepeat: boolean,
 ): string | null {
   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/src/index.ts

@@ -22,7 +22,7 @@
 // 本文件只做装配，具体逻辑在各自的模块里。
 
 import type { Context } from '@deepseek-ai/cordis';
-import { createConfigSource } from './config.js';
+import { createRuntime } from './config.js';
 import { createStreamGuard } from './stream-guard.js';
 import { createTurnStoppingGuard } from './turn-stopping-guard.js';
 import type { GuardState } from './types.js';
@@ -35,7 +35,7 @@ export default function repeatGuard(ctx: Context): void {
   // 直接写 stdout：dsh 把插件的 stdout 收进 journal，便于确认插件确实被加载。
   console.log('[repeat-guard] 已加载，复读拦截生效');
   const state: GuardState = { 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/src/resume.ts

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

@@ -29,6 +29,7 @@ type StreamListener = (
  * @param sessionId - 当前会话 id；有值才登记待续跑标记。
  * @param state - 跨监听保留的拦截状态。
  * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
+ * @param countHit - 记一次拦截；只在真的掐断时调用。
  * @returns 包好的流。
  */
 async function* guardStream(
@@ -36,6 +37,7 @@ async function* guardStream(
   sessionId: GenerateOptions['sessionId'],
   state: GuardState,
   readConfig: ConfigSource,
+  countHit: () => void,
 ): AsyncGenerator<StreamChunk> {
   const iterator = downstream[Symbol.asyncIterator]();
   let accumulated = '';
@@ -49,10 +51,16 @@ async function* guardStream(
       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);
             }
@@ -92,14 +100,19 @@ async function* guardStream(
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
  * @param readConfig - 取当前配置。
+ * @param countHit - 记一次拦截。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export function createStreamGuard(state: GuardState, readConfig: ConfigSource): StreamListener {
+export function createStreamGuard(
+  state: GuardState,
+  readConfig: ConfigSource,
+  countHit: () => void,
+): StreamListener {
   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/src/turn-stopping-guard.ts

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