@furongjun1999/dsh-memory 0.7.2 → 0.7.4

package/lib/hooks.js

@@ -20,7 +20,9 @@
  * `origin` / `delegationDepth`）的自动记忆**整条会话拦掉**；② **消息级**——
  * `source.form === 'relay'`（「另一个 agent 发给本 agent 的消息」）不写。
  * 两条判据均为「**字段在场且取值匹配才拦**」：字段缺失一律退化为不过滤（默认放行），
- * 且宿主是否真写这些字段**未在真实会话事件上验证过**（见 installMemoryHooks 内注释）。
+ * 宿主字段面已在本机真实会话事件上观测（2026-10-05 订正：19 场，会话头
+ * `delegationDepth=0` 真实在写）；**仍未观测**的是 `origin='subagent'` /
+ * `delegationDepth>0` / `form='relay'` 的真实出现（见 installMemoryHooks 内注释）。
  *
  * autoRecall：通过 system-prompt/assemble 事件（waterfall，异步允许）在每次
  * 模型请求组装 system prompt 时自动注入灵枢最近记忆
@@ -43,6 +45,10 @@
 import '@deepseek-ai/dsh-session';
 import '@deepseek-ai/dsh-system-prompt';
 import { escapePromptBraces, renderUntrustedMemoryBlock } from './lib/prompt_safety.js';
+import { HookAuditRecorder, kindOf } from './lib/hook_audit.js';
+// 运行期会话状态单点（B 治本批）：观测在 hooks 面，写归因注入在工具面
+// （src/tools.ts）——两处共用同一状态，见 lib/session_state.ts 头注。
+import { currentSession, noteSession, UNASSIGNED_SESSION } from './lib/session_state.js';
 /** 从 ContentBlock[] 提取纯文本。 */
 function extractText(blocks) {
     const parts = [];
@@ -88,8 +94,18 @@ export const WORD_CHARS = `A-Za-z0-9_${FW_DIGITS}${FW_UPPER}${FW_LOWER}＿`;
 /** 两宽数字类。 */
 const DIGIT_CHARS = `0-9${FW_DIGITS}`;
 /** 两宽凭据值类：词字符 + `@ # $ % ^ & * ! . -` 的两宽形态。
- *  ASCII 连字符一律转义（`\\-`）——`[_-－]` 会被解析成 `_`→`－` 的**巨区间**。 */
-const CRED_VALUE_CHARS = `${WORD_CHARS}@＠#$＄%^＆*!.\\-－．`;
+ *  ASCII 连字符一律转义（`\\-`）——`[_-－]` 会被解析成 `_`→`－` 的**巨区间**。
+ *
+ *  N265（本轮补齐）：半角 `&` 与全角 `＃％＾＊` 此前缺位——其对照形态（全角 `＆`、
+ *  半角 `# % ^ *`）早在类里，构成「同形不同过滤」：缺口字符落在值前 4 位内 ⇒ 整条漏检、
+ *  落在第 4 位之后 ⇒ 命中被截断在缺口处、尾部留明文。守卫
+ *  test/fullwidth_redact.test.ts ⑧（形态一）与 ⑨（形态二）钉住这两只退化形态。
+ *
+ *  ⚠️ 全角 `！` **不在**本类，且与半角 `!` 不对称（`!` 在类）——这是**有意保留**的现口径：
+ *  本文件「边界」段与同文件守卫 ④ 把全角叹号钉为句读边界（值在此收住）。
+ *  2026-10-05 使用者裁决：判 by-design——保留全角 ！ 为句读边界，不得并入值类
+ *  （并入必动守卫④），**勿在补字符集时顺手塞进来**——否则守卫 ④ 会红。 */
+const CRED_VALUE_CHARS = `${WORD_CHARS}@＠#＃$＄%％^＾&＆*＊!.\\-－．`;
 /** 两宽令牌值类（本项目令牌 id/secret 的字符集：词字符 + `-`）。
  *  导出供守卫核对字面量规则的同源性（同 ⑦），不承诺稳定 ABI。 */
 export const TOKEN_VALUE_CHARS = `${WORD_CHARS}\\-－`;
@@ -132,12 +148,27 @@ export const SENSITIVE_PATTERNS = [
             + `(?:${twoWidth('password')}|${twoWidth('passwd')}|${twoWidth('pwd')})`
             + `(?![${WORD_CHARS}])\\s*[:=＝：]\\s*[^\\s,，。;；]+`, 'gi'), label: '密码' },
     { re: new RegExp(`${twoWidth('Bearer')}\\s+[${BEARER_VALUE_CHARS}]{8,}`, 'gi'), label: '令牌' },
-    // 中文密码：值限定非中文连续串（凭据特征），避免误伤「密码是重要的安全概念」；
+    // 中文/日文密码标签：值限定非中文连续串（凭据特征），避免误伤「密码是重要的安全概念」；
     // 分隔符补全角等号 `＝`（半角 `=` 本就不在本规则的集合里，故只补全角形态）。
