@max-null/dsh-allostasis 0.2.0 → 0.2.1

package/README.md

@@ -7,7 +7,9 @@ This plugin belongs to the **`@max-null/*` family** — a set of plugins that to
 Allostasis for the DeepSeek Harness — session self-regulation rather than monitoring.
 Before each step it reads the most recent reasoning block and appends one near-end message
 when that thinking has drifted into English (**Chinese anchoring**) or collapsed into
-repetition (**degeneration reminder**).
+repetition (**degeneration reminder**). When a turn ends with no visible output at all
+(**silent turn**), it records the verdict in the session log and the browser half shows a
+notice beneath that turn.
 
 ## 它做什么
 
@@ -17,15 +19,19 @@ repetition (**degeneration reminder**).
 |---|---|---|
 | **中文锚定** | **已实现** | 上一步思考的英文功能词密度越线 |
 | **推理退化提醒** | **已实现** | 上一步思考的重复率越线，且连续 N 步成立 |
+| **空回合提示** | **已实现** | 回合收尾时末条助手消息没有非空文本（只在 `completed` 回合上判） |
 | 上下文占用感知 | 计划中 | 需先定「什么情况下才出现」（持续在场会退化成背景音） |
 | 压缩预约落盘 | 计划中 | 待通路验证：退化样本散布在整段退化区间，「只压一小段」能否打断循环尚无证据（二期方案 §八.1） |
 
-两类提醒都以 `notice` 形式注入——在**轨迹页**是折叠态就显示一行摘要的注入行，不弹窗、不打断；
+前两类提醒以 `notice` 形式注入——在**轨迹页**是折叠态就显示一行摘要的注入行，不弹窗、不打断；
 **对话页不显示**（2026-09-29 在 SSiD dev / DSH 0.2.0-rc.1 上实测，口径见二期方案 §九）。
-退化触发时还会 append 一条 `allostasis/degeneration` 事件，记下当时的重复率、阈值与连续步数，
-因此「插件当时判了什么、用的什么阈值」可事后重建。
 
-**它全程静默，所以「确认它在工作」只能靠日志。** 本插件没有任何界面元素，命中时也只在轨迹页留一行；不命中时一个字都不说——「装了没有」「阈值生效没有」「这一步为什么没提醒」三个问题原本都无从回答，只能靠改配置去试。因此它在 `src/index.ts` 的 `apply` 里留两行痕：
+**空回合提示是三者里唯一有界面的一个**，就挂在那一段空白下面（见「截图」段）。它不发消息、不改模型输入——
+浏览器半边从 `turn/start` / `assistant/message` / `turn/end` 自己折叠出判定，投影成 Turn 尾部的一行提示。
+
+**判定结果不写会话日志。** 内核的事件词汇表在构建期生成，下游插件的自定义类型不在其中，而 `Session.append()` 没有 `ignorable` 标记通道；无标记的自定义事件会让**整份**日志在下次加载时被拒读。判定输入本来就可重放，留痕由 `console.debug` 诊断行与界面上那行提示承担。理由与取证见 `docs/设计/2026-09-30-空回合检测与可见化.md` §十一。
+
+**除空回合外全程静默，所以「确认它在工作」只能靠日志。** 前两类命中时只在轨迹页留一行；不命中时一个字都不说——「装了没有」「阈值生效没有」「这一步为什么没提醒」三个问题原本都无从回答，只能靠改配置去试。因此它在 `src/index.ts` 的 `apply` 里留两行痕：
 
 ```
 [dsh-allostasis] loaded · driftThreshold=0.15 repetitionThreshold=0.5 consecutiveSteps=2
@@ -66,14 +72,17 @@ repetition (**degeneration reminder**).
 
 **退化与上下文占用脱钩**：同一会话里 26.1% 占用时重复率 84%、67.9% 时 83–92%，压缩到 26.1% 并不降低重复率。所以「调低阈值」治不了它；压缩能否治它取决于力度。完整数据见 `docs/排查/2026-09-28-推理退化与上下文占用脱钩.md`。
 
-退化触发时除提醒消息外还会 append 一条 `allostasis/degeneration` 事件，记下当时的重复率、阈值与连续步数——判定依据因此可事后重建，而不是只能按现在的脚本重算。
+退化触发的留痕是 `console.debug` 诊断行（`repetition=` 那一段给出 `units` 与 `ratio`）加上轨迹页那行提醒。**判定结果不落会话日志**——理由与空回合那条同源，见前文。
 
 ## 截图
 
-本插件是**会话行为调节类**：不新增任何按钮、面板或设置项。它每个 step 前读取最近一条思考，判定为语言漂移或推理退化时向请求末尾追加一条提醒，效果体现在模型行为上。
+空回合提示：浏览器半边从会话事件流自行折叠出「这一轮没有产出内容」，对话页在该回合尾部显示一行说明。它贴着那一段空白，回看历史时也还在原处。
 
-> 按《SSiD 开发手册》§9 截图规范：截图须回答「装完会多出/变成什么」的**入口与面板**。
-> 本插件无界面元素（no UI surface），故**不适用**该项要求，改以上述行为效果说明代替。
+| 空回合提示 |
+|---|
+| ![空回合提示](docs/shots/silent-turn-1.png) |
+
+其余两个能力（中文锚定、推理退化提醒）是**提示注入类**：不新增按钮、面板或设置项，每个 step 前读取最近一条思考，判定越线时向请求末尾追加一条提醒，效果体现在模型行为上——那两项按《SSiD 开发手册》§9 走无 UI 插件豁免，只有空回合提示有界面元素。
 
 ## Compose
 
@@ -88,13 +97,16 @@ Installs as a bundle: `dsh plugin --profile <name> add @max-null/dsh-allostasis`
 
 ## Config
 
-三个判定阈值可在 `config` 段覆盖；省略即用括号内的默认值。
+三个判定阈值加一个空回合档位可在 `config` 段覆盖；省略即用括号内的默认值。
 
 | 字段 | 默认 | 含义 |
 |---|---|---|
 | `driftThreshold` | `0.15` | 英文功能词密度达到此值即判为漂移 |
 | `repetitionThreshold` | `0.5` | 推理重复率阈值，取值 0–1 |
 | `consecutiveSteps` | `2` | 连续多少步越线才触发退化提醒 |
+| `silentTurn` | `observe` | 空回合档位：`off` 宿主不判定也不干预、`observe` 判定并打一行诊断、`steer` 额外补一次生成 |
+
+**档位管不到对话页那行提示**：提示由浏览器半边折叠会话事件流得出，与宿主判据同源但独立于档位——浏览器半边的 `apply` 拿不到插件配置（2026-10-01 实测：在 `cordis.patch.yml` 里配 `silentTurn: off`，宿主读到 `off`，浏览器半边收到空对象）。要完全静默请禁用插件。
 
 ```yaml
 - id: allostasis

package/dist/client.js

