@max-null/dsh-allostasis 0.1.0 → 0.2.0

package/README.md

@@ -5,9 +5,9 @@
 This plugin belongs to the **`@max-null/*` family** — a set of plugins that together form the **[SSID (思灵 · Seek Soul in Darkness)](https://github.com/Max-Null/seek-soul-in-darkness)** desktop experience.
 
 Allostasis for the DeepSeek Harness — session self-regulation rather than monitoring.
-Its first capability is **Chinese anchoring**: before each step it reads the most recent
-reasoning block, and when that thinking has drifted into English it appends one near-end
-message to bring it back.
+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**).
 
 ## 它做什么
 
@@ -16,10 +16,27 @@ message to bring it back.
 | 能力 | 状态 | 触发条件 |
 |---|---|---|
 | **中文锚定** | **已实现** | 上一步思考的英文功能词密度越线 |
+| **推理退化提醒** | **已实现** | 上一步思考的重复率越线，且连续 N 步成立 |
 | 上下文占用感知 | 计划中 | 需先定「什么情况下才出现」（持续在场会退化成背景音） |
-| 压缩预约落盘 | 计划中 | 待通路验证：`turn/end` → `whenIdle()` → `compactNow()` |
+| 压缩预约落盘 | 计划中 | 待通路验证：退化样本散布在整段退化区间，「只压一小段」能否打断循环尚无证据（二期方案 §八.1） |
 
-判据来源、实测数据与完整设计见 `docs/设计/2026-09-20-应变-设计方案.md`。
+两类提醒都以 `notice` 形式注入——在**轨迹页**是折叠态就显示一行摘要的注入行，不弹窗、不打断；
+**对话页不显示**（2026-09-29 在 SSiD dev / DSH 0.2.0-rc.1 上实测，口径见二期方案 §九）。
+退化触发时还会 append 一条 `allostasis/degeneration` 事件，记下当时的重复率、阈值与连续步数，
+因此「插件当时判了什么、用的什么阈值」可事后重建。
+
+**它全程静默，所以「确认它在工作」只能靠日志。** 本插件没有任何界面元素，命中时也只在轨迹页留一行；不命中时一个字都不说——「装了没有」「阈值生效没有」「这一步为什么没提醒」三个问题原本都无从回答，只能靠改配置去试。因此它在 `src/index.ts` 的 `apply` 里留两行痕：
+
+```
+[dsh-allostasis] loaded · driftThreshold=0.15 repetitionThreshold=0.5 consecutiveSteps=2
+[dsh-allostasis] turn 8 step 11 · drift=chinese funcDensity=0.6% chars=1764
+                 · repetition=normal units=29 ratio=0%
+```
+
+第一行 `info`、每个进程一次，报的是**生效阈值**（`Config` 的解析结果，不是代码里的缺省常量）。第二行 `debug`、**每一步判定一行**：两类判据的三态结论加度量。默认静默，排查时打开即可——不必为了看一眼判定结果去动阈值。其中 `units` 是切分后的单元数，**低于 12 判 `insufficient`**（样本不足不下结论），此时 `ratio` 仍会给出，只是不参与判定。
+
+判据来源、实测数据与完整设计见 `docs/设计/2026-09-20-应变-设计方案.md`、
+`docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`。
 
 ## 为什么需要它
 
@@ -29,6 +46,10 @@ message to bring it back.
 
 ## 判据
 
+两类提醒各有一个纯函数判据，都在 `src/` 下，都附实测依据。
+
+### 语言漂移
+
 **英文功能词密度** =（`the` / `is` / `are` / `and` / `of` / `to` / `that` 这类功能词数）/ 英文词数，**且英文词数 ≥ 50 才判定**。
 
 实测数据（一份 10 turn / 157 step 的真实会话）：中文期中位 **0.012**、英文期中位 **0.273–0.389**，阈值 **0.15** 使两群完全分离。词数门槛不可省——中文期唯一的越线点只有 26 个英文词，小样本会让密度失真。
@@ -37,9 +58,19 @@ message to bring it back.
 
 阈值由 `tools/analyze-thinking-lang.mjs` 在一份真实会话上标定，该工具随包发布。
 
+### 推理退化
+
+**重复率** = 单条推理按换行与中英句读切分后，**出现 ≥3 次的单元占全部单元的比例**；**单元数 ≥ 12 才判定**，**连续 N 步（默认 2）越线才触发**。
+
+实测数据（一份 19 轮 / 416 条助手消息的真实会话）：正常期 **0%–35%**、退化期 **48%–92%**，阈值 **0.5** 落在隔离带中段。连续步数不可省——正常期也有单次抖动（实测峰值 35%）；代价是延迟，按同一份数据回放会晚约 3 步触发。
+
+**退化与上下文占用脱钩**：同一会话里 26.1% 占用时重复率 84%、67.9% 时 83–92%，压缩到 26.1% 并不降低重复率。所以「调低阈值」治不了它；压缩能否治它取决于力度。完整数据见 `docs/排查/2026-09-28-推理退化与上下文占用脱钩.md`。
+
+退化触发时除提醒消息外还会 append 一条 `allostasis/degeneration` 事件，记下当时的重复率、阈值与连续步数——判定依据因此可事后重建，而不是只能按现在的脚本重算。
+
 ## 截图
 
-本插件是**会话行为调节类**：不新增任何按钮、面板或设置项。它在会话过程中读取思考的语言，漂移时向请求末尾追加一条提醒，效果体现在模型行为上。
+本插件是**会话行为调节类**：不新增任何按钮、面板或设置项。它每个 step 前读取最近一条思考，判定为语言漂移或推理退化时向请求末尾追加一条提醒，效果体现在模型行为上。
 
 > 按《SSiD 开发手册》§9 截图规范：截图须回答「装完会多出/变成什么」的**入口与面板**。
 > 本插件无界面元素（no UI surface），故**不适用**该项要求，改以上述行为效果说明代替。
@@ -57,7 +88,24 @@ Installs as a bundle: `dsh plugin --profile <name> add @max-null/dsh-allostasis`
 
 ## Config
 
