dsh-repeat-guard 0.1.0 → 0.1.1

package/README.md

@@ -57,7 +57,7 @@
 ## 工作原理
 
 1. 包一层 `llm/stream`（模型调用的流式 waterfall），逐 chunk 观察 `reasoning-delta`，累积本次响应已产出的思考文本。
-2. 命中退化时，把触发退化的那个 delta 照常放行，补一个 `block-end` 闭合思考块，再补一个 `finish(stop)`，然后结束流。agent-loop 的 `BlockAssembler` 会把这种"没有 finish 就结束"的流当作正常 `stop`，于是本次调用被当成正常完成：已生成的思考照常落盘。
+2. 命中退化时，把触发退化的那个 delta 照常放行，补一个 `block-end` 闭合思考块，再补一个 `finish(stop)`，然后结束流。对 agent-loop 而言这就是一次正常完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
 3. 提前结束流时显式向下游传播 `iterator.return()`，否则上游 HTTP 流会继续跑到结束，供应商照常计满 token，且连接悬挂。
 4. 光截断只会让本轮就此结束、停下来等用户输入。所以再挂一个 `agent/turn-stopping` 监听器，在本轮边界提交之前调 `agent.steer(...)` 推一条输入，本轮就会接着再跑一步。
 
@@ -147,16 +147,16 @@ journalctl --user -u dsh-web --no-pager | grep -a repeat-guard
 
 ⚠️ 插件加载失败会让 **dsh 启动直接失败**，而 dsh-web 是本机 GUI 的唯一通道。改完先离线验证再重启：用假上下文 import 产物调一次入口，或喂一段真实 chunk 序列。
 
-## 开发约束：不得 import 外部包
+## 依赖
 
-**不得 import 任何外部包，包括 `@deepseek-ai/cordis`；模块之间只用相对路径互相导入。**
+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 按常规向上查找即可解析到。
 
-`cordis-plugin-loader` 的 `import()` 对**裸 specifier**（包名）直接 `import(name)`，锚点是 loader 自身的文件位置（dsh 安装目录内部），从 profile 或全局顶层加载时都可能解析不到插件的依赖。而**相对 specifier** 走 `new URL(name, baseUrl)`，由 Node 原生 ESM 按当前文件位置解析，不受影响——所以内部拆模块是安全的，新增模块时只连相对路径即可，源码里要带 `.js` 后缀。
+所以：
 
-由这条约束派生的两点：
-
-- 类型一律在 `src/types.ts` 里声明，不 import dsh 的类型（那还要为 `tsc` 配 `paths` 指向 dsh 安装目录，路径里带 node 版本号，dsh 一升级就失效），也不引 `@types/node`（各模块按需 `declare` 用到的全局）；
-- 只用 TypeScript 写源码，由 `tsc` 产出 `lib/` 供 dsh 加载。dsh 的 loader 是原生 ESM import，**没有转译层**，运行时读到的永远是编译产物——改完 `src/` 必须重新构建才能生效。`lib/` 只随 npm 包发布，不进版本库。
+- **宿主提供的包写 `peerDependencies`**：`@deepseek-ai/cordis`、`@deepseek-ai/dsh-llm`、`@deepseek-ai/dsh-agent`。它们不在 profile 里重复安装，用 dsh 自带的那份。
+- **类型一律从官方引**，不在本地重抄。`Context`、`StreamChunk`、`GenerateOptions`、`Agent`、`UserMessage` 都是 dsh 导出的；本地抄一份只会在 dsh 升级后于运行时暴露字段对不上，官方声明则会在 `tsc` 阶段直接报错。
+- `src/types.ts` 只放本插件自有的类型（当前是 `GuardState`）。
+- 仍然只用 TypeScript 写源码，由 `tsc` 产出 `lib/` 供 dsh 加载。dsh 的 loader 是原生 ESM import，**没有转译层**，运行时读到的永远是编译产物——改完 `src/` 必须重新构建。`lib/` 只随 npm 包发布，不进版本库。
 
 ## 代码约定
 
@@ -177,8 +177,8 @@ journalctl --user -u dsh-web --no-pager | grep -a repeat-guard
 .
 ├── src/
 │   ├── index.ts                 插件入口：装配状态，注册两个监听器（只做装配）