@@ -0,0 +1,238 @@
+window.__ModuleLoader__.load({
+	id: "@max-null/dsh-allostasis",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region src/tail.ts
+		/**
+		* 统计一条助手消息的块构成。
+		*
+		* `text` 按去掉首尾空白后的长度计入：只含空白的文本块在界面上不产生任何可见内容，
+		* 把它算作「说了话」会让判据漏掉真实的空回合。
+		* @param turn - 该消息所属的 turn。
+		* @param step - 该消息所属的 step。
+		* @param content - 助手消息的内容块，按出现顺序。
+		* @returns 该消息的产出形态。
+		*/
+		function shapeOf(turn, step, content) {
+			let textChars = 0;
+			let reasoningChars = 0;
+			const blocks = {
+				reasoning: 0,
+				text: 0,
+				toolCalls: 0
+			};
+			for (const block of content) if (block.type === "reasoning") {
+				blocks.reasoning += 1;
+				reasoningChars += block.text?.length ?? 0;
+			} else if (block.type === "text") {
+				blocks.text += 1;
+				textChars += block.text?.trim().length ?? 0;
+			} else if (block.type === "tool-call") blocks.toolCalls += 1;
+			return {
+				turn,
+				step,
+				textChars,
+				reasoningChars,
+				blocks
+			};
+		}
+		/**
+		* 对一次测量下判定。
+		*
+		* 只有「有助手消息且它没有非空文本」才算空回合。工具调用**不**改变判定：一个以
+		* `tool-call` 结尾的完成态回合同样是异常（工具执行完还会再走一步，除非回合已经结束）。
+		* @param shape - 末条助手消息的形态；没有助手消息时传 `undefined`。
+		* @returns 三态判定。
+		*/
+		function tailVerdict(shape) {
+			if (shape === void 0) return "unknown";
+			return shape.textChars > 0 ? "spoke" : "silent";
+		}
+		//#endregion
+		//#region src/client/silent-turn.ts
+		/** Turn 数据键；同时用作 Definition 的 `kind`。 */
+		const SILENT_TURN_KEY = "allostasis-silent";
+		/**
+		* 对一个已收尾的 Turn 下判定。
+		* @param turn - 收尾的回合号。
+		* @param reason - `turn/end` 记录的收尾原因。
+		* @param tail - 本 Turn 末条助手消息的形态；没有助手消息时为 null。
+		* @returns 命中时渲染端要读到的事实，否则 null。
+		*/
+		function silentData(turn, reason, tail) {
+			if (reason.kind !== "completed" || tail === null) return null;
+			if (tailVerdict(tail) !== "silent") return null;
+			return {
+				turn,
+				textChars: tail.textChars,
+				reasoningChars: tail.reasoningChars
+			};
+		}
+		/**
+		* 累积空回合判定。
+		*
+		* `match` 只读当前事件：`turn/start` 开一个 Turn，之后两条更新各自折进 State。历史窗口从
+		* 中间加载时 `turn/start` 可能不在窗口里，那种情况下本 Definition 不启动——没有开头就
+		* 无从知道这一轮是怎么开始的。
+		*/
+		const silentTurnDefinition = {
+			kind: SILENT_TURN_KEY,
+			match: (event) => {
+				if (event.type === "turn/start") return {
+					id: String(event.data.turn),
+					role: "start"
+				};
+				if (event.type === "assistant/message") return {
+					id: String(event.data.turn),
+					role: "update"
+				};
+				if (event.type === "turn/end") return {
+					id: String(event.data.turn),
+					role: "update"
+				};
+				return null;
+			},
+			start: (_context, match) => {
+				if (match.event.type !== "turn/start") throw new Error("allostasis-silent start requires turn/start");
+				return {
+					turn: match.event.data.turn,
+					tail: null,
+					found: null
+				};
+			},
+			update: (context, match) => {
+				const { event } = match;
+				if (event.type === "assistant/message") return {
+					...context.state,
+					turn: event.data.turn,
+					tail: shapeOf(event.data.turn, event.data.step, event.data.message.content)
+				};
+				if (event.type === "turn/end") return {
+					...context.state,
+					turn: event.data.turn,
+					found: silentData(event.data.turn, event.data.reason, context.state.tail)
+				};
+				return context.state;
+			},
+			buildLocationData: (context, scope, previous) => {
+				const { state } = context;
+				if (scope !== "turn" || state === void 0 || state.found === null) return null;
+				if (previous?.kind === "turn" && previous.turn === state.turn && previous.key === "allostasis-silent" && previous.value === state.found) return previous;
+				return {
+					kind: "turn",
+					turn: state.turn,
+					key: SILENT_TURN_KEY,
+					value: state.found
+				};
+			}
+		};
+		//#endregion
+		//#region src/client/SilentTurnNotice.tsx
+		/**
+		* 渲染本 Turn 的空回合提示；该 Turn 没有命中判定时什么都不渲染。
+		*
+		* 每个 list 条目都会对每一轮渲染一次，所以判定在这里收窄到自己的那两个键上。
+		* @param props - 回合尾部 owner 货币与本地化座位。
+		* @returns 提示条，或 `null`。
+		*/
+		function SilentTurnNotice({ turn, t }) {
+			const data = turn.data.get(SILENT_TURN_KEY);
+			if (data === void 0) return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: wrap,
+				role: "status",
+				"data-allostasis-silent-turn": data.turn,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: headline,
+					children: t("silent.headline")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: hint,
+					children: data.reasoningChars > 0 ? t("silent.hintReasoned") : t("silent.hintEmpty")
+				})]
+			});
+		}
+		const wrap = {
+			display: "flex",
+			flexDirection: "column",
+			gap: "2px",
+			margin: "6px 0 2px",
+			padding: "8px 12px",
+			borderLeft: "2px solid var(--dsw-alias-label-caption)",
+			borderRadius: "var(--dsw-radius-md)",
+			background: "var(--dsw-alias-bg-overlay)",
+			color: "var(--dsw-alias-label-secondary)",
+			fontFamily: "var(--dsw-font-family)",
+			fontSize: "12px",
+			lineHeight: "18px"
+		};
+		const headline = {
+			color: "var(--dsw-alias-label-primary)",
+			fontWeight: 600
+		};
+		const hint = { opacity: .85 };
+		//#endregion
+		//#region src/client/locales.ts
+		/**
+		* 浏览器半边的文案字典。
+		*
+		* 产品可见字符串一律走这里，组件不内联文案（DSH 的 `verify-client-ui-i18n` 按来源
+		* 归属校验）。`LocaleNamespaceMap` 里登记的是 `keyof typeof en`，两套字典的键必须一致。
+		*
+		* 措辞对着**用户此刻的困惑**写：他看到的是空白，所以先说明发生了什么，再给一条出路。
+		* 不说「模型坏了」——那是归因，而这里只知道「这一轮没有产出」。
+		* @module @max-null/dsh-allostasis/client/locales
+		*/
+		/** 本插件在浏览器半边占用的 locale 命名空间。 */
+		const NS = "allostasis";
+		/** 中文文案。 */
+		const zh = {
+			/** 一行叙述：这条提醒说的是什么。 */
+			"silent.headline": "这一轮结束时模型没有产出内容",
+			/** 末步只生成了推理时的说明：给出可执行的下一步。 */
+			"silent.hintReasoned": "最后一步只生成了推理就停下了。可以再问一句让它接着说完，或直接看上面的操作记录。",
+			/** 末步什么块都没有时的说明。 */
+			"silent.hintEmpty": "最后一步没有产出任何内容。可以重问一次，或换一种说法。"
+		};
+		/** 英文文案；键与 {@link zh} 一一对应。 */
+		const en = {
+			"silent.headline": "This turn ended with no visible output",
+			"silent.hintReasoned": "The last step stopped after reasoning. Ask again to let it finish the thought, or read the operation log above.",
+			"silent.hintEmpty": "The last step produced nothing at all. Ask again, or rephrase the request."
+		};
+		//#endregion
+		//#region src/client/index.tsx
+		/** 本插件在浏览器半边的包名，用作诊断行的前缀。 */
+		const PLUGIN_ID = "@max-null/dsh-allostasis";
+		/** 需要槽位注册表、文案服务与 Conversation 的事件注册表。 */
+		const inject = [
+			"slots",
+			"locale",
+			"uiConversation"
+		];
+		/**
+		* 登记文案与回合尾部座位。
+		* @param ctx - 浏览器半边上下文。
+		*/
+		function apply(ctx) {
+			console.info(`[${PLUGIN_ID}] client applied`);
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}), "dsh-allostasis: 文案字典");
+			ctx.effect(() => ctx.uiConversation.events.register(silentTurnDefinition), "dsh-allostasis: 空回合投影");
+			ctx.slots.inject("conversation.chat.turnTail", () => ctx.slots.register({
+				name: "conversation.chat.turnTail",
+				id: SILENT_TURN_KEY,
+				order: 10,
+				locale: NS
+			}, SilentTurnNotice));
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});