-第一期没有配置项；阈值与门槛是经过标定的常量，写在 `src/drift.ts` 里并附实测依据。
+三个判定阈值可在 `config` 段覆盖；省略即用括号内的默认值。
+
+| 字段 | 默认 | 含义 |
+|---|---|---|
+| `driftThreshold` | `0.15` | 英文功能词密度达到此值即判为漂移 |
+| `repetitionThreshold` | `0.5` | 推理重复率阈值，取值 0–1 |
+| `consecutiveSteps` | `2` | 连续多少步越线才触发退化提醒 |
+
+```yaml
+- id: allostasis
+  name: '@max-null/dsh-allostasis'
+  config:
+    repetitionThreshold: 0.6
+```
+
+判据里的**小样本门槛**（`MIN_WORDS` / `MIN_UNITS` / `REPEAT_MIN_COUNT`）不是配置项——它们不是偏好，改了就是把密度与比例算飞。值域外的取值会让插件**报错中止**而不是静默回退：静默回退会让「我明明改了配置」与「插件按默认值跑」同时成立而无从察觉。
+
+这几个阈值都是**起点值而非标定结果**——单会话样本给出的隔离带中段，标定留给数据积累（设计方案 §5.1 的三条路：显性配置项、数据积累、LLM 自调）。
 
 ## Develop
 

package/cordis.patch.yml

@@ -1,6 +1,10 @@
 # dsh-allostasis bundle patch: one insert over the profile root.
 # `system-prompt` / `agents` / `token-meter` already live in the host (dsh-base);
 # this adds only the allostasis plugin, which registers its own reminders.
+#
+# `config` 可覆盖三个判定阈值：driftThreshold / repetitionThreshold / consecutiveSteps。
+# 字段都可省略，省略即用插件内的默认值——这里刻意不写具体值，免得默认值有两个来源。
+# 各字段的含义、取值范围与默认值见 README 的「配置」段。
 - insert:
     - id: allostasis
       name: '@max-null/dsh-allostasis'

package/dist/config.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 插件的可配置面。
+ *
+ * 只暴露**判定阈值**这一类值：它们是「宁可晚一点也别误报」这条取舍的刻度，随任务类型
+ * 与模型行为漂移，属于部署间会变的选择（DSH 插件规范 "No hardcoded tunables in
+ * plugins"）。判据里的小样本门槛（`MIN_WORDS` / `MIN_UNITS` / `REPEAT_MIN_COUNT`）
+ * 不在此列——它们不是偏好，改了就是把密度与比例算飞，属于判据几何的一部分。
+ *
+ * **schema 只管形式，缺省与范围在 `resolveConfig`**：两处各管一半是有意的。schema 用
+ * `.default()` 会让输出类型变成 `number | Volatile<number>`（默认值允许是动态函数），
+ * 与接口对不上，内核自己也要在那里补 `as Schema<T>` 断言；而缺省值有两个来源之后，
+ * 「我明明改了配置」与「插件按默认值跑」就能同时成立而无从察觉。缺省值就是判据模块里的
+ * 常量本身，因此不配置时行为与配置前逐字一致。
+ *
+ * @module @max-null/dsh-allostasis/config
+ */
+import Schema from '@deepseek-ai/schemastery';
+/**
+ * 插件配置，与同名 schemastery schema 一起由 Loader 校验。
+ *
+ * 值域外的取值在 `resolveConfig` 里**报错中止**，不静默回退。
+ */
+export interface Config {
+    /** 英文功能词密度达到此值即判为漂移（默认 0.15）。实测中文期中位 0.012、英文期 0.273 以上。 */
+    driftThreshold?: number;
+    /** 重复率阈值，0–1（默认 0.5）。取 1 等于事实上关闭退化提醒。 */
+    repetitionThreshold?: number;
+    /** 连续多少步越线才触发退化提醒（默认 2）。取 1 会跟着正常期的单次抖动误报。 */
+    consecutiveSteps?: number;
+}
+/** {@link Config} 经校验后的形态：字段齐全，可直接参与判定。 */
+export interface ResolvedConfig {
+    /** 见 {@link Config.driftThreshold}。 */
+    readonly driftThreshold: number;
+    /** 见 {@link Config.repetitionThreshold}。 */
+    readonly repetitionThreshold: number;
+    /** 见 {@link Config.consecutiveSteps}。 */
+    readonly consecutiveSteps: number;
+}
+/** Loader 用于校验 `cordis.patch.yml` 里 `config` 段的 schema。 */
+export declare const Config: Schema<Config>;
+/**
+ * 校验配置并补齐缺省值。
+ *
+ * 范围约束不交给 schema 的 `.min()/.max()`：那样报错只会说「number」，而说出该字段的
+ * 合理区间与收到的实际值，正是 fail-loud 的全部价值。
+ * @param config - Loader 传入的配置；未配置时传 `undefined` 或 `{}`。
+ * @returns 字段齐全且已校验的配置。
+ */
+export declare function resolveConfig(config?: Config): ResolvedConfig;

package/dist/config.js

@@ -0,0 +1,54 @@
+/**
+ * 插件的可配置面。
+ *
+ * 只暴露**判定阈值**这一类值：它们是「宁可晚一点也别误报」这条取舍的刻度，随任务类型
+ * 与模型行为漂移，属于部署间会变的选择（DSH 插件规范 "No hardcoded tunables in
+ * plugins"）。判据里的小样本门槛（`MIN_WORDS` / `MIN_UNITS` / `REPEAT_MIN_COUNT`）
+ * 不在此列——它们不是偏好，改了就是把密度与比例算飞，属于判据几何的一部分。
+ *
+ * **schema 只管形式，缺省与范围在 `resolveConfig`**：两处各管一半是有意的。schema 用
+ * `.default()` 会让输出类型变成 `number | Volatile<number>`（默认值允许是动态函数），
+ * 与接口对不上，内核自己也要在那里补 `as Schema<T>` 断言；而缺省值有两个来源之后，
+ * 「我明明改了配置」与「插件按默认值跑」就能同时成立而无从察觉。缺省值就是判据模块里的
+ * 常量本身，因此不配置时行为与配置前逐字一致。
+ *
+ * @module @max-null/dsh-allostasis/config
+ */
+import Schema from '@deepseek-ai/schemastery';
+import { DRIFT_THRESHOLD } from "./drift.js";
+import { CONSECUTIVE_STEPS, REPETITION_THRESHOLD } from "./repetition.js";
+/** Loader 用于校验 `cordis.patch.yml` 里 `config` 段的 schema。 */
+export const Config = Schema.object({
+    driftThreshold: Schema.number(),
+    repetitionThreshold: Schema.number(),
+    consecutiveSteps: Schema.number(),
+});
+/**
+ * 校验一个 0–1 的阈值字段。
+ * @param field - 字段名，用于报错文案。
+ * @param value - 字段值。
+ * @returns 校验通过的原值。
+ */
+function ratio(field, value) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`dsh-allostasis: \`${field}\` must be a number between 0 and 1, got ${value}`);
+    }
+    return value;
+}
+/**
+ * 校验配置并补齐缺省值。
+ *
+ * 范围约束不交给 schema 的 `.min()/.max()`：那样报错只会说「number」，而说出该字段的
+ * 合理区间与收到的实际值，正是 fail-loud 的全部价值。
+ * @param config - Loader 传入的配置；未配置时传 `undefined` 或 `{}`。
+ * @returns 字段齐全且已校验的配置。
+ */
+export function resolveConfig(config = {}) {
+    const driftThreshold = ratio('driftThreshold', config.driftThreshold ?? DRIFT_THRESHOLD);
+    const repetitionThreshold = ratio('repetitionThreshold', config.repetitionThreshold ?? REPETITION_THRESHOLD);
+    const consecutiveSteps = config.consecutiveSteps ?? CONSECUTIVE_STEPS;
+    if (!Number.isInteger(consecutiveSteps) || consecutiveSteps < 1) {
+        throw new Error(`dsh-allostasis: \`consecutiveSteps\` must be an integer >= 1, got ${consecutiveSteps}`);
+    }
+    return { driftThreshold, repetitionThreshold, consecutiveSteps };
+}

