@max-null/dsh-allostasis 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max-Null
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# @max-null/dsh-allostasis
+
+本插件属于 **`@max-null/*` 插件系列**——这一系列共同构成 **[SSID（思灵 · Seek Soul in Darkness）](https://github.com/Max-Null/seek-soul-in-darkness)** 桌面体验。SSID 是整合它们的盒：`dsh-allostasis` · `dsh-capture` · `dsh-chat-rail` · `dsh-chinese-thinking` · `dsh-draft-polish` · `dsh-guardian` · `dsh-habit` · `dsh-memory` · `dsh-node-appearance` · `dsh-plugin-center` · `dsh-quick-toolbar` · `dsh-skill-mcp-center` · `dsh-ssid-panels` · `dsh-ssid-zh-ui` · `dsh-achievements`。
+
+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.
+
+## 它做什么
+
+**应变**（allostasis）取「**通过改变自己来维持自己**」之义——它不只是一个监测器，它会改变行为。
+
+| 能力 | 状态 | 触发条件 |
+|---|---|---|
+| **中文锚定** | **已实现** | 上一步思考的英文功能词密度越线 |
+| 上下文占用感知 | 计划中 | 需先定「什么情况下才出现」（持续在场会退化成背景音） |
+| 压缩预约落盘 | 计划中 | 待通路验证：`turn/end` → `whenIdle()` → `compactNow()` |
+
+判据来源、实测数据与完整设计见 `docs/设计/2026-09-20-应变-设计方案.md`。
+
+## 为什么需要它
+
+`dsh-chinese-thinking` 把「始终使用中文进行思考」挂在 system prompt 的**固定前缀**上——那是对的定位：基线、常驻、cache-safe。但固定前缀离每一次输出最远，而语言模式受**近因**支配；长会话里基线会变弱。
+
+本插件补的是**纠偏信号**——「你正在漂移」。它是叠加而非替代：基线层永远在场，增强层只在检测到漂移时出现。**平时不出现**正是它作为信号的前提；一段一直存在的提醒会退化成背景音，重演它要修的那个问题。
+
+## 判据
+
+**英文功能词密度** =（`the` / `is` / `are` / `and` / `of` / `to` / `that` 这类功能词数）/ 英文词数，**且英文词数 ≥ 50 才判定**。
+
+实测数据（一份 10 turn / 157 step 的真实会话）：中文期中位 **0.012**、英文期中位 **0.273–0.389**，阈值 **0.15** 使两群完全分离。词数门槛不可省——中文期唯一的越线点只有 26 个英文词，小样本会让密度失真。
+
+另外两个看起来更直观的指标被否掉：**中文字符占比**（中文思考本来就大量夹英文标识符，实测中文期只有 0.19–0.37，区分度不足）；**最长连续英文游程**（中文思考引用一段代码就会把它顶高，它测的是「引用了多长的代码」而非「用什么语言思考」）。
+
+阈值由 `tools/analyze-thinking-lang.mjs` 在一份真实会话上标定，该工具随包发布。
+
+## 截图
+
+本插件是**会话行为调节类**：不新增任何按钮、面板或设置项。它在会话过程中读取思考的语言，漂移时向请求末尾追加一条提醒，效果体现在模型行为上。
+
+> 按《SSiD 开发手册》§9 截图规范：截图须回答「装完会多出/变成什么」的**入口与面板**。
+> 本插件无界面元素（no UI surface），故**不适用**该项要求，改以上述行为效果说明代替。
+
+## Compose
+
+```yaml
+# cordis.yml (or via the bundle patch):
+- id: allostasis
+  name: '@max-null/dsh-allostasis'
+```
+
+Requires `agents` and `system-prompt` in the host composition (dsh-base ships both).
+Installs as a bundle: `dsh plugin --profile <name> add @max-null/dsh-allostasis`.
+
+## Config
+
+第一期没有配置项；阈值与门槛是经过标定的常量，写在 `src/drift.ts` 里并附实测依据。
+
+## Develop
+
+```sh
+npm install --legacy-peer-deps   # DSH peer types resolve via tsconfig paths
+npm test                         # vitest
+npm run typecheck                # tsc against the adjacent deepseek-harness lib/types
+npm run build                    # emit dist/
+```
+
+**注意 tsconfig 的 `paths` 用 `../../deepseek-harness/...`**（本仓库位于 `max-null-plugins/` 下，`deepseek-harness/` 在再上一级）。写成 `../deepseek-harness/...` 时 TypeScript 会**静默回落**到 `node_modules` 里 npm 装的旧版 DSH 类型——症状是「某些显然存在的成员报 not exported」，而不是找不到模块。

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# 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.
+- insert:
+    - id: allostasis
+      name: '@max-null/dsh-allostasis'

package/dist/anchor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 锚定文本的组装。
+ *
+ * 单独成文件而不是留在入口里：入口 `index.ts` 要导入 `@deepseek-ai/dsh-llm` 的
+ * `createUserMessage`（运行时依赖，由宿主 profile 提供），而测试环境只装了 npm 上的
+ * 部分 DSH 包——放在同一个文件里会让纯文本逻辑的测试连带去解析 DSH 运行时。
+ * @module @max-null/dsh-allostasis/anchor
+ */
+import type { DriftMetrics } from './drift.ts';
+/**
+ * 组装锚定文本。
+ *
+ * 刻意点明「引用英文标识符是正常的」：判据只看英文语法结构，若不说明，模型可能为了
+ * 规避提醒而不敢写代码符号，那会伤到正常工作。
+ * 第二次起带上序号并改口径（「你仍然在用英文思考」）：节流之后，同一条提醒仍可能在
+ * 后续 turn 重复出现，措辞一成不变的话，重复的那几条就是纯噪音。
+ * @param turn - 产出该思考的 turn。
+ * @param step - 产出该思考的 step。
+ * @param metrics - 那一步思考的量化结果。
+ * @param reminder - 这是本会话第几次提醒；默认 1。
+ * @returns 一条锚定消息的正文。
+ */
+export declare function anchorText(turn: number, step: number, metrics: DriftMetrics, reminder?: number): string;

package/dist/anchor.js

@@ -0,0 +1,31 @@
+/**
+ * 锚定文本的组装。
+ *
+ * 单独成文件而不是留在入口里：入口 `index.ts` 要导入 `@deepseek-ai/dsh-llm` 的
+ * `createUserMessage`（运行时依赖，由宿主 profile 提供），而测试环境只装了 npm 上的
+ * 部分 DSH 包——放在同一个文件里会让纯文本逻辑的测试连带去解析 DSH 运行时。
+ * @module @max-null/dsh-allostasis/anchor
+ */
+/**
+ * 组装锚定文本。
+ *
+ * 刻意点明「引用英文标识符是正常的」：判据只看英文语法结构，若不说明，模型可能为了
+ * 规避提醒而不敢写代码符号，那会伤到正常工作。
+ * 第二次起带上序号并改口径（「你仍然在用英文思考」）：节流之后，同一条提醒仍可能在
+ * 后续 turn 重复出现，措辞一成不变的话，重复的那几条就是纯噪音。
+ * @param turn - 产出该思考的 turn。
+ * @param step - 产出该思考的 step。
+ * @param metrics - 那一步思考的量化结果。
+ * @param reminder - 这是本会话第几次提醒；默认 1。
+ * @returns 一条锚定消息的正文。
+ */
+export function anchorText(turn, step, metrics, reminder = 1) {
+    const where = `（turn ${turn} step ${step}）的思考是英文的`
+        + `（英文功能词密度 ${metrics.funcDensity.toFixed(2)}，共 ${metrics.words} 个英文词）。`;
+    const head = reminder > 1
+        ? `⚠️ 语言漂移提醒（应变，第 ${reminder} 次）：你仍然在用英文思考——上一步${where}`
+        : `⚠️ 语言漂移提醒（应变）：你上一步${where}`;
+    return head
+        + '现在回到中文思考。注意：读代码时引用英文标识符是正常的，'
+        + '这里判定的是整句英文——出现英文语法结构才算漂移。';
+}

package/dist/drift.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 思考语言漂移判定。
+ *
+ * 判据是**英文功能词密度** = 英文功能词数 / 英文词数，并要求英文词数达到门槛。
+ * 实测依据（2026-09-20，会话 `session-3bf8bcfb`，156 条 `assistant/message`）：
+ * 中文期中位密度 0.012、英文期中位 0.273–0.389，阈值 0.15 两群完全分离。词数门槛
+ * 是必需的——中文期唯一的越线点（密度 0.192）只有 26 个英文词，小样本让密度失真。
+ *
+ * 另外两个看起来更直观的指标不可用：
+ *   · 中文字符占比：中文思考本来就大量夹英文标识符，实测中文期只有 0.19–0.37，
+ *     与英文期的 0.00–0.15 区分度太小。
+ *   · 最长连续英文游程：中文思考引用一段代码就会把它顶到 43，它测的是「引用了多长
+ *     的代码」，不是「用什么语言思考」。
+ *
+ * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md` §4.3
+ * @module @max-null/dsh-allostasis/drift
+ */
+/** 功能词密度达到此值即判为漂移；中文期中位 0.012、英文期中位 0.273 以上。 */
+export declare const DRIFT_THRESHOLD = 0.15;
+/** 判定所需的最少英文词数；低于此值只报数不判定，避免小样本把密度算飞。 */
+export declare const MIN_WORDS = 50;
+/** 一条思考文本的量化结果。 */
+export interface DriftMetrics {
+    /** 文本总字符数。 */
+    chars: number;
+    /** 中文字符数。 */
+    cjk: number;
+    /** 中文字符占比，仅用于诊断，不参与判定。 */
+    cjkRatio: number;
+    /** 英文词数。 */
+    words: number;
+    /** 英文功能词数。 */
+    funcWords: number;
+    /** 功能词密度——判据本体。 */
+    funcDensity: number;
+}
+/** 三态判定；词数不足时不下结论。 */
+export type DriftVerdict = 'drift' | 'chinese' | 'insufficient';
+/** 统计一条思考文本的各量。空文本返回全零。 */
+export declare function measureThinking(text: string): DriftMetrics;
+/** 对一次测量下判定。 */
+export declare function verdict(metrics: DriftMetrics): DriftVerdict;

package/dist/drift.js

@@ -0,0 +1,48 @@
+/**
+ * 思考语言漂移判定。
+ *
+ * 判据是**英文功能词密度** = 英文功能词数 / 英文词数，并要求英文词数达到门槛。
+ * 实测依据（2026-09-20，会话 `session-3bf8bcfb`，156 条 `assistant/message`）：
+ * 中文期中位密度 0.012、英文期中位 0.273–0.389，阈值 0.15 两群完全分离。词数门槛
+ * 是必需的——中文期唯一的越线点（密度 0.192）只有 26 个英文词，小样本让密度失真。
+ *
+ * 另外两个看起来更直观的指标不可用：
+ *   · 中文字符占比：中文思考本来就大量夹英文标识符，实测中文期只有 0.19–0.37，
+ *     与英文期的 0.00–0.15 区分度太小。
+ *   · 最长连续英文游程：中文思考引用一段代码就会把它顶到 43，它测的是「引用了多长
+ *     的代码」，不是「用什么语言思考」。
+ *
+ * 设计出处：`docs/设计/2026-09-20-应变-设计方案.md` §4.3
+ * @module @max-null/dsh-allostasis/drift
+ */
+/** 英文功能词：中文思考引用英文标识符时不会带这些词。 */
+const FUNC_WORDS = new Set(('the is are was were and or but to of in that this with for it as be not if on at by from an a ' +
+    'we i you they have has will can should would there which when what how so then than also all ' +
+    'one two no yes do does did its their our my his her them these those been being more most some ' +
+    'any each both into over after before while because however thus therefore instead about only ' +
+    'just even still yet first second next last new same other such per here where who whose must ' +
+    'may might shall').split(' '));
+/** 功能词密度达到此值即判为漂移；中文期中位 0.012、英文期中位 0.273 以上。 */
+export const DRIFT_THRESHOLD = 0.15;
+/** 判定所需的最少英文词数；低于此值只报数不判定，避免小样本把密度算飞。 */
+export const MIN_WORDS = 50;
+/** 统计一条思考文本的各量。空文本返回全零。 */
+export function measureThinking(text) {
+    const cjk = text.match(/[\u4e00-\u9fff]/g)?.length ?? 0;
+    const words = text.match(/[A-Za-z][A-Za-z'-]*/g) ?? [];
+    const funcWords = words.filter(word => FUNC_WORDS.has(word.toLowerCase())).length;
+    return {
+        chars: text.length,
+        cjk,
+        cjkRatio: text.length === 0 ? 0 : cjk / text.length,
+        words: words.length,
+        funcWords,
+        funcDensity: words.length === 0 ? 0 : funcWords / words.length,
+    };
+}
+/** 对一次测量下判定。 */
+export function verdict(metrics) {
+    if (metrics.words < MIN_WORDS)
+        return 'insufficient';
+    return metrics.funcDensity >= DRIFT_THRESHOLD ? 'drift' : 'chinese';
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 应变（allostasis）：会话状态的自我调节。
+ *
+ * 第一期只实现一个能力——**中文锚定**：每个 step 之前读最近一条思考，若判定为语言
+ * 漂移（英文功能词密度越线），就在请求末尾追加一条中文锚定消息。**平时不出现、漂移
+ * 时才出现**——按需出现是它作为信号的前提。但漂移持续时也不每个 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`
+ * @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";
+/** 需要 `agents` 服务来接收 `agent/pre-step` 事件。 */
+export declare const inject: string[];
+export { anchorText };
+/**
+ * 注册 pre-step 监听器；监听器随 `ctx` 生命周期销毁。
+ *
+ * 用 `{ prepend: true }` 以取得 `next()` 的决策后再追加，与官方 `time-context` 一致。
+ * @param ctx - 插件上下文。
+ */
+export declare function apply(ctx: Context): void;

package/dist/index.js

@@ -0,0 +1,65 @@
+/**
+ * 应变（allostasis）：会话状态的自我调节。
+ *
+ * 第一期只实现一个能力——**中文锚定**：每个 step 之前读最近一条思考，若判定为语言
+ * 漂移（英文功能词密度越线），就在请求末尾追加一条中文锚定消息。**平时不出现、漂移
+ * 时才出现**——按需出现是它作为信号的前提。但漂移持续时也不每个 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`
+ * @module @max-null/dsh-allostasis
+ */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { anchorText } from "./anchor.js";
+import { measureThinking, verdict } from "./drift.js";
+import { latestThinking } from "./thinking.js";
+import { admitAnchor } from "./throttle.js";
+/** Cordis 插件名，同时用作注入消息的 `source.plugin` 与 section 名。 */
+export const name = 'dsh-allostasis';
+/** 需要 `agents` 服务来接收 `agent/pre-step` 事件。 */
+export const inject = ['agents'];
+export { anchorText };
+/**
+ * 注册 pre-step 监听器；监听器随 `ctx` 生命周期销毁。
+ *
+ * 用 `{ prepend: true }` 以取得 `next()` 的决策后再追加，与官方 `time-context` 一致。
+ * @param ctx - 插件上下文。
+ */
+export function apply(ctx) {
+    /** 每个会话一份节流状态；用 WeakMap 以免会话销毁后残留。 */
+    const throttles = new WeakMap();
+    ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || signal.aborted)
+            return decision;
+        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)
+            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 }] },
+                }),
+            ],
+        };
+    }, { prepend: true });
+}

