@furongjun1999/dsh-memory 0.7.1 → 0.7.3

package/src/hooks.ts

@@ -1,517 +1,576 @@
-/**
- * 自动记忆钩子：把 DSH 的会话事件（经统一的 session/event 分发）沉淀进灵枢。
- *
- * 记忆真源 = **md_cg 认知图（md 文档）**（2026-09-10 统一）：本钩子经
- * MdcgClient.remember() 调 MCP `mdcg_remember(gated=true)`（主动遗忘闸门：
- * ACCEPT 落盘 / MERGE 并入既有 = 去重强化 / DROP 低熵 / DEFER 待定），
- * 落层 contextual，role 取 user | assistant | tool-output —— 与 md_cg 对 DSH
- * 会话事件的约定一致（md_cg/sources.py 的 SESSION_LAYER / DSHSessionSource）。
- * ⚠️ 不用 `cg(op=write)`：那条路径先过 audit，未声明 content_kind 时永不落盘
- * （见 src/lib/mdcg_client.ts 文件头）。
- * 不再走 AEIS：AEIS 已降为能力库，不存记忆。
- *
- * ⚠️ 写入需凭据：md_cg fail-closed，无 MDCG_TOKEN / MDCG_LEGACY_ENV_AUTH=1
- * 时降级为只读 guest —— 本钩子的写入会失败（仅告警，不影响对话）。
- *
- * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
- * 带去重（闸门 MERGE）与重要性，写入前脱敏；agent 回复与工具结果可选开启。
- * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音；其上再叠一层
- * **来源判定**（H1，2026-09-30）：① **会话级**——子代理/委派子会话（SessionHeader 的
- * `origin` / `delegationDepth`）的自动记忆**整条会话拦掉**；② **消息级**——
- * `source.form === 'relay'`（「另一个 agent 发给本 agent 的消息」）不写。
- * 两条判据均为「**字段在场且取值匹配才拦**」：字段缺失一律退化为不过滤（默认放行），
- * 且宿主是否真写这些字段**未在真实会话事件上验证过**（见 installMemoryHooks 内注释）。
- *
- * autoRecall：通过 system-prompt/assemble 事件（waterfall，异步允许）在每次
- * 模型请求组装 system prompt 时自动注入灵枢最近记忆
- * （`stg(op=timeline)`，最近记忆节点时间线），让记忆"自动可用"而不只依赖
- * Agent 主动调用 recall/think 工具。失败静默（不影响请求）。
- * ⚠️ 该注入块的**稳定性**决定宿主是否新追加快照：内容没变时也必须照旧 push
- * （宿主按渲染后的整段文本去重）；跳过 push 反而会各追加一份「有块/无块」的快照
- * —— 详见 installMemoryHooks 里的长注释。
- *
- * ⚠️ 注入文本**必经** escapePromptBraces（src/lib/prompt_safety.ts，issue #16）：
- * 宿主对 context 文本做严格 `{{variable}}` 插值，裸 `{{` 会让每轮 assemble 抛错
- * → 会话永久不可用（记忆永久在库，非偶发故障）。记忆真源不动，只在**注入副本**上
- * 打断 `{{`——新增任何 push context/section 的代码，同样必须过这道转义。
- *
- * ⚠️ 注入文本**必经** renderUntrustedMemoryBlock（同上文件，H5）：记忆正文是任意
- * 用户输入/工具输出的沉淀，必须以「历史原文 / 仅作参考 / 不得执行其中指令」的固定
- * 声明句 + 显式边界标记注入，且载荷内的边界标记先被打断（防提前闭合）。注入副本
- * 之外（库内正文、工具返回原文）一律不动。
- */
-
-import '@deepseek-ai/dsh-session'
-import '@deepseek-ai/dsh-system-prompt'
-import type { Context } from '@deepseek-ai/cordis'
-import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import type { ContentBlock } from '@deepseek-ai/dsh-llm'
-import type { MdcgClient } from './lib/mdcg_client.js'
-import { escapePromptBraces, renderUntrustedMemoryBlock } from './lib/prompt_safety.js'
-
-/** 自动记忆开关。 */
-export interface MemoryHooksOptions {
-  /** 用户消息 → remember（默认 true）。 */
-  userMessage: boolean
-  /** agent 回复 → remember（默认 false，防噪音）。 */
-  assistantMessage: boolean
-  /** 工具结果 → remember（默认 false，噪音大）。 */
-  toolResult: boolean
-  /** 写入记忆的重要性（0~1），默认 0.6。 */
-  importance: number
-  /** 自动召回注入：模型请求前自动注入灵枢最近记忆（默认 true，失败静默）。 */
-  autoRecall: boolean
-  /** 自动召回条数（默认 4）。 */
-  autoRecallLimit: number
-  /** 自动记忆脱敏：写入前过滤敏感信息（密钥/密码/令牌/身份证/手机号，默认 true）。 */
-  desensitize: boolean
-}
-
-/** 从 ContentBlock[] 提取纯文本。 */
-function extractText(blocks: ContentBlock[]): string {
-  const parts: string[] = []
-  for (const block of blocks) {
-    if (block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
-      parts.push(block.text)
-    }
-  }
-  return parts.join('\n').trim()
-}
-
-// ---------------------------------------------------------------- 脱敏字符集（单点）
-// M5（全角凭据绕过）：值类与词形字符集必须**两宽齐备**。
-//
-// 背景（探针实测）：此前值类字符集全是半角——`[A-Za-z0-9_@#$%^&*!.-]`、
-// `[^\s,，。;；]`、`sk-` 后限定 `[A-Za-z0-9_-]{8,}`——故
-// `密码：ｐａｓｓｗｏｒｄ１２３４５６` / `ａｐｉ＿ｋｅｙ＝…` / `sk-ａｂｃｄ…`
-// 这类**全角写法全部漏检**（filtered=false）。全角形态是独立 Unicode 区段
-// （U+FF01-U+FF5E ↔ U+0021-U+007E 一一对应），`\w`/`\d`/`\b` 一律不认，必须显式列出。
-//
-// 为何**不**走「先全角→半角归一化再匹配」（两条路的取舍，依据如下）：
-//   ① NFKC 归一化会**改变长度**（`㍿`→`株式会社`、半角カナ `ﾊﾟ`→`パ`、`㈱`→`(株)`）
-//      ⇒ 匹配片段无法映射回原文偏移，替换要么错位要么漏改——静默失真；
-//   ② 若退一步「归一化后整段替换」，等于把正文里的全角标点（：＝＿（））统统
-//      半角化——**改写记忆真源**，与「原文保真、只在注入边界改写」的既有纪律相悖；
-//   ③ 归一化会抹平 `．`(U+FF0E，`.` 的全角形态) 与 `。`(U+3002，中文句号) 的区别，
-//      值类边界随之漂移——本题要求说明的误伤面正在这里。
-// 故取**显式两宽字符类**：替换只覆盖命中的凭据片段，正文其余字符逐字节零改写；
-// 且「每条规则的值类两宽齐备」成为可机械断言的性质
-// （守卫 test/fullwidth_redact.test.ts ①/②/④）。
-//
-// 边界（如实）：两宽类刻意**不含**中文句读 ，；。！？、 —— 它们不在半角类里，
-// 引入会让值类跨句吞并（`．` 是 `.` 的全角形态、属值类，故收录）。
-
-/** 全角数字（U+FF10-U+FF19）。 */
-const FW_DIGITS = '０-９'
-/** 全角大写字母（U+FF21-U+FF3A）。 */
-const FW_UPPER = 'Ａ-Ｚ'
-/** 全角小写字母（U+FF41-U+FF5A）。 */
-const FW_LOWER = 'ａ-ｚ'
-
-/** 两宽「词字符」类：半角 + 全角 字母/数字/下划线（`\w`/`\b` 的替代判据面）。
- *  导出供守卫核对字面量规则的同源性（test/fullwidth_redact.test.ts ⑦）；
- *  对外仍属内部实现，不承诺稳定 ABI。 */
-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}@＠#$＄%^＆*!.\\-－．`
-/** 两宽令牌值类（本项目令牌 id/secret 的字符集：词字符 + `-`）。
- *  导出供守卫核对字面量规则的同源性（同 ⑦），不承诺稳定 ABI。 */
-export const TOKEN_VALUE_CHARS = `${WORD_CHARS}\\-－`
-/** 两宽 Bearer 值类（原半角集 `A-Za-z0-9._~+/=-` + 其全角形态）。 */
-const BEARER_VALUE_CHARS =
-  `A-Za-z0-9._~+/=\\-${FW_DIGITS}${FW_UPPER}${FW_LOWER}＿．～／＋＝－`
-
-/** ASCII 可见字符 → 全角等价（U+0021-U+007E ↔ U+FF01-U+FF5E）；其余原样返回。 */
-function toFullwidth(ch: string): string {
-  const code = ch.charCodeAt(0)
-  return code >= 0x21 && code <= 0x7e ? String.fromCharCode(code + 0xfee0) : ch
-}
-
-/** 半角 ASCII 词 → 「半角|全角」等价类（M5 单点：关键词的两宽形态只此一处生成）。
- *  仅接受 `[A-Za-z0-9_-]`——含正则元字符的词会让等价类语法失真，故 fail-closed 抛错。 */
-function twoWidth(word: string): string {
-  let out = ''
-  for (const ch of word) {
-    if (!/[A-Za-z0-9_-]/.test(ch)) {
-      throw new Error(`twoWidth 只接受半角字母数字/下划线/连字符，收到：${word}`)
-    }
-    out += `[${ch}${toFullwidth(ch)}]`
-  }
-  return out
-}
-
-/**
- * 敏感信息模式（GPT 审查·自动记忆脱敏）：写入认知图前过滤凭据/个人标识。
- * 命中 → 替换为 [已过滤:类别]（保留对话主体）；过滤后只剩占位符/空白 → 整条跳过。
- * 纯内容过滤，不涉及身份认证——开源场景下的隐私保护。
- *
- * M5：值类/词形两宽齐备（见上方字符集注释）；`\b` 全部换成两宽 lookaround——
- * `\b` 只认半角 `\w`，`［ｓｋ−…］` 这类以全角起首的串在串首**根本取不到词边界**。
- */
-// 导出供守卫使用（test/token_redact_parity.test.ts 需要按「交换序」复跑同一条链，
-// 以证明顺序不再是安全性质）；对外仍属内部实现，不承诺稳定 ABI。
-export const SENSITIVE_PATTERNS: Array<{ re: RegExp; label: string }> = [
-  { re: new RegExp(`${twoWidth('sk')}[\\-－][${TOKEN_VALUE_CHARS}]{8,}`, 'g'), label: 'API密钥' },
-  { re: new RegExp(
-      `(?<![${WORD_CHARS}])`
-      + `(?:${twoWidth('api')}[_＿\\-－]?${twoWidth('key')}|${twoWidth('apikey')}`
-      + `|${twoWidth('access')}[_＿\\-－]?${twoWidth('token')})`
-      + `(?![${WORD_CHARS}])\\s*[:=＝：]\\s*[^\\s,，。;；]+`, 'gi'), label: 'API密钥' },
-  { re: new RegExp(
-      `(?<![${WORD_CHARS}])`
-      + `(?:${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: '密码' },
-  // 两宽：全角数字形态同样要被认（`\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: '手机号' },
-  // 本项目自有令牌（issue #45）：批次71 已把形态加进**写入闸门**的禁表，但自动
-  // 记忆走的是 mdcg_remember(gated=true)、**不过 audit**，此处是这条路上唯一的
-  // 防线——此前不认自家令牌，用户粘一次即明文落进共用记忆库。
-  // 顺序要点：**完整令牌在前**。四段形态为 `mdcg1.<role>.<token_id>.<secret>`
-  // （md_cg/tokens.py:make_token），若先匹配裸 token_id，secret 段会留成明文
-  // （实测：`…designer.[已过滤:id].SECRET…`），故整条令牌必须整段吃掉。
-  //
-  // 2026-09-28 加固（PR#46 合并当批）：**去 `\b` 词边界、role/secret 字符类放宽、
-  // secret 下限 16→8**——原式有三处「整条规则失配 ⇒ id 规则独吃 id、secret 留明文」
-  // 的触发面（实测复现）：① 前导为词字符（`k_mdcg1.…`、`a mdcg1.…` 紧邻字母数字下划线
-  // 时 `\b` 失效）；② role 含非字母（如 `sub-agent1`——`parse_token` 只要求非空，
-  // 不校验字符集）；③ secret 短于 16 字符（`make_token` 不校验长度）。三者都让整条规则
-  // 失配，而裸 id 规则照旧命中 ⇒ secret 明文落库（与顺序错配同一形态）。放宽后与禁表
-  // 第 11 条 `mdcg1\.[A-Za-z0-9._\-]{20,}`（本就无 `\b`）同口径。
-  // M5（两宽）：四段令牌的**值类**（role/id/secret）与分隔点 `.,` 全部两宽；前缀写成
-  // 「半角|全角」两种**拼写**的互斥分支（`(?:mdcg1|ｍｄｃｇ１)`）——两分支是不同字符，
-  // 故不是冗余、也不是字符类。
-  //
-  // ⚠️ 这两条令牌规则**必须保持 `/…/g` 字面量、单行且 Python 兼容**：形态守卫
-  // `md_cg/test_token_lowercase_form.py` 的 G7d~G7g 逐行抽取本文件的 `/…/g` 字面，
-  // 再用 Python `re` 复跑（定宽后顾 `(?<!…)`、字符类里的全角字面量在 Python `re` 下同义）。
-  // 改成 `new RegExp(...)` 拼装会让那条守卫抽不到规则（G7d 直接红，实测见本批报告），
-  // 故此处**不**用 `twoWidth()` 组合；值类字面量须与共享字符集常量同源，
-  // 由 test/fullwidth_redact.test.ts ⑦ 机械核对。
-  { re: /(?:mdcg1|ｍｄｃｇ１)[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿\-－]+[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿]+[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿\-－]{8,}/g, label: '令牌' },
-  // 裸令牌 id（`tk_` + 12 位 hex，1.15e14 空间不可猜——由 tokens.py 的
-  // `secrets.token_hex(6)` 生成；id 本身即凭据，与禁表 `\btk_[0-9a-f]{8,}\b` 同形）。
-  //
-  // 加固：**把尾随的 `.secret` 段一并吃掉**（`(?:\.[A-Za-z0-9_-]{4,})?`）。不变量＝
-  // 「id 规则绝不能只吃 id、把 secret 留给下一条规则或留给用户」——顺序正确时那条尾巴
-  // 由整条规则先吃；顺序被改、或整条规则因任何理由失配时，id 规则自己带上尾巴，
-  // **顺序从此不再是安全性质**（防御纵深，由 test/token_redact_parity.test.ts ④ 钉住）。
-  // 下限取 4 是为了不吃掉 `tk_…py` / `tk_…md` 这类短文件名尾巴。
-  // M5（两宽）：`\b` 只认半角 `\w`（`ｔｋ＿…` 在串首取不到词边界 ⇒ 整条漏检），
-  // 换成两宽后顾；hex 值类、尾巴分隔点 `.,` 一并两宽，前缀同「半角|全角互斥分支」。
-  // 字面量/Python 兼容要求同上一条（形态守卫 G7d~G7g 抽取 `/…/g` 字面复跑）。
-  { re: /(?<![A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿])(?:tk_|ｔｋ＿)[0-9a-f０-９ａ-ｆ]{8,}(?:[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿\-－]{4,})?/g, label: '令牌id' },
-]
-
-/** 脱敏：替换敏感片段；返回 null 表示整条都是敏感内容（应跳过写入）。 */
-export function desensitize(text: string): string | null {
-  let out = text
-  for (const { re, label } of SENSITIVE_PATTERNS) {
-    out = out.replace(re, `[已过滤:${label}]`)
-  }
-  // 过滤后只剩占位符/空白 → 纯凭据消息，不写（或全部被替换）
-  const residue = out.replace(/\[已过滤:[^\]]+\]/g, '').trim()
-  if (!residue) return null
-  return out
-}
-
-/** 时间线载荷 → 注入文本。
- *  `stg(op=timeline)` 返回 {count, limit, items:[{id, layer, start, end, preview}]}。
- *  （保留原始实现；自动召回改用下面的分级递减渲染） */
-function formatTimeline(payload: unknown): string {
-  const items = (payload && typeof payload === 'object'
-    && Array.isArray((payload as { items?: unknown }).items))
-    ? (payload as { items: Array<Record<string, unknown>> }).items
-    : []
-  return items
-    .map((it) => {
-      const preview = String(it['preview'] ?? '').replace(/\s+/g, ' ').trim()
-      if (!preview) return ''
-      const layer = it['layer'] ? `[${String(it['layer'])}] ` : ''
-      return `- ${layer}${preview}`
-    })
-    .filter(Boolean)
-    .join('\n')
-}
-
-// ---------------------------------------------------------------- 自动召回渲染
-// 常量写死在此处（而非 config schema）——未知键会被 schema 剥离。
-/** 第 1 档（最新 1 条）每条字符上限。 */
-const RECALL_BASE_CHARS = 160
-/** 每 N 条降一档。 */
-const RECALL_DECAY_EVERY = 1
-/** 每档缩放比例（−10%）。 */
-const RECALL_DECAY_RATIO = 0.9
-/** 最小保留字符。 */
-const RECALL_MIN_CHARS = 24
-/** 整块上限（与调用点 slice 对齐）。 */
-const RECALL_MAX_CHARS = 1400
-/** 永久层不自动注入（按需用 mdcg_recall / lingshu_stg 取）。 */
-const RECALL_SKIP_LAYERS = new Set(['anchor', 'self'])
-
-/** 分级递减渲染：按距当前的次序逐档收窄，早期条目信息量更大。
- *
- *  动机：注入块总长受限，而"最近 N 条"里越靠前的越可能被用到；线性等宽分配
- *  会让整块被最旧的一条挤掉。逐档递减后整块实测约 1133 字符（≈472 tok），
- *  9 条全部保留。（注意：整块仍远小于一条知识节点 500~800 tok，故本块定位是
- *  「存在性索引/提醒」，不承载知识本身——要知识请显式 mdcg_recall 并给足预算。） */
-function formatTimelineDecayed(payload: unknown): string {
-  const items = (payload && typeof payload === 'object'
-    && Array.isArray((payload as { items?: unknown }).items))
-    ? (payload as { items: Array<Record<string, unknown>> }).items
-    : []
-  const out: string[] = []
-  let rank = 0
-  for (const it of items) {
-    const layer = String(it['layer'] ?? '')
-    if (RECALL_SKIP_LAYERS.has(layer)) continue
-    const preview = String(it['preview'] ?? '').replace(/\s+/g, ' ').trim()
-    if (!preview) continue
-    const tier = Math.floor(rank / RECALL_DECAY_EVERY)
-    const budget = Math.max(
-      RECALL_MIN_CHARS,
-      Math.round(RECALL_BASE_CHARS * Math.pow(RECALL_DECAY_RATIO, tier)),
-    )
-    out.push(`- [${layer}] ` + (preview.length > budget ? preview.slice(0, budget) + '…' : preview))
-    rank += 1
-    if (out.join('\n').length >= RECALL_MAX_CHARS) break
-  }
-  return out.join('\n').slice(0, RECALL_MAX_CHARS)
-}
-
-/** 取宿主会话标识（只用于**归因/隔离**，不参与任何权限判断）。
- *
- *  动机：记忆写入必须带会话身份才能区分不同会话；读取默认只看本会话（防串台），
- *  而「所有会话做了什么」用显式 session="*" 取。两侧都依赖这个标识。
- *
- *  字段名按 DSH 既有形态（`id` / `sessionId`）防御式读取，取不到就返回空串——
- *  空串在上游一律等同「不分会话」（退回旧行为），故宿主改字段名最坏只是失去
- *  隔离能力，不会注入错块、不会抛错。 */
-function sessionIdOf(raw: unknown): string {
-  const s = raw as { id?: unknown; sessionId?: unknown } | null | undefined
-  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'
-
-/** 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 harness，真实宿主是否真给子代理
- *  子会话写这两个字段，**只在类型面成立、未在真实会话事件上观测过**。故判据取
- *  「**字段在场且取值匹配才拦**」的形态：header 缺失 / 非对象 / 两个字段都取不到
- *  或不匹配 → 一律返回 false（**不拦**，安全退化为既有行为），绝不因字段缺失而
- *  报错，也不因此改变既有写入行为。
- *
- *  默认行为（显式声明）：**子代理会话的自动记忆默认拦掉**（默认拦）——委派指令是
- *  「另一个 agent 发给本 agent 的指令」，不是用户的长期记忆，写进来会污染真人记忆；
- *  而判据不确定时**默认放行**（字段缺失即不拦）——宁可多记，不可因宿主字段缺失
- *  而静默丢掉真人记忆。 */
-function isSubagentSession(session: unknown): boolean {
-  const header = (session as { header?: unknown } | null | undefined)?.header
-  if (!header || typeof header !== 'object') return false
-  const h = header as { origin?: unknown; delegationDepth?: unknown }
-  if (h.origin === 'subagent') return true
-  const depth = h.delegationDepth
-  return typeof depth === 'number' && Number.isFinite(depth) && depth > 0
-}
-
-/** 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）。
- *
- *  ⚠️ **未验证项（如实标注）**：真实宿主是否真给委派消息写 `form: 'relay'`
- *  **未观测过**。故同样取「字段在场且取值匹配才拦」；source 缺失/非对象 → false。
- *
- *  与既有 `kind !== 'user'` 判据的关系：类型面下 `kind='plugin'` 的中继**本就被**
- *  那条拦掉；本判据放在它**之前**，是为了 ① 不把委派判定押在 `source.kind` 单点上、
- *  ② 覆盖「生产者把中继标成 `kind='user'` 且带 form」这一类型面之外的形态——子会话
- *  的**首轮用户提示**就可能是这种：它与真人输入在 `kind` 上不可分，只有会话级判据
- *  （或这里的 form）能拦。 */
-function isRelayedMessage(source: unknown): boolean {
-  const s = source as { form?: unknown } | null | undefined
-  return !!s && typeof s === 'object' && s.form === 'relay'
-}
-
-/** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。
- *
- *  mdcg 为 null（config.mdcg.enabled=false）时自动记忆整体停用：记忆真源是
- *  认知图，没有它就没有可写的去处——**不会退回 AEIS**（AEIS 已不存记忆）。 */
-export function installMemoryHooks(ctx: Context, mdcg: MdcgClient | null, opts: MemoryHooksOptions): void {
-  if (!mdcg) {
-    ctx.logger.warn('dsh-memory: 认知图未启用（config.mdcg.enabled=false），自动记忆已停用')
-    return
-  }
-  const graph = mdcg
-
-  /** 最近一次观测到的宿主会话标识（见 sessionIdOf；空串 = 未知/无会话）。 */
-  let lastSession = ''
-
-  /** 记忆沉淀（fire-and-forget）。认知图未就绪则跳过并告警（不退回 AEIS）。 */
-  const memorize = (label: string, run: (g: MdcgClient) => Promise<unknown>): void => {
-    if (!graph.isReady()) {
-      ctx.logger.warn(`dsh-memory: 认知图未就绪，跳过自动记忆（${label}）`)
-      return
-    }
-    void run(graph).catch((err: Error) =>
-      ctx.logger.warn(`dsh-memory: 自动记忆 ${label} 失败: ${err.message}`))
-  }
-
-  // P1 完善（GPT 审查·自动记忆脱敏）：写入前过滤敏感信息（默认开启）。
-  // 命中敏感模式 → 替换为 [已过滤:类别]；纯凭据消息 → 跳过写入（不落库）。
-  const sanitize = (text: string): string | null => {
-    if (!opts.desensitize) return text
-    return desensitize(text)
-  }
-
-  // P1 完善（自动 recall 注入）：每次模型请求组装 system prompt 时，注入灵枢最近记忆。
-  // 用 system-prompt/assemble 事件（waterfall）而非 llm/stream——后者请求 deep-frozen 不可改写。
-  //
-  // ⚠️ 必须**每步都 push**，哪怕内容与上一步逐字节相同。原因在宿主侧（dsh-agent-loop 的
-  // RuntimeContextProjection）：assembly.contexts 会被渲染成一段「运行时上下文快照」，
-  // 每个 step 拿渲染后的**整段文本**与上一份已提交的快照比对，**只有不同才**在会话里
-  // append 一条新的 user/message（append 语义，旧的不会被替换或移除）。于是：
-  //   · 内容不变 + 照旧 push → 渲染文本不变 → 宿主不追加任何东西（零开销、零增长）；
-  //   · 内容不变 + 跳过 push → 渲染文本**变了**（少了本块）→ 宿主追加一份「没有本块」的
-  //     快照；下一步再 push 又把本块加回来 → **再**追加一份。跳过一次反而多花两份快照
-  //     （实测每份 ~250 tok），这正是 v0.4.8「每 8 步强制补一次」的自愈刷新会把长会话的
-  //     inject 推到 30k+ tok 的原因。
-  // 因此本实现把「要不要补」交还给宿主：压缩归档后宿主会把 retained 置空并重新投影快照
-  // （RuntimeContextProjection 的 retained === null 分支），本块自然跟着回来——
-  // 不需要插件自己数步数做自愈。
-  if (opts.autoRecall) {
-    const recallLimit = Math.max(1, Math.min(10, opts.autoRecallLimit || 4))
-    ctx.on('system-prompt/assemble', async (assembly, _ctx, next) => {
-      try {
-        // 异步取最近记忆节点（失败静默——不阻塞模型请求）
-        if (graph.isReady()) {
-          // 会话隔离（P45）：自动召回只注入**本会话**的记忆，防多会话串台；
-          // 取不到会话标识则退回旧行为（不加过滤），不做半吊子猜测。
-          // ⚠️ 取值必须**每步稳定**：本块按 v0.4.8 契约每步都 push，内容一旦与上
-          // 一步不同宿主就 append 一份新快照——会话标识若中途才出现，会让「无过滤
-          // → 有过滤」翻转一次，白付两份快照。故优先取 ctx 上的会话（首步即在），
-          // 退回「最近一次 session/event 的会话」。
-          // 想读**所有**会话做了什么：别走自动召回（它会串台），显式调
-          // `stg(op=timeline, session="*")`，返回项带 session 归属。
-          const hostCtx = (_ctx as unknown) as { agent?: { session?: unknown } } | undefined
-          const sid = sessionIdOf(hostCtx?.agent?.session) || lastSession
-          const text = formatTimelineDecayed(
-            await graph.timeline(recallLimit, sid ? { session: sid } : {}))
-          if (text) {
-            // 注入边界转义（issue #16）：宿主 system-prompt 对 context 文本做严格
-            // `{{variable}}` 插值，裸 `{{` 会 throw → 该轮请求整体失败。记忆原文
-            // （含用户命令里的 `{{.X}}`）必须保真落库，故只在注入副本上打断 `{{`。
-            //
-            // H5（不可信内容边界）：注入块**必经** renderUntrustedMemoryBlock——
-            // 固定声明句（UNTRUSTED_MEMORY_NOTICE，常量单点）+ 显式边界标记 +
-            // 载荷内边界标记的打断。记忆是任意用户输入/工具输出的沉淀，
-            // 无边界时模型无从区分「数据」与「指令」（提示注入面）。
-            // 三层顺序：边界渲染（含载荷打断）→ `{{` 转义；两者都只改注入副本。
-            assembly.contexts.push({
-              name: 'lingshu:auto-recall',
-              text: escapePromptBraces(renderUntrustedMemoryBlock(
-                `【灵枢最近记忆】\n${text.slice(0, RECALL_MAX_CHARS)}`)),
-            })
-          }
-        }
-      }
-      catch { /* 静默：召回失败不影响请求 */ }
-      return next()
-    })
-  }
-
-  ctx.on('session/event', (session, event: SessionEvent) => {
-    // H1（2026-09-30）**会话级**判据：子代理/委派子会话的自动记忆**整条会话**拦掉。
-    // 位置在取 sid **之前**——子代理会话不得污染 lastSession，否则顶层会话的自动
-    // 召回会拿子代理的 session 去读（读错会话）。字段缺失即不拦，见 isSubagentSession。
-    if (isSubagentSession(session)) {
-      ctx.logger.info('dsh-memory: 子代理会话的自动记忆被拦（H1：header.origin/delegationDepth）')
-      return
-    }
-    // 会话归属（P45）：记忆写入必须带会话身份，用来区分不同会话的记忆。
-    // 空串 = 宿主未给出会话标识 → **显式标注 unassigned**（H2③：不落内核的进程级
-    // 随机 sess_*，也不编造宿主会话 id——见 UNASSIGNED_SESSION 的注释）。
-    const sid = sessionIdOf(session)
-    if (sid) lastSession = sid
-    const sessionTag = sid ? { session: sid } : { session: UNASSIGNED_SESSION }
-    if (event.type === 'user/message' && opts.userMessage) {
-      // H1 **消息级**判据：委派/中继消息（`form: 'relay'` 语义＝「另一个 agent
-      // 发给本 agent 的消息」）不写。先于 kind 判据，理由见 isRelayedMessage 注释。
-      if (isRelayedMessage(event.data.source)) {
-        ctx.logger.info('dsh-memory: 委派/中继消息的自动记忆被拦（H1：source.form=relay）')
-        return
-      }
-      // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
-      if (event.data.source?.kind !== 'user') {
-        // T4 诊断（2026-08-30）：dsh 端对话零写入排查——记录被滤事件的实际
-        // source.kind（若 dsh 新版改了 kind 值，此处日志可定位）
-        ctx.logger.info(`dsh-memory: user/message 事件被滤（source.kind=${event.data.source?.kind ?? 'undefined'}）`)
-        return
-      }
-      const text = extractText(event.data.content)
-      if (!text) return
-      const safe = sanitize(text)  // 脱敏：纯凭据消息 → null → 跳过写入
-      if (safe === null) return
-      memorize('user', (g) => g.remember(safe, {
-        role: 'user', tags: ['dsh', 'user'], importance: opts.importance,
-        ...sessionTag,
-      }))
-      // T4：用用户消息做一次语义召回——md_cg 的读取会记 access log（复用观测，
-      // 供 importance / scrub 陈旧度使用），同时预热检索路径。
-      // （AEIS 侧的 `_note_reuse` 在 md_cg 中不存在，其等价物就是这次记访问。）
-      //
-      // H2③（2026-09-30）：**显式带会话**。此前不传 session，靠服务端「cg 读路径
-      // 丢弃请求 session」侥幸不串台；一旦读侧归一化在召回链路上生效，不传就等价于
-      // 跨会话（全库）召回。此处走 `read(query, {k, ...sessionTag})`——与
-      // `recall(query, k)` 是同一条 MCP 出口（`cg(op=read)`，见 mdcg_client.ts 的
-      // recall → read），差别只在能带上会话槽；`recall` 没有 extra 形参，给它加槽要
-      // 改 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 }))
-    } 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) return
-      memorize('assistant', (g) => g.remember(safe, {
-        role: 'assistant', tags: ['dsh', 'assistant'], importance: opts.importance * 0.8,
-        ...sessionTag,
-      }))
-    } else if (event.type === 'tool/result' && opts.toolResult) {
-      if (event.data.error) return
-      const text = extractText(event.data.message.content)
-      if (!text) return
-      const safe = sanitize(text)
-      if (safe === null) return
-      memorize('tool', (g) => g.remember(safe, {
-        role: 'tool-output', tags: ['dsh', 'tool'], importance: opts.importance * 0.6,
-        ...sessionTag,
-      }))
-    }
-  })
-}
+/**
+ * 自动记忆钩子：把 DSH 的会话事件（经统一的 session/event 分发）沉淀进灵枢。
+ *
+ * 记忆真源 = **md_cg 认知图（md 文档）**（2026-09-10 统一）：本钩子经
+ * MdcgClient.remember() 调 MCP `mdcg_remember(gated=true)`（主动遗忘闸门：
+ * ACCEPT 落盘 / MERGE 并入既有 = 去重强化 / DROP 低熵 / DEFER 待定），
+ * 落层 contextual，role 取 user | assistant | tool-output —— 与 md_cg 对 DSH
+ * 会话事件的约定一致（md_cg/sources.py 的 SESSION_LAYER / DSHSessionSource）。
+ * ⚠️ 不用 `cg(op=write)`：那条路径先过 audit，未声明 content_kind 时永不落盘
+ * （见 src/lib/mdcg_client.ts 文件头）。
+ * 不再走 AEIS：AEIS 已降为能力库，不存记忆。
+ *
+ * ⚠️ 写入需凭据：md_cg fail-closed，无 MDCG_TOKEN / MDCG_LEGACY_ENV_AUTH=1
+ * 时降级为只读 guest —— 本钩子的写入会失败（仅告警，不影响对话）。
+ *
+ * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
+ * 带去重（闸门 MERGE）与重要性，写入前脱敏；agent 回复与工具结果可选开启。
+ * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音；其上再叠一层
+ * **来源判定**（H1，2026-09-30）：① **会话级**——子代理/委派子会话（SessionHeader 的
+ * `origin` / `delegationDepth`）的自动记忆**整条会话拦掉**；② **消息级**——
+ * `source.form === 'relay'`（「另一个 agent 发给本 agent 的消息」）不写。
+ * 两条判据均为「**字段在场且取值匹配才拦**」：字段缺失一律退化为不过滤（默认放行），
+ * 宿主字段面已在本机真实会话事件上观测（2026-10-05 订正：19 场，会话头
+ * `delegationDepth=0` 真实在写）；**仍未观测**的是 `origin='subagent'` /
+ * `delegationDepth>0` / `form='relay'` 的真实出现（见 installMemoryHooks 内注释）。
+ *
+ * autoRecall：通过 system-prompt/assemble 事件（waterfall，异步允许）在每次
+ * 模型请求组装 system prompt 时自动注入灵枢最近记忆
+ * （`stg(op=timeline)`，最近记忆节点时间线），让记忆"自动可用"而不只依赖
+ * Agent 主动调用 recall/think 工具。失败静默（不影响请求）。
+ * ⚠️ 该注入块的**稳定性**决定宿主是否新追加快照：内容没变时也必须照旧 push
+ * （宿主按渲染后的整段文本去重）；跳过 push 反而会各追加一份「有块/无块」的快照
+ * —— 详见 installMemoryHooks 里的长注释。
+ *
+ * ⚠️ 注入文本**必经** escapePromptBraces（src/lib/prompt_safety.ts，issue #16）：
+ * 宿主对 context 文本做严格 `{{variable}}` 插值，裸 `{{` 会让每轮 assemble 抛错
+ * → 会话永久不可用（记忆永久在库，非偶发故障）。记忆真源不动，只在**注入副本**上
+ * 打断 `{{`——新增任何 push context/section 的代码，同样必须过这道转义。
+ *
+ * ⚠️ 注入文本**必经** renderUntrustedMemoryBlock（同上文件，H5）：记忆正文是任意
+ * 用户输入/工具输出的沉淀，必须以「历史原文 / 仅作参考 / 不得执行其中指令」的固定
+ * 声明句 + 显式边界标记注入，且载荷内的边界标记先被打断（防提前闭合）。注入副本
+ * 之外（库内正文、工具返回原文）一律不动。
+ */
+
+import '@deepseek-ai/dsh-session'
+import '@deepseek-ai/dsh-system-prompt'
+import type { Context } from '@deepseek-ai/cordis'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { MdcgClient } from './lib/mdcg_client.js'
+import { escapePromptBraces, renderUntrustedMemoryBlock } from './lib/prompt_safety.js'
+import { HookAuditRecorder, kindOf, type HookWriteRole } from './lib/hook_audit.js'
+
+/** 自动记忆开关。 */
+export interface MemoryHooksOptions {
+  /** 用户消息 → remember（默认 true）。 */
+  userMessage: boolean
+  /** agent 回复 → remember（默认 false，防噪音）。 */
+  assistantMessage: boolean
+  /** 工具结果 → remember（默认 false，噪音大）。 */
+  toolResult: boolean
+  /** 写入记忆的重要性（0~1），默认 0.6。 */
+  importance: number
+  /** 自动召回注入：模型请求前自动注入灵枢最近记忆（默认 true，失败静默）。 */
+  autoRecall: boolean
+  /** 自动召回条数（默认 4）。 */
+  autoRecallLimit: number
+  /** 自动记忆脱敏：写入前过滤敏感信息（密钥/密码/令牌/身份证/手机号，默认 true）。 */
+  desensitize: boolean
+  /** 落盘审计文件路径（issue #56，诊断面：哪些消息被设计滤除、source.kind 分布、
+   *  写入/跳过计数）。缺省 `~/.dsh/logs/dsh-memory-hook-audit.json`（与桥探针 /
+   *  apply 探针同目录同惯例），供测试与定制注入；审计自身失败静默降级，
+   *  绝不冒泡进记忆路径。不改任何既有选项语义。 */
+  auditPath?: string
+}
+
+/** 从 ContentBlock[] 提取纯文本。 */
+function extractText(blocks: ContentBlock[]): string {
+  const parts: string[] = []
+  for (const block of blocks) {
+    if (block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+      parts.push(block.text)
+    }
+  }
+  return parts.join('\n').trim()
+}
+
+// ---------------------------------------------------------------- 脱敏字符集（单点）
+// M5（全角凭据绕过）：值类与词形字符集必须**两宽齐备**。
+//
+// 背景（探针实测）：此前值类字符集全是半角——`[A-Za-z0-9_@#$%^&*!.-]`、
+// `[^\s,，。;；]`、`sk-` 后限定 `[A-Za-z0-9_-]{8,}`——故
+// `密码：ｐａｓｓｗｏｒｄ１２３４５６` / `ａｐｉ＿ｋｅｙ＝…` / `sk-ａｂｃｄ…`
+// 这类**全角写法全部漏检**（filtered=false）。全角形态是独立 Unicode 区段
+// （U+FF01-U+FF5E ↔ U+0021-U+007E 一一对应），`\w`/`\d`/`\b` 一律不认，必须显式列出。
+//
+// 为何**不**走「先全角→半角归一化再匹配」（两条路的取舍，依据如下）：
+//   ① NFKC 归一化会**改变长度**（`㍿`→`株式会社`、半角カナ `ﾊﾟ`→`パ`、`㈱`→`(株)`）
+//      ⇒ 匹配片段无法映射回原文偏移，替换要么错位要么漏改——静默失真；
+//   ② 若退一步「归一化后整段替换」，等于把正文里的全角标点（：＝＿（））统统
+//      半角化——**改写记忆真源**，与「原文保真、只在注入边界改写」的既有纪律相悖；
+//   ③ 归一化会抹平 `．`(U+FF0E，`.` 的全角形态) 与 `。`(U+3002，中文句号) 的区别，
+//      值类边界随之漂移——本题要求说明的误伤面正在这里。
+// 故取**显式两宽字符类**：替换只覆盖命中的凭据片段，正文其余字符逐字节零改写；
+// 且「每条规则的值类两宽齐备」成为可机械断言的性质
+// （守卫 test/fullwidth_redact.test.ts ①/②/④）。
+//
+// 边界（如实）：两宽类刻意**不含**中文句读 ，；。！？、 —— 它们不在半角类里，
+// 引入会让值类跨句吞并（`．` 是 `.` 的全角形态、属值类，故收录）。
+
+/** 全角数字（U+FF10-U+FF19）。 */
+const FW_DIGITS = '０-９'
+/** 全角大写字母（U+FF21-U+FF3A）。 */
+const FW_UPPER = 'Ａ-Ｚ'
+/** 全角小写字母（U+FF41-U+FF5A）。 */
+const FW_LOWER = 'ａ-ｚ'
+
+/** 两宽「词字符」类：半角 + 全角 字母/数字/下划线（`\w`/`\b` 的替代判据面）。
+ *  导出供守卫核对字面量规则的同源性（test/fullwidth_redact.test.ts ⑦）；
+ *  对外仍属内部实现，不承诺稳定 ABI。 */
+export const WORD_CHARS = `A-Za-z0-9_${FW_DIGITS}${FW_UPPER}${FW_LOWER}＿`
+/** 两宽数字类。 */
+const DIGIT_CHARS = `0-9${FW_DIGITS}`
+/** 两宽凭据值类：词字符 + `@ # $ % ^ & * ! . -` 的两宽形态。
+ *  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}\\-－`
+/** 两宽 Bearer 值类（原半角集 `A-Za-z0-9._~+/=-` + 其全角形态）。 */
+const BEARER_VALUE_CHARS =
+  `A-Za-z0-9._~+/=\\-${FW_DIGITS}${FW_UPPER}${FW_LOWER}＿．～／＋＝－`
+
+/** ASCII 可见字符 → 全角等价（U+0021-U+007E ↔ U+FF01-U+FF5E）；其余原样返回。 */
+function toFullwidth(ch: string): string {
+  const code = ch.charCodeAt(0)
+  return code >= 0x21 && code <= 0x7e ? String.fromCharCode(code + 0xfee0) : ch
+}
+
+/** 半角 ASCII 词 → 「半角|全角」等价类（M5 单点：关键词的两宽形态只此一处生成）。
+ *  仅接受 `[A-Za-z0-9_-]`——含正则元字符的词会让等价类语法失真，故 fail-closed 抛错。 */
+function twoWidth(word: string): string {
+  let out = ''
+  for (const ch of word) {
+    if (!/[A-Za-z0-9_-]/.test(ch)) {
+      throw new Error(`twoWidth 只接受半角字母数字/下划线/连字符，收到：${word}`)
+    }
+    out += `[${ch}${toFullwidth(ch)}]`
+  }
+  return out
+}
+
+/**
+ * 敏感信息模式（GPT 审查·自动记忆脱敏）：写入认知图前过滤凭据/个人标识。
+ * 命中 → 替换为 [已过滤:类别]（保留对话主体）；过滤后只剩占位符/空白 → 整条跳过。
+ * 纯内容过滤，不涉及身份认证——开源场景下的隐私保护。
+ *
+ * M5：值类/词形两宽齐备（见上方字符集注释）；`\b` 全部换成两宽 lookaround——
+ * `\b` 只认半角 `\w`，`［ｓｋ−…］` 这类以全角起首的串在串首**根本取不到词边界**。
+ */
+// 导出供守卫使用（test/token_redact_parity.test.ts 需要按「交换序」复跑同一条链，
+// 以证明顺序不再是安全性质）；对外仍属内部实现，不承诺稳定 ABI。
+export const SENSITIVE_PATTERNS: Array<{ re: RegExp; label: string }> = [
+  { re: new RegExp(`${twoWidth('sk')}[\\-－][${TOKEN_VALUE_CHARS}]{8,}`, 'g'), label: 'API密钥' },
+  { re: new RegExp(
+      `(?<![${WORD_CHARS}])`
+      + `(?:${twoWidth('api')}[_＿\\-－]?${twoWidth('key')}|${twoWidth('apikey')}`
+      + `|${twoWidth('access')}[_＿\\-－]?${twoWidth('token')})`
+      + `(?![${WORD_CHARS}])\\s*[:=＝：]\\s*[^\\s,，。;；]+`, 'gi'), label: 'API密钥' },
+  { re: new RegExp(
+      `(?<![${WORD_CHARS}])`
+      + `(?:${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: '令牌' },
+  // 中文/日文密码标签：值限定非中文连续串（凭据特征），避免误伤「密码是重要的安全概念」；
+  // 分隔符补全角等号 `＝`（半角 `=` 本就不在本规则的集合里，故只补全角形态）。
+  // 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**，此处是这条路上唯一的
+  // 防线——此前不认自家令牌，用户粘一次即明文落进共用记忆库。
+  // 顺序要点：**完整令牌在前**。四段形态为 `mdcg1.<role>.<token_id>.<secret>`
+  // （md_cg/tokens.py:make_token），若先匹配裸 token_id，secret 段会留成明文
+  // （实测：`…designer.[已过滤:id].SECRET…`），故整条令牌必须整段吃掉。
+  //
+  // 2026-09-28 加固（PR#46 合并当批）：**去 `\b` 词边界、role/secret 字符类放宽、
+  // secret 下限 16→8**——原式有三处「整条规则失配 ⇒ id 规则独吃 id、secret 留明文」
+  // 的触发面（实测复现）：① 前导为词字符（`k_mdcg1.…`、`a mdcg1.…` 紧邻字母数字下划线
+  // 时 `\b` 失效）；② role 含非字母（如 `sub-agent1`——`parse_token` 只要求非空，
+  // 不校验字符集）；③ secret 短于 16 字符（`make_token` 不校验长度）。三者都让整条规则
+  // 失配，而裸 id 规则照旧命中 ⇒ secret 明文落库（与顺序错配同一形态）。放宽后与禁表
+  // 第 11 条 `mdcg1\.[A-Za-z0-9._\-]{20,}`（本就无 `\b`）同口径。
+  // M5（两宽）：四段令牌的**值类**（role/id/secret）与分隔点 `.,` 全部两宽；前缀写成
+  // 「半角|全角」两种**拼写**的互斥分支（`(?:mdcg1|ｍｄｃｇ１)`）——两分支是不同字符，
+  // 故不是冗余、也不是字符类。
+  //
+  // ⚠️ 这两条令牌规则**必须保持 `/…/g` 字面量、单行且 Python 兼容**：形态守卫
+  // `md_cg/test_token_lowercase_form.py` 的 G7d~G7g 逐行抽取本文件的 `/…/g` 字面，
+  // 再用 Python `re` 复跑（定宽后顾 `(?<!…)`、字符类里的全角字面量在 Python `re` 下同义）。
+  // 改成 `new RegExp(...)` 拼装会让那条守卫抽不到规则（G7d 直接红，实测见本批报告），
+  // 故此处**不**用 `twoWidth()` 组合；值类字面量须与共享字符集常量同源，
+  // 由 test/fullwidth_redact.test.ts ⑦ 机械核对。
+  { re: /(?:mdcg1|ｍｄｃｇ１)[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿\-－]+[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿]+[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿\-－]{8,}/g, label: '令牌' },
+  // 裸令牌 id（`tk_` + 12 位 hex，1.15e14 空间不可猜——由 tokens.py 的
+  // `secrets.token_hex(6)` 生成；id 本身即凭据，与禁表 `\btk_[0-9a-f]{8,}\b` 同形）。
+  //
+  // 加固：**把尾随的 `.secret` 段一并吃掉**（`(?:\.[A-Za-z0-9_-]{4,})?`）。不变量＝
+  // 「id 规则绝不能只吃 id、把 secret 留给下一条规则或留给用户」——顺序正确时那条尾巴
+  // 由整条规则先吃；顺序被改、或整条规则因任何理由失配时，id 规则自己带上尾巴，
+  // **顺序从此不再是安全性质**（防御纵深，由 test/token_redact_parity.test.ts ④ 钉住）。
+  // 下限取 4 是为了不吃掉 `tk_…py` / `tk_…md` 这类短文件名尾巴。
+  // M5（两宽）：`\b` 只认半角 `\w`（`ｔｋ＿…` 在串首取不到词边界 ⇒ 整条漏检），
+  // 换成两宽后顾；hex 值类、尾巴分隔点 `.,` 一并两宽，前缀同「半角|全角互斥分支」。
+  // 字面量/Python 兼容要求同上一条（形态守卫 G7d~G7g 抽取 `/…/g` 字面复跑）。
+  { re: /(?<![A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿])(?:tk_|ｔｋ＿)[0-9a-f０-９ａ-ｆ]{8,}(?:[.．][A-Za-z0-9_０-９Ａ-Ｚａ-ｚ＿\-－]{4,})?/g, label: '令牌id' },
+]
+
+/** 脱敏：替换敏感片段；返回 null 表示整条都是敏感内容（应跳过写入）。 */
+export function desensitize(text: string): string | null {
+  let out = text
+  for (const { re, label } of SENSITIVE_PATTERNS) {
+    out = out.replace(re, `[已过滤:${label}]`)
+  }
+  // 过滤后只剩占位符/空白 → 纯凭据消息，不写（或全部被替换）
+  const residue = out.replace(/\[已过滤:[^\]]+\]/g, '').trim()
+  if (!residue) return null
+  return out
+}
+
+/** 时间线载荷 → 注入文本。
+ *  `stg(op=timeline)` 返回 {count, limit, items:[{id, layer, start, end, preview}]}。
+ *  （保留原始实现；自动召回改用下面的分级递减渲染） */
+function formatTimeline(payload: unknown): string {
+  const items = (payload && typeof payload === 'object'
+    && Array.isArray((payload as { items?: unknown }).items))
+    ? (payload as { items: Array<Record<string, unknown>> }).items
+    : []
+  return items
+    .map((it) => {
+      const preview = String(it['preview'] ?? '').replace(/\s+/g, ' ').trim()
+      if (!preview) return ''
+      const layer = it['layer'] ? `[${String(it['layer'])}] ` : ''
+      return `- ${layer}${preview}`
+    })
+    .filter(Boolean)
+    .join('\n')
+}
+
+// ---------------------------------------------------------------- 自动召回渲染
+// 常量写死在此处（而非 config schema）——未知键会被 schema 剥离。
+/** 第 1 档（最新 1 条）每条字符上限。 */
+const RECALL_BASE_CHARS = 160
+/** 每 N 条降一档。 */
+const RECALL_DECAY_EVERY = 1
+/** 每档缩放比例（−10%）。 */
+const RECALL_DECAY_RATIO = 0.9
+/** 最小保留字符。 */
+const RECALL_MIN_CHARS = 24
+/** 整块上限（与调用点 slice 对齐）。 */
+const RECALL_MAX_CHARS = 1400
+/** 永久层不自动注入（按需用 mdcg_recall / lingshu_stg 取）。 */
+const RECALL_SKIP_LAYERS = new Set(['anchor', 'self'])
+
+/** 分级递减渲染：按距当前的次序逐档收窄，早期条目信息量更大。
+ *
+ *  动机：注入块总长受限，而"最近 N 条"里越靠前的越可能被用到；线性等宽分配
+ *  会让整块被最旧的一条挤掉。逐档递减后整块实测约 1133 字符（≈472 tok），
+ *  9 条全部保留。（注意：整块仍远小于一条知识节点 500~800 tok，故本块定位是
+ *  「存在性索引/提醒」，不承载知识本身——要知识请显式 mdcg_recall 并给足预算。） */
+function formatTimelineDecayed(payload: unknown): string {
+  const items = (payload && typeof payload === 'object'
+    && Array.isArray((payload as { items?: unknown }).items))
+    ? (payload as { items: Array<Record<string, unknown>> }).items
+    : []
+  const out: string[] = []
+  let rank = 0
+  for (const it of items) {
+    const layer = String(it['layer'] ?? '')
+    if (RECALL_SKIP_LAYERS.has(layer)) continue
+    const preview = String(it['preview'] ?? '').replace(/\s+/g, ' ').trim()
+    if (!preview) continue
+    const tier = Math.floor(rank / RECALL_DECAY_EVERY)
+    const budget = Math.max(
+      RECALL_MIN_CHARS,
+      Math.round(RECALL_BASE_CHARS * Math.pow(RECALL_DECAY_RATIO, tier)),
+    )
+    out.push(`- [${layer}] ` + (preview.length > budget ? preview.slice(0, budget) + '…' : preview))
+    rank += 1
+    if (out.join('\n').length >= RECALL_MAX_CHARS) break
+  }
+  return out.join('\n').slice(0, RECALL_MAX_CHARS)
+}
+
+/** 取宿主会话标识（只用于**归因/隔离**，不参与任何权限判断）。
+ *
+ *  动机：记忆写入必须带会话身份才能区分不同会话；读取默认只看本会话（防串台），
+ *  而「所有会话做了什么」用显式 session="*" 取。两侧都依赖这个标识。
+ *
+ *  字段名按 DSH 既有形态（`id` / `sessionId`）防御式读取，取不到就返回空串——
+ *  空串在上游一律等同「不分会话」（退回旧行为），故宿主改字段名最坏只是失去
+ *  隔离能力，不会注入错块、不会抛错。 */
+function sessionIdOf(raw: unknown): string {
+  const s = raw as { id?: unknown; sessionId?: unknown } | null | undefined
+  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'
+
+/** H1 **会话级**判据：这条 session 是否「子代理/委派子会话」。
+ *
+ *  字段来源（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）。
+ *
+ *  ⚠️ **观测面（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（**不拦**，安全退化为既有行为），绝不因字段缺失而
+ *  报错，也不因此改变既有写入行为。
+ *
+ *  默认行为（显式声明）：**子代理会话的自动记忆默认拦掉**（默认拦）——委派指令是
+ *  「另一个 agent 发给本 agent 的指令」，不是用户的长期记忆，写进来会污染真人记忆；
+ *  而判据不确定时**默认放行**（字段缺失即不拦）——宁可多记，不可因宿主字段缺失
+ *  而静默丢掉真人记忆。 */
+function isSubagentSession(session: unknown): boolean {
+  const header = (session as { header?: unknown } | null | undefined)?.header
+  if (!header || typeof header !== 'object') return false
+  const h = header as { origin?: unknown; delegationDepth?: unknown }
+  if (h.origin === 'subagent') return true
+  const depth = h.delegationDepth
+  return typeof depth === 'number' && Number.isFinite(depth) && depth > 0
+}
+
+/** H1 **消息级**判据：这条消息是否是「另一个 agent 发给本 agent 的」（委派/中继）。
+ *
+ *  字段来源（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）。
+ *
+ *  ⚠️ **观测面（2026-10-05 订正）**：本机**已装** DSH 2.0；19 场真实会话中
+ *  `form='relay'` 从未出现（270 条 `user/message` 实测无 relay），即**真实出现
+ *  仍未观测**。故同样取「字段在场且取值匹配才拦」；source 缺失/非对象 → false。
+ *
+ *  与既有 `kind !== 'user'` 判据的关系：`kind` 非 `'user'` 的中继**本就被**那条拦掉
+ *  （19 场实测的注入类 kind 均非 `'user'`）；本判据放在它**之前**，是为了
+ *  ① 不把委派判定押在 `source.kind` 单点上、② 覆盖「生产者把中继标成
+ *  `kind='user'` 且带 form」这一类型面之外的形态——子会话的**首轮用户提示**就可能
+ *  是这种：它与真人输入在 `kind` 上不可分，只有会话级判据（或这里的 form）能拦。 */
+function isRelayedMessage(source: unknown): boolean {
+  const s = source as { form?: unknown } | null | undefined
+  return !!s && typeof s === 'object' && s.form === 'relay'
+}
+
+/** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。
+ *
+ *  mdcg 为 null（config.mdcg.enabled=false）时自动记忆整体停用：记忆真源是
+ *  认知图，没有它就没有可写的去处——**不会退回 AEIS**（AEIS 已不存记忆）。 */
+export function installMemoryHooks(ctx: Context, mdcg: MdcgClient | null, opts: MemoryHooksOptions): void {
+  if (!mdcg) {
+    ctx.logger.warn('dsh-memory: 认知图未启用（config.mdcg.enabled=false），自动记忆已停用')
+    return
+  }
+  const graph = mdcg
+
+  /** 落盘审计（issue #56，诊断面）：三处过滤分支与写入/跳过路径各留一道**盘面**
+   *  痕迹——宿主 logger 不落盘时，单看记忆侧无法区分「被设计滤除」与
+   *  「写入失败/漏记」。审计失败静默降级（见 src/lib/hook_audit.ts），
+   *  绝不冒泡进记忆路径、不改任何写入/过滤判定。 */
+  const audit = new HookAuditRecorder(opts.auditPath)
+
+  /** 最近一次观测到的宿主会话标识（见 sessionIdOf；空串 = 未知/无会话）。 */
+  let lastSession = ''
+
+  /** 记忆沉淀（fire-and-forget）。认知图未就绪则跳过并告警（不退回 AEIS）。
+   *  `role`=null 表示**读预热**（user-recall）——审计只统计写入路径，
+   *  故读预热不参与 written/skipped 计数（它不写记忆）。 */
+  const memorize = (label: string, role: HookWriteRole | null, run: (g: MdcgClient) => Promise<unknown>): void => {
+    if (!graph.isReady()) {
+      if (role) audit.skipped('not_ready', role)
+      ctx.logger.warn(`dsh-memory: 认知图未就绪，跳过自动记忆（${label}）`)
+      return
+    }
+    if (role) audit.written(role)
+    void run(graph).catch((err: Error) => {
+      if (role) audit.skipped('failed', role)
+      ctx.logger.warn(`dsh-memory: 自动记忆 ${label} 失败: ${err.message}`)
+    })
+  }
+
+  // P1 完善（GPT 审查·自动记忆脱敏）：写入前过滤敏感信息（默认开启）。
+  // 命中敏感模式 → 替换为 [已过滤:类别]；纯凭据消息 → 跳过写入（不落库）。
+  const sanitize = (text: string): string | null => {
+    if (!opts.desensitize) return text
+    return desensitize(text)
+  }
+
+  // P1 完善（自动 recall 注入）：每次模型请求组装 system prompt 时，注入灵枢最近记忆。
+  // 用 system-prompt/assemble 事件（waterfall）而非 llm/stream——后者请求 deep-frozen 不可改写。
+  //
+  // ⚠️ 必须**每步都 push**，哪怕内容与上一步逐字节相同。原因在宿主侧（dsh-agent-loop 的
+  // RuntimeContextProjection）：assembly.contexts 会被渲染成一段「运行时上下文快照」，
+  // 每个 step 拿渲染后的**整段文本**与上一份已提交的快照比对，**只有不同才**在会话里
+  // append 一条新的 user/message（append 语义，旧的不会被替换或移除）。于是：
+  //   · 内容不变 + 照旧 push → 渲染文本不变 → 宿主不追加任何东西（零开销、零增长）；
+  //   · 内容不变 + 跳过 push → 渲染文本**变了**（少了本块）→ 宿主追加一份「没有本块」的
+  //     快照；下一步再 push 又把本块加回来 → **再**追加一份。跳过一次反而多花两份快照
+  //     （实测每份 ~250 tok），这正是 v0.4.8「每 8 步强制补一次」的自愈刷新会把长会话的
+  //     inject 推到 30k+ tok 的原因。
+  // 因此本实现把「要不要补」交还给宿主：压缩归档后宿主会把 retained 置空并重新投影快照
+  // （RuntimeContextProjection 的 retained === null 分支），本块自然跟着回来——
+  // 不需要插件自己数步数做自愈。
+  if (opts.autoRecall) {
+    const recallLimit = Math.max(1, Math.min(10, opts.autoRecallLimit || 4))
+    ctx.on('system-prompt/assemble', async (assembly, _ctx, next) => {
+      try {
+        // 异步取最近记忆节点（失败静默——不阻塞模型请求）
+        if (graph.isReady()) {
+          // 会话隔离（P45）：自动召回只注入**本会话**的记忆，防多会话串台；
+          // 取不到会话标识则退回旧行为（不加过滤），不做半吊子猜测。
+          // ⚠️ 取值必须**每步稳定**：本块按 v0.4.8 契约每步都 push，内容一旦与上
+          // 一步不同宿主就 append 一份新快照——会话标识若中途才出现，会让「无过滤
+          // → 有过滤」翻转一次，白付两份快照。故优先取 ctx 上的会话（首步即在），
+          // 退回「最近一次 session/event 的会话」。
+          // 想读**所有**会话做了什么：别走自动召回（它会串台），显式调
+          // `stg(op=timeline, session="*")`，返回项带 session 归属。
+          const hostCtx = (_ctx as unknown) as { agent?: { session?: unknown } } | undefined
+          const sid = sessionIdOf(hostCtx?.agent?.session) || lastSession
+          const text = formatTimelineDecayed(
+            await graph.timeline(recallLimit, sid ? { session: sid } : {}))
+          if (text) {
+            // 注入边界转义（issue #16）：宿主 system-prompt 对 context 文本做严格
+            // `{{variable}}` 插值，裸 `{{` 会 throw → 该轮请求整体失败。记忆原文
+            // （含用户命令里的 `{{.X}}`）必须保真落库，故只在注入副本上打断 `{{`。
+            //
+            // H5（不可信内容边界）：注入块**必经** renderUntrustedMemoryBlock——
+            // 固定声明句（UNTRUSTED_MEMORY_NOTICE，常量单点）+ 显式边界标记 +
+            // 载荷内边界标记的打断。记忆是任意用户输入/工具输出的沉淀，
+            // 无边界时模型无从区分「数据」与「指令」（提示注入面）。
+            // 三层顺序：边界渲染（含载荷打断）→ `{{` 转义；两者都只改注入副本。
+            assembly.contexts.push({
+              name: 'lingshu:auto-recall',
+              text: escapePromptBraces(renderUntrustedMemoryBlock(
+                `【灵枢最近记忆】\n${text.slice(0, RECALL_MAX_CHARS)}`)),
+            })
+          }
+        }
+      }
+      catch { /* 静默：召回失败不影响请求 */ }
+      return next()
+    })
+  }
+
+  ctx.on('session/event', (session, event: SessionEvent) => {
+    // H1（2026-09-30）**会话级**判据：子代理/委派子会话的自动记忆**整条会话**拦掉。
+    // 位置在取 sid **之前**——子代理会话不得污染 lastSession，否则顶层会话的自动
+    // 召回会拿子代理的 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 的注释）。
+    const sid = sessionIdOf(session)
+    if (sid) lastSession = sid
+    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'），跳过插件注入/系统上下文
+      if (event.data.source?.kind !== 'user') {
+        // 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) { audit.skipped('sanitized', 'user'); return }
+      memorize('user', 'user', (g) => g.remember(safe, {
+        role: 'user', tags: ['dsh', 'user'], importance: opts.importance,
+        ...sessionTag,
+      }))
+      // T4：用用户消息做一次语义召回——md_cg 的读取会记 access log（复用观测，
+      // 供 importance / scrub 陈旧度使用），同时预热检索路径。
+      // （AEIS 侧的 `_note_reuse` 在 md_cg 中不存在，其等价物就是这次记访问。）
+      //
+      // H2③（2026-09-30）：**显式带会话**。此前不传 session，靠服务端「cg 读路径
+      // 丢弃请求 session」侥幸不串台；一旦读侧归一化在召回链路上生效，不传就等价于
+      // 跨会话（全库）召回。此处走 `read(query, {k, ...sessionTag})`——与
+      // `recall(query, k)` 是同一条 MCP 出口（`cg(op=read)`，见 mdcg_client.ts 的
+      // recall → read），差别只在能带上会话槽；`recall` 没有 extra 形参，给它加槽要
+      // 改 mdcg_client.ts（本件放行面之外），故在调用点改走等价出口。
+      // 带上它不构成越权：cg 读路径的 session 是**归因/视图**维度，不参与任何授权
+      // （issue #35 定稿「身份不可自报」，见 md_cg/mdcos.py 的 _candidates）。
+      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) { audit.skipped('sanitized', 'assistant'); return }
+      memorize('assistant', 'assistant', (g) => g.remember(safe, {
+        role: 'assistant', tags: ['dsh', 'assistant'], importance: opts.importance * 0.8,
+        ...sessionTag,
+      }))
+    } else if (event.type === 'tool/result' && opts.toolResult) {
+      if (event.data.error) return
+      const text = extractText(event.data.message.content)
+      if (!text) return
+      const safe = sanitize(text)
+      if (safe === null) { audit.skipped('sanitized', 'tool'); return }
+      memorize('tool', 'tool', (g) => g.remember(safe, {
+        role: 'tool-output', tags: ['dsh', 'tool'], importance: opts.importance * 0.6,
+        ...sessionTag,
+      }))
+    }
+  })
+}