package/dist/drift.d.ts

@@ -38,5 +38,10 @@ export interface DriftMetrics {
 export type DriftVerdict = 'drift' | 'chinese' | 'insufficient';
 /** 统计一条思考文本的各量。空文本返回全零。 */
 export declare function measureThinking(text: string): DriftMetrics;
-/** 对一次测量下判定。 */
-export declare function verdict(metrics: DriftMetrics): DriftVerdict;
+/**
+ * 对一次测量下判定。
+ * @param metrics - 量化结果。
+ * @param threshold - 功能词密度阈值；缺省用 {@link DRIFT_THRESHOLD}。
+ * @returns 三态判定。
+ */
+export declare function verdict(metrics: DriftMetrics, threshold?: number): DriftVerdict;

package/dist/drift.js

@@ -40,9 +40,14 @@ export function measureThinking(text) {
         funcDensity: words.length === 0 ? 0 : funcWords / words.length,
     };
 }
-/** 对一次测量下判定。 */
-export function verdict(metrics) {
+/**
+ * 对一次测量下判定。
+ * @param metrics - 量化结果。
+ * @param threshold - 功能词密度阈值；缺省用 {@link DRIFT_THRESHOLD}。
+ * @returns 三态判定。
+ */
+export function verdict(metrics, threshold = DRIFT_THRESHOLD) {
     if (metrics.words < MIN_WORDS)
         return 'insufficient';
-    return metrics.funcDensity >= DRIFT_THRESHOLD ? 'drift' : 'chinese';
+    return metrics.funcDensity >= threshold ? 'drift' : 'chinese';
 }

package/dist/events.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 退化触发的会话事件——「插件当时判了什么」的落盘。
+ *
+ * 判定输入本来就可重放（推理原文在日志的 `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

@@ -0,0 +1,40 @@
+/**
+ * 退化触发的会话事件——「插件当时判了什么」的落盘。
+ *
+ * 判定输入本来就可重放（推理原文在日志的 `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,
+        })),
+    };
+}

package/dist/index.d.ts

@@ -1,33 +1,43 @@
 /**
  * 应变（allostasis）：会话状态的自我调节。
  *
- * 第一期只实现一个能力——**中文锚定**：每个 step 之前读最近一条思考，若判定为语言
- * 漂移（英文功能词密度越线），就在请求末尾追加一条中文锚定消息。**平时不出现、漂移
- * 时才出现**——按需出现是它作为信号的前提。但漂移持续时也不每个 step 都提醒：同一
- * turn 至多一次，见 `throttle.ts`。
+ * 两期能力都落在同一个 `agent/pre-step` 上，因为它们读的是同一份输入——最近一条思考：
+ *
+ * · **一期 · 中文锚定**：判定为语言漂移（英文功能词密度越线）就追加一条中文锚定消息。
+ * · **二期 · 退化提醒**：判定为推理退化（重复率越线且连续若干步成立）就追加减速提醒，
+ *   并向会话日志 append 一条 `allostasis/degeneration` 记录当时的判定依据。
+ *
+ * **平时不出现、异常时才出现**——按需出现是它作为信号的前提。但异常持续时也不每个 step
+ * 都提醒：同一 turn 至多一次，见 `throttle.ts`。两类提醒各有独立的一份节流状态：判据无关，
+ * 共用状态会让先说的那类把另一类挡在门外。
  *
  * 为什么不挂到 system prompt 前缀上：那是 `dsh-chinese-thinking` 的位置，它作为基线
  * 永远在场。而基线在长会话里会失效（固定前缀离输出最远，语言模式受近因支配）。本插件
- * 补的是「**你正在漂移**」这个纠偏信号，因此必须落在近因位置。
+ * 补的是「**你正在漂移 / 正在打转**」这个纠偏信号，因此必须落在近因位置。
  *
  * 为什么用 `agent/pre-step` 而不是 `systemPrompt.context()`：前者直接给出 `turn` /
  * `step`，且追加的是一条独立消息，落点比快照里的一个段更靠后。用法先例见官方
  * `packages/context/time-context/src/index.ts:180-220`。
  *
- * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md`
+ * 阈值全部走 `config.ts` 的配置面。**压缩动作按设计方案 §九 暂缓**：数据指向退化样本
+ * 散布在整段退化区间，而 `compactRegion` 只压指定区间，能否打断循环尚未验证。
+ *
+ * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md`、
+ * `docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`
  * @module @max-null/dsh-allostasis
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { anchorText } from './anchor.ts';
-/** Cordis 插件名，同时用作注入消息的 `source.plugin` 与 section 名。 */
-export declare const name = "dsh-allostasis";
+import { Config } from './config.ts';
+import { name } from './name.ts';
+export { anchorText, Config, name };
 /** 需要 `agents` 服务来接收 `agent/pre-step` 事件。 */
 export declare const inject: string[];
-export { anchorText };
 /**
  * 注册 pre-step 监听器；监听器随 `ctx` 生命周期销毁。
  *
  * 用 `{ prepend: true }` 以取得 `next()` 的决策后再追加，与官方 `time-context` 一致。
  * @param ctx - 插件上下文。
+ * @param config - `cordis.patch.yml` 里的配置段；省略时全部取判据模块的缺省值。
  */
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context, config?: Config): void;

package/dist/index.js