-│   ├── types.ts                 与 dsh 交互的接口声明（纯类型，编译后为空模块）
-│   ├── detect.ts                复读判定：阈值常量 + 纯函数，不碰会话状态
+│   ├── types.ts                 本插件自有的类型（dsh 的接口一律从 @deepseek-ai/* 引）
+│   ├── detect.ts                复读判定：FRAGMENTS 表 + 查表纯函数，不碰会话状态
 │   ├── resume.ts                续跑：注入文案、消息构造、推送
 │   ├── stream-guard.ts          llm/stream 监听器：思考段检测与掐断
 │   └── turn-stopping-guard.ts   agent/turn-stopping 监听器：让本轮继续

package/lib/index.d.ts

@@ -1,6 +1,6 @@
-import type { PluginContext } from './types.js';
+import type { Context } from '@deepseek-ai/cordis';
 /**
  * 函数式插件入口。ctx 为 cordis 上下文，注册的监听随插件卸载自动释放。
  * @param ctx - 宿主 cordis 上下文。
  */
-export default function repeatGuard(ctx: PluginContext): void;
+export default function repeatGuard(ctx: Context): void;

package/lib/index.js

@@ -2,25 +2,22 @@
 //
 // 做法：包一层 `llm/stream`（模型调用的流式 waterfall），逐 chunk 观察思考段
 // （reasoning-delta）。命中退化时，把触发退化的那个 delta 照常放行，补一个 block-end
-// 闭合思考块，再补一个 finish(stop)，然后直接结束流。agent-loop 的 BlockAssembler 会把
-// 这种"没有 finish 就结束"的流当作正常 stop（assembler.js: `this._finish ?? {kind:'stop'}`），
-// 于是本次调用被当成正常完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
+// 闭合思考块，再补一个 finish(stop)，然后直接结束流。对 agent-loop 而言这就是一次正常
+// 完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
 //
 // 只检测思考段：正文 text-delta 不参与判定。复读退化先出现在思考段，那时正文往往还没
 // 开始产出；等正文也碎掉再掐，思考段已经白烧了一遍。
 //
-// 判定做什么：思考段里出现单独成行的一句空话（中文一到两个汉字，如"好。""执行。"；
-// 英文不超过三个单词，如"OK." "Let me go."）就掐断。判据的取舍见 detect.ts 的注释——
-// 关键是不能把"同样的碎片出现了几次"当作复读信号，那样会误伤正常的短句。
+// 判定做什么：思考段里出现独占一行的表项（如"好。""执行。""Let me go."）就掐断，
+// 表在 detect.ts 的 FRAGMENTS 里。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
+// 具体、可增删、可审计的。
 //
 // 掐断之后要让本轮继续，而不是停下来等用户输入：挂在 `agent/turn-stopping` 上，在本轮
 // 边界提交之前调 `agent.steer(...)` 推一条输入，机器就会再跑一步。详见 resume.ts。
 //
-// 依赖约束（重要）：不得 import 任何外部包，包括 @deepseek-ai/cordis。
-// cordis-plugin-loader 解析裸 specifier 时直接 `import(name)`，锚点是 loader 自身的
-// 文件位置（dsh 安装目录内部），从 profile 或全局顶层加载时都可能解析不到插件的依赖。
-// **相对路径 import 不受此限**：它由 Node 原生 ESM 按当前文件位置解析，所以本插件内部
-// 按职责拆出的这些模块可以正常互相导入。新增模块时照此办理：只连相对路径。
+// 依赖：dsh 把 bundle 的 dependencies / peerDependencies 从安装目录软链进 profile
+// （dsh-app-boot 的 healProfileModuleFallback），所以本插件可以正常 import
+// `@deepseek-ai/*`——它们声明在 peerDependencies 里，由宿主提供。
 //
 // 本文件只做装配，具体逻辑在各自的模块里。
 import { createStreamGuard } from './stream-guard.js';

package/lib/resume.d.ts

@@ -10,12 +10,13 @@
  *     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 type { GuardState, SteerableAgent } from './types.js';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { GuardState } from './types.js';
 /**
  * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
  * @param state - 跨监听保留的拦截状态。
  * @param agent - 本轮所属的 agent 句柄。
  */
-export declare function reviveTurn(state: GuardState, agent: SteerableAgent | undefined): void;
+export declare function reviveTurn(state: GuardState, agent: Agent): void;

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,14 @@
  *
  * 只检测 reasoning-delta（思考段）。正文 text-delta 不参与判定，原样透传。
  */
-import type { GenerateOptions, GuardState, StreamChunk } from './types.js';
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+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 - 跨监听保留的拦截状态。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
 export declare function createStreamGuard(state: GuardState): StreamListener;
+export {};

package/lib/stream-guard.js