package/dist/config.d.ts

@@ -1,8 +1,8 @@
 /**
  * 插件的可配置面。
  *
- * 只暴露**判定阈值**这一类值：它们是「宁可晚一点也别误报」这条取舍的刻度，随任务类型
- * 与模型行为漂移，属于部署间会变的选择（DSH 插件规范 "No hardcoded tunables in
+ * 只暴露**判定阈值与档位**这一类值：它们是「宁可晚一点也别误报」这条取舍的刻度，随任务
+ * 类型与模型行为漂移，属于部署间会变的选择（DSH 插件规范 "No hardcoded tunables in
  * plugins"）。判据里的小样本门槛（`MIN_WORDS` / `MIN_UNITS` / `REPEAT_MIN_COUNT`）
  * 不在此列——它们不是偏好，改了就是把密度与比例算飞，属于判据几何的一部分。
  *
@@ -15,6 +15,7 @@
  * @module @max-null/dsh-allostasis/config
  */
 import Schema from '@deepseek-ai/schemastery';
+import { type SilentTurnMode } from './tail.ts';
 /**
  * 插件配置，与同名 schemastery schema 一起由 Loader 校验。
  *
@@ -27,6 +28,21 @@ export interface Config {
     repetitionThreshold?: number;
     /** 连续多少步越线才触发退化提醒（默认 2）。取 1 会跟着正常期的单次抖动误报。 */
     consecutiveSteps?: number;