@@ -1,41 +1,114 @@
 /**
  * 应变（allostasis）：会话状态的自我调节。
  *
- * 第一期只实现一个能力——**中文锚定**：每个 step 之前读最近一条思考，若判定为语言
- * 漂移（英文功能词密度越线），就在请求末尾追加一条中文锚定消息。**平时不出现、漂移
- * 时才出现**——按需出现是它作为信号的前提。但漂移持续时也不每个 step 都提醒：同一
- * turn 至多一次，见 `throttle.ts`。
+ * 两期能力都落在同一个 `agent/pre-step` 上，因为它们读的是同一份输入——最近一条思考：
+ *
+ * · **一期 · 中文锚定**：判定为语言漂移（英文功能词密度越线）就追加一条中文锚定消息。
+ * · **二期 · 退化提醒**：判定为推理退化（重复率越线且连续若干步成立）就追加减速提醒，
+ *   并向会话日志 append 一条 `allostasis/degeneration` 记录当时的判定依据。
+ *
+ * **平时不出现、异常时才出现**——按需出现是它作为信号的前提。但异常持续时也不每个 step
+ * 都提醒：同一 turn 至多一次，见 `throttle.ts`。两类提醒各有独立的一份节流状态：判据无关，
+ * 共用状态会让先说的那类把另一类挡在门外。
  *
  * 为什么不挂到 system prompt 前缀上：那是 `dsh-chinese-thinking` 的位置，它作为基线
  * 永远在场。而基线在长会话里会失效（固定前缀离输出最远，语言模式受近因支配）。本插件
- * 补的是「**你正在漂移**」这个纠偏信号，因此必须落在近因位置。
+ * 补的是「**你正在漂移 / 正在打转**」这个纠偏信号，因此必须落在近因位置。
  *
  * 为什么用 `agent/pre-step` 而不是 `systemPrompt.context()`：前者直接给出 `turn` /
  * `step`，且追加的是一条独立消息，落点比快照里的一个段更靠后。用法先例见官方
  * `packages/context/time-context/src/index.ts:180-220`。
  *
- * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md`
+ * 阈值全部走 `config.ts` 的配置面。**压缩动作按设计方案 §九 暂缓**：数据指向退化样本
+ * 散布在整段退化区间，而 `compactRegion` 只压指定区间，能否打断循环尚未验证。
+ *
+ * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md`、
+ * `docs/设计/2026-09-28-应变二期-退化检测与自动干预.md`
  * @module @max-null/dsh-allostasis
  */
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
 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 { name } from "./name.js";
+import { measureRepetition, repetitionVerdict, trackLoop } from "./repetition.js";
 import { latestThinking } from "./thinking.js";
-import { admitAnchor } from "./throttle.js";
-/** Cordis 插件名，同时用作注入消息的 `source.plugin` 与 section 名。 */
-export const name = 'dsh-allostasis';
+import { admitPerTurn } from "./throttle.js";
+export { anchorText, Config, name };
 /** 需要 `agents` 服务来接收 `agent/pre-step` 事件。 */
 export const inject = ['agents'];
-export { anchorText };
+/**
+ * 组装一期的语言漂移提醒。
+ * @param session - 产出该思考的会话，用作节流状态的键。
+ * @param sample - 最近一条思考。
+ * @param resolved - 已校验的配置。
+ * @param throttles - 漂移提醒的节流状态表。
+ * @returns 应当追加的消息；本步不提醒时返回 `undefined`。
+ */
+function driftMessage(session, sample, resolved, throttles) {
+    const metrics = measureThinking(sample.text);
+    if (verdict(metrics, resolved.driftThreshold) !== 'drift')
+        return undefined;
+    const advanced = admitPerTurn(throttles.get(session), sample.turn);
+    if (advanced === undefined)
+        return undefined;
+    throttles.set(session, advanced);
+    return pluginNotice(anchorText(sample.turn, sample.step, metrics, advanced.count), `语言漂移 · turn ${sample.turn} · 第 ${advanced.count} 次`);
+}
+/**
+ * 组装二期的推理退化提醒，并落下判定依据。
+ *
+ * 追踪状态**每步都推进**，包括被节流挡住的那几步：计数描述的是退化本身持续了多久，
+ * 与「这一步有没有说出口」无关。
+ * @param session - 产出该思考的会话。
+ * @param sample - 最近一条思考。
+ * @param resolved - 已校验的配置。
+ * @param trackers - 连续越线的追踪状态表。
+ * @param throttles - 退化提醒的节流状态表。
+ * @returns 应当追加的消息；本步不提醒时返回 `undefined`。
+ */
+function loopMessage(session, sample, resolved, trackers, throttles) {
+    const metrics = measureRepetition(sample.text);
+    const stepVerdict = repetitionVerdict(metrics, resolved.repetitionThreshold);
+    const tracked = trackLoop(trackers.get(session), sample.turn, stepVerdict, resolved.consecutiveSteps);
+    trackers.set(session, tracked.state);
+    if (!tracked.fire)
+        return undefined;
+    const advanced = admitPerTurn(throttles.get(session), sample.turn);
+    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)}%`);
+}
 /**
  * 注册 pre-step 监听器；监听器随 `ctx` 生命周期销毁。
  *
  * 用 `{ prepend: true }` 以取得 `next()` 的决策后再追加，与官方 `time-context` 一致。
  * @param ctx - 插件上下文。
+ * @param config - `cordis.patch.yml` 里的配置段；省略时全部取判据模块的缺省值。
  */
-export function apply(ctx) {
-    /** 每个会话一份节流状态；用 WeakMap 以免会话销毁后残留。 */
-    const throttles = new WeakMap();
+export function apply(ctx, config = {}) {
+    const resolved = resolveConfig(config);
+    // 留痕：本插件没有任何界面元素，命中时也只在轨迹页留一行摘要，因此「装了没有、
+    // 生效阈值是多少、每步判成了什么」必须能从日志直接读到——否则装上了也无从判断，
+    // 更无从测试（2026-09-29：确认不了它是否加载）。加载行用 info（每个进程一次）；
+    // 判定行走 debug，默认静默、排查时打开即可，不必为了看一眼判定去改阈值试。
+    console.info(`[${name}] loaded · driftThreshold=${resolved.driftThreshold}`
+        + ` repetitionThreshold=${resolved.repetitionThreshold}`
+        + ` consecutiveSteps=${resolved.consecutiveSteps}`);
+    /** 每个会话各一份状态；用 WeakMap 以免会话销毁后残留。 */
+    const anchorThrottles = new WeakMap();
+    const loopThrottles = new WeakMap();
+    const loopTrackers = new WeakMap();
     ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
         const decision = await next();
         if (decision.kind === 'reject' || signal.aborted)
@@ -43,23 +116,24 @@ export function apply(ctx) {
         const sample = latestThinking(agent.session);
         if (sample === undefined)
             return decision;
-        const metrics = measureThinking(sample.text);
-        if (verdict(metrics) !== 'drift')
-            return decision;
-        const advanced = admitAnchor(throttles.get(agent.session), sample.turn);
-        if (advanced === undefined)
+        // 诊断行与下面的判定各算一次度量：两者都是纯字符串统计，重复计算的代价远低于
+        // 让 metrics 在三个函数之间穿梭带来的耦合。
+        const dMetrics = measureThinking(sample.text);
+        const rMetrics = measureRepetition(sample.text);
+        console.debug(`[${name}] turn ${sample.turn} step ${sample.step}`
+            + ` · drift=${verdict(dMetrics, resolved.driftThreshold)}`
+            + ` funcDensity=${(dMetrics.funcDensity * 100).toFixed(1)}% chars=${dMetrics.chars}`
+            + ` · repetition=${repetitionVerdict(rMetrics, resolved.repetitionThreshold)}`
+            + ` units=${rMetrics.units} ratio=${(rMetrics.ratio * 100).toFixed(0)}%`);
+        const appended = [];
+        const drift = driftMessage(agent.session, sample, resolved, anchorThrottles);
+        if (drift !== undefined)
+            appended.push(drift);
+        const loop = loopMessage(agent.session, sample, resolved, loopTrackers, loopThrottles);
+        if (loop !== undefined)
+            appended.push(loop);
+        if (appended.length === 0)
             return decision;
-        throttles.set(agent.session, advanced);
-        const text = anchorText(sample.turn, sample.step, metrics, advanced.count);
-        return {
-            ...decision,
-            messages: [
-                ...decision.messages,
-                createUserMessage({
-                    content: [{ type: 'text', text }],
-                    source: { kind: 'plugin', plugin: name, form: 'snapshot', sections: [{ name, text }] },
-                }),
-            ],
-        };
+        return { ...decision, messages: [...decision.messages, ...appended] };
     }, { prepend: true });
 }

package/dist/messages.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 本插件产生的消息：source 登记与正文组装。
+ *
+ * 单独成文件与 `anchor.ts` 同因——入口要导入 `@deepseek-ai/dsh-llm` 的运行时值，
+ * 而测试环境只装了 npm 上的部分 DSH 包。
+ *
+ * **source 用 `notice` 而不是 `snapshot`**：`snapshot` 的语义是「同一生产者的后一份
+ * 取代前一份」，而每次提醒都是独立的即时信号，谁也不取代谁——那是 `notice` 的定义
+ * （`llm/llm/src/message.ts:60-67`）。两者的差别不只是措辞：轨迹视图按 form 决定
+ * 呈现方式，snapshot 会被当作可折叠的上下文块，notice 是一行「刚发生了什么」。
+ *
+ * **kind 走声明合并而不是类型断言**：`MessageSourceMap` 是可合并扩展的，官方明确
+ * 「each producer declares its own `kind` in its own module; there is no shared
+ * catch-all `plugin` kind」（同文件 L303-307），官方插件如 `repeat-tool-reminder`
+ * 正是这么登记的。`plugin:<名>` 是 v4 会话格式对第三方生产者的规范形式
+ * （`session-format-v3-to-v4/src/sources.ts:64` 的 `return \`plugin:${plugin}\``）。
+ * @module @max-null/dsh-allostasis/messages
+ */
+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';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /** 应变注入的即时提醒：语言漂移锚定与推理退化提醒共用这一个生产者身份。 */
+        'plugin:dsh-allostasis': {
+            kind: typeof SOURCE_KIND;
+        } & ContextFormed;
+    }
+}
+/**
+ * 把一段提醒正文包成一条 `notice` 形式的消息。
+ * @param text - 模型读到的正文。
+ * @param summary - 客户端一行叙述；超长会被 `boundContextSummary` 截断。
+ * @returns 可追加到 pre-step 决策上的用户消息。
+ */
+export declare function pluginNotice(text: string, summary: string): UserMessage;
+/**
+ * 组装推理退化提醒。
+ *
+ * 刻意点明「重复不等于想得更细」：退化期的输出读起来像在认真铺陈，若不说明，模型可能
+ * 把重复当成详尽而继续加码。给的两条出路是具体的——给结论，或换一个与前面不同的动作，
+ * 而不是「请继续努力」这类没有落点的督促。
+ * @param turn - 产出该思考的 turn。
+ * @param step - 产出该思考的 step。
+ * @param metrics - 那一步思考的重复度量化结果。
+ * @param reminder - 这是本会话第几次退化提醒；默认 1。
+ * @returns 一条退化提醒消息的正文。
+ */
+export declare function degenerationText(turn: number, step: number, metrics: RepetitionMetrics, reminder?: number): string;