package/dist/thinking.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 从会话事件里取最近一条思考文本。
+ *
+ * 落点：`assistant/message` 事件的 `stream` 数组里 `type: 'reasoning-chunks'` 的
+ * `texts`（`packages/llm/llm/src/assistant-stream.ts:28-34`，文件头注明是
+ * `Lossless compact representation`）。每个 step 一条事件，带 `turn` / `step`。
+ *
+ * 取「最近一条含思考的事件」而不是「恰好上一步」：有些 step 没有思考文本（极短的
+ * 工具步），沿事件倒扫直到命中可以跨过它们。
+ *
+ * 用 `snapshotEvents()` 而非 `eventAt(SessionSeq(n))` 遍历：后者需要 `SessionSeq`，
+ * 而它并未从 `@deepseek-ai/dsh-session` 的包入口导出（`lib/types/index.d.ts:11` 只有
+ * import，不是 re-export）。前者的用法在 `agent-loop/src/runtime-context.ts` 有先例。
+ * @module @max-null/dsh-allostasis/thinking
+ */
+import type { Session } from '@deepseek-ai/dsh-session';
+/** 一条思考文本及其来源位置。 */
+export interface ThinkingSample {
+    /** 产出它的 turn。 */
+    turn: number;
+    /** 产出它的 step。 */
+    step: number;
+    /** 拼接后的思考全文。 */
+    text: string;
+}
+/** 取会话里最近一条非空思考；一条都没有时返回 `undefined`。 */
+export declare function latestThinking(session: Session): ThinkingSample | undefined;