-    { re: new RegExp(`密码\\s*[:：是＝]\\s*[${CRED_VALUE_CHARS}]{4,}`, 'g'), label: '密码' },
+    // N269：词形补齐——繁体「密碼」、日文「パスワード」、中文「口令」与「密码」同表同口径
+    //（三者此前整条漏检：界面承诺 :66「密码…默认过滤」，却认不出这三种常见写法）；
+    // 日文 `は` 一类助词**刻意不并入分隔符集合**（`パスワードは重要です` 是普通句子，
+    // 并进去即刻误伤，与「值类不含中文」同一取舍）。
+    { re: new RegExp(`(?:密码|密碼|口令|パスワード)\\s*[:：是＝]\\s*[${CRED_VALUE_CHARS}]{4,}`, 'g'), label: '密码' },
     // 两宽：全角数字形态同样要被认（`\b` 换成两宽 lookaround，见上）
     { re: new RegExp(`(?<![${WORD_CHARS}])[${DIGIT_CHARS}]{17}[${DIGIT_CHARS}XxＸｘ](?![${WORD_CHARS}])`, 'g'), label: '身份证号' },
     { re: new RegExp(`(?<![${WORD_CHARS}])[1１][3-9３-９][${DIGIT_CHARS}]{9}(?![${WORD_CHARS}])`, 'g'), label: '手机号' },
+    // N269：凭据标签词形的「标签: 值」形态——密钥 / token / secret / creds 此前整条漏检
+    //（界面承诺 :66「密钥/密码/令牌…默认过滤」，而裸 `token:`/`secret=`/`creds=` 一个都不认）。
+    // 值类取共享单点 CRED_VALUE_CHARS 并设 `{4,}` 下限（与中文密码规则同口径）：比
+    // 「任意非空白续写」窄，避免吃掉 `token: 这句是说明文字` 一类普通文本；词形用
+    // twoWidth 单点生成（半角/全角拼写都认，`ＴＯＫＥＮ：…` 同样命中）；标签前后沿用
+    // 两宽 lookaround（`mytoken=`/`tokenize:` 不命中）。
+    // 位置约束：两条令牌规则必须留在数组**最后两位**（test/token_redact_parity.test.ts
+    // 的交换序按 n-2/n-1 取它们做对拍），故本规则插在其前。
+    { re: new RegExp(`(?<![${WORD_CHARS}])`
+            + `(?:密钥|${twoWidth('token')}|${twoWidth('secret')}|${twoWidth('creds')})`
+            + `(?![${WORD_CHARS}])\\s*[:=＝：]\\s*[${CRED_VALUE_CHARS}]{4,}`, 'gi'), label: '密钥' },
     // 本项目自有令牌（issue #45）：批次71 已把形态加进**写入闸门**的禁表，但自动
     // 记忆走的是 mdcg_remember(gated=true)、**不过 audit**，此处是这条路上唯一的
     // 防线——此前不认自家令牌，用户粘一次即明文落进共用记忆库。
@@ -263,26 +294,21 @@ function sessionIdOf(raw) {
     const v = s?.id ?? s?.sessionId;
     return typeof v === 'string' ? v.trim() : '';
 }