package/dist/messages.js

@@ -0,0 +1,67 @@
+/**
+ * 本插件产生的消息：source 登记与正文组装。
+ *
+ * 单独成文件与 `anchor.ts` 同因——入口要导入 `@deepseek-ai/dsh-llm` 的运行时值，
+ * 而测试环境只装了 npm 上的部分 DSH 包。
+ *
+ * **source 用 `notice` 而不是 `snapshot`**：`snapshot` 的语义是「同一生产者的后一份
+ * 取代前一份」，而每次提醒都是独立的即时信号，谁也不取代谁——那是 `notice` 的定义
+ * （`llm/llm/src/message.ts:60-67`）。两者的差别不只是措辞：轨迹视图按 form 决定
+ * 呈现方式，snapshot 会被当作可折叠的上下文块，notice 是一行「刚发生了什么」。
+ *
+ * **kind 走声明合并而不是类型断言**：`MessageSourceMap` 是可合并扩展的，官方明确
+ * 「each producer declares its own `kind` in its own module; there is no shared
+ * catch-all `plugin` kind」（同文件 L303-307），官方插件如 `repeat-tool-reminder`
+ * 正是这么登记的。`plugin:<名>` 是 v4 会话格式对第三方生产者的规范形式
+ * （`session-format-v3-to-v4/src/sources.ts:64` 的 `return \`plugin:${plugin}\``）。
+ * @module @max-null/dsh-allostasis/messages
+ */
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm';
+import { SOURCE_KIND } from "./name.js";
+/** 提醒文本里每个重复单元的截断长度；比落盘的 `UNIT_SAMPLE_MAX_CHARS` 更短，因为它要读起来顺。 */
+const TOP_UNIT_MAX_CHARS = 40;
+/** 提醒文本里最多列举几个高频单元。 */
+const TOP_UNITS_SHOWN = 3;
+/**
+ * 把一段提醒正文包成一条 `notice` 形式的消息。
+ * @param text - 模型读到的正文。
+ * @param summary - 客户端一行叙述；超长会被 `boundContextSummary` 截断。
+ * @returns 可追加到 pre-step 决策上的用户消息。
+ */
+export function pluginNotice(text, summary) {
+    return createUserMessage({
+        content: [{ type: 'text', text }],
+        source: {
+            kind: SOURCE_KIND,
+            form: 'notice',
+            summary: boundContextSummary(summary),
+        },
+    });
+}
+/**
+ * 组装推理退化提醒。
+ *
+ * 刻意点明「重复不等于想得更细」：退化期的输出读起来像在认真铺陈，若不说明，模型可能
+ * 把重复当成详尽而继续加码。给的两条出路是具体的——给结论，或换一个与前面不同的动作，
+ * 而不是「请继续努力」这类没有落点的督促。
+ * @param turn - 产出该思考的 turn。
+ * @param step - 产出该思考的 step。
+ * @param metrics - 那一步思考的重复度量化结果。
+ * @param reminder - 这是本会话第几次退化提醒；默认 1。
+ * @returns 一条退化提醒消息的正文。
+ */
+export function degenerationText(turn, step, metrics, reminder = 1) {
+    const head = reminder > 1
+        ? `⚠️ 推理退化提醒（应变，第 ${reminder} 次）：你仍然在重复自己——上一步`
+        : '⚠️ 推理退化提醒（应变）：你上一步';
+    const where = `（turn ${turn} step ${step}）的思考在重复自己——重复率 `
+        + `${(metrics.ratio * 100).toFixed(0)}%（${metrics.units} 个片段里有 `
+        + `${metrics.repeated} 个出现 3 次以上）`;
+    const top = metrics.top.slice(0, TOP_UNITS_SHOWN)
+        .map(entry => `「${entry.unit.length <= TOP_UNIT_MAX_CHARS ? entry.unit : `${entry.unit.slice(0, TOP_UNIT_MAX_CHARS)}…`}」×${entry.count}`)
+        .join('、');
+    return `${head}${where}，最高频的是 ${top}。`
+        + '重复不等于想得更细，它是原地打转：这些片段没有带来新信息。'
+        + '现在检查手上已有的信息够不够完成任务——够就直接给结论，'
+        + '不够就换一个与前面不同的动作去取，而不是把同一句话再写一遍。';
+}