+    /**
+     * 空回合兜底的档位（默认 `observe`）。
+     *
+     * `off` 宿主不判定也不干预；`observe` 判定并打一行诊断；`steer` 在判定之外追加一次
+     * 补生成请求。补生成受两条边界约束：同一回合至多一次（`throttle.ts`），取消的回合与
+     * 子代理会话不触发（见 `index.ts` 的 `installSilentTurn`）。
+     *
+     * **档位管不到对话页那行提示**：提示由浏览器半边折叠会话事件流得出，与宿主判据同源
+     * 但独立于档位——浏览器半边的 `apply` 拿不到插件配置（2026-10-01 实测）。要完全静默
+     * 就禁用插件。
+     *
+     * **默认取 `observe` 而不是 `steer`**：补生成能不能改变采样轨迹尚未验证
+     * （设计文档 §六.1），先让它只观测、由使用者显式打开。
+     */
+    silentTurn?: SilentTurnMode;
 }
 /** {@link Config} 经校验后的形态：字段齐全，可直接参与判定。 */
 export interface ResolvedConfig {
@@ -36,6 +52,8 @@ export interface ResolvedConfig {
     readonly repetitionThreshold: number;
     /** 见 {@link Config.consecutiveSteps}。 */
     readonly consecutiveSteps: number;
+    /** 见 {@link Config.silentTurn}。 */
+    readonly silentTurn: SilentTurnMode;
 }
 /** Loader 用于校验 `cordis.patch.yml` 里 `config` 段的 schema。 */
 export declare const Config: Schema<Config>;

package/dist/config.js

@@ -1,8 +1,8 @@
 /**
  * 插件的可配置面。
  *
- * 只暴露**判定阈值**这一类值：它们是「宁可晚一点也别误报」这条取舍的刻度，随任务类型
- * 与模型行为漂移，属于部署间会变的选择（DSH 插件规范 "No hardcoded tunables in
+ * 只暴露**判定阈值与档位**这一类值：它们是「宁可晚一点也别误报」这条取舍的刻度，随任务
+ * 类型与模型行为漂移，属于部署间会变的选择（DSH 插件规范 "No hardcoded tunables in
  * plugins"）。判据里的小样本门槛（`MIN_WORDS` / `MIN_UNITS` / `REPEAT_MIN_COUNT`）
  * 不在此列——它们不是偏好，改了就是把密度与比例算飞，属于判据几何的一部分。
  *
@@ -17,11 +17,13 @@
 import Schema from '@deepseek-ai/schemastery';
 import { DRIFT_THRESHOLD } from "./drift.js";
 import { CONSECUTIVE_STEPS, REPETITION_THRESHOLD } from "./repetition.js";
+import { SILENT_TURN_MODE, SILENT_TURN_MODES } from "./tail.js";
 /** Loader 用于校验 `cordis.patch.yml` 里 `config` 段的 schema。 */
 export const Config = Schema.object({
     driftThreshold: Schema.number(),
     repetitionThreshold: Schema.number(),
     consecutiveSteps: Schema.number(),
+    silentTurn: Schema.union(SILENT_TURN_MODES),
 });
 /**
  * 校验一个 0–1 的阈值字段。
@@ -35,6 +37,19 @@ function ratio(field, value) {
     }
     return value;
 }
+/**
+ * 校验一个枚举字段。
+ * @param field - 字段名，用于报错文案。
+ * @param value - 字段值。
+ * @param allowed - 允许的取值。
+ * @returns 校验通过的原值。
+ */
+function oneOf(field, value, allowed) {
+    if (!allowed.includes(value)) {
+        throw new Error(`dsh-allostasis: \`${field}\` must be one of ${allowed.join(' | ')}, got ${String(value)}`);
+    }
+    return value;
+}
 /**
  * 校验配置并补齐缺省值。
  *
@@ -50,5 +65,6 @@ export function resolveConfig(config = {}) {
     if (!Number.isInteger(consecutiveSteps) || consecutiveSteps < 1) {
         throw new Error(`dsh-allostasis: \`consecutiveSteps\` must be an integer >= 1, got ${consecutiveSteps}`);
     }
-    return { driftThreshold, repetitionThreshold, consecutiveSteps };
+    const silentTurn = oneOf('silentTurn', config.silentTurn ?? SILENT_TURN_MODE, SILENT_TURN_MODES);
+    return { driftThreshold, repetitionThreshold, consecutiveSteps, silentTurn };
 }

package/dist/index.d.ts

@@ -1,11 +1,29 @@
 /**
  * 应变（allostasis）：会话状态的自我调节。
  *
- * 两期能力都落在同一个 `agent/pre-step` 上，因为它们读的是同一份输入——最近一条思考：
- *
- * · **一期 · 中文锚定**：判定为语言漂移（英文功能词密度越线）就追加一条中文锚定消息。
- * · **二期 · 退化提醒**：判定为推理退化（重复率越线且连续若干步成立）就追加减速提醒，
- *   并向会话日志 append 一条 `allostasis/degeneration` 记录当时的判定依据。
+ * 三个能力落在两个挂载点上：
+ *
+ * · **一期 · 中文锚定**（`agent/pre-step`）：判定为语言漂移（英文功能词密度越线）就追加
+ *   一条中文锚定消息。
+ * · **二期 · 退化提醒**（`agent/pre-step`）：判定为推理退化（重复率越线且连续若干步成立）
+ *   就追加减速提醒。
+ * · **空回合检测**（`agent/turn-stopping`）：回合收尾时末条助手消息没有非空文本即判定成立，
+ *   `steer` 档位下追加一次补生成。
+ *
+ * **判定结果不写会话日志**。会话日志的事件词汇表 `KNOWN_SESSION_EVENT_TYPES` 由内核在构建期
+ * 生成，下游插件的事件类型不在其中；`Session.append()` 的封装
+ * （`packages/core/session/src/index.ts:744-750`）没有 `ignorable` 通道，而
+ * `SessionEvent.ignorable` 的契约要求这类「丢失不影响重建」的记录必须自带该标记
+ * （`packages/core/session/src/types.ts:501-511`）。缺标记的自定义类型会让**整份**日志在下次
+ * 加载时被拒读（`packages/session/session-persistence/src/storage-contract.ts:75-80`）——
+ * 2026-10-01 实测：dev 与装版各有会话因此打不开。判定输入本来就可重放（推理原文在
+ * `reasoning-chunks.texts`、回合边界在 `turn/start` / `turn/end`），留痕因此改由本模块的
+ * `console.debug` 诊断行与浏览器半边的提示承担；浏览器半边自行从事件流折叠判定，
+ * 见 `client/silent-turn.ts`。
+ *
+ * 前两个共用 `agent/pre-step`，因为它们读同一份输入——最近一条思考。空回合读的是另一种
+ * 输入（这一轮最终产出了什么），而且**它之后没有下一步**，`pre-step` 不会被再次调用，
+ * 判定只能落在回合收尾。
  *
  * **平时不出现、异常时才出现**——按需出现是它作为信号的前提。但异常持续时也不每个 step
  * 都提醒：同一 turn 至多一次，见 `throttle.ts`。两类提醒各有独立的一份节流状态：判据无关，
@@ -13,17 +31,19 @@
  *
  * 为什么不挂到 system prompt 前缀上：那是 `dsh-chinese-thinking` 的位置，它作为基线
  * 永远在场。而基线在长会话里会失效（固定前缀离输出最远，语言模式受近因支配）。本插件
- * 补的是「**你正在漂移 / 正在打转**」这个纠偏信号，因此必须落在近因位置。
+ * 补的是「**你正在漂移 / 正在打转 / 这一轮什么也没说**」这类纠偏信号，因此必须落在近因
+ * 或收尾位置。
  *
  * 为什么用 `agent/pre-step` 而不是 `systemPrompt.context()`：前者直接给出 `turn` /
  * `step`，且追加的是一条独立消息，落点比快照里的一个段更靠后。用法先例见官方
  * `packages/context/time-context/src/index.ts:180-220`。
  *
- * 阈值全部走 `config.ts` 的配置面。**压缩动作按设计方案 §九 暂缓**：数据指向退化样本
- * 散布在整段退化区间，而 `compactRegion` 只压指定区间，能否打断循环尚未验证。
+ * 阈值与档位全部走 `config.ts` 的配置面。**压缩动作按设计方案 §九 暂缓**：数据指向退化
+ * 样本散布在整段退化区间，而 `compactRegion` 只压指定区间，能否打断循环尚未验证。
  *
  * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md`、
- * `docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`
+ * `docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`、
+ * `docs/设计/2026-09-30-空回合检测与可见化.md`
  * @module @max-null/dsh-allostasis
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -31,7 +51,7 @@ import { anchorText } from './anchor.ts';
 import { Config } from './config.ts';
 import { name } from './name.ts';
 export { anchorText, Config, name };
-/** 需要 `agents` 服务来接收 `agent/pre-step` 事件。 */
+/** 需要 `agents` 服务来接收 `agent/pre-step` 与 `agent/turn-stopping` 事件。 */
 export declare const inject: string[];
 /**
  * 注册 pre-step 监听器；监听器随 `ctx` 生命周期销毁。

package/dist/index.js

@@ -1,11 +1,29 @@
 /**
  * 应变（allostasis）：会话状态的自我调节。
  *
- * 两期能力都落在同一个 `agent/pre-step` 上，因为它们读的是同一份输入——最近一条思考：
+ * 三个能力落在两个挂载点上：
  *
- * · **一期 · 中文锚定**：判定为语言漂移（英文功能词密度越线）就追加一条中文锚定消息。
- * · **二期 · 退化提醒**：判定为推理退化（重复率越线且连续若干步成立）就追加减速提醒，
- *   并向会话日志 append 一条 `allostasis/degeneration` 记录当时的判定依据。
+ * · **一期 · 中文锚定**（`agent/pre-step`）：判定为语言漂移（英文功能词密度越线）就追加
+ *   一条中文锚定消息。
+ * · **二期 · 退化提醒**（`agent/pre-step`）：判定为推理退化（重复率越线且连续若干步成立）
+ *   就追加减速提醒。
+ * · **空回合检测**（`agent/turn-stopping`）：回合收尾时末条助手消息没有非空文本即判定成立，
+ *   `steer` 档位下追加一次补生成。
+ *
+ * **判定结果不写会话日志**。会话日志的事件词汇表 `KNOWN_SESSION_EVENT_TYPES` 由内核在构建期
+ * 生成，下游插件的事件类型不在其中；`Session.append()` 的封装
+ * （`packages/core/session/src/index.ts:744-750`）没有 `ignorable` 通道，而
+ * `SessionEvent.ignorable` 的契约要求这类「丢失不影响重建」的记录必须自带该标记
+ * （`packages/core/session/src/types.ts:501-511`）。缺标记的自定义类型会让**整份**日志在下次
+ * 加载时被拒读（`packages/session/session-persistence/src/storage-contract.ts:75-80`）——
+ * 2026-10-01 实测：dev 与装版各有会话因此打不开。判定输入本来就可重放（推理原文在
+ * `reasoning-chunks.texts`、回合边界在 `turn/start` / `turn/end`），留痕因此改由本模块的
+ * `console.debug` 诊断行与浏览器半边的提示承担；浏览器半边自行从事件流折叠判定，
+ * 见 `client/silent-turn.ts`。
+ *
+ * 前两个共用 `agent/pre-step`，因为它们读同一份输入——最近一条思考。空回合读的是另一种
+ * 输入（这一轮最终产出了什么），而且**它之后没有下一步**，`pre-step` 不会被再次调用，
+ * 判定只能落在回合收尾。
  *
  * **平时不出现、异常时才出现**——按需出现是它作为信号的前提。但异常持续时也不每个 step
  * 都提醒：同一 turn 至多一次，见 `throttle.ts`。两类提醒各有独立的一份节流状态：判据无关，
@@ -13,30 +31,32 @@
  *
  * 为什么不挂到 system prompt 前缀上：那是 `dsh-chinese-thinking` 的位置，它作为基线
  * 永远在场。而基线在长会话里会失效（固定前缀离输出最远，语言模式受近因支配）。本插件
- * 补的是「**你正在漂移 / 正在打转**」这个纠偏信号，因此必须落在近因位置。
+ * 补的是「**你正在漂移 / 正在打转 / 这一轮什么也没说**」这类纠偏信号，因此必须落在近因
+ * 或收尾位置。
  *
  * 为什么用 `agent/pre-step` 而不是 `systemPrompt.context()`：前者直接给出 `turn` /
  * `step`，且追加的是一条独立消息，落点比快照里的一个段更靠后。用法先例见官方
  * `packages/context/time-context/src/index.ts:180-220`。
  *
- * 阈值全部走 `config.ts` 的配置面。**压缩动作按设计方案 §九 暂缓**：数据指向退化样本
- * 散布在整段退化区间，而 `compactRegion` 只压指定区间，能否打断循环尚未验证。
+ * 阈值与档位全部走 `config.ts` 的配置面。**压缩动作按设计方案 §九 暂缓**：数据指向退化
+ * 样本散布在整段退化区间，而 `compactRegion` 只压指定区间，能否打断循环尚未验证。
  *
  * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md`、
- * `docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`
+ * `docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`、
+ * `docs/设计/2026-09-30-空回合检测与可见化.md`
  * @module @max-null/dsh-allostasis
  */
 import { anchorText } from "./anchor.js";
 import { Config, resolveConfig } from "./config.js";
 import { measureThinking, verdict } from "./drift.js";
-import { degenerationEvent } from "./events.js";
-import { degenerationText, pluginNotice } from "./messages.js";
+import { degenerationText, pluginNotice, silentTurnText } from "./messages.js";
 import { name } from "./name.js";
 import { measureRepetition, repetitionVerdict, trackLoop } from "./repetition.js";
+import { measureTail, tailSamples, tailVerdict } from "./tail.js";
 import { latestThinking } from "./thinking.js";
 import { admitPerTurn } from "./throttle.js";
 export { anchorText, Config, name };
-/** 需要 `agents` 服务来接收 `agent/pre-step` 事件。 */
+/** 需要 `agents` 服务来接收 `agent/pre-step` 与 `agent/turn-stopping` 事件。 */
 export const inject = ['agents'];
 /**
  * 组装一期的语言漂移提醒。
@@ -57,7 +77,7 @@ function driftMessage(session, sample, resolved, throttles) {
     return pluginNotice(anchorText(sample.turn, sample.step, metrics, advanced.count), `语言漂移 · turn ${sample.turn} · 第 ${advanced.count} 次`);
 }
 /**
- * 组装二期的推理退化提醒，并落下判定依据。
+ * 组装二期的推理退化提醒。
  *
  * 追踪状态**每步都推进**，包括被节流挡住的那几步：计数描述的是退化本身持续了多久，
  * 与「这一步有没有说出口」无关。
@@ -79,16 +99,64 @@ function loopMessage(session, sample, resolved, trackers, throttles) {
     if (advanced === undefined)
         return undefined;
     throttles.set(session, advanced);
-    session.append('allostasis/degeneration', degenerationEvent({
-        turn: sample.turn,
-        step: sample.step,
-        metrics,
-        consecutive: tracked.state.consecutive,
-        threshold: resolved.repetitionThreshold,
-        required: resolved.consecutiveSteps,
-    }));
     return pluginNotice(degenerationText(sample.turn, sample.step, metrics, advanced.count), `推理退化 · turn ${sample.turn} · 重复率 ${(metrics.ratio * 100).toFixed(0)}%`);
 }
+/**
+ * 注册回合收尾监听：检出空回合；`steer` 档位下追加一次补生成。
+ *
+ * **为什么整段包 try/catch**：内核的契约测试写明该事件里抛出的异常会让 turn 以 error
+ * 结束（`packages/core/agent-loop/tests/contract-regressions.spec.ts:357`，loop 本身
+ * 存活）。判据失败不得升级成回合失败——与二期对 `compactRegion` 的要求同源。这里记
+ * `warn` 而不是 `debug`：它意味着判据本身坏了，与「这一步判成了什么」不是一类。
+ *
+ * **为什么要排除取消与子代理**：`aborted` / `interrupted` 回合的沉默是用户中止的预期
+ * 结果（实测 22 轮里 12 轮），子代理的回合属于父回复的中间产物——两者都不该计入空回合，
+ * 前者由 `signal.aborted` 判、后者由会话头的 `parentSession` 判，两条先例见
+ * `@changfenhuang/dsh-genui` 的 `fenceFeedback`。
+ *
+ * **补生成的记账发生在发送之前**：`turn-stopping` 是可能重入的边界，先记账才能保证同一次
+ * 补生成不会被投两遍——与 `fenceFeedback` 同一条约束。
+ *
+ * **补生成单独包一层 catch**：判定已经成立，补生成失败不该升级成回合失败。
+ * @param ctx - 插件上下文。
+ * @param resolved - 已校验的配置。
+ * @param steers - 补生成的节流状态表，按会话各一份。
+ */
+function installSilentTurn(ctx, resolved, steers) {
+    ctx.on('agent/turn-stopping', ({ agent, turn, signal }) => {
+        try {
+            if (resolved.silentTurn === 'off')
+                return;
+            if (signal.aborted)
+                return;
+            if (agent.session.header.parentSession !== undefined)
+                return;
+            const { session } = agent;
+            const shape = measureTail(tailSamples(session.snapshotEvents()), turn);
+            if (shape === undefined || tailVerdict(shape) !== 'silent')
+                return;
+            const plan = resolved.silentTurn === 'steer' ? admitPerTurn(steers.get(session), turn) : undefined;
+            if (plan !== undefined)
+                steers.set(session, plan);
+            console.debug(`[${name}] 空回合 · turn ${turn} step ${shape.step}`
+                + ` · reasoning ${shape.reasoningChars} 字`
+                + ` blocks=reasoning×${shape.blocks.reasoning} text×${shape.blocks.text}`
+                + ` tool×${shape.blocks.toolCalls}`
+                + ` steered=${plan !== undefined}`);
+            if (plan === undefined)
+                return;
+            try {
+                agent.steer(pluginNotice(silentTurnText(turn, shape), `空回合 · turn ${turn} · 补一次生成`));
+            }
+            catch (error) {
+                ctx.logger?.warn?.(`${name}: silent-turn steer failed (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
+        catch (error) {
+            ctx.logger?.warn?.(`${name}: silent-turn check failed (${error instanceof Error ? error.message : String(error)})`);
+        }
+    });
+}
 /**
  * 注册 pre-step 监听器；监听器随 `ctx` 生命周期销毁。
  *
@@ -104,11 +172,13 @@ export function apply(ctx, config = {}) {
     // 判定行走 debug，默认静默、排查时打开即可，不必为了看一眼判定去改阈值试。
     console.info(`[${name}] loaded · driftThreshold=${resolved.driftThreshold}`
         + ` repetitionThreshold=${resolved.repetitionThreshold}`
-        + ` consecutiveSteps=${resolved.consecutiveSteps}`);
+        + ` consecutiveSteps=${resolved.consecutiveSteps}`
+        + ` silentTurn=${resolved.silentTurn}`);
     /** 每个会话各一份状态；用 WeakMap 以免会话销毁后残留。 */
     const anchorThrottles = new WeakMap();
     const loopThrottles = new WeakMap();
     const loopTrackers = new WeakMap();
+    const silentSteers = new WeakMap();
     ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
         const decision = await next();
         if (decision.kind === 'reject' || signal.aborted)
@@ -136,4 +206,5 @@ export function apply(ctx, config = {}) {
             return decision;
         return { ...decision, messages: [...decision.messages, ...appended] };
     }, { prepend: true });
+    installSilentTurn(ctx, resolved, silentSteers);
 }

package/dist/messages.d.ts

@@ -20,6 +20,7 @@ import type { ContextFormed } from '@deepseek-ai/dsh-llm';
 import type { UserMessage } from '@deepseek-ai/dsh-session';
 import { SOURCE_KIND } from './name.ts';
 import type { RepetitionMetrics } from './repetition.ts';
+import type { TailShape } from './tail.ts';
 declare module '@deepseek-ai/dsh-llm' {
     interface MessageSourceMap {
         /** 应变注入的即时提醒：语言漂移锚定与推理退化提醒共用这一个生产者身份。 */
@@ -48,3 +49,14 @@ export declare function pluginNotice(text: string, summary: string): UserMessage
  * @returns 一条退化提醒消息的正文。
  */
 export declare function degenerationText(turn: number, step: number, metrics: RepetitionMetrics, reminder?: number): string;
+/**
+ * 组装空回合的补生成请求。
+ *
+ * 措辞对着**用户此刻的处境**写：他看到的是空白，所以先说清发生了什么，再给一条可执行的
+ * 出路。两条禁令是必要的——不点明「不要重做工具」，模型很可能把整轮动作再跑一遍，而这一轮
+ * 的产出已经不是用户缺的东西了。
+ * @param turn - 判定的回合号。
+ * @param shape - 该回合末条助手消息的产出形态。
+ * @returns 一条补生成请求的正文。
+ */
+export declare function silentTurnText(turn: number, shape: TailShape): string;

package/dist/messages.js

@@ -65,3 +65,25 @@ export function degenerationText(turn, step, metrics, reminder = 1) {
         + '现在检查手上已有的信息够不够完成任务——够就直接给结论，'
         + '不够就换一个与前面不同的动作去取，而不是把同一句话再写一遍。';
 }
+/**
+ * 组装空回合的补生成请求。
+ *
+ * 措辞对着**用户此刻的处境**写：他看到的是空白，所以先说清发生了什么，再给一条可执行的
+ * 出路。两条禁令是必要的——不点明「不要重做工具」，模型很可能把整轮动作再跑一遍，而这一轮
+ * 的产出已经不是用户缺的东西了。
+ * @param turn - 判定的回合号。
+ * @param shape - 该回合末条助手消息的产出形态。
+ * @returns 一条补生成请求的正文。
+ */
+export function silentTurnText(turn, shape) {
+    const produced = shape.reasoningChars > 0
+        ? `只生成了推理（${shape.reasoningChars} 字），没有文本`
+        : '没有产出任何内容';
+    const tools = shape.blocks.toolCalls > 0
+        ? `，另有 ${shape.blocks.toolCalls} 个工具调用`
+        : '，也没有工具调用';
+    return `⚠️ 空回合（应变）：turn ${turn} 的最后一步${produced}${tools}。`
+        + '用户此刻看到的是一串折叠的操作条，然后什么都没有——他不知道这一轮发生了什么。'
+        + '用一两句话补上：这一轮得出的结论、以及下一步需要他做什么。'
+        + '不要重做已经执行过的工具调用，也不要复述推理里的过程。';
+}

package/dist/tail.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 回合末步的产出形态判定（空回合检测的判据）。
+ *
+ * 落点：`assistant/message` 事件的 `message.content` —— 与 `thinking.ts` 读同一个事件的
+ * 另一个字段（那边读 `stream` 里的 `reasoning-chunks`，这里读 `content` 的块构成）。
+ *
+ * 判据 = **本 turn 最后一条助手消息里没有非空 text 块**。
+ *
+ * 实测依据（2026-09-30，14 天内 1202 个 `completed` 回合）：完成态结尾沉默 34 轮
+ * （2.8%），其中 **32 轮的末步只有 `reasoning`** —— 判据纯度 94%，误报面小。
+ * `aborted` / `interrupted` 的沉默另有 15 轮，但那是用户中止的预期结果，**不在判据内**：
+ * 调用方按 `signal.aborted` 排除，见 `index.ts` 的 turn-stopping 监听。
+ *
+ * 为什么读 `content` 而不是 `stream`：`stream` 里的 `text-chunks` 回答「模型有没有生成过
+ * 文本」，`content` 回答「这一步最终产出了什么」。判据要的是后者，前者只在排查时用来
+ * 交叉验证（设计文档 §2.2）。
+ *
+ * 设计出处：`docs/设计/2026-09-30-空回合检测与可见化.md` §二
+ * @module @max-null/dsh-allostasis/tail
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/** 空回合兜底的档位：`off` 不判定，`observe` 判定并留痕，`steer` 额外补一次生成。 */
+export type SilentTurnMode = 'off' | 'observe' | 'steer';
+/** 全部档位，供配置校验枚举。 */
+export declare const SILENT_TURN_MODES: readonly SilentTurnMode[];
+/**
+ * 空回合兜底的档位缺省值。
+ *
+ * `observe` 而不是 `off`：判定与留痕必须先跑起来，否则「这个现象有多频繁、判据准不准」
+ * 永远没有数据。补生成（`steer`）要等到有数据说明它值得开之后再加。
+ */
+export declare const SILENT_TURN_MODE: SilentTurnMode;
+/** 判定只需要块的类型与文本；用最小形状接收，判据模块因此不依赖会话包的内容类型。 */
+export interface TailBlock {
+    /** 块类型：`reasoning` / `text` / `tool-call`。 */
+    readonly type: string;
+    /** 文本与推理块的正文；工具调用块没有这个字段。 */
+    readonly text?: string;
+}
+/** 一条助手消息的产出形态。 */
+export interface TailShape {
+    /** 该消息所属的 turn。 */
+    readonly turn: number;
+    /** 该消息所属的 step。 */
+    readonly step: number;
+    /** 非空 `text` 块的总字符数。空回合恒为 0。 */
+    readonly textChars: number;
+    /** `reasoning` 块的总字符数——区分「想了很久没说」与「完全没输出」。 */
+    readonly reasoningChars: number;
+    /** 按类型的块计数。 */
+    readonly blocks: {
+        readonly reasoning: number;
+        readonly text: number;
+        readonly toolCalls: number;
+    };
+}
+/**
+ * 三态判定。`unknown` 用于「本回合没有助手消息」——比如用户消息刚落下、助手还没产出，
+ * 此时既不能说它说了话，也不能说它是空回合。
+ */
+export type TailVerdict = 'spoke' | 'silent' | 'unknown';
+/**
+ * 统计一条助手消息的块构成。
+ *
+ * `text` 按去掉首尾空白后的长度计入：只含空白的文本块在界面上不产生任何可见内容，
+ * 把它算作「说了话」会让判据漏掉真实的空回合。
+ * @param turn - 该消息所属的 turn。
+ * @param step - 该消息所属的 step。
+ * @param content - 助手消息的内容块，按出现顺序。
+ * @returns 该消息的产出形态。
+ */
+export declare function shapeOf(turn: number, step: number, content: readonly TailBlock[]): TailShape;
+/** 从会话事件里取出的助手消息样本：判定只读这三个字段。 */
+export interface TailSample {
+    /** 该消息所属的 turn。 */
+    readonly turn: number;
+    /** 该消息所属的 step。 */
+    readonly step: number;
+    /** 内容块，按出现顺序。 */
+    readonly content: readonly TailBlock[];
+}
+/**
+ * 把会话事件收窄成判定样本。
+ *
+ * 与 {@link measureTail} 分成两步，是为了让判定完全落在纯函数上：`SessionEvent` 是
+ * 所有事件的联合，拿它当参数就得在测试里伪造整个事件（含 `usage` / `stream`），
+ * 或者用类型断言把缺口盖掉。收窄只在这里做一次。
+ * @param events - 会话事件，按 seq 升序。
+ * @returns 助手消息样本，保持原顺序；其它类型的事件被跳过。
+ */
+export declare function tailSamples(events: readonly SessionEvent[]): TailSample[];
+/**
+ * 取本 turn **最后一条**助手消息的产出形态。
+ *
+ * 倒扫而不是取「最后一条样本」：会话里可能夹着别的 turn 的助手消息（中断后的残留、
+ * 子代理的投递），而判定要问的是「这一轮结束时用户看到了什么」。
+ * @param samples - {@link tailSamples} 的产出。
+ * @param turn - 要检查的 turn。
+ * @returns 末条助手消息的形态；该 turn 没有助手消息时返回 `undefined`。
+ */
+export declare function measureTail(samples: readonly TailSample[], turn: number): TailShape | undefined;
+/**
+ * 对一次测量下判定。
+ *
+ * 只有「有助手消息且它没有非空文本」才算空回合。工具调用**不**改变判定：一个以
+ * `tool-call` 结尾的完成态回合同样是异常（工具执行完还会再走一步，除非回合已经结束）。
+ * @param shape - 末条助手消息的形态；没有助手消息时传 `undefined`。
+ * @returns 三态判定。
+ */
+export declare function tailVerdict(shape: TailShape | undefined): TailVerdict;

package/dist/tail.js

@@ -0,0 +1,111 @@
+/**
+ * 回合末步的产出形态判定（空回合检测的判据）。
+ *
+ * 落点：`assistant/message` 事件的 `message.content` —— 与 `thinking.ts` 读同一个事件的
+ * 另一个字段（那边读 `stream` 里的 `reasoning-chunks`，这里读 `content` 的块构成）。
+ *
+ * 判据 = **本 turn 最后一条助手消息里没有非空 text 块**。
+ *
+ * 实测依据（2026-09-30，14 天内 1202 个 `completed` 回合）：完成态结尾沉默 34 轮
+ * （2.8%），其中 **32 轮的末步只有 `reasoning`** —— 判据纯度 94%，误报面小。
+ * `aborted` / `interrupted` 的沉默另有 15 轮，但那是用户中止的预期结果，**不在判据内**：
+ * 调用方按 `signal.aborted` 排除，见 `index.ts` 的 turn-stopping 监听。
+ *
+ * 为什么读 `content` 而不是 `stream`：`stream` 里的 `text-chunks` 回答「模型有没有生成过
+ * 文本」，`content` 回答「这一步最终产出了什么」。判据要的是后者，前者只在排查时用来
+ * 交叉验证（设计文档 §2.2）。
+ *
+ * 设计出处：`docs/设计/2026-09-30-空回合检测与可见化.md` §二
+ * @module @max-null/dsh-allostasis/tail
+ */
+/** 全部档位，供配置校验枚举。 */
+export const SILENT_TURN_MODES = ['off', 'observe', 'steer'];
+/**
+ * 空回合兜底的档位缺省值。
+ *
+ * `observe` 而不是 `off`：判定与留痕必须先跑起来，否则「这个现象有多频繁、判据准不准」
+ * 永远没有数据。补生成（`steer`）要等到有数据说明它值得开之后再加。
+ */
+export const SILENT_TURN_MODE = 'observe';
+/**
+ * 统计一条助手消息的块构成。
+ *
+ * `text` 按去掉首尾空白后的长度计入：只含空白的文本块在界面上不产生任何可见内容，
+ * 把它算作「说了话」会让判据漏掉真实的空回合。
+ * @param turn - 该消息所属的 turn。
+ * @param step - 该消息所属的 step。
+ * @param content - 助手消息的内容块，按出现顺序。
+ * @returns 该消息的产出形态。
+ */
+export function shapeOf(turn, step, content) {
+    let textChars = 0;
+    let reasoningChars = 0;
+    const blocks = { reasoning: 0, text: 0, toolCalls: 0 };
+    for (const block of content) {
+        if (block.type === 'reasoning') {
+            blocks.reasoning += 1;
+            reasoningChars += block.text?.length ?? 0;
+        }
+        else if (block.type === 'text') {
+            blocks.text += 1;
+            textChars += block.text?.trim().length ?? 0;
+        }
+        else if (block.type === 'tool-call') {
+            blocks.toolCalls += 1;
+        }
+    }
+    return { turn, step, textChars, reasoningChars, blocks };
+}
+/**
+ * 把会话事件收窄成判定样本。
+ *
+ * 与 {@link measureTail} 分成两步，是为了让判定完全落在纯函数上：`SessionEvent` 是
+ * 所有事件的联合，拿它当参数就得在测试里伪造整个事件（含 `usage` / `stream`），
+ * 或者用类型断言把缺口盖掉。收窄只在这里做一次。
+ * @param events - 会话事件，按 seq 升序。
+ * @returns 助手消息样本，保持原顺序；其它类型的事件被跳过。
+ */
+export function tailSamples(events) {
+    const samples = [];
+    for (const event of events) {
+        if (event.type !== 'assistant/message')
+            continue;
+        samples.push({
+            turn: event.data.turn,
+            step: event.data.step,
+            content: event.data.message.content,
+        });
+    }
+    return samples;
+}
+/**
+ * 取本 turn **最后一条**助手消息的产出形态。
+ *
+ * 倒扫而不是取「最后一条样本」：会话里可能夹着别的 turn 的助手消息（中断后的残留、
+ * 子代理的投递），而判定要问的是「这一轮结束时用户看到了什么」。
+ * @param samples - {@link tailSamples} 的产出。
+ * @param turn - 要检查的 turn。
+ * @returns 末条助手消息的形态；该 turn 没有助手消息时返回 `undefined`。
+ */
+export function measureTail(samples, turn) {
+    for (let index = samples.length - 1; index >= 0; index -= 1) {
+        const sample = samples[index];
+        if (sample === undefined || sample.turn !== turn)
+            continue;
+        return shapeOf(sample.turn, sample.step, sample.content);
+    }
+    return undefined;
+}
+/**
+ * 对一次测量下判定。
+ *
+ * 只有「有助手消息且它没有非空文本」才算空回合。工具调用**不**改变判定：一个以
+ * `tool-call` 结尾的完成态回合同样是异常（工具执行完还会再走一步，除非回合已经结束）。
+ * @param shape - 末条助手消息的形态；没有助手消息时传 `undefined`。
+ * @returns 三态判定。
+ */
+export function tailVerdict(shape) {
+    if (shape === undefined)
+        return 'unknown';
+    return shape.textChars > 0 ? 'spoke' : 'silent';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-allostasis",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "应变（allostasis）：会话状态的自我调节。第一期：中文思考的漂移检测与近因锚定",
   "license": "MIT",
   "publishConfig": {
@@ -13,16 +13,26 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./client": "./dist/client.js"
   },
   "files": [
     "dist",
     "cordis.patch.yml",
-    "tools"
+    "tools",
+    "docs/shots"
   ],
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
     }
   },
   "keywords": [
@@ -42,7 +52,7 @@
     "url": "git+https://github.com/Max-Null/dsh-allostasis.git"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && tsdown",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "vitest run",
     "prepublishOnly": "npm run build"
@@ -57,13 +67,16 @@
     "@deepseek-ai/dsh-session": ">=0.1.7-rc.1 <0.3.0"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
-    "tsx": "^4.0.0",
-    "typescript": "^5.5.0",
-    "vitest": "^2.1.0",
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-agent": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.7-rc.2"
+    "@deepseek-ai/dsh-session": "^0.1.7-rc.2",
+    "@types/node": "^26.2.0",
+    "@types/react": "~18.3.31",
+    "react": "^18.3.1",
+    "tsdown": "^0.22.14",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.1.0"
   }
 }

package/dist/events.d.ts

@@ -1,67 +0,0 @@
-/**
- * 退化触发的会话事件——「插件当时判了什么」的落盘。
- *
- * 判定输入本来就可重放（推理原文在日志的 `reasoning-chunks.texts`，占用与压缩点在
- * `data.usage` / `compaction/start`），所以「如果当时阈值是 X 会怎样」能离线回答。
- * 缺的是**插件实际用过的阈值与判定结果**：只靠重算，复盘的是「按现在的脚本判会怎样」，
- * 不是「插件当时判了什么」，两个口径会随时间漂移。这个事件补的就是这道缝
- * （设计方案 §4.3 选项 A）。
- *
- * `SessionEventMap` 是 merge-extensible 的，内核的会话 invariant 对未知事件类型直接
- * 放行——「Merge-extensible event relations belong to their owning plugin」
- * （`packages/core/session/src/invariant.ts:165-167`），因此这里不需要在内核侧登记。
- *
- * @module @max-null/dsh-allostasis/events
- */
-import type { RepetitionMetrics } from './repetition.ts';
-declare module '@deepseek-ai/dsh-session/types' {
-    interface SessionEventMap {
-        /** 一次退化触发；只记录判定，不记录干预——压缩动作是否发生由压缩事件自己回答。 */
-        'allostasis/degeneration': DegenerationEvent;
-    }
-}
-/** 落盘时每个重复单元的截断长度；够复盘看出重复的是什么，又不让日志被碎片撑大。 */
-export declare const UNIT_SAMPLE_MAX_CHARS = 80;
-/** {@link degenerationEvent} 的输入。 */
-export interface DegenerationTrigger {
-    /** 产出该推理的 turn。 */
-    readonly turn: number;
-    /** 产出该推理的 step。 */
-    readonly step: number;
-    /** 该步的重复度量化结果。 */
-    readonly metrics: RepetitionMetrics;
-    /** 已连续越线的步数。 */
-    readonly consecutive: number;
-    /** 判定所用的重复率阈值。 */
-    readonly threshold: number;
-    /** 触发所需的连续步数。 */
-    readonly required: number;
-}
-/** `allostasis/degeneration` 的 payload：一次触发的完整判定依据。 */
-export interface DegenerationEvent {
-    /** 产出该推理的 turn。 */
-    turn: number;
-    /** 产出该推理的 step。 */
-    step: number;
-    /** 触发时的重复率。 */
-    ratio: number;
-    /** 单元总数，即重复率的样本量。 */
-    units: number;
-    /** 已连续越线的步数。 */
-    consecutive: number;
-    /** 判定所用的重复率阈值。 */
-    threshold: number;
-    /** 触发所需的连续步数。 */
-    required: number;
-    /** 最高频的重复单元，按出现次数降序，单元已截断。 */
-    top: Array<{
-        unit: string;
-        count: number;
-    }>;
-}
-/**
- * 把一次触发整理成事件 payload。
- * @param trigger - 触发时的判定依据。
- * @returns 可直接交给 `session.append` 的 payload。
- */
-export declare function degenerationEvent(trigger: DegenerationTrigger): DegenerationEvent;

package/dist/events.js

@@ -1,40 +0,0 @@
-/**
- * 退化触发的会话事件——「插件当时判了什么」的落盘。
- *
- * 判定输入本来就可重放（推理原文在日志的 `reasoning-chunks.texts`，占用与压缩点在
- * `data.usage` / `compaction/start`），所以「如果当时阈值是 X 会怎样」能离线回答。
- * 缺的是**插件实际用过的阈值与判定结果**：只靠重算，复盘的是「按现在的脚本判会怎样」，
- * 不是「插件当时判了什么」，两个口径会随时间漂移。这个事件补的就是这道缝
- * （设计方案 §4.3 选项 A）。
- *
- * `SessionEventMap` 是 merge-extensible 的，内核的会话 invariant 对未知事件类型直接
- * 放行——「Merge-extensible event relations belong to their owning plugin」
- * （`packages/core/session/src/invariant.ts:165-167`），因此这里不需要在内核侧登记。
- *
- * @module @max-null/dsh-allostasis/events
- */
-/** 落盘时每个重复单元的截断长度；够复盘看出重复的是什么，又不让日志被碎片撑大。 */
-export const UNIT_SAMPLE_MAX_CHARS = 80;
-/**
- * 把一次触发整理成事件 payload。
- * @param trigger - 触发时的判定依据。
- * @returns 可直接交给 `session.append` 的 payload。
- */
-export function degenerationEvent(trigger) {
-    const { metrics } = trigger;
-    return {
-        turn: trigger.turn,
-        step: trigger.step,
-        ratio: metrics.ratio,
-        units: metrics.units,
-        consecutive: trigger.consecutive,
-        threshold: trigger.threshold,
-        required: trigger.required,
-        top: metrics.top.map(entry => ({
-            unit: entry.unit.length <= UNIT_SAMPLE_MAX_CHARS
-                ? entry.unit
-                : `${entry.unit.slice(0, UNIT_SAMPLE_MAX_CHARS)}…`,
-            count: entry.count,
-        })),
-    };
-}