package/dist/thinking.js

@@ -0,0 +1,34 @@
+/**
+ * 从会话事件里取最近一条思考文本。
+ *
+ * 落点：`assistant/message` 事件的 `stream` 数组里 `type: 'reasoning-chunks'` 的
+ * `texts`（`packages/llm/llm/src/assistant-stream.ts:28-34`，文件头注明是
+ * `Lossless compact representation`）。每个 step 一条事件，带 `turn` / `step`。
+ *
+ * 取「最近一条含思考的事件」而不是「恰好上一步」：有些 step 没有思考文本（极短的
+ * 工具步），沿事件倒扫直到命中可以跨过它们。
+ *
+ * 用 `snapshotEvents()` 而非 `eventAt(SessionSeq(n))` 遍历：后者需要 `SessionSeq`，
+ * 而它并未从 `@deepseek-ai/dsh-session` 的包入口导出（`lib/types/index.d.ts:11` 只有
+ * import，不是 re-export）。前者的用法在 `agent-loop/src/runtime-context.ts` 有先例。
+ * @module @max-null/dsh-allostasis/thinking
+ */
+/** 取会话里最近一条非空思考；一条都没有时返回 `undefined`。 */
+export function latestThinking(session) {
+    const events = session.snapshotEvents();
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type !== 'assistant/message')
+            continue;
+        const parts = [];
+        for (const record of event.data.stream) {
+            if (record.type === 'reasoning-chunks')
+                parts.push(...record.texts);
+        }
+        const text = parts.join('');
+        if (text.length === 0)
+            continue;
+        return { turn: event.data.turn, step: event.data.step, text };
+    }
+    return undefined;
+}