package/dist/name.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cordis 插件名。单独成模块是为了让 `messages.ts` 与入口共用同一个字面量——
+ * 它同时是插件身份、注入消息的 `source.plugin` 与轨迹里的生产者标签，两处漂移的代价
+ * 是日志里出现两个看似无关的生产者。
+ * @module @max-null/dsh-allostasis/name
+ */
+/** Cordis 插件名，同时用作注入消息 source 的 kind 与 section 名。 */
+export declare const name = "dsh-allostasis";
+/**
+ * 注入消息 source 的 `kind`：v4 会话格式对第三方生产者的规范形式。
+ *
+ * `as const` 是必需的——`MessageSourceMap` 的成员键必须是字面量类型，而模板字符串
+ * 默认推断为 `string`。`messages.ts` 的声明合并键与这里必须是同一个值。
+ */
+export declare const SOURCE_KIND: "plugin:dsh-allostasis";

package/dist/name.js

@@ -0,0 +1,15 @@
+/**
+ * Cordis 插件名。单独成模块是为了让 `messages.ts` 与入口共用同一个字面量——
+ * 它同时是插件身份、注入消息的 `source.plugin` 与轨迹里的生产者标签，两处漂移的代价
+ * 是日志里出现两个看似无关的生产者。
+ * @module @max-null/dsh-allostasis/name
+ */
+/** Cordis 插件名，同时用作注入消息 source 的 kind 与 section 名。 */
+export const name = 'dsh-allostasis';
+/**
+ * 注入消息 source 的 `kind`：v4 会话格式对第三方生产者的规范形式。
+ *
+ * `as const` 是必需的——`MessageSourceMap` 的成员键必须是字面量类型，而模板字符串
+ * 默认推断为 `string`。`messages.ts` 的声明合并键与这里必须是同一个值。
+ */
+export const SOURCE_KIND = `plugin:${name}`;

package/dist/repetition.d.ts

@@ -0,0 +1,91 @@
+/**
+ * 思考重复度判定（退化检测的判据）。
+ *
+ * 判据 = 单条推理按换行与中英句读切分后，**出现 ≥3 次的单元占全部单元的比例**，
+ * 并要求连续若干步越线才触发。
+ *
+ * 实测依据（2026-09-28，会话 `session-fabc21b2`，19 轮 416 条助手消息）：
+ * 正常期重复率 0%–35%、退化期 48%–92%，隔离带很宽。阈值取 50% 落在这份单会话样本
+ * 两端的中点附近，**不是标定结果**——它是第一期可用的起点，标定留给数据积累
+ * （设计方案 §4.2 与 §五）。
+ *
+ * 连续 N 步是必需的：正常期也会出现单次抖动（实测峰值 35%），只按单步触发会让误报
+ * 跟着抖动走。代价是延迟——按同一份数据回放，触发会落在 t11/s2 而不是 t10/s44，
+ * 晚约 3 步（中间夹了一个 48%，低于阈值、计数归零）。
+ *
+ * 为什么不用推理长度当辅助判据：退化期的单条推理并不特别长（实测 1,000–2,600
+ * 字符），长度不区分两群；重复率本身已经把「这段内容有多少信息」量化了。
+ *
+ * 设计出处：`docs/设计/2026-09-28-应变二期-退化检测与自动干预.md` §四
+ * @module @max-null/dsh-allostasis/repetition
+ */
+/** 单元重复达到此次数才计入「重复单元」。 */
+export declare const REPEAT_MIN_COUNT = 3;
+/** 判定所需的最少单元数；低于此值只报数不判定，避免小样本把比例算飞。 */
+export declare const MIN_UNITS = 12;
+/** 重复率判定阈值——起点值，非标定值。 */
+export declare const REPETITION_THRESHOLD = 0.5;
+/** 触发所需的连续越线步数。 */
+export declare const CONSECUTIVE_STEPS = 2;
+/** 一条思考的重复度量化结果。 */
+export interface RepetitionMetrics {
+    /** 切分后的单元总数（去空白后）。 */
+    units: number;
+    /** 重复单元的**总出现次数**（同一单元出现 5 次计 5，不是计 1）。 */
+    repeated: number;
+    /** 重复率——判据本体。空文本与样本不足时仍给出可算的实数，判定另看 `repetitionVerdict`。 */
+    ratio: number;
+    /** 最高频的若干单元，按出现次数降序；供提醒文本直接引用。 */
+    top: Array<{
+        unit: string;
+        count: number;
+    }>;
+}
+/** 三态判定；单元数不足时不下结论。 */
+export type RepetitionVerdict = 'loop' | 'normal' | 'insufficient';
+/**
+ * 统计一条思考文本的重复度。空文本返回全零。
+ *
+ * 单元按 `UNIT_SEPARATOR` 切分并去掉空白，因此纯空行的段落不参与统计。
+ * `top` 只收达到 `REPEAT_MIN_COUNT` 的单元，最多 5 条，同次数按单元字典序稳定排序。
+ * @param text - 推理原文。
+ * @returns 量化结果。
+ */
+export declare function measureRepetition(text: string): RepetitionMetrics;
+/**
+ * 对一次测量下判定。
+ *
+ * 单元数不足 `MIN_UNITS` 时返回 `insufficient`——**不下结论**。调用方据此决定该步
+ * 既不算越线也不算清白（见 `trackLoop`）。
+ * @param metrics - 量化结果。
+ * @param threshold - 重复率阈值；缺省用 {@link REPETITION_THRESHOLD}。
+ * @returns 三态判定。
+ */
+export declare function repetitionVerdict(metrics: RepetitionMetrics, threshold?: number): RepetitionVerdict;
+/** 连续越线的追踪状态。不可变——每次推进都返回一份新状态。 */
+export interface LoopTrackerState {
+    /** 当前已连续越线的步数。 */
+    consecutive: number;
+    /** 最近一次判定的 turn，用于识别「换了一轮」。 */
+    lastTurn: number;
+}
+/**
+ * 推进连续越线计数，并判定本次是否触发。
+ *
+ * **状态不跨 turn 延续**：新一轮的第一条推理重新起算。turn 是用户可感知的边界，
+ * 而且实测里退化在同一个 turn 内就已连成片（t10 的 44%–64% 全在一轮内），跨轮累加
+ * 只会让触发更晚。
+ *
+ * `insufficient` 的样本**保持计数不变**：它既不是越线也不是清白，算作清零会让
+ * 「推理偶尔写得很短」反复推迟触发。
+ *
+ * @param state - 上一次的状态；首次调用传 `undefined`。
+ * @param turn - 产出该思考的 turn。
+ * @param verdict - 该步的判定。
+ * @param required - 触发所需的连续越线步数；缺省用 {@link CONSECUTIVE_STEPS}。
+ * @returns `state` 为推进后的新状态；`fire` 为本次是否达到触发条件。
+ */
+export declare function trackLoop(state: LoopTrackerState | undefined, turn: number, verdict: RepetitionVerdict, required?: number): {
+    state: LoopTrackerState;
+    fire: boolean;
+};

