dsh-repeat-guard 0.1.0 → 0.1.2

package/lib/resume.js

@@ -10,55 +10,40 @@
  *     if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读，读到东西就不 break
  *
  * 所以在监听器里调 `agent.steer(...)` 推入一条输入，本轮就会再跑一步，而不是停下来等
- * 用户输入。dsh 自己在 dsh-hooks-claude-code/lib/index.js:292 有同样的用法。
+ * 用户输入。dsh 自己的 dsh-hooks-claude-code/lib/index.js:300 就是这么用的。
  */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
 /** 续跑时推给模型的指令正文。 */
 const RESUME_TEXT = [
     '[复读拦截]',
     '你上一段思考退化成了碎片复读（反复输出"好。"一类的空话），已被系统截断。',
     '请直接继续执行下一步，不要再输出任何确认语、寒暄或空话。',
 ].join('\n');
-/** 折叠行显示的一行摘要；空字符串会让客户端回退成 opaque 渲染，故不可为空。 */
-const RESUME_SUMMARY = '复读已截断：请继续执行';
 /**
- * 构造推给模型的一条输入，结构与 dsh 的 createUserMessage 对齐。
- * @returns 一条插件来源的 user 消息，客户端会渲染成折叠的 context 行。
+ * 这条注入消息的来源标记。
+ * `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
+ * 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
  */
-function resumeMessage() {
-    return {
-        id: crypto.randomUUID(),
-        role: 'user',
-        content: [{ type: 'text', text: RESUME_TEXT }],
-        source: {
-            kind: 'plugin',
-            plugin: 'repeat-guard',
-            form: 'notice',
-            summary: RESUME_SUMMARY,
-        },
-    };
-}
+const PLUGIN_SOURCE = {
+    kind: 'plugin',
+    plugin: 'repeat-guard',
+    form: 'notice',
+    summary: '复读已截断：请继续执行',
+};
 /**
  * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
  * @param state - 跨监听保留的拦截状态。
  * @param agent - 本轮所属的 agent 句柄。
  */
 export function reviveTurn(state, agent) {
-    // 三个提前返回都要留痕：不打印就无法区分"没触发""id 对不上""没有标记"。
-    if (agent === undefined || typeof agent.steer !== 'function') {
-        console.log('[repeat-guard] turn-stopping：载荷里没有 agent 句柄，不续跑');
-        return;
-    }
-    const sessionId = agent.session?.id;
-    if (sessionId === undefined) {
-        console.log('[repeat-guard] turn-stopping：agent 上没有会话 id，不续跑');
-        return;
-    }
+    const sessionId = agent.session.id;
     if (!state.pending.has(sessionId)) {
-        console.log(`[repeat-guard] turn-stopping：会话 ${sessionId} 没有待续跑标记，不续跑` +
-            `（当前有标记的会话：${[...state.pending].join(',') || '无'}）`);
         return;
     }
     state.pending.delete(sessionId);
     console.log(`[repeat-guard] turn-stopping：会话 ${sessionId} 续跑一步`);
-    agent.steer(resumeMessage());
+    agent.steer(createUserMessage({
+        content: [{ type: 'text', text: RESUME_TEXT }],
+        source: PLUGIN_SOURCE,
+    }));
 }

package/lib/stream-guard.d.ts

@@ -3,12 +3,16 @@
  *
  * 只检测 reasoning-delta（思考段）。正文 text-delta 不参与判定，原样透传。
  */
-import type { GenerateOptions, GuardState, StreamChunk } from './types.js';
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ConfigSource } from './config.js';
+import type { GuardState } from './types.js';
 /** `llm/stream` 的监听器签名。 */