-/** 会话归属未知时的**显式占位**（H2③，2026-09-30）。
- *
- *  ⚠️ 不可退回「不传 session 键」：md_cg 的 `Principal.__init__` 在 session 为假值时
- *  生成**进程级随机** `sess_<hex>`（md_cg/security.py:117）——插件不传，等于让一个
- *  进程内所有「宿主未给标识」的会话共用一个**不可辨认**的随机桶：归属在审计上既
- *  读不出是谁、跨进程也对不上，是静默的归属丢失。
- *  本常量把这一态写成**显式值**：跨进程一致、可辨认、可审计，且不是伪造的宿主
- *  会话 id（非 DSH 形态，服务端 `_normalize_session` 原样采用、不会被改写成别的桶）。
- *  要读这个桶：`stg(op=timeline, session="unassigned")`。 */
-const UNASSIGNED_SESSION = 'unassigned';
+// UNASSIGNED_SESSION（会话归属未知时的显式占位常量）单点已移至
+// lib/session_state.ts（B 治本批：本文件与工具面共用同一常量与同一会话状态）。
 /** H1 **会话级**判据：这条 session 是否「子代理/委派子会话」。
  *
- *  字段来源（DSH 类型面，node_modules/@deepseek-ai/dsh-session/lib/types/types.d.ts）：
- *    · `header.origin?: 'subagent'`（:64「Coarse product classification for a
- *      session created as a subagent child」）；
- *    · `header.delegationDepth?: number`（:70「absent (zero) for a top-level
- *      session, parent depth + 1 for a subagent child」）。
+ *  字段来源（DSH 类型面，dsh-session/lib/types/types.d.ts）：实装 DSH 2.0
+ *  （`dsh-0.2.0-rc.2`）:81 `header.origin?: 'subagent'`「Coarse product
+ *  classification for a session created as a subagent child」；:87
+ *  `header.delegationDepth?: number`「absent (zero) for a top-level session,
+ *  parent depth + 1 for a subagent child」（本仓 devDeps `0.1.0-rc.8` 同字段
+ *  在 :64 / :70）。
  *
- *  ⚠️ **未验证项（如实标注）**：本机未装 DSH harness，真实宿主是否真给子代理
- *  子会话写这两个字段，**只在类型面成立、未在真实会话事件上观测过**。故判据取
+ *  ⚠️ **观测面（2026-10-05 订正）**：本机**已装** DSH 2.0（`dsh-0.2.0-rc.2`）；
+ *  19 场真实会话（`sessions/…/session.v4.jsonl.zstd`）观测到会话头
+ *  `delegationDepth=0` 真实在写（19/19），`origin` 键从未出现。**仍未观测**：
+ *  `origin='subagent'` / `delegationDepth>0` 的真实出现。故判据取
  *  「**字段在场且取值匹配才拦**」的形态：header 缺失 / 非对象 / 两个字段都取不到
  *  或不匹配 → 一律返回 false（**不拦**，安全退化为既有行为），绝不因字段缺失而
  *  报错，也不因此改变既有写入行为。
@@ -303,18 +329,22 @@ function isSubagentSession(session) {
 }
 /** H1 **消息级**判据：这条消息是否是「另一个 agent 发给本 agent 的」（委派/中继）。
  *
- *  字段来源（DSH 类型面，node_modules/@deepseek-ai/dsh-llm/lib/types/message.d.ts）：
- *  `ContextForm` 的 `'relay'`（:52 注释原文「A message another agent addressed to
- *  this one」），按类型只挂在 `kind: 'plugin'` 变体的 `form` 上（:98-101）。
+ *  字段来源（DSH 类型面，dsh-llm/lib/types/message.d.ts）：实装 DSH 2.0 里 `'relay'`
+ *  在 `ContextFormed` 判别联合上（:90 `readonly form: 'relay';`；:55-56 注释原文
+ *  「A message another agent addressed to this one」），该联合由各生产者按需混入自己的
+ *  source 类型——2.0 的 `MessageSourceMap` 注释明确**无共享 catch-all `plugin`
+ *  类别**，`kind` 由各生产者声明在自己的模块里（:94-100；本仓 devDeps
+ *  `0.1.0-rc.8` 同段在 :52 / :86）。
  *
- *  ⚠️ **未验证项（如实标注）**：真实宿主是否真给委派消息写 `form: 'relay'`
- *  **未观测过**。故同样取「字段在场且取值匹配才拦」；source 缺失/非对象 → false。
+ *  ⚠️ **观测面（2026-10-05 订正）**：本机**已装** DSH 2.0；19 场真实会话中
+ *  `form='relay'` 从未出现（270 条 `user/message` 实测无 relay），即**真实出现
+ *  仍未观测**。故同样取「字段在场且取值匹配才拦」；source 缺失/非对象 → false。
  *
- *  与既有 `kind !== 'user'` 判据的关系：类型面下 `kind='plugin'` 的中继**本就被**
- *  那条拦掉；本判据放在它**之前**，是为了 ① 不把委派判定押在 `source.kind` 单点上、
- *  ② 覆盖「生产者把中继标成 `kind='user'` 且带 form」这一类型面之外的形态——子会话
- *  的**首轮用户提示**就可能是这种：它与真人输入在 `kind` 上不可分，只有会话级判据
- *  （或这里的 form）能拦。 */
+ *  与既有 `kind !== 'user'` 判据的关系：`kind` 非 `'user'` 的中继**本就被**那条拦掉
+ *  （19 场实测的注入类 kind 均非 `'user'`）；本判据放在它**之前**，是为了
+ *  ① 不把委派判定押在 `source.kind` 单点上、② 覆盖「生产者把中继标成
+ *  `kind='user'` 且带 form」这一类型面之外的形态——子会话的**首轮用户提示**就可能
+ *  是这种：它与真人输入在 `kind` 上不可分，只有会话级判据（或这里的 form）能拦。 */
 function isRelayedMessage(source) {
     const s = source;
     return !!s && typeof s === 'object' && s.form === 'relay';
@@ -329,15 +359,46 @@ export function installMemoryHooks(ctx, mdcg, opts) {
         return;
     }
     const graph = mdcg;
-    /** 最近一次观测到的宿主会话标识（见 sessionIdOf；空串 = 未知/无会话）。 */
-    let lastSession = '';
-    /** 记忆沉淀（fire-and-forget）。认知图未就绪则跳过并告警（不退回 AEIS）。 */
-    const memorize = (label, run) => {
+    /** 落盘审计（issue #56，诊断面）：三处过滤分支与写入/跳过路径各留一道**盘面**
+     *  痕迹——宿主 logger 不落盘时，单看记忆侧无法区分「被设计滤除」与
+     *  「写入失败/漏记」。审计失败静默降级（见 src/lib/hook_audit.ts），
+     *  绝不冒泡进记忆路径、不改任何写入/过滤判定。 */
+    const audit = new HookAuditRecorder(opts.auditPath);
+    /** 本实例是否曾观测到会话（B 治本批）。
+     *
+     *  会话状态本体是**进程级单点**（lib/session_state.ts；hooks 面观测、工具面
+     *  src/tools.ts 的写归因注入共用）；而「本实例有没有观测过」是**实例级**事实：
+     *  多实例并存时（测试；或宿主重装钩子），不得让**别的实例**的观测替本实例决定
+     *  召回过滤——否则新装的钩子在尚未观测到会话时就按别的实例的会话去读
+     *  （读错会话，正是 P45 会话隔离要防的形态）。真机单实例下两者等价：首个
+     *  session/event 之前模块状态为空，之后回落值恒为同一单点值。
+     *
+     *  ⚠️ 这是**经 owner 裁定的契约字面偏离（dwfq-7b3a555e-1）**：契约给的形态是
+     *  下方回落处直接 `|| currentSession()`（无本门）；但字面形态与硬边界
+     *  「test/session-attribution.test.ts 逐字未动且全绿」互斥——该守卫 ② 以
+     *  「新建 harness = 未观测」为前提，字面回落会读成前一实例的 sess_B。裁定
+     *  接受本门，两条理由：① 保留原闭包变量「新实例 = 干净状态」的**有意**语义
+     *  （新装钩子未观测时不加召回过滤）；② 冻结守卫零误伤。真机单实例与字面
+     *  **逐位等价**（差异窗口「本实例未观测 ∧ 模块单点非空」单实例下不可达；
+     *  HMR 重载时新实例回落 '' 属更保守行为）。 */
+    let observedSession = false;
+    /** 记忆沉淀（fire-and-forget）。认知图未就绪则跳过并告警（不退回 AEIS）。
+     *  `role`=null 表示**读预热**（user-recall）——审计只统计写入路径，
+     *  故读预热不参与 written/skipped 计数（它不写记忆）。 */
+    const memorize = (label, role, run) => {
         if (!graph.isReady()) {
+            if (role)
+                audit.skipped('not_ready', role);
             ctx.logger.warn(`dsh-memory: 认知图未就绪，跳过自动记忆（${label}）`);
             return;
         }
-        void run(graph).catch((err) => ctx.logger.warn(`dsh-memory: 自动记忆 ${label} 失败: ${err.message}`));
+        if (role)
+            audit.written(role);
+        void run(graph).catch((err) => {
+            if (role)
+                audit.skipped('failed', role);
+            ctx.logger.warn(`dsh-memory: 自动记忆 ${label} 失败: ${err.message}`);
+        });
     };
     // P1 完善（GPT 审查·自动记忆脱敏）：写入前过滤敏感信息（默认开启）。
     // 命中敏感模式 → 替换为 [已过滤:类别]；纯凭据消息 → 跳过写入（不落库）。
@@ -376,7 +437,13 @@ export function installMemoryHooks(ctx, mdcg, opts) {
                     // 想读**所有**会话做了什么：别走自动召回（它会串台），显式调
                     // `stg(op=timeline, session="*")`，返回项带 session 归属。
                     const hostCtx = _ctx;
-                    const sid = sessionIdOf(hostCtx?.agent?.session) || lastSession;
+                    // 回落 = **本实例观测门 × 模块单点值**（裁定项 dwfq-7b3a555e-1，见上方
+                    // observedSession 注释）：本实例尚未观测 → 回落 ''（保持「新实例 =
+                    // 干净状态」，与 test/session-attribution.test.ts ② 的「未观测 → 不加
+                    // 过滤」相容）；已观测 → 取 lib/session_state.ts 的进程级单点值。
+                    // 真机单实例下两者逐位等价（差异窗口不可达）。
+                    const sid = sessionIdOf(hostCtx?.agent?.session)
+                        || (observedSession ? currentSession() : '');
                     const text = formatTimelineDecayed(await graph.timeline(recallLimit, sid ? { session: sid } : {}));
                     if (text) {
                         // 注入边界转义（issue #16）：宿主 system-prompt 对 context 文本做严格
@@ -401,24 +468,34 @@ export function installMemoryHooks(ctx, mdcg, opts) {
     }
     ctx.on('session/event', (session, event) => {
         // H1（2026-09-30）**会话级**判据：子代理/委派子会话的自动记忆**整条会话**拦掉。
-        // 位置在取 sid **之前**——子代理会话不得污染 lastSession，否则顶层会话的自动
-        // 召回会拿子代理的 session 去读（读错会话）。字段缺失即不拦，见 isSubagentSession。
+        // 位置在取 sid **之前**——子代理会话不得污染会话状态（lib/session_state.ts
+        // 单点），否则顶层会话的自动召回会拿子代理的 session 去读（读错会话）。
+        // 字段缺失即不拦，见 isSubagentSession。
         if (isSubagentSession(session)) {
             ctx.logger.info('dsh-memory: 子代理会话的自动记忆被拦（H1：header.origin/delegationDepth）');
+            audit.filtered('subagent');
             return;
         }
         // 会话归属（P45）：记忆写入必须带会话身份，用来区分不同会话的记忆。
         // 空串 = 宿主未给出会话标识 → **显式标注 unassigned**（H2③：不落内核的进程级
-        // 随机 sess_*，也不编造宿主会话 id——见 UNASSIGNED_SESSION 的注释）。
+        // 随机 sess_*，也不编造宿主会话 id——见 lib/session_state.ts 的常量注释）。
         const sid = sessionIdOf(session);
-        if (sid)
-            lastSession = sid;
+        // 观测即记录（B 治本批）：注入单点在 lib/session_state.ts——工具面
+        // （src/tools.ts 的写归因转发）读同一个状态；位置不动（H1 子代理闸之后）。
+        if (sid) {
+            noteSession(sid);
+            observedSession = true;
+        }
         const sessionTag = sid ? { session: sid } : { session: UNASSIGNED_SESSION };
         if (event.type === 'user/message' && opts.userMessage) {
+            // 落盘审计（issue #56）：source.kind 分布——先于两级判据记录**完整**输入分布
+            // （含被滤与放行），「宿主到底给这条消息标了什么 kind」是排障第一问。
+            audit.observeKind(kindOf(event.data.source));
             // H1 **消息级**判据：委派/中继消息（`form: 'relay'` 语义＝「另一个 agent
             // 发给本 agent 的消息」）不写。先于 kind 判据，理由见 isRelayedMessage 注释。
             if (isRelayedMessage(event.data.source)) {
                 ctx.logger.info('dsh-memory: 委派/中继消息的自动记忆被拦（H1：source.form=relay）');
+                audit.filtered('relay', kindOf(event.data.source));
                 return;
             }
             // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
@@ -426,15 +503,18 @@ export function installMemoryHooks(ctx, mdcg, opts) {
                 // T4 诊断（2026-08-30）：dsh 端对话零写入排查——记录被滤事件的实际
                 // source.kind（若 dsh 新版改了 kind 值，此处日志可定位）
                 ctx.logger.info(`dsh-memory: user/message 事件被滤（source.kind=${event.data.source?.kind ?? 'undefined'}）`);
+                audit.filtered('kind', kindOf(event.data.source));
                 return;
             }
             const text = extractText(event.data.content);
             if (!text)
                 return;
             const safe = sanitize(text); // 脱敏：纯凭据消息 → null → 跳过写入
-            if (safe === null)
+            if (safe === null) {
+                audit.skipped('sanitized', 'user');
                 return;
-            memorize('user', (g) => g.remember(safe, {
+            }
+            memorize('user', 'user', (g) => g.remember(safe, {
                 role: 'user', tags: ['dsh', 'user'], importance: opts.importance,
                 ...sessionTag,
             }));
@@ -450,16 +530,18 @@ export function installMemoryHooks(ctx, mdcg, opts) {
             // 改 mdcg_client.ts（本件放行面之外），故在调用点改走等价出口。
             // 带上它不构成越权：cg 读路径的 session 是**归因/视图**维度，不参与任何授权
             // （issue #35 定稿「身份不可自报」，见 md_cg/mdcos.py 的 _candidates）。
-            memorize('user-recall', (g) => g.read(safe.slice(0, 200), { k: 3, ...sessionTag }));
+            memorize('user-recall', null, (g) => g.read(safe.slice(0, 200), { k: 3, ...sessionTag }));
         }
         else if (event.type === 'assistant/message' && opts.assistantMessage) {
             const text = extractText(event.data.message.content);
             if (!text)
                 return;
             const safe = sanitize(text);
-            if (safe === null)
+            if (safe === null) {
+                audit.skipped('sanitized', 'assistant');
                 return;
-            memorize('assistant', (g) => g.remember(safe, {
+            }
+            memorize('assistant', 'assistant', (g) => g.remember(safe, {
                 role: 'assistant', tags: ['dsh', 'assistant'], importance: opts.importance * 0.8,
                 ...sessionTag,
             }));
@@ -471,9 +553,11 @@ export function installMemoryHooks(ctx, mdcg, opts) {
             if (!text)
                 return;
             const safe = sanitize(text);
-            if (safe === null)
+            if (safe === null) {
+                audit.skipped('sanitized', 'tool');
                 return;
-            memorize('tool', (g) => g.remember(safe, {
+            }
+            memorize('tool', 'tool', (g) => g.remember(safe, {
                 role: 'tool-output', tags: ['dsh', 'tool'], importance: opts.importance * 0.6,
                 ...sessionTag,
             }));

package/lib/lib/hook_audit.d.ts

@@ -0,0 +1,55 @@
+/** 三处过滤分支的成因（与 hooks.ts 一一对应：子代理会话 / 中继消息 / kind 非 user）。 */
+export type HookFilterReason = 'subagent' | 'relay' | 'kind';
+/** 写入路径的角色（与 md_cg 对 DSH 会话事件的 role 约定一致）。 */
+export type HookWriteRole = 'user' | 'assistant' | 'tool';
+/** 跳过写入的成因。 */
+export type HookSkipReason = 'sanitized' | 'not_ready' | 'failed';
+/** last 的一条摘要（**绝不含消息内容**——只有动作、成因、kind 与 role）。 */
+export interface HookAuditEntry {
+    ts: string;
+    action: 'filtered' | 'written' | 'skipped';
+    reason?: HookFilterReason | HookSkipReason;
+    kind?: string;
+    role?: HookWriteRole;
+}
+/** 审计状态（= 状态文件的结构）。 */
+export interface HookAuditState {
+    counts: {
+        /** 三处过滤分支的计数。 */
+        filtered: Record<HookFilterReason, number>;
+        /** 成功发起的写入计数（按 role 分解）。 */
+        written: Record<HookWriteRole, number>;
+        /** 跳过写入的计数（脱敏置空 / 认知图未就绪 / 写入失败）。 */
+        skipped: Record<HookSkipReason, number>;
+    };
+    /** 进入消息级处理的 `source.kind` 分布（缺字段/空串/非字符串记 "undefined"）。 */
+    kinds: Record<string, number>;
+    /** 最近 ≤MAX_LAST 条摘要。 */
+    last: HookAuditEntry[];
+    updated_at: string;
+}
+/** 缺省审计文件：与桥探针 / apply 探针同目录同惯例（README.md:110）。 */
+export declare const DEFAULT_HOOK_AUDIT_PATH: string;
+/** `source.kind` 的规范化取值：非字符串（含缺字段）或空串一律记 "undefined"
+ *  （不可辨认即无值——空串与缺字段在排障上同义）。 */
+export declare function kindOf(source: unknown): string;
+/**
+ * 有界落盘审计记录器（**静默降级**：任何公共方法都不会抛错）。
+ *
+ * 用法（hooks.ts 内）：`new HookAuditRecorder(opts.auditPath)`，随后在
+ * 三处过滤分支与写入/跳过路径各调一次对应方法。审计失败只影响审计自身。
+ */
+export declare class HookAuditRecorder {
+    #private;
+    /** 实际生效的审计文件路径（构造时定死，供日志/测试核对）。 */
+    readonly path: string;
+    constructor(path?: string);
+    /** 一条**被设计滤除**的消息（三处过滤分支各调一次）。 */
+    filtered(reason: HookFilterReason, kind?: string): void;
+    /** `source.kind` 分布（每条**进入消息级处理**的事件调一次，含被滤与放行）。 */
+    observeKind(kind: string): void;
+    /** 成功**发起**的写入（按 role；发起后失败另记 skipped.failed）。 */
+    written(role: HookWriteRole): void;
+    /** 跳过写入（脱敏置空 / 认知图未就绪 / 写入失败）。 */
+    skipped(reason: HookSkipReason, role?: HookWriteRole): void;
+}

package/lib/lib/hook_audit.js

@@ -0,0 +1,208 @@
+/**
+ * hook_audit.ts · 自动记忆钩子的**有界落盘审计**（issue #56，诊断面）
+ *
+ * 病灶（报告人 jiamajie，v0.7.1 实测）：src/hooks.ts 的三处过滤分支（子代理会话 /
+ * 中继消息 / `source.kind !== 'user'`）只调 `ctx.logger.info`——宿主 logger 不落盘，
+ * 盘面完全无痕。其它插件按设计注入的 `role:"user"` 消息（如 @michengai/dsh-pua 的
+ * PUA_RUNTIME_V1 提示）不进记忆库时，从记忆侧只能看到「少了一条」，无法区分
+ * 「被设计滤除」与「写入失败/漏记」。
+ *
+ * 本模块 = **诊断面**，不参与任何写入/过滤判定（红线：哪些消息进记忆一字不动）：
+ *   ① 维护一份小 JSON 状态文件（缺省 `~/.dsh/logs/dsh-memory-hook-audit.json`，
+ *      与 `lingshu-bridge-debug.log` / `dsh-memory-apply-error.log` 同目录同惯例，
+ *      见 README.md:110）；
+ *   ② 每事件只写计数与「最近条目」摘要（action/reason/kind/role），**绝不记录
+ *      消息内容**（内容可能含隐私/凭据，审计文件是可被随手打开的诊断件）；
+ *   ③ 原子写：同目录临时文件 + rename（读者永远不会看到半截 JSON）；
+ *   ④ 有界：last 截断到 MAX_LAST=20（无追加式增长）；kinds 键数上限 MAX_KINDS，
+ *      超限归并到 "other"（kind 值域理论上由宿主决定，防异常值把文件撑大）；
+ *   ⑤ 静默降级：公共方法全部 try/catch 包死——审计失败绝不冒泡进记忆路径
+ *      （审计是增益，记忆写入必须照常）。
+ *
+ * 为什么落盘采用**同步** fs：`session/event` 回调是同步的，异步落盘会引入
+ * 「多事件并发写同一文件」的乱序与竞态；状态文件只有几 KB，一次同步读（仅首次）
+ * 加一次全量重写的代价远小于它守护的诊断价值。
+ *
+ * 与 ctx.logger.info 的关系：hook 内三行 info 日志**保留不动**（in-memory 实时
+ * 视图），本审计是**盘面**视图（宿主 logger 不落盘时仍可复盘）。
+ *
+ * 边界（如实）：
+ *   · 状态是「进程内缓存 + 每次全量重写」，多进程同时写同一路径会互相覆盖
+ *     （插件单实例部署下不构成问题；审计非关键路径，不做跨进程锁）；
+ *   · 审计文件损坏/手改致形态不符时按空态重建（数值归零、last 逐条过滤），
+ *     不抛错、不保留非法内容；
+ *   · `written` 记的是「**成功发起**」的写入（fire-and-forget 的发起时刻），
+ *     发起后失败另记 `skipped.failed`——与 hooks.ts 的 memorize 两段式对应。
+ */
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/** 缺省审计文件：与桥探针 / apply 探针同目录同惯例（README.md:110）。 */
+export const DEFAULT_HOOK_AUDIT_PATH = join(homedir(), '.dsh', 'logs', 'dsh-memory-hook-audit.json');
+/** last 条数上限（有界性单点——没有它 audit 文件会随会话无限增长）。 */
+const MAX_LAST = 20;
+/** kinds 键数上限（超限归并到 OTHER_KIND，防宿主 kind 值域异常撑大文件）。 */
+const MAX_KINDS = 32;
+/** kinds 归并桶。 */
+const OTHER_KIND = 'other';
+const FILTER_REASONS = ['subagent', 'relay', 'kind'];
+const WRITE_ROLES = ['user', 'assistant', 'tool'];
+const SKIP_REASONS = ['sanitized', 'not_ready', 'failed'];
+/** `source.kind` 的规范化取值：非字符串（含缺字段）或空串一律记 "undefined"
+ *  （不可辨认即无值——空串与缺字段在排障上同义）。 */
+export function kindOf(source) {
+    const k = source?.kind;
+    return typeof k === 'string' && k.length > 0 ? k : 'undefined';
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function emptyState() {
+    return {
+        counts: {
+            filtered: { subagent: 0, relay: 0, kind: 0 },
+            written: { user: 0, assistant: 0, tool: 0 },
+            skipped: { sanitized: 0, not_ready: 0, failed: 0 },
+        },
+        kinds: {},
+        last: [],
+        updated_at: nowIso(),
+    };
+}
+/** 计数位：只认有限非负整数，其余归零（防手改/坏文件把计数变成 NaN）。 */
+function countOf(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? Math.floor(v) : 0;
+}
+/** 盘面内容 → 状态：逐字段归并，形态不符的字段一律丢弃（不信任盘面内容）。 */
+function mergeState(raw) {
+    const s = emptyState();
+    if (!raw || typeof raw !== 'object')
+        return s;
+    const r = raw;
+    if (r.counts && typeof r.counts === 'object') {
+        const c = r.counts;
+        const buckets = [
+            [s.counts.filtered, FILTER_REASONS, c.filtered],
+            [s.counts.written, WRITE_ROLES, c.written],
+            [s.counts.skipped, SKIP_REASONS, c.skipped],
+        ];
+        for (const [dst, keys, src] of buckets) {
+            if (!src || typeof src !== 'object')
+                continue;
+            for (const key of keys)
+                dst[key] = countOf(src[key]);
+        }
+    }
+    if (r.kinds && typeof r.kinds === 'object') {
+        for (const [k, v] of Object.entries(r.kinds)) {
+            if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+                s.kinds[k] = Math.floor(v);
+        }
+    }
+    if (Array.isArray(r.last)) {
+        for (const e of r.last) {
+            if (!e || typeof e !== 'object')
+                continue;
+            const entry = e;
+            if (typeof entry.ts !== 'string')
+                continue;
+            if (entry.action !== 'filtered' && entry.action !== 'written' && entry.action !== 'skipped')
+                continue;
+            s.last.push(entry);
+        }
+        if (s.last.length > MAX_LAST)
+            s.last = s.last.slice(-MAX_LAST);
+    }
+    return s;
+}
+/**
+ * 有界落盘审计记录器（**静默降级**：任何公共方法都不会抛错）。
+ *
+ * 用法（hooks.ts 内）：`new HookAuditRecorder(opts.auditPath)`，随后在
+ * 三处过滤分支与写入/跳过路径各调一次对应方法。审计失败只影响审计自身。
+ */
+export class HookAuditRecorder {
+    /** 实际生效的审计文件路径（构造时定死，供日志/测试核对）。 */
+    path;
+    /** 进程内状态缓存（首次记录时从盘面载入，此后只增量改内存 + 全量重写）。 */
+    #state = null;
+    constructor(path) {
+        this.path = typeof path === 'string' && path.trim() ? path.trim() : DEFAULT_HOOK_AUDIT_PATH;
+    }
+    /** 一条**被设计滤除**的消息（三处过滤分支各调一次）。 */
+    filtered(reason, kind) {
+        this.#mutate((s) => {
+            s.counts.filtered[reason] += 1;
+            s.last.push(kind === undefined
+                ? { ts: nowIso(), action: 'filtered', reason }
+                : { ts: nowIso(), action: 'filtered', reason, kind });
+        });
+    }
+    /** `source.kind` 分布（每条**进入消息级处理**的事件调一次，含被滤与放行）。 */
+    observeKind(kind) {
+        this.#mutate((s) => {
+            const key = this.#boundedKindKey(s, kind);
+            s.kinds[key] = (s.kinds[key] ?? 0) + 1;
+        });
+    }
+    /** 成功**发起**的写入（按 role；发起后失败另记 skipped.failed）。 */
+    written(role) {
+        this.#mutate((s) => {
+            s.counts.written[role] += 1;
+            s.last.push({ ts: nowIso(), action: 'written', role });
+        });
+    }
+    /** 跳过写入（脱敏置空 / 认知图未就绪 / 写入失败）。 */
+    skipped(reason, role) {
+        this.#mutate((s) => {
+            s.counts.skipped[reason] += 1;
+            s.last.push(role === undefined
+                ? { ts: nowIso(), action: 'skipped', reason }
+                : { ts: nowIso(), action: 'skipped', reason, role });
+        });
+    }
+    /** 键数有界：已见键原样用；新键在未达上限时收录，达限后统一归并到 "other"。 */
+    #boundedKindKey(s, kind) {
+        if (Object.prototype.hasOwnProperty.call(s.kinds, kind))
+            return kind;
+        return Object.keys(s.kinds).length >= MAX_KINDS ? OTHER_KIND : kind;
+    }
+    /** 读改写 + 原子落盘；整段 try/catch——审计失败静默降级（绝不冒泡进记忆路径）。 */
+    #mutate(fn) {
+        try {
+            const s = this.#state ?? (this.#state = this.#load());
+            fn(s);
+            if (s.last.length > MAX_LAST)
+                s.last = s.last.slice(-MAX_LAST);
+            s.updated_at = nowIso();
+            this.#save(s);
+        }
+        catch { /* 审计失败静默降级：记忆路径必须照常 */ }
+    }
+    /** 盘面 → 状态；不存在/不可读/坏 JSON/形态不符 → 空态重建（不抛）。 */
+    #load() {
+        try {
+            return mergeState(JSON.parse(readFileSync(this.path, 'utf8')));
+        }
+        catch {
+            return emptyState();
+        }
+    }
+    /** 原子写：同目录临时文件 + rename（临时文件在 rename 失败时清理）。 */
+    #save(s) {
+        const dir = dirname(this.path);
+        mkdirSync(dir, { recursive: true });
+        const tmp = `${this.path}.${process.pid.toString(36)}.${Date.now().toString(36)}.tmp`;
+        writeFileSync(tmp, `${JSON.stringify(s, null, 2)}\n`, 'utf8');
+        try {
+            renameSync(tmp, this.path);
+        }
+        catch (err) {
+            try {
+                unlinkSync(tmp);
+            }
+            catch { /* 清理失败忽略：残留 .tmp 不影响读路径 */ }
+            throw err;
+        }
+    }
+}

package/lib/lib/mutual.js

@@ -211,8 +211,12 @@ export async function llmReview(claim, whitebox, reviewFn) {
 export function combineVerdict(w, l) {
     const c = l.conclusion || '';
     // P1 修复（GPT 审查）：白箱通道异常 → fail-closed（不因复核「同意」而 pass）
+    // N268：**复核通道**异常的标记由 llmReview 写在 `l.conclusion`（`llm_error: …`）——
+    // 此前只查 w.judgment（该字段只可能由 whiteboxVerify 写 whitebox_error）⇒ 该分支
+    // 是死条件，复核抛异常时白箱「采纳」径直判 pass（复核不可用反成「通过」）。
+    // 两字段都查：l 侧是真正的生产者口径，w 侧保留同形防御（防上游把异常塞进白箱字段）。
     if (w.judgment.startsWith('whitebox_error') || w.judgment.startsWith('llm_error')
-        || w.d_norm < 0) {
+        || c.startsWith('llm_error') || w.d_norm < 0) {
         return 'needs_revision';
     }
     if (w.judgment.startsWith('采纳')) {

package/lib/lib/roleplay_web.js

@@ -844,6 +844,17 @@ export async function installRoleplayWeb(ctx, capability, config, disposers, mdc
                         res.end(JSON.stringify({ ok: false, error: '非法角色 id（白名单 ^[A-Za-z0-9_.-]{1,64}$）' }));
                         return;
                     }
+                    // N266：入口类型闸——message 必须是字符串。此前这段直接
+                    // `p.message.includes(w)`：message 为数组时静默走
+                    // Array.prototype.includes（逐元素**全等**比较），把敏感词拆进
+                    // 不同元素即整条绕过硬拦截；数字/对象/缺省则抛 TypeError 落 500
+                    // （内部异常文本随响应外泄）。与 role_id 同口径：非法形态在入口
+                    // 一律 400 拒——不转发引擎、不落转录。
+                    if (typeof p.message !== 'string') {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ ok: false, route: 'refused', refused: 'bad_message', error: 'message 必须是字符串（非字符串形态不得绕过内容硬拦截，N266）' }));
+                        return;
+                    }
                     // P1 完善（会话隔离）：按客户端实例隔离 session 与转录
                     const cid = clientIdOf(req);
                     // —— 服务端内容分级硬拦截（不依赖前端，法律与协议保护）——
@@ -857,13 +868,17 @@ export async function installRoleplayWeb(ctx, capability, config, disposers, mdc
                         res.end(JSON.stringify({ reply: '⛔ 已拒绝：涉及未成年人的性内容违反国家法律与灵枢协议（未成年人保护）。灵枢不提供任何涉及未成年人的性扮演内容。', route: 'refused', refused: 'minor_nsfw' }));
                         return;
                     }
-                    appendTranscript(role, { time: Date.now(), role: 'user', text: p.message }, cid);
-                    void toGraph('user-turn', (g) => g.writeTranscript(role, cid, 'user', p.message));
                     if (!capReady()) {
                         res.writeHead(503, { 'Content-Type': 'application/json; charset=utf-8' });
                         res.end(JSON.stringify({ reply: '', route: 'unavailable', error: CAP_ABSENT_MSG }));
                         return;
                     }
+                    // N266：落盘移到内容门控与就绪闸**之后**——被内容门控拒绝的、以及
+                    // 「能力未接入」（503）的回合都从未发生，此前这两笔写在校验与
+                    // capReady 之前，未经门控的 message 原文会被留进本地转录
+                    //（读同一文件的历史接口随即原样回放）。
+                    appendTranscript(role, { time: Date.now(), role: 'user', text: p.message }, cid);
+                    void toGraph('user-turn', (g) => g.writeTranscript(role, cid, 'user', p.message));
                     const r = await capability.callTool('roleplay_chat', {
                         message: p.message, role_id: role, session_id: sessionFor(role, cid), data_dir: roleDataDir,
                     });