package/dist/repetition.js

@@ -0,0 +1,100 @@
+/**
+ * 思考重复度判定（退化检测的判据）。
+ *
+ * 判据 = 单条推理按换行与中英句读切分后，**出现 ≥3 次的单元占全部单元的比例**，
+ * 并要求连续若干步越线才触发。
+ *
+ * 实测依据（2026-09-28，会话 `session-fabc21b2`，19 轮 416 条助手消息）：
+ * 正常期重复率 0%–35%、退化期 48%–92%，隔离带很宽。阈值取 50% 落在这份单会话样本
+ * 两端的中点附近，**不是标定结果**——它是第一期可用的起点，标定留给数据积累
+ * （设计方案 §4.2 与 §五）。
+ *
+ * 连续 N 步是必需的：正常期也会出现单次抖动（实测峰值 35%），只按单步触发会让误报
+ * 跟着抖动走。代价是延迟——按同一份数据回放，触发会落在 t11/s2 而不是 t10/s44，
+ * 晚约 3 步（中间夹了一个 48%，低于阈值、计数归零）。
+ *
+ * 为什么不用推理长度当辅助判据：退化期的单条推理并不特别长（实测 1,000–2,600
+ * 字符），长度不区分两群；重复率本身已经把「这段内容有多少信息」量化了。
+ *
+ * 设计出处：`docs/设计/2026-09-28-应变二期-退化检测与自动干预.md` §四
+ * @module @max-null/dsh-allostasis/repetition
+ */
+/** 单元重复达到此次数才计入「重复单元」。 */
+export const REPEAT_MIN_COUNT = 3;
+/** 判定所需的最少单元数；低于此值只报数不判定，避免小样本把比例算飞。 */
+export const MIN_UNITS = 12;
+/** 重复率判定阈值——起点值，非标定值。 */
+export const REPETITION_THRESHOLD = 0.5;
+/** 触发所需的连续越线步数。 */
+export const CONSECUTIVE_STEPS = 2;
+/** 切分单元用的分隔符：换行与中英句读。 */
+const UNIT_SEPARATOR = /[\n。！？]/;
+/**
+ * 统计一条思考文本的重复度。空文本返回全零。
+ *
+ * 单元按 `UNIT_SEPARATOR` 切分并去掉空白，因此纯空行的段落不参与统计。
+ * `top` 只收达到 `REPEAT_MIN_COUNT` 的单元，最多 5 条，同次数按单元字典序稳定排序。
+ * @param text - 推理原文。
+ * @returns 量化结果。
+ */
+export function measureRepetition(text) {
+    const units = text.split(UNIT_SEPARATOR)
+        .map(part => part.trim())
+        .filter(part => part !== '');
+    const counts = new Map();
+    for (const unit of units)
+        counts.set(unit, (counts.get(unit) ?? 0) + 1);
+    let repeated = 0;
+    const frequent = [];
+    for (const [unit, count] of counts) {
+        if (count < REPEAT_MIN_COUNT)
+            continue;
+        repeated += count;
+        frequent.push({ unit, count });
+    }
+    frequent.sort((a, b) => b.count - a.count || a.unit.localeCompare(b.unit));
+    return {
+        units: units.length,
+        repeated,
+        ratio: units.length === 0 ? 0 : repeated / units.length,
+        top: frequent.slice(0, 5),
+    };
+}
+/**
+ * 对一次测量下判定。
+ *
+ * 单元数不足 `MIN_UNITS` 时返回 `insufficient`——**不下结论**。调用方据此决定该步
+ * 既不算越线也不算清白（见 `trackLoop`）。
+ * @param metrics - 量化结果。
+ * @param threshold - 重复率阈值；缺省用 {@link REPETITION_THRESHOLD}。
+ * @returns 三态判定。
+ */
+export function repetitionVerdict(metrics, threshold = REPETITION_THRESHOLD) {
+    if (metrics.units < MIN_UNITS)
+        return 'insufficient';
+    return metrics.ratio >= threshold ? 'loop' : 'normal';
+}
+/**
+ * 推进连续越线计数，并判定本次是否触发。
+ *
+ * **状态不跨 turn 延续**：新一轮的第一条推理重新起算。turn 是用户可感知的边界，
+ * 而且实测里退化在同一个 turn 内就已连成片（t10 的 44%–64% 全在一轮内），跨轮累加
+ * 只会让触发更晚。
+ *
+ * `insufficient` 的样本**保持计数不变**：它既不是越线也不是清白，算作清零会让
+ * 「推理偶尔写得很短」反复推迟触发。
+ *
+ * @param state - 上一次的状态；首次调用传 `undefined`。
+ * @param turn - 产出该思考的 turn。
+ * @param verdict - 该步的判定。
+ * @param required - 触发所需的连续越线步数；缺省用 {@link CONSECUTIVE_STEPS}。
+ * @returns `state` 为推进后的新状态；`fire` 为本次是否达到触发条件。
+ */
+export function trackLoop(state, turn, verdict, required = CONSECUTIVE_STEPS) {
+    const current = state ?? { consecutive: 0, lastTurn: Number.NaN };
+    const base = current.lastTurn === turn ? current.consecutive : 0;
+    if (verdict === 'insufficient')
+        return { state: { consecutive: base, lastTurn: turn }, fire: false };
+    const consecutive = verdict === 'loop' ? base + 1 : 0;
+    return { state: { consecutive, lastTurn: turn }, fire: consecutive >= required };
+}