@@ -25,7 +25,7 @@ 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);
                 if (hit !== null) {
@@ -34,9 +34,8 @@ async function* guardStream(downstream, sessionId, state) {
                     }
                     console.log(`[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`);
                     // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
-                    const index = chunk.index ?? 0;
                     yield chunk;
-                    yield { type: 'block-end', index, block: { type: 'reasoning', text: accumulated } };
+                    yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
                     yield { type: 'finish', reason: { kind: 'stop' } };
                     return;
                 }

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.1",
   "description": "流式输出退化拦截：检测碎片复读，掐断本次生成并提醒模型直接执行工具调用",
   "type": "module",
   "main": "lib/index.js",
@@ -28,7 +28,16 @@
   },
   "license": "MIT",
   "author": "yuqing",
+  "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"
+  },
   "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+    "@types/node": "^22.0.0",
     "typescript": "^7.0.2"
   }
 }

package/src/index.ts

@@ -2,40 +2,35 @@
 //
 // 做法：包一层 `llm/stream`（模型调用的流式 waterfall），逐 chunk 观察思考段
 // （reasoning-delta）。命中退化时，把触发退化的那个 delta 照常放行，补一个 block-end
-// 闭合思考块，再补一个 finish(stop)，然后直接结束流。agent-loop 的 BlockAssembler 会把
-// 这种"没有 finish 就结束"的流当作正常 stop（assembler.js: `this._finish ?? {kind:'stop'}`），
-// 于是本次调用被当成正常完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
+// 闭合思考块，再补一个 finish(stop)，然后直接结束流。对 agent-loop 而言这就是一次正常
+// 完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
 //
 // 只检测思考段：正文 text-delta 不参与判定。复读退化先出现在思考段，那时正文往往还没
 // 开始产出；等正文也碎掉再掐，思考段已经白烧了一遍。
 //
-// 判定做什么：思考段里出现单独成行的一句空话（中文一到两个汉字，如"好。""执行。"；
-// 英文不超过三个单词，如"OK." "Let me go."）就掐断。判据的取舍见 detect.ts 的注释——
-// 关键是不能把"同样的碎片出现了几次"当作复读信号，那样会误伤正常的短句。
+// 判定做什么：思考段里出现独占一行的表项（如"好。""执行。""Let me go."）就掐断，
+// 表在 detect.ts 的 FRAGMENTS 里。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
+// 具体、可增删、可审计的。
 //
 // 掐断之后要让本轮继续，而不是停下来等用户输入：挂在 `agent/turn-stopping` 上，在本轮
 // 边界提交之前调 `agent.steer(...)` 推一条输入，机器就会再跑一步。详见 resume.ts。
 //
-// 依赖约束（重要）：不得 import 任何外部包，包括 @deepseek-ai/cordis。
-// cordis-plugin-loader 解析裸 specifier 时直接 `import(name)`，锚点是 loader 自身的
-// 文件位置（dsh 安装目录内部），从 profile 或全局顶层加载时都可能解析不到插件的依赖。
-// **相对路径 import 不受此限**：它由 Node 原生 ESM 按当前文件位置解析，所以本插件内部
-// 按职责拆出的这些模块可以正常互相导入。新增模块时照此办理：只连相对路径。
+// 依赖：dsh 把 bundle 的 dependencies / peerDependencies 从安装目录软链进 profile
+// （dsh-app-boot 的 healProfileModuleFallback），所以本插件可以正常 import
+// `@deepseek-ai/*`——它们声明在 peerDependencies 里，由宿主提供。
 //
 // 本文件只做装配，具体逻辑在各自的模块里。
 
+import type { Context } from '@deepseek-ai/cordis';
 import { createStreamGuard } from './stream-guard.js';
 import { createTurnStoppingGuard } from './turn-stopping-guard.js';
-import type { GuardState, PluginContext } from './types.js';
-
-/** dsh 跑在 Node 上；只声明本插件用到的全局，避免为此引入 @types/node。 */
-declare const console: { log(...args: unknown[]): void };
+import type { GuardState } from './types.js';
 
 /**
  * 函数式插件入口。ctx 为 cordis 上下文，注册的监听随插件卸载自动释放。
  * @param ctx - 宿主 cordis 上下文。
  */
