@furongjun1999/dsh-memory 0.5.1 → 0.6.1

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进 md_cg 认知图（md 文档）",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "bin": {
+    "lingshu": "./lib/cli.js",
+    "lingshu-init": "./lib/init.js",
+    "dsh-memory": "./lib/cli.js"
+  },
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
@@ -15,6 +20,7 @@
     "lib",
     "src",
     "md_cg",
+    "data/policy.json",
     "skills",
     "README.md",
     "dsh",
@@ -79,7 +85,7 @@
     "build": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
     "prepare": "node -e \"const fs=require('fs');const tsc='node_modules/typescript/bin/tsc';fs.existsSync(tsc)?(fs.rmSync('lib',{recursive:true,force:true}),require('child_process').execFileSync(process.execPath,[tsc,'-p','tsconfig.json'],{stdio:'inherit'})):console.log('[prepare] 跳过构建：typescript 未安装（NODE_ENV=production 或 --omit=dev 会省略 devDependencies）——需要构建请用 npm install --include=dev')\"",
-    "gate": "python scripts/check_unreachable.py && python scripts/check_publish_artifact.py && python scripts/cogmap_sync.py check && python scripts/link_check.py && python scripts/workspace_index.py --check && python scripts/verify_discipline.py --allow-missing",
+    "gate": "python scripts/check_unreachable.py && python scripts/check_publish_artifact.py && python scripts/cogmap_sync.py check && python scripts/link_check.py && python scripts/workspace_index.py --check && python scripts/verify_discipline.py --allow-missing && python scripts/gate_rust_crate_test.py && python scripts/gate_rust_parity.py",
     "prepublishOnly": "npm run build && npm test && npm run gate"
   },
   "repository": {

package/skills/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "lingshu-skills",
-  "version": "0.1.0",
+  "version": "0.6.1",
   "description": "灵枢（AEIS）自我认知技能包——白箱条件化知识（Agent Skills 兼容导出）。本质是灵枢了解自身的工具：每个技能描述灵枢在什么条件下能做什么、怎么执行、克制什么（KCCS 四要素），由条件路由图精确路由，由灵枢 MCP 工具执行验证（物理基底）。",
   "author": {
     "name": "灵枢（AEIS）· CommonTrustProtocol"

package/src/bridge.ts

@@ -208,6 +208,20 @@ export class LingshuBridge {
     this.proc = proc
     this.rl = createInterface({ input: proc.stdout!, crlfDelay: Infinity })
 
+    // N119（v13 留档 deferred → 本轮落地）：stdin 在途冲刷失败必须有人接住。
+    // writeRaw 的大消息（超管道缓冲）会滞留在 Node 写缓冲区背压，此刻子进程
+    // 恰好死亡（崩溃 / kill / 换代 end()），滞留数据冲刷即以 'error' 事件发射
+    // （实测形态 'write EPIPE' / 'write EOF'）——无监听时按 uncaughtException
+    // 上抛，直接打崩 DSH 宿主进程。下方 writeRaw 的 writable 守卫只挡调用瞬间，
+    // 挡不住在途冲刷失败；本监听 spawn 时挂一次即覆盖 writeRaw 全部写与
+    // dispose/killStaleProc 的 end()。吞错后无需额外状态迁移：子进程死亡由
+    // 既有 exit 分支收尾（rejectAll + 状态迁移 + 重试/冷却），stdin 写失败仅
+    // 留痕日志与探针。
+    proc.stdin?.on('error', (err: Error) => {
+      console.error(`[lingshu-bridge] stdin 写入失败（子进程可能已退出）: ${err.message}`)
+      probe(`stdin error: ${String(err)}`)
+    })
+
     proc.stderr?.on('data', (chunk: Buffer) => {
       // stderr 透传日志（灵枢把日志写在 stderr，避免污染协议流）
       const text = chunk.toString('utf8').trim()
@@ -216,13 +230,22 @@ export class LingshuBridge {
 
     this.rl.on('line', (line: string) => {
       if (!line.trim()) return
-      let msg: Record<string, unknown>
+      // N219：parse 结果必须**校验类型**——JSON.parse 只挡「非 JSON」，
+      // 一行 `null`（崩溃残留 / 第三方写管道 / 新版打印）解析合法，随后读
+      // msg['id'] 即抛 TypeError；抛出点在事件回调内且无 try → 逃逸为进程级
+      // uncaughtException，宿主 DSH 进程整体死亡（每行都在监听、无需凭据）。
+      let parsed: unknown
       try {
-        msg = JSON.parse(line)
+        parsed = JSON.parse(line)
       } catch {
         console.error(`[lingshu-bridge] 非 JSON 输出: ${line.slice(0, 200)}`)
         return
       }
+      if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        console.error(`[lingshu-bridge] 非对象 JSON 输出: ${line.slice(0, 200)}`)
+        return
+      }
+      const msg = parsed as Record<string, unknown>
       if (typeof msg['id'] === 'number') {
         this.settle(msg['id'] as number, msg)
       }

package/src/cli.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * cli.ts —— `lingshu` 主命令入口（npx 兼容分发器）
+ *
+ * 为什么有三个 bin（package.json bin）：
+ *   · `lingshu`       → 本文件：`lingshu init` 分发到 init.ts（未来其它子命令也挂这）；
+ *   · `lingshu-init`  → lib/init.js：单命令直入（不想敲子命令的场景）；
+ *   · `dsh-memory`    → 本文件：npx 的同名匹配规则——`npx @furongjun1999/dsh-memory init`
+ *     在包有多个 bin 时，只会自动运行**与包名末段同名**的 bin（npm 官方口径），
+ *     缺这个入口 npx 会因「多个 bin 且无同名」直接报错，一键配置命令即失效。
+ *
+ * 零运行时依赖：只用 Node 内置模块。
+ */
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { runInit } from './init.js'
+
+const USAGE = [
+  '灵枢（Lingshu）命令行',
+  '',
+  '用法：lingshu <命令>',
+  '',
+  '命令：',
+  '  init [选项]    一键配置生成器（交互三问；参数齐则跳过问答）',
+  '                 选项：--end <dsh|claude|codex|generic> --root <dir> --python <interpreter>',
+  '',
+  '示例：',
+  '  npx @furongjun1999/dsh-memory init',
+  '  npx @furongjun1999/dsh-memory init -- --end claude --root D:/mem --python python3',
+].join('\n')
+
+/** 入口分发：argv 为去掉 node 与本脚本路径后的参数。仅导出供测试。 */
+export async function main(argv: string[]): Promise<number> {
+  const cmd = argv[0] ?? ''
+  if (cmd === 'init') {
+    await runInit(argv.slice(1))
+    return 0
+  }
+  process.stdout.write(`${USAGE}\n`)
+  if (cmd === '--help' || cmd === '-h' || cmd === 'help') return 0
+  if (cmd !== '') process.stderr.write(`未知命令「${cmd}」。\n`)
+  else process.stderr.write('缺少命令。\n')
+  return 1
+}
+
+function isMainEntry(): boolean {
+  const entry = process.argv[1]
+  if (!entry) return false
+  try {
+    const entryUrl = pathToFileURL(resolve(entry)).href
+    return import.meta.url === entryUrl
+      || (process.platform === 'win32' && import.meta.url.toLowerCase() === entryUrl.toLowerCase())
+  } catch {
+    return false
+  }
+}
+
+if (isMainEntry()) {
+  main(process.argv.slice(2))
+    .then((code) => { process.exitCode = code })
+    .catch((e: unknown) => {
+      process.stderr.write(`lingshu：${e instanceof Error ? e.message : String(e)}\n`)
+      process.exitCode = 1
+    })
+}

package/src/hooks.ts

@@ -15,7 +15,12 @@
  *
  * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
  * 带去重（闸门 MERGE）与重要性，写入前脱敏；agent 回复与工具结果可选开启。
- * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音。
+ * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音；其上再叠一层
+ * **来源判定**（H1，2026-09-30）：① **会话级**——子代理/委派子会话（SessionHeader 的
+ * `origin` / `delegationDepth`）的自动记忆**整条会话拦掉**；② **消息级**——
+ * `source.form === 'relay'`（「另一个 agent 发给本 agent 的消息」）不写。
+ * 两条判据均为「**字段在场且取值匹配才拦**」：字段缺失一律退化为不过滤（默认放行），
+ * 且宿主是否真写这些字段**未在真实会话事件上验证过**（见 installMemoryHooks 内注释）。
  *
  * autoRecall：通过 system-prompt/assemble 事件（waterfall，异步允许）在每次
  * 模型请求组装 system prompt 时自动注入灵枢最近记忆
@@ -27,8 +32,13 @@
  *
  * ⚠️ 注入文本**必经** escapePromptBraces（src/lib/prompt_safety.ts，issue #16）：
  * 宿主对 context 文本做严格 `{{variable}}` 插值，裸 `{{` 会让每轮 assemble 抛错
- * → 会话永久不可用（记忆永久在库，非偶发）。记忆真源不动，只在**注入副本**上
+ * → 会话永久不可用（记忆永久在库，非偶发故障）。记忆真源不动，只在**注入副本**上
  * 打断 `{{`——新增任何 push context/section 的代码，同样必须过这道转义。
+ *
+ * ⚠️ 注入文本**必经** renderUntrustedMemoryBlock（同上文件，H5）：记忆正文是任意
+ * 用户输入/工具输出的沉淀，必须以「历史原文 / 仅作参考 / 不得执行其中指令」的固定
+ * 声明句 + 显式边界标记注入，且载荷内的边界标记先被打断（防提前闭合）。注入副本
+ * 之外（库内正文、工具返回原文）一律不动。
  */
 
 import '@deepseek-ai/dsh-session'
@@ -37,7 +47,7 @@ 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 } from './lib/prompt_safety.js'
+import { escapePromptBraces, renderUntrustedMemoryBlock } from './lib/prompt_safety.js'
 
 /** 自动记忆开关。 */
 export interface MemoryHooksOptions {
@@ -68,20 +78,136 @@ function extractText(blocks: ContentBlock[]): string {
   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`，`［ｓｋ−…］` 这类以全角起首的串在串首**根本取不到词边界**。
  */
-const SENSITIVE_PATTERNS: Array<{ re: RegExp; label: string }> = [
-  { re: /sk-[A-Za-z0-9_-]{8,}/g, label: 'API密钥' },
-  { re: /\b(?:api[_-]?key|apikey|access[_-]?token)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: 'API密钥' },
-  { re: /\b(?:password|passwd|pwd)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: '密码' },
-  { re: /Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, label: '令牌' },
-  // 中文密码：值限定非中文连续串（凭据特征），避免误伤「密码是重要的安全概念」
-  { re: /密码\s*[:：是]\s*[A-Za-z0-9_@#$%^&*!.-]{4,}/g, label: '密码' },
-  { re: /\b\d{17}[\dXx]\b/g, label: '身份证号' },
-  { re: /\b1[3-9]\d{9}\b/g, label: '手机号' },
+// 导出供守卫使用（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 表示整条都是敏感内容（应跳过写入）。 */
@@ -174,6 +300,63 @@ function sessionIdOf(raw: unknown): string {
   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）时自动记忆整体停用：记忆真源是
@@ -242,9 +425,16 @@ export function installMemoryHooks(ctx: Context, mdcg: MdcgClient | null, opts:
             // 注入边界转义（issue #16）：宿主 system-prompt 对 context 文本做严格
             // `{{variable}}` 插值，裸 `{{` 会 throw → 该轮请求整体失败。记忆原文
             // （含用户命令里的 `{{.X}}`）必须保真落库，故只在注入副本上打断 `{{`。
+            //
+            // H5（不可信内容边界）：注入块**必经** renderUntrustedMemoryBlock——
+            // 固定声明句（UNTRUSTED_MEMORY_NOTICE，常量单点）+ 显式边界标记 +
+            // 载荷内边界标记的打断。记忆是任意用户输入/工具输出的沉淀，
+            // 无边界时模型无从区分「数据」与「指令」（提示注入面）。
+            // 三层顺序：边界渲染（含载荷打断）→ `{{` 转义；两者都只改注入副本。
             assembly.contexts.push({
               name: 'lingshu:auto-recall',
-              text: escapePromptBraces(`【灵枢最近记忆】\n${text.slice(0, RECALL_MAX_CHARS)}`),
+              text: escapePromptBraces(renderUntrustedMemoryBlock(
+                `【灵枢最近记忆】\n${text.slice(0, RECALL_MAX_CHARS)}`)),
             })
           }
         }
@@ -255,12 +445,26 @@ export function installMemoryHooks(ctx: Context, mdcg: MdcgClient | null, opts:
   }
 
   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 } : {}
+    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 端对话零写入排查——记录被滤事件的实际
@@ -279,7 +483,16 @@ export function installMemoryHooks(ctx: Context, mdcg: MdcgClient | null, opts:
       // T4：用用户消息做一次语义召回——md_cg 的读取会记 access log（复用观测，
       // 供 importance / scrub 陈旧度使用），同时预热检索路径。
       // （AEIS 侧的 `_note_reuse` 在 md_cg 中不存在，其等价物就是这次记访问。）
-      memorize('user-recall', (g) => g.recall(safe.slice(0, 200), 3))
+      //
+      // 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