package/dist/throttle.d.ts

@@ -1,5 +1,5 @@
 /**
- * 锚定注入的节流。
+ * 提醒注入的节流：**同一 turn 至多一次**。
  *
  * 实测（2026-09-21，会话 `session-502b3e2b`，记录见设计方案 §12.4）：漂移持续时**每个
  * step 都会判定为漂移**，于是同一个 turn 内会连着注入多条几乎一样的提醒——观测到 3 连注，
@@ -8,13 +8,16 @@
  * 所以收紧到「同一 turn 至多一次」：turn 是用户能感知的自然边界，重试留到下一轮，
  * 而不是在一步之内反复催促。上限写成常数而不是配置项，是因为**没有数据支撑别的取值**；
  * 等无对抗的自然漂移样本出来，再决定要不要放宽（设计方案 §八 第 9 条）。
+ *
+ * 退化提醒复用同一契约、独立一份状态：两类提醒的判据无关，共用状态会让先说的那类
+ * 把另一类挡在门外。
  * @module @max-null/dsh-allostasis/throttle
  */
-/** 锚定在单个 turn 内的注入上限。 */
-export declare const MAX_ANCHORS_PER_TURN = 1;
+/** 同一 turn 内的提醒注入上限。 */
+export declare const MAX_PER_TURN = 1;
 /** 节流状态。不可变——每次放行都返回一份新状态。 */
-export interface AnchorThrottleState {
-    /** 最近一次注入所针对的 turn（产出那段漂移思考的 turn）。 */
+export interface PerTurnThrottleState {
+    /** 最近一次注入所针对的 turn（产出那段异常输出的 turn）。 */
     lastTurn: number;
     /** 该 turn 内已经注入了几次。 */
     inTurn: number;
@@ -24,10 +27,10 @@ export interface AnchorThrottleState {
 /**
  * 判定本次是否放行，并推进状态。
  *
- * `sampledTurn` 是**产出那段被判定漂移的思考**的 turn，不是当前 turn——锚定的措辞
+ * `sampledTurn` 是**产出那段被判定异常的输出的 turn**，不是当前 turn——提醒的措辞
  * 指向「你上一步在想什么」，节流的计次也应当跟着它走。
  * @param state - 上一次的状态；首次调用传 `undefined`。
- * @param sampledTurn - 产出该思考的 turn。
+ * @param sampledTurn - 产出该输出的 turn。
  * @returns 放行时返回新状态；应当跳过时返回 `undefined`。
  */
-export declare function admitAnchor(state: AnchorThrottleState | undefined, sampledTurn: number): AnchorThrottleState | undefined;
+export declare function admitPerTurn(state: PerTurnThrottleState | undefined, sampledTurn: number): PerTurnThrottleState | undefined;

package/dist/throttle.js

@@ -1,5 +1,5 @@
 /**
- * 锚定注入的节流。
+ * 提醒注入的节流：**同一 turn 至多一次**。
  *
  * 实测（2026-09-21，会话 `session-502b3e2b`，记录见设计方案 §12.4）：漂移持续时**每个
  * step 都会判定为漂移**，于是同一个 turn 内会连着注入多条几乎一样的提醒——观测到 3 连注，
@@ -8,23 +8,26 @@
  * 所以收紧到「同一 turn 至多一次」：turn 是用户能感知的自然边界，重试留到下一轮，
  * 而不是在一步之内反复催促。上限写成常数而不是配置项，是因为**没有数据支撑别的取值**；
  * 等无对抗的自然漂移样本出来，再决定要不要放宽（设计方案 §八 第 9 条）。
+ *
+ * 退化提醒复用同一契约、独立一份状态：两类提醒的判据无关，共用状态会让先说的那类
+ * 把另一类挡在门外。
  * @module @max-null/dsh-allostasis/throttle
  */
-/** 锚定在单个 turn 内的注入上限。 */
-export const MAX_ANCHORS_PER_TURN = 1;
+/** 同一 turn 内的提醒注入上限。 */
+export const MAX_PER_TURN = 1;
 /**
  * 判定本次是否放行，并推进状态。
  *
- * `sampledTurn` 是**产出那段被判定漂移的思考**的 turn，不是当前 turn——锚定的措辞
+ * `sampledTurn` 是**产出那段被判定异常的输出的 turn**，不是当前 turn——提醒的措辞
  * 指向「你上一步在想什么」，节流的计次也应当跟着它走。
  * @param state - 上一次的状态；首次调用传 `undefined`。
- * @param sampledTurn - 产出该思考的 turn。
+ * @param sampledTurn - 产出该输出的 turn。
  * @returns 放行时返回新状态；应当跳过时返回 `undefined`。
  */
-export function admitAnchor(state, sampledTurn) {
+export function admitPerTurn(state, sampledTurn) {
     const current = state ?? { lastTurn: Number.NaN, inTurn: 0, count: 0 };
     const inTurn = current.lastTurn === sampledTurn ? current.inTurn : 0;
-    if (inTurn >= MAX_ANCHORS_PER_TURN)
+    if (inTurn >= MAX_PER_TURN)
         return undefined;
     return { lastTurn: sampledTurn, inTurn: inTurn + 1, count: current.count + 1 };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-allostasis",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "应变（allostasis）：会话状态的自我调节。第一期：中文思考的漂移检测与近因锚定",
   "license": "MIT",
   "publishConfig": {
@@ -48,13 +48,13 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "zod": "^4.4.3"
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.1"
+    "@deepseek-ai/dsh-agent": ">=0.1.7-rc.1 <0.3.0",
+    "@deepseek-ai/dsh-llm": ">=0.1.7-rc.1 <0.3.0",
+    "@deepseek-ai/dsh-session": ">=0.1.7-rc.1 <0.3.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
@@ -62,8 +62,8 @@
     "typescript": "^5.5.0",
     "vitest": "^2.1.0",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.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"
   }
 }