-export default function repeatGuard(ctx: PluginContext): void {
+export default function repeatGuard(ctx: Context): void {
   // 直接写 stdout：dsh 把插件的 stdout 收进 journal，便于确认插件确实被加载。
   console.log('[repeat-guard] 已加载，复读拦截生效');
   const state: GuardState = { pending: new Set() };

package/src/resume.ts

@@ -10,14 +10,12 @@
  *     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 type { GuardState, SteerableAgent } from './types.js';
-
-/** dsh 跑在 Node 上；只声明本插件用到的全局，避免为此引入 @types/node。 */
-declare const crypto: { randomUUID(): string };
-declare const console: { log(...args: unknown[]): void };
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import type { GuardState } from './types.js';
 
 /** 续跑时推给模型的指令正文。 */
 const RESUME_TEXT = [
@@ -26,51 +24,34 @@ const RESUME_TEXT = [
   '请直接继续执行下一步，不要再输出任何确认语、寒暄或空话。',
 ].join('\n');
 
-/** 折叠行显示的一行摘要；空字符串会让客户端回退成 opaque 渲染，故不可为空。 */
-const RESUME_SUMMARY = '复读已截断：请继续执行';
-
 /**
- * 构造推给模型的一条输入，结构与 dsh 的 createUserMessage 对齐。
- * @returns 一条插件来源的 user 消息，客户端会渲染成折叠的 context 行。
+ * 这条注入消息的来源标记。
+ * `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
+ * 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
  */
-function resumeMessage(): Record<string, unknown> {
-  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: '复读已截断：请继续执行',
+} as const;
 
 /**
  * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
  * @param state - 跨监听保留的拦截状态。
  * @param agent - 本轮所属的 agent 句柄。
  */
-export function reviveTurn(state: GuardState, agent: SteerableAgent | undefined): void {
-  // 三个提前返回都要留痕：不打印就无法区分"没触发""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;
-  }
+export function reviveTurn(state: GuardState, agent: Agent): void {
+  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/src/stream-guard.ts

@@ -4,14 +4,12 @@
  * 只检测 reasoning-delta（思考段）。正文 text-delta 不参与判定，原样透传。
  */
 
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
 import { findDegenerateLine } from './detect.js';
-import type { GenerateOptions, GuardState, StreamChunk } from './types.js';
-
-/** dsh 跑在 Node 上；只声明本插件用到的全局，避免为此引入 @types/node。 */
-declare const console: { log(...args: unknown[]): void };
+import type { GuardState } from './types.js';
 
 /** `llm/stream` 的监听器签名。 */
-export type StreamListener = (
+type StreamListener = (
   options: GenerateOptions,
   next: () => AsyncIterable<StreamChunk>,
 ) => AsyncIterable<StreamChunk>;
@@ -29,7 +27,7 @@ export type StreamListener = (
  */
 async function* guardStream(
   downstream: AsyncIterable<StreamChunk>,
-  sessionId: string | undefined,
+  sessionId: GenerateOptions['sessionId'],
   state: GuardState,
 ): AsyncGenerator<StreamChunk> {
   const iterator = downstream[Symbol.asyncIterator]();
@@ -41,7 +39,7 @@ async function* guardStream(
         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);
         if (hit !== null) {
@@ -52,9 +50,8 @@ async function* guardStream(
             `[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
           );
           // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
-          const index = chunk.index ?? 0;
           yield chunk;
-          yield { type: 'block-end', index, block: { type: 'reasoning', text: accumulated } };
+          yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
           yield { type: 'finish', reason: { kind: 'stop' } };
           return;
         }

package/src/turn-stopping-guard.ts

@@ -5,20 +5,17 @@
  * `agent.steer(...)`，见 resume.ts 的说明。
  */
 
+import type { Agent } from '@deepseek-ai/dsh-agent';
 import { reviveTurn } from './resume.js';
-import type { GuardState, TurnStoppingPayload } from './types.js';
-
-/** `agent/turn-stopping` 的监听器签名。 */
-export type TurnStoppingListener = (payload: unknown) => void;
+import type { GuardState } from './types.js';
 
 /**
  * 造一个 `agent/turn-stopping` 监听器。
  * @param state - 跨监听保留的拦截状态。
  * @returns 监听器；只在有待续跑标记时推一条输入。
  */
-export function createTurnStoppingGuard(state: GuardState): TurnStoppingListener {
-  return (rawPayload) => {
-    const payload = rawPayload as TurnStoppingPayload;
-    reviveTurn(state, payload?.agent);
+export function createTurnStoppingGuard(state: GuardState) {
+  return (payload: { agent: Agent }): void => {
+    reviveTurn(state, payload.agent);
   };
 }

package/src/types.ts

@@ -1,55 +1,11 @@
 /**
- * 与本插件交互的 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。 */