package/dist/throttle.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 锚定注入的节流。
+ *
+ * 实测（2026-09-21，会话 `session-502b3e2b`，记录见设计方案 §12.4）：漂移持续时**每个
+ * step 都会判定为漂移**，于是同一个 turn 内会连着注入多条几乎一样的提醒——观测到 3 连注，
+ * 其中 turn 1 之内就有 2 条。第 2 条起信息量已经递减：模型上一个 step 刚读过同一句话。
+ *
+ * 所以收紧到「同一 turn 至多一次」：turn 是用户能感知的自然边界，重试留到下一轮，
+ * 而不是在一步之内反复催促。上限写成常数而不是配置项，是因为**没有数据支撑别的取值**；
+ * 等无对抗的自然漂移样本出来，再决定要不要放宽（设计方案 §八 第 9 条）。
+ * @module @max-null/dsh-allostasis/throttle
+ */
+/** 锚定在单个 turn 内的注入上限。 */
+export declare const MAX_ANCHORS_PER_TURN = 1;
+/** 节流状态。不可变——每次放行都返回一份新状态。 */
+export interface AnchorThrottleState {
+    /** 最近一次注入所针对的 turn（产出那段漂移思考的 turn）。 */
+    lastTurn: number;
+    /** 该 turn 内已经注入了几次。 */
+    inTurn: number;
+    /** 本会话累计注入次数，用于让重复提醒带上序号。 */
+    count: number;
+}
+/**
+ * 判定本次是否放行，并推进状态。
+ *
+ * `sampledTurn` 是**产出那段被判定漂移的思考**的 turn，不是当前 turn——锚定的措辞
+ * 指向「你上一步在想什么」，节流的计次也应当跟着它走。
+ * @param state - 上一次的状态；首次调用传 `undefined`。
+ * @param sampledTurn - 产出该思考的 turn。
+ * @returns 放行时返回新状态；应当跳过时返回 `undefined`。
+ */
+export declare function admitAnchor(state: AnchorThrottleState | undefined, sampledTurn: number): AnchorThrottleState | undefined;