-export type StreamListener = (options: GenerateOptions, next: () => AsyncIterable<StreamChunk>) => AsyncIterable<StreamChunk>;
+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 {
@@ -25,20 +30,29 @@ async function* guardStream(downstream, sessionId, state) {
                 return;
             }
             const chunk = step.value;
-            if (chunk?.type === 'reasoning-delta' && typeof chunk.text === 'string') {
+            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)}`);
-                    // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
-                    const index = chunk.index ?? 0;
+                    console.log(`[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`);
                     yield chunk;
-                    yield { type: 'block-end', index, block: { type: 'reasoning', text: accumulated } };
-                    yield { type: 'finish', reason: { kind: 'stop' } };
-                    return;
+                    if (!probe.done) {
+                        yield probe.value;
+                    }
+                    continue;
                 }
             }
             yield chunk;
@@ -58,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/lib/turn-stopping-guard.d.ts

@@ -4,12 +4,13 @@
  * 监听器的返回值不被使用（该事件是 serial 的副作用钩子），实现方式是调
  * `agent.steer(...)`，见 resume.ts 的说明。
  */
+import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { GuardState } from './types.js';
-/** `agent/turn-stopping` 的监听器签名。 */
-export type TurnStoppingListener = (payload: unknown) => void;
 /**
  * 造一个 `agent/turn-stopping` 监听器。
  * @param state - 跨监听保留的拦截状态。
  * @returns 监听器；只在有待续跑标记时推一条输入。
  */
-export declare function createTurnStoppingGuard(state: GuardState): TurnStoppingListener;
+export declare function createTurnStoppingGuard(state: GuardState): (payload: {
+    agent: Agent;
+}) => void;

package/lib/turn-stopping-guard.js

@@ -11,8 +11,7 @@ import { reviveTurn } from './resume.js';
  * @returns 监听器；只在有待续跑标记时推一条输入。
  */
 export function createTurnStoppingGuard(state) {
-    return (rawPayload) => {
-        const payload = rawPayload;
-        reviveTurn(state, payload?.agent);
+    return (payload) => {
+        reviveTurn(state, payload.agent);
     };
 }

package/lib/types.d.ts

@@ -1,49 +1,10 @@
 /**
- * 与本插件交互的 dsh 接口声明。
+ * 本插件自有的类型。
  *
- * 这些类型一律在本插件内声明，不 import dsh 的类型：那样还要为 tsc 配 paths 指向
- * dsh 安装目录，路径里带 node 版本号，dsh 一升级就失效。
+ * 与 dsh 交互的类型不在这里重抄：`Context`、`StreamChunk`、`GenerateOptions`、
+ * `Agent`、`UserMessage` 一律从 `@deepseek-ai/*` 引。本地抄一份会在 dsh 升级时
+ * 静默过期，而官方声明会让它在构建期就报出来。
  */
-/** 一个流式 chunk。本插件只读 reasoning-delta 的 index/text，其余字段原样透传。 */
-export interface StreamChunk {
-    readonly type: string;
-    readonly index?: number;
-    readonly text?: string;
-    readonly [key: string]: unknown;
-}
-/** 一次模型调用的参数；只声明本插件读到的两个字段。 */
-export interface GenerateOptions {
-    readonly purpose?: string;
-    readonly sessionId?: string;
-}
-/**
- * `agent/turn-stopping` 的载荷。
- *
- * dsh 的注释写明：本轮即将关闭（模型不再欠响应）时、在边界提交之前 await 这个事件；
- * 监听器若不同意关闭，就调 `agent.steer(...)` 推入新的输入，机器会重读收件箱——
- * 有新的 steering 就再跑一步，没有才真正关闭本轮。
- */
-export interface TurnStoppingPayload {
-    readonly agent?: SteerableAgent;
-}
-/** 能往本轮收件箱推输入、从而让本轮继续的 agent 句柄。 */
-export interface SteerableAgent {
-    readonly session?: {
-        readonly id?: string;
-    };
-    /** 推入 `next-step` 并唤醒驱动器：本轮再跑一步。 */
-    steer(input: unknown): void;
-}
-/** 注入给 dsh 的 cordis 上下文；只声明本插件用到的能力。 */
-export interface PluginContext {
-    /**
-     * 监听器的形参随所监听的事件而异，只能声明成 any[]：换成 unknown[] 会因函数
-     * 参数逆变，导致各监听器的具体签名无法赋值。
-     */
-    on(name: string, listener: (...args: any[]) => unknown, options?: {
-        global?: boolean;
-    }): void;
-}
 /** 跨两次监听保留的拦截状态。 */
 export interface GuardState {
     /** 发生过截断、等待下一步续跑的会话 id。 */

package/lib/types.js

@@ -1,7 +1,8 @@
 /**
- * 与本插件交互的 dsh 接口声明。
+ * 本插件自有的类型。
  *
- * 这些类型一律在本插件内声明，不 import dsh 的类型：那样还要为 tsc 配 paths 指向
- * dsh 安装目录，路径里带 node 版本号，dsh 一升级就失效。
+ * 与 dsh 交互的类型不在这里重抄：`Context`、`StreamChunk`、`GenerateOptions`、
+ * `Agent`、`UserMessage` 一律从 `@deepseek-ai/*` 引。本地抄一份会在 dsh 升级时
+ * 静默过期，而官方声明会让它在构建期就报出来。
  */
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-repeat-guard",
-  "version": "0.1.0",
+  "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,15 +23,42 @@
   "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",
   "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/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;