package/dist/throttle.js

@@ -0,0 +1,30 @@
+/**
+ * 锚定注入的节流。
+ *
+ * 实测（2026-09-21，会话 `session-502b3e2b`，记录见设计方案 §12.4）：漂移持续时**每个
+ * step 都会判定为漂移**，于是同一个 turn 内会连着注入多条几乎一样的提醒——观测到 3 连注，
+ * 其中 turn 1 之内就有 2 条。第 2 条起信息量已经递减：模型上一个 step 刚读过同一句话。
+ *
+ * 所以收紧到「同一 turn 至多一次」：turn 是用户能感知的自然边界，重试留到下一轮，
+ * 而不是在一步之内反复催促。上限写成常数而不是配置项，是因为**没有数据支撑别的取值**；
+ * 等无对抗的自然漂移样本出来，再决定要不要放宽（设计方案 §八 第 9 条）。
+ * @module @max-null/dsh-allostasis/throttle
+ */
+/** 锚定在单个 turn 内的注入上限。 */
+export const MAX_ANCHORS_PER_TURN = 1;
+/**
+ * 判定本次是否放行，并推进状态。
+ *
+ * `sampledTurn` 是**产出那段被判定漂移的思考**的 turn，不是当前 turn——锚定的措辞
+ * 指向「你上一步在想什么」，节流的计次也应当跟着它走。
+ * @param state - 上一次的状态；首次调用传 `undefined`。
+ * @param sampledTurn - 产出该思考的 turn。
+ * @returns 放行时返回新状态；应当跳过时返回 `undefined`。
+ */
+export function admitAnchor(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)
+        return undefined;
+    return { lastTurn: sampledTurn, inTurn: inTurn + 1, count: current.count + 1 };
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@max-null/dsh-allostasis",
+  "version": "0.1.0",
+  "description": "应变（allostasis）：会话状态的自我调节。第一期：中文思考的漂移检测与近因锚定",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml",
+    "tools"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "allostasis",
+    "应变",
+    "self-regulation",
+    "plugin",
+    "cordis"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Max-Null/dsh-allostasis.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "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"
+  },
+  "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.1-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.1"
+  }
+}

package/tools/analyze-thinking-lang.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * 思考块语言漂移分析 — 读一份 DSH 会话日志（`session.v3.jsonl`），逐 step 量「思考用什么语言」。
+ *
+ * 判据：**英文功能词密度** = 英文功能词数 / 英文词数，且**英文词数 ≥ 50** 才判定。
+ *   中文期（中位 0.012）与英文期（中位 0.273–0.389）以 **0.15** 干净分开。
+ *
+ * 为什么要词数门槛：中文期唯一的越线点（Turn 1 step 13，密度 0.192）只有 26 个英文词——
+ *   小样本让密度失真。加门槛后中文期零越线、英文期全部越线。
+ *
+ * 为什么不用另外两个看起来更直观的指标：
+ *   · `cjkRatio`（中文字符占比）—— 中文思考本来就大量夹英文标识符，实测中文期只有
+ *     0.19–0.37，与英文期的 0.00–0.15 区分度太小。
+ *   · `maxRun`（最长连续英文游程）—— 中文思考里引用一段代码就会把它顶到 43，而英文期
+ *     反而有大量 1–5 的短思考。它测的是「引用了多长的代码」，不是「用什么语言思考」。
+ *
+ * 用法：
+ *   node analyze-thinking-lang.mjs <session.v3.jsonl>             # 逐 step 明细
+ *   node analyze-thinking-lang.mjs <session.v3.jsonl> --summary   # 只报每 turn 汇总与首个越线点
+ *
+ * 退出码：0 = 未发现漂移；1 = 有 step 越线；2 = 用法错误或读不出 reasoning 文本。
+ *
+ * 实测样本（2026-09-20，会话 session-3bf8bcfb-fd48-4127-a9e7-08b89b4e7167）：
+ *   10 turn / 157 step / 156 条 `assistant/message`，其中 147 条含 reasoning 文本。
+ *   Turn 1（deepseek-flash）中文；Turn 1→2 之间 4 次 `model/selection` 切到
+ *   `qwen-token-plan/qwen3.8-flash`，Turn 2 全程英文；Turn 2→3 切回 deepseek-flash 后
+ *   **英文仍未恢复**——Turn 2 的英文思考已进会话历史，后续模型跟随历史的语言。
+ *
+ * 设计输入（判据来源与完整数据）：`max-null-plugins/dsh-allostasis/docs/设计/2026-09-20-应变-设计方案.md` §4
+ */
+import { readFileSync } from 'node:fs'
+
+const FUNC = new Set(('the is are was were and or but to of in that this with for it as be not if on at by from an a ' +
+  'we i you they have has will can should would there which when what how so then than also all one two no yes do does did ' +
+  'its their our my his her them these those been being more most some any each both into over after before while because ' +
+  'however thus therefore instead about only just even still yet first second next last new same other such per here where ' +
+  'who whose must may might shall').split(' '))
+
+/** 功能词密度越线阈值；中文期中位 0.012、英文期中位 0.273 以上，取两者之间。 */
+const DRIFT_THRESHOLD = 0.15
+
+/** 判定所需的最少英文词数；低于此值只报数不判定，避免小样本把密度算飞。 */
+const MIN_WORDS = 50
+
+/** 从一条思考文本算出各量。`funcDensity` 是判据，其余保留用于诊断与对比。 */
+function metrics(text) {
+  const cjk = (text.match(/[\u4e00-\u9fff]/g) || []).length
+  const words = text.match(/[A-Za-z][A-Za-z'-]*/g) || []
+  const funcw = words.filter(w => FUNC.has(w.toLowerCase())).length
+  const segs = text.split(/[\u4e00-\u9fff]+/)
+  let maxRun = 0
+  for (const s of segs) {
+    const n = (s.match(/[A-Za-z][A-Za-z'-]*/g) || []).length
+    if (n > maxRun) maxRun = n
+  }
+  return {
+    chars: text.length,
+    cjk,
+    cjkRatio: text.length ? cjk / text.length : 0,
+    words: words.length,
+    funcw,
+    funcDensity: words.length ? funcw / words.length : 0,
+    maxRun,
+  }
+}
+
+/** 三态判定：词数不够时不下结论。 */
+function verdict(s) {
+  if (s.words < MIN_WORDS) return '样本不足'
+  return s.funcDensity >= DRIFT_THRESHOLD ? '漂移' : '中文'
+}
+
+const file = process.argv[2]
+const summaryOnly = process.argv.includes('--summary')
+if (!file) {
+  console.error('用法：node analyze-thinking-lang.mjs <session.v3.jsonl> [--summary]')
+  process.exit(2)
+}
+
+const steps = []
+for (const line of readFileSync(file, 'utf8').split('\n')) {
+  if (!line.trim()) continue
+  let ev
+  try { ev = JSON.parse(line) } catch { continue }
+  if (ev.type !== 'assistant/message') continue
+  const d = ev.data || {}
+  const texts = []
+  for (const rec of Array.isArray(d.stream) ? d.stream : []) {
+    if (rec && rec.type === 'reasoning-chunks' && Array.isArray(rec.texts)) texts.push(...rec.texts)
+  }
+  steps.push({ turn: d.turn, step: d.step, ...metrics(texts.join('')) })
+}
+
+const withThinking = steps.filter(s => s.chars > 0)
+if (withThinking.length === 0) {
+  console.error(`读不出 reasoning 文本：${steps.length} 条 assistant/message 全为空。`)
+  console.error('这通常意味着该会话是旧格式（无 reasoning-chunks），别把「扫不出来」读成「没问题」。')
+  process.exit(2)
+}
+
+const drifted = withThinking.filter(s => verdict(s) === '漂移')
+const skipped = withThinking.filter(s => verdict(s) === '样本不足')
+const first = drifted[0]
+
+console.log(`assistant/message ${steps.length} 条，含 reasoning 文本 ${withThinking.length} 条`)
+console.log(`判据「英文功能词密度」≥ ${DRIFT_THRESHOLD} 且英文词数 ≥ ${MIN_WORDS} 视为漂移；越线 ${drifted.length} 条，样本不足 ${skipped.length} 条`)
+if (first) {
+  console.log(`首个越线点：turn ${first.turn} step ${first.step}（密度 ${first.funcDensity.toFixed(2)}，${first.words} 词）`)
+} else {
+  console.log('未发现越线 step。')
+}
+console.log('')
+
+if (summaryOnly) {
+  const byTurn = new Map()
+  for (const s of withThinking) {
+    if (!byTurn.has(s.turn)) byTurn.set(s.turn, [])
+    byTurn.get(s.turn).push(s)
+  }
+  console.log('turn  步数   中位密度   最大密度   越线  样本不足  cjkRatio 范围')
+  for (const [turn, list] of [...byTurn.entries()].sort((a, b) => a[0] - b[0])) {
+    const dens = list.map(s => s.funcDensity).sort((a, b) => a - b)
+    const median = dens[Math.floor(dens.length / 2)]
+    const ratios = list.map(s => s.cjkRatio)
+    console.log(
+      String(turn).padStart(4) + ' ' +
+      String(list.length).padStart(5) + ' ' +
+      median.toFixed(3).padStart(10) + ' ' +
+      Math.max(...dens).toFixed(3).padStart(10) + ' ' +
+      String(list.filter(s => verdict(s) === '漂移').length).padStart(5) + '  ' +
+      String(list.filter(s => verdict(s) === '样本不足').length).padStart(7) + '   ' +
+      Math.min(...ratios).toFixed(2) + '–' + Math.max(...ratios).toFixed(2))
+  }
+} else {
+  console.log('turn step   chars    cjk  cjkRat  words  funcW  density  maxRun  判定')
+  for (const s of withThinking) {
+    console.log(
+      String(s.turn).padStart(4) + ' ' +
+      String(s.step).padStart(4) + ' ' +
+      String(s.chars).padStart(7) + ' ' +
+      String(s.cjk).padStart(6) + ' ' +
+      s.cjkRatio.toFixed(2).padStart(6) + ' ' +
+      String(s.words).padStart(6) + ' ' +
+      String(s.funcw).padStart(6) + ' ' +
+      s.funcDensity.toFixed(3).padStart(8) + ' ' +
+      String(s.maxRun).padStart(6) + '  ' +
+      verdict(s))
+  }
+}
+
+process.exit(drifted.length > 0 ? 1 : 0)