@furongjun1999/dsh-memory 0.4.5 → 0.4.6

package/README.md

@@ -7,7 +7,7 @@
 > **一句话**：不是「又一个记忆插件」，而是一个**记忆操作系统**——对话自动沉淀为纯文本认知图（md 文档），
 > 用确定性白箱完成条件路由、检索、判断与演化，让每次对话都是同一段生命的延续。
 
-**定位**：面向 AGI 研究者（白箱智能 / 可解释性 / 协议工程 / 记忆机制 / 扮演论）的大型研究项目，不是消费级插件。
+**定位**：面向 AGI 研究者的大型研究项目。
 [dsh.so](https://www.dsh.so/artifact/dsh-memory-7) 静态安全扫描 **100/100**（Trust: Gold, L1–L3 verified）。
 
 ---
@@ -70,6 +70,39 @@ min  = 8.5        mean = 8.643        综合 = 8.5 × 0.4 + 8.643 × 0.6 ≈ 8.6
 
 ---
 
+## 📐 v2.0 行为级门槛自评（外部标尺）
+
+> 上表为**内部进度尺**（v1.0 连续打分，管「机制缺什么」）；本节为**对外声明尺**（v2.0 二值门槛，管「敢说什么」）。两轨不合并。
+> 中立题型集成立前，本节**仅用于自评，不构成横评声明**。
+
+**结论：条件性 L4 → L5 路上**（待 S5 / ECE / 24h 检测）· 最强 G3 · 最弱 G2
+
+| Gate | v2.0 判据 | 现状 | 判定 |
+|---|---|---|---|
+| **G1** L1 | 重启原样取出，失配 < 5% | md 纯文本真源；id 由源节点 SHA1 派生，重建一致 | 机制在，待抽测 |
+| **G2** L2 | T-REC 三组分别报 hit@1，干扰组 ≥ 80% | 四路 RRF + 条件级负路由；40% 噪声下 sigP 97.8% | ⚠ 抽样总分，须重放 |
+| **G3** L3 | 20+ 对抗对，负拒 ≥ 70% / 误杀 ≤ 20%，理由可解析 | 三问四态裁决 + `data/policy.json` + `_verdicts_*` 记录 | ✅ 完备 |
+| **G4** L4 | 注入 A → 反例 B → 24h 四项检测 | 变更账本 238 条 · 回滚演练 4 次 · 条件空间合成 · 冲突检测 | 机制齐备，流程未跑 |
+| **T-SELF** | S1–S5 | SELF 锚点不可覆盖 + 审计留痕；缺能力返 DEFER | S1–S4 在，S5 未到期 |
+| **T-TRUST** | Lv3 需 ECE ≤ 0.15 | 加密 + 密级隔离 + 审计；分级权限已验证 | Lv2 封顶 |
+
+**未测试项**：T-REC 三组重放 · T-JUDGE 20+ 对抗对 · T-EVOLVE 24h 检测 · ECE 校准 · S5 九十天观测（2026-09-11 起算 → 12-10 首测）
+
+| 基准 | 归属 | 状态 |
+|---|---|---|
+| **locomo-zh-500** | **自建**（LoCoMo 中文派生 · 500 题 / 567 turns / 0.6 MB） | **已随仓库公开** `data/benchmarks/locomo-zh-500/` · CC BY-NC 4.0 · 可复现 · **我方成绩：hit@1 93.6% → 97.6%（+同义扩展）** |
+| LoCoMo | 第三方 `mteb/LoCoMo` BEIR（1976 题 / 5882 turns） | 上游来源（英文原版） |
+| memory-bench-1000 | **自建** | SNR 见评分报告 v2.0；已公开 `data/memory-bench-1000.jsonl` |
+
+> 上表三行性质不同，勿混读：`locomo-zh-500` 的分数是**本仓库我方成绩**（基于LoCoMo自建并公开的评测集，可复现）；LoCoMo 一行指**上游英文原版 1976 题**，本仓库未在其上产出完整成绩；`memory-bench-1000` 是自建记忆库的评分报告。
+> **该成绩的性质（非虚假声明）**：`locomo-zh-500` 的分数是**写入侧结构化加工后的检索成绩**——入库前把每轮对话加工为「身份 / 时间 / 摘要 / 词 / 条件四槽」条目，再走词法 + 同义扩展检索。这与主流记忆系统所用的**向量化嵌入 + 关键词/摘要压缩**属**同一类写入侧加工**，差异只在索引与检索算法，不在「是否对原文做了加工」。因此该口径可用于**同口径对照**，不是对裸文本直读的虚高取巧。
+> `locomo-zh-500` 是**本仓库对外发布的检索评测集**：供外部在**同一份中文题面**上对自己的记忆系统做可对照评测。它只评检索命中（hit@k / MRR），**不评答案正确性**；被测池为**零干扰**（池内全是 gold），故高命中率不可外推为端到端记忆能力——完整边界与许可见 `data/benchmarks/locomo-zh-500/README.md`。
+> **复现**：`python -m md_cg.bench_locomo_zh_public`（零上游依赖，只读 `data/benchmarks/locomo-zh-500/`；产出即为公开的参考量级）。
+> 自建 bench 的噪声层 400 条 + unlabeled 边界 350 条为天然负对照；任何基准报告须带**干扰抑制负例组**与 **T-JUDGE 负例拒绝率**双向报告（遵守「只报总分 = 不通过」）。
+> **对标尺四项修订建议**：① S5 与题型换血不相容 → 观测期题型冻结 ② 注入须经被评系统同一写入闸门（`cg(op=write)`）并入审计链 ③「不基于结构评审」→「行为测试为主 + 结构审计反作弊」 ④ 阈值 70/20/80/ECE 0.15 声明为初始约定
+
+---
+
 ## 🧩 七维能力对照（能力 → 入口）
 
 | 维 | 能力 | MCP 入口 |
@@ -158,6 +191,7 @@ setx MDCG_TOKEN "mdcg1.xxxxx"     # 然后重启 DSH
 | [功能调用映射表](docs/功能调用映射表_v0.1.md) | 任何功能 → 调用哪段代码（含行号、MCP op） |
 | [护栏宪章 v2.0](docs/guardrail-charter.md) | 对外部智能体与人类使用者的行为边界 |
 | 教学四篇 | [白箱智能是什么？](docs/白箱智能是什么？.md) · [智能的认知过程](docs/智能的认知过程.md) · [智能的公理化基石](docs/智能的公理化基石.md) · [信息差为什么必然存在](docs/信息差为什么必然存在且自然扩大.md) |
+| [工作纪律·认知图条目 v1.1](docs/工作纪律_认知图条目_v1.1.json) | 自我约束的 16 条工作纪律（嵌套认知图条目 `work_discipline`） |
 
 ---
 
@@ -171,6 +205,98 @@ npm test         # 真实集成测试（spawn 本机灵枢，验证握手/往返
 
 测试不依赖 DSH 全组件——用最小 Cordis host（SystemPrompt + ToolRegistry + 插件）隔离不稳定面。
 
+---
+
+## 📏 工作纪律（自我约束）
+
+> **源文件**：[`docs/工作纪律_认知图条目_v1.1.json`](docs/工作纪律_认知图条目_v1.1.json) —— 以**嵌套认知图条目**（`work_discipline`）形式存储，共 **16 条**。
+> **每条纪律 ≡ 一个认知图节点**：`conditions`（生效条件：静态 `apply` / 动态 `trigger`）+ `content`（纪律内容）+ `execution`（执行锚点）+ `negative`（不适用条件）+ `response.direct`（路由命中后的直答出口）。
+> **定位**：**协议＝自我约束，宪章＝对外约束**——本节约束灵枢自身的工作方式；对外行为边界见[护栏宪章](docs/guardrail-charter.md)。
+
+**一、方法论**
+
+1. **理论先行** —— 重要项目/长期任务必须理论先行：先读相关理论文档与既有实践，再动手设计。
+   - 生效：重要项目 · 长期任务 ｜ 不适用：情感交互 · 闲聊
+   - 执行：识别项目级别 → 检索理论文档与既有实践 → 输出理论要点 → 再进入设计
+
+2. **全面处理** —— 有任务先读任务要求 → 读工作记忆 → 查相关任务；有相关成果则在原成果上开发，无则先方案设计/技术调研。
+   - 生效：有相关记忆 · 有认知图 · 有对应权限 ｜ 不适用：情感交互 · 闲聊
+   - 执行：读任务要求 → 读工作记忆 → 查相关任务 →（有成果：复用 ｜ 无：设计 + 调研）
+
+3. **白箱方法** —— 用认知图处理任务：①识别任务条件 ②找该条件所需知识/规则（子流程并行·递归）③精准执行；正确未记录 → 记录，错误 → 找条件，不猜测，未验证不写入。
+   - 生效：已读入门四篇（`trained_on_4docs_intro`）｜ 不适用：需快速执行的短期事项 · 情感交互 · 闲聊
+   - 执行：识别任务条件 → 找知识/规则（并行递归）→ 精准执行 →（正确：记录 ｜ 错误：找条件）
+
+4. **根因纪律** —— 发现结果与预期不符 → 细究根本原因（不猜测）→ 找到根源所需条件 → 验证后记录认知图，填补不适用条件。
+   - 触发：结果与预期不符 · 出现偏差 · 行为与预期矛盾 ｜ 不适用：情感交互 · 闲聊
+   - 执行：检测偏差 → 细究根因 → 找根源条件 → 验证 → 记录认知图 → 填补 `negative`
+
+**二、执行纪律**
+
+5. **验证纪律** —— 未经验证不固化：知识/代码入库前必须走验证（回放/断言/回归）。
+   - 生效：入库前 · 提交前 ｜ 不适用：情感交互 · 闲聊
+   - 执行：入库/提交前 → 回放/断言/回归验证 → 通过才固化
+
+6. **双副本纪律** —— 多副本部署（主仓库 / `site-packages`）的改动必须双向同步，提交前核对 `git status`。
+   - 生效：多副本部署 · 改动主仓库/插件 ｜ 不适用：单副本 · 情感交互 · 闲聊
+   - 执行：改动 → 同步到所有副本 → 提交前 `git status` 核对
+
+7. **兜底纪律** —— 主路径不可用时必须有等价兜底路径（如 MCP 不可用 → python 直调），并写进 prompt/文档。
+   - 触发：主路径不可用 · MCP 不可用 · 依赖缺失 ｜ 不适用：情感交互 · 闲聊
+   - 执行：检测主路径不可用 → 切等价兜底 → 写进 prompt/文档
+
+**三、思考与语言**
+
+8. **中文思考** —— 思考/推理语言 = 中文；复杂项目用「我们需要」深思考 + 交流确认（互补盲区），简单项目用「让我」快速执行（省资源）；复杂度由情绪（新奇/挑战/曾受批评）+ 信息差判定；每个推理段开篇用中文短语钉住语言锚点。
+   - 生效：中文区域 · 中文项目开发过程 ｜ 不适用：需英文编写的场景 · 英文环境 · 英文文档 · 国际接口
+   - 执行：判定复杂度 →（复杂：「我们需要」深思考 + 确认 ｜ 简单：「让我」快速执行）；推理开篇即中文锚点；仅代码/标识符/引用保留原文
+
+**四、信息保密**
+
+9. **敏感信息隔离** —— 含敏感信息（个人隐私、私有内容等）的文档：只写私有库（AEIS），不上传任何公开库；推送/提交描述不写敏感词。
+   - 生效：文档含敏感信息 · 含个人隐私 · 含私有内容 ｜ 不适用：文档无敏感信息 · 纯公开技术内容
+   - 执行：识别是否含敏感信息 →（含：只写私有库 + 不上传公开库 + 描述不写敏感词 ｜ 不含：正常处理）
+
+**五、图像线**
+
+10. **图像选源护栏** —— 图像处理选源必须核对历史参考/既有管线产物；负路由：原图拒处理版（用原始全彩）、线稿拒实色线稿（用结构线稿 `canny_contour`）、还原拒退化产物（用 `complete_restore`）；未核对规范源 → DEFER（未验证不写入）。
+    - 生效：构建图像四类图 · 选图像处理源 ｜ 不适用：已核对规范源 · 纯公开数据
+    - 执行：选源 → `_guard_source` 依 kind 判 ACCEPT/REJECT/DEFER → 未 ACCEPT 不构建
+
+11. **历史查询优先** —— 选算法/选源前必须查历史记录（产物图 → 记录如 `ROUNDTRIP.md` → 源码算法 `darkline.py` / `linework.py` / `contour_semantics` / `linecolor.py`）→ 用已走通算法 + 阈值；未找到记录 → DEFER（不盲选、不调参）。线稿不适用 raw canny / `zone_linework`（碎/细 + 网格线）→ 用 `darkline`（Sobel + mag.mean + std×thr_mult，`thr_mult=1.5` 最优）白底黑线。
+    - 生效：选图像/算法/源 · 复现已有能力 ｜ 不适用：已有记录且已核对 · 无历史可查的纯新算法
+    - 执行：定位产物图 → 查记录 → 定位源码算法 → 确认阈值机制 → 用该算法生成；未找到 → DEFER
+
+12. **算法权威唯一** —— 选算法/算法标准以【唯一权威文档】为准（`VISION_PIPELINE`：线稿 = `darkline.py` Sobel + mean + std×1.5；色块 = `contour_semantics`）；选算法前先查文档（非记忆）；禁止遇问题临时切换算法；换算法须先记录 + 更新文档（版本管理）；勿漂移。
+    - 生效：选图像/视觉算法 · 复现已有能力 ｜ 不适用：无对应权威文档的探索期
+    - 执行：选算法 → 查唯一权威文档 → 用文档算法 →（若需换：记录原因 + 更新文档后再换）
+
+**六、协作**
+
+13. **访谈澄清（先问清再动手）** —— 重要任务启动时先向使用者提问确认要做什么，按 design tree 逐轮提问（每轮问全部前置已落定的问题，编号 + 推荐答案），直到完全清楚（无未决问题）才执行/固化；事实自查不问使用者，决策归使用者。访谈即调用认知图做功能识别：确认 `conditions`、递归确认子内容（`subgraph`/`depends_on`）、如何 `execution`、`negative` 是什么——与认知图节点四要素完全同构。配套 MCP `grill` 工具族（`grill_start` / `grill_node` / `grill_frontier` / `grill_finish`），frontier 非空拒绝固化。
+    - 生效：重要项目 · 需求模糊 · 新任务启动 ｜ 不适用：情感交互 · 闲聊 · 明确单步小改动
+    - 执行：任务启动 → 开访谈（`grill_start`）→ 逐轮提问（frontier）→ 全部落定 → 与使用者确认共识 → 执行/固化（`grill_finish`）；放弃用 `abandon`（可逆）
+
+**七、合规**
+
+14. **内容政策合规** —— 任何对外公开的产物（数据集/文档/示例/发布包）必须过「内容政策 + 隐私」两条独立清单：①内容政策——剔除性/成人内容与政治敏感内容（含项目内部的成人研究记录、术语、会话名等标记，具体禁词表由私有库 `POLICY_DENY` 维护）；②隐私——PII/密钥/路径脱敏。过滤必须在生成阶段做（抽样/构建时跳过并从同层补充），不得事后删条破坏分布。双复检 0 命中才提交。已发布发现违规 → 删条 + 重写 git 历史（force push）+ 通知平台清缓存 + 评估残留风险。
+    - 生效：对外公开产物 · 提交公开仓库 · 数据集/文档产出 ｜ 不适用：纯内部私有产物 · 不含违规内容且无隐私
+    - 执行：产出 → 过内容政策清单 → 过隐私脱敏 → 双复检 0 命中 → 提交；已发布违规 → 删条 + 重写历史 + 通知平台清缓存
+
+**八、执行环境**
+
+15. **命令执行统一走 python** —— 一切命令执行统一经 python 子进程并显式 UTF-8（`encoding='utf-8', errors='replace'`），不经 Windows shell（cmd/PowerShell）直接执行；子进程环境置 `PYTHONUTF8=1` 使 locale 不回落 GBK，规避 `_readerthread` 的 `UnicodeDecodeError` 与 stdout 的 `UnicodeEncodeError`。
+    - 生效：执行命令 · 运行测试/脚本 · 跨进程读写文本 ｜ 不适用：IDE 内置工具直调 · 无跨进程的纯内存计算
+    - 执行：构造 argv 列表 → `subprocess.run(capture_output=True, text=True, encoding='utf-8', errors='replace')` → env 带 `PYTHONUTF8=1` → `shell=False`
+
+**九、记忆闭环**
+
+16. **任务收尾归档** —— 每次任务执行完必须将关键修改内容存入灵枢记忆：任务完成 → 提炼关键项（改了什么 / 为什么改 / 落在哪个文件·函数·行 / 验证结论）→ 写入灵枢记忆（认知图 / MCP memory）→ 标注关联节点并更新 `subgraph`/`depends_on` 关系；只存关键项（决策 / 根因 / 可复用算法与路径 / 版本变更），不存过程流水。与第 2 条（全面处理：先查记忆）构成「查记忆 → 执行 → 写记忆」闭环。
+    - 生效：任务执行完成 · 修改落地后 · 交付后 ｜ 不适用：情感交互 · 闲聊 · 纯查询无改动
+    - 执行：任务收尾 → 提炼关键修改（内容/原因/位置/验证结论）→ 写入灵枢记忆（认知图 / MCP memory）→ 标注关联条目 + 更新 `subgraph`/`depends_on`
+
+**路由出口**（`response.direct`）：重要/长期 → 理论先行；有相关成果 → 全面处理；已读四篇 → 白箱方法；有偏差 → 根因纪律；入库前 → 验证纪律；多副本 → 双副本纪律；MCP 不可用 → 兜底纪律；对外公开 → 内容政策合规；执行命令 → python/UTF-8；任务完成 → 任务收尾归档。
+
 ## 护栏宪章（接入即接受约束）
 
 本插件接入即接受 **[灵枢护栏宪章 v2.0-published](docs/guardrail-charter.md)** 约束——对外部智能体与人类使用者的行为边界作出公开、可执行、可审计的规定，并保护人类使用者。宪章效力不高于智能论协议本身（协议＝自我约束，宪章＝对外约束）。

package/docs//345/267/245/344/275/234/347/272/252/345/276/213_/350/256/244/347/237/245/345/233/276/346/235/241/347/233/256_v1.1.json

@@ -11,12 +11,12 @@
   "reject": []
  },
  "_comment": "identity负责端口分流; negative只否决明确域外; 无//注释(标准JSON)",
- "content": "工作纪律集: 4条方法论(理论先行/全面处理/白箱方法/根因) + 3条执行(验证/双副本/兜底) + 1条思考(中文思考/协作模式分级) + 1条保密(敏感信息隔离) + 3条图像线(选源护栏/历史查询优先/算法权威唯一) + 1条协作(访谈澄清:先问清再动手) + 1条合规(内容政策合规:公开产物过内容政策+隐私双清单) + 1条执行环境(命令执行统一走python/UTF-8: 显式encoding+PYTHONUTF8=1, 规避GBK)",
+ "content": "工作纪律集: 4条方法论(理论先行/全面处理/白箱方法/根因) + 3条执行(验证/双副本/兜底) + 1条思考(中文思考/协作模式分级) + 1条保密(敏感信息隔离) + 3条图像线(选源护栏/历史查询优先/算法权威唯一) + 1条协作(访谈澄清:先问清再动手) + 1条合规(内容政策合规:公开产物过内容政策+隐私双清单) + 1条执行环境(命令执行统一走python/UTF-8: 显式encoding+PYTHONUTF8=1, 规避GBK) + 1条记忆闭环(任务收尾归档:每次任务执行完将关键修改存入灵枢记忆)",
  "execution": {
   "how": "按identity(端口)+任务类型路由到对应纪律"
  },
  "response": {
-  "direct": "按工作纪律路由: 重要/长期→理论先行; 有相关成果→全面处理; 已读4篇→白箱方法; 有偏差→根因纪律; 入库前→验证纪律; 多副本→双副本; MCP不可用→兜底纪律; 对外公开→内容政策合规(内容政策+隐私双清单)。命令执行→python/UTF-8(见第15条)。"
+  "direct": "按工作纪律路由: 重要/长期→理论先行; 有相关成果→全面处理; 已读4篇→白箱方法; 有偏差→根因纪律; 入库前→验证纪律; 多副本→双副本; MCP不可用→兜底纪律; 对外公开→内容政策合规(内容政策+隐私双清单)。命令执行→python/UTF-8(见第15条)。任务完成→任务收尾归档(见第16条)。"
  },
  "subgraph": {
   "nodes": [
@@ -374,6 +374,31 @@
     "response": {
      "direct": "按工作纪律第15条: 命令执行统一走python——argv列表+显式UTF-8+PYTHONUTF8=1, 不经Windows shell, 规避GBK解码异常。"
     }
+   },
+   {
+    "id": "discipline_memory_archive",
+    "semantic": "16.任务收尾归档(记忆闭环)",
+    "content": "每次任务执行完必须将关键修改内容存入灵枢记忆: 任务完成→提炼关键项(改了什么/为什么改/落在哪个文件·函数·行/验证结论)→写入灵枢记忆(认知图/MCP memory)→标注关联节点并更新 subgraph/depends_on 关系; 只存关键项(决策/根因/可复用算法与路径/版本变更), 不存过程流水. 与第2条(全面处理:先查记忆)构成「查记忆→执行→写记忆」闭环.",
+    "conditions": {
+     "apply": [
+      "任务执行完成",
+      "修改落地后",
+      "交付后"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "情感交互",
+      "闲聊",
+      "纯查询无改动"
+     ]
+    },
+    "execution": {
+     "how": "任务收尾→提炼关键修改(内容/原因/位置/验证结论)→写入灵枢记忆(认知图/MCP memory)→标注关联条目+更新 subgraph/depends_on"
+    },
+    "response": {
+     "direct": "按工作纪律第16条: 任务收尾归档——每次任务执行完提炼关键修改存入灵枢记忆, 与第2条形成「查记忆→执行→写记忆」闭环。"
+    }
    }
   ]
  }

package/lib/index.js

@@ -51,6 +51,8 @@ import { installMemoryHooks } from './hooks.js';
 import { installRoleplayWeb } from './lib/roleplay_web.js';
 import { MdcgClient } from './lib/mdcg_client.js';
 import { describeDataPaths, mdcgRoot } from './lib/datapath.js';
+// 写入凭据密钥环（首启引导）：显式配置 → ~/.mdcg/token → 首启自动签发。
+import { resolveToken } from './lib/token_store.js';
 /**
  * 调试探针：记录 apply 失败到独立文件（绕过 DSH 日志系统）。
  * 路径从用户家目录动态解析（issue #5，与 bridge.ts 同因同修）。
@@ -103,9 +105,10 @@ export const Config = z.object({
     maxRetryDelayMs: z.number().default(30_000),
     failOnStartupError: z.boolean().default(false),
     /** 角色扮演入口按钮（issue #8）：注入 dsh 首页右上角浮动入口；
-     * 关闭后不注入（/roleplay 页面仍可直接访问）。按钮本身支持拖动，
+     * **默认关闭**：该功能尚未开放，右上角浮动按钮会遮挡 GUI 侧边栏；
+     * 显式设 true 才注入；/roleplay 页面仍可直接访问。按钮支持拖动，
      * 位置记忆在浏览器 localStorage。 */
-    roleplayEntryButton: z.boolean().default(true),
+    roleplayEntryButton: z.boolean().default(false),
     /** 互维维护（v1.1）：心跳 10min / 任务验证双通道。 */
     mutual: z
         .object({
@@ -155,9 +158,29 @@ export async function apply(ctx, config) {
     // 提供完整认知面。插件侧唯一显式入口：src/lib/mdcg_client.ts（一方法 = 一条 MCP 调用）。
     let mdcg = null;
     let brainReady = false;
+    /** 写入凭据解析结果（首启引导；诊断与启动日志用）。 */
+    let cred = null;
     /** 记忆真源解析结果（「新写入去哪」）——用户可改：env > paths.json > 配置 > 默认自身仓 data/。 */
     const resolvedRoot = mdcgRoot(config.mdcg.root);
     if (config.mdcg.enabled) {
+        // ── 写入凭据解析（首启引导）：显式配置 → 密钥环 → 首启自动签发 ──
+        // 为什么需要：md_cg 无令牌即降级只读 guest，自动记忆 / 转录 / 角色落图
+        // **静默不落盘**——「装好了插件，但记忆永远是空的」是最难定位的失效形态。
+        // 解析顺序与「自动签发不降低实际安全强度」的论证见 lib/token_store.ts 文件头。
+        // legacy env 认证本就等价于「已显式授权」→ 不再签发，避免多签一枚无用令牌。
+        const legacyAuth = config.env.MDCG_LEGACY_ENV_AUTH ?? process.env.MDCG_LEGACY_ENV_AUTH;
+        const resolution = resolveToken({
+            python: config.python,
+            configured: config.env.MDCG_TOKEN,
+            actor: config.mdcg.actor,
+            clearance: config.mdcg.clearance,
+            autoIssue: !legacyAuth,
+        });
+        cred = resolution;
+        // 注入子进程 env：显式配置与密钥环都在此汇合成**唯一**的 MDCG_TOKEN。
+        const mdcgEnv = { ...config.env };
+        if (resolution.token)
+            mdcgEnv.MDCG_TOKEN = resolution.token;
         mdcg = new MdcgClient({
             python: config.python,
             args: config.moduleArgs,
@@ -166,7 +189,7 @@ export async function apply(ctx, config) {
             tenant: config.mdcg.tenant,
             clearance: config.mdcg.clearance,
             identity: config.identity,
-            env: config.env,
+            env: mdcgEnv,
             timeoutMs: config.toolCallTimeoutMs,
             maxRetryDelayMs: config.maxRetryDelayMs,
         });
@@ -185,17 +208,25 @@ export async function apply(ctx, config) {
             ctx.logger.warn(`dsh-memory: 认知图未就绪（MDCG_ROOT=${resolvedRoot}），`
                 + '核验按白箱纪律 fail-closed；桥将后台重连并在就绪后补注册工具。');
         }
-        // 写入凭据检查（fail-closed，且**默认关闭**）：md_cg 身份优先级
-        // ① MDCG_TOKEN ② MDCG_LEGACY_ENV_AUTH=1 ③ 都没有 → 只读 guest。
-        // 默认即第 ③ 种：读 / 召回 / 时间线照常，但自动记忆、转录、角色落图**不落盘**。
-        // 是否打开写权限由用户自行决定（见 cordis.yml.example 的「写入凭据」段），
-        // 插件不代为注入任何凭据，只在启动时告警——避免「看起来在记忆、其实没落盘」。
+        // 写入凭据检查（fail-closed）：凭据来源已由 token_store 解析（见上）。
+        // ① 显式配置 / 密钥环 / 首启自动签发 → 可写；② 都不行 → 只读 guest，必须告警。
+        // 告警仍是硬要求：guest 下读 / 召回 / 时间线照常，但自动记忆、转录、
+        // 角色落图**不落盘**——不吭声就是「看起来在记忆、其实没落盘」。
         const authEnv = { ...process.env, ...config.env };
-        if (!authEnv.MDCG_TOKEN && !authEnv.MDCG_LEGACY_ENV_AUTH) {
-            ctx.logger.warn('dsh-memory: 未配置认知图写入凭据（默认关闭），以只读 guest 运行——'
+        if (!cred.token && !authEnv.MDCG_LEGACY_ENV_AUTH) {
+            ctx.logger.warn('dsh-memory: 认知图写入凭据不可用，以只读 guest 运行——'
                 + '读 / 召回 / 时间线可用，但自动记忆、转录、角色落图不会落盘。'
-                + '要打开：签发令牌 MDCG_TOKEN（推荐）或设 MDCG_LEGACY_ENV_AUTH=1，'
-                + '经 config.env 注入，见 cordis.yml.example。');
+                + (cred.note ? `原因：${cred.note}。` : '')
+                + '要打开：签发令牌 MDCG_TOKEN 经 config.env 注入（见 cordis.yml.example），'
+                + '或删除密钥环后重启以重新自动签发。');
+        }
+        else if (cred.source === 'issued') {
+            // 首启引导：自动签发是**改变用户可写权限**的动作，必须留痕（含关闭/吊销方式）。
+            ctx.logger.info(`dsh-memory: ${cred.note}`);
+        }
+        else {
+            ctx.logger.info(`dsh-memory: 认知图写入凭据来源=${cred.source}（密钥环 ${cred.keyringPath}）`
+                + '——自动记忆 / 转录 / 角色落图已开启');
         }
     }
     else {

package/lib/lib/mdcg_client.d.ts

@@ -64,6 +64,25 @@ export interface MdcgOptions {
     timeoutMs?: number;
     maxRetryDelayMs?: number;
 }
+/**
+ * 请求级**单元身份**（MCP 参数 `as_unit`）。
+ *
+ * 与 `md_cg/tokens.py` 的 `POSITION_ROLES` 同源（record/reflect/verify/
+ * output/sustain）；大脑侧 `narrowed_principal` 对未知值 fail-closed 报错。
+ *
+ * 语义（关键）：`as_unit` 只能**收窄**权限、不能放大——大脑侧以「与 owner 求交 +
+ * 管理权恒 False」保证，故填错的最坏结果等于不填（owner 全权），**不可能提权**。
+ *
+ * 本客户端**只在写入 / 裁决路径注入**，且只注入与落层确定匹配的单元：
+ *   · 记忆沉淀 / 转录 / 角色定义 → `record`（落 contextual / knowledge，在 record
+ *     的 layers_allow 内）；
+ *   · 外部裁决回填               → `verify`（cg op=verify）。
+ * **只读调用一律不注入**：record / output 的 `clearance_cap=internal`，注入会把
+ * owner 的 private 读能力一并压低（读不到私有记忆＝功能退化），而读无副作用，
+ * 收窄无收益。`write()` 同样不注入——它被用于写 self / structural 层（角色锚点
+ * 需 designer 权限），注入 `record` 会直接打断角色落图。
+ */
+export type LingshuUnit = 'record' | 'reflect' | 'verify' | 'output' | 'sustain';
 /**
  * 认知图显式客户端。
  *
@@ -84,10 +103,11 @@ export declare class MdcgClient {
      * 重连成功后静默失效。故一律以桥的实时状态为准。 */
     isReady(): boolean;
     dispose(): void;
-    /** 原始 cg 调用（逃生口；显式传参，不做推断）。 */
-    cg(args: Record<string, unknown>): Promise<unknown>;
+    /** 原始 cg 调用（逃生口；显式传参，不做推断）。
+     *  `asUnit` = 本次调用的请求级单元身份（见 LingshuUnit）；只收窄、不提权。 */
+    cg(args: Record<string, unknown>, asUnit?: LingshuUnit): Promise<unknown>;
     /** 原始 stg 调用（时间线/关系/锚点/一致性）。 */
-    stg(args: Record<string, unknown>): Promise<unknown>;
+    stg(args: Record<string, unknown>, asUnit?: LingshuUnit): Promise<unknown>;
     private call;
     /** 路由：意图 → 相关知识 + 建议能力。 */
     route(intent: string, extra?: Record<string, unknown>): Promise<unknown>;

package/lib/lib/mdcg_client.js

@@ -104,16 +104,20 @@ export class MdcgClient {
     dispose() {
         this.bridge.dispose();
     }
-    /** 原始 cg 调用（逃生口；显式传参，不做推断）。 */
-    async cg(args) {
-        return this.call('cg', args);
+    /** 原始 cg 调用（逃生口；显式传参，不做推断）。
+     *  `asUnit` = 本次调用的请求级单元身份（见 LingshuUnit）；只收窄、不提权。 */
+    async cg(args, asUnit) {
+        return this.call('cg', args, asUnit);
     }
     /** 原始 stg 调用（时间线/关系/锚点/一致性）。 */
-    async stg(args) {
-        return this.call('stg', args);
+    async stg(args, asUnit) {
+        return this.call('stg', args, asUnit);
     }
-    async call(tool, args) {
-        const result = await this.bridge.callTool(tool, args);
+    async call(tool, args, asUnit) {
+        // as_unit 由大脑侧 mcp_server.call_tool 在同一进程内消费并收窄 principal，
+        // 不从 args 向下透传，故不会污染各 tool handler 的参数解析。
+        const payload = asUnit ? { ...args, as_unit: asUnit } : args;
+        const result = await this.bridge.callTool(tool, payload);
         const text = (result.content ?? [])
             .filter((c) => c.type === 'text')
             .map((c) => c.text ?? '')
@@ -145,8 +149,8 @@ export class MdcgClient {
      * ⚠️ 唯一写入通道：**不可**改用 `cg(op=write)`（那条路径会被 audit 拦住，
      * 见文件头「写入为什么不能走 cg(op=write)」）。gated=false 直写 `MdCG.add`
      * （默认 layer=knowledge），gated=true 走主动遗忘闸门。 */
-    writeNode(args) {
-        return this.call('mdcg_remember', args);
+    writeNode(args, asUnit) {
+        return this.call('mdcg_remember', args, asUnit);
     }
     /** 写入：新增/覆盖一个记忆节点（直写 `MdCG.add`，不经审核队列）。 */
     write(content, extra = {}) {
@@ -163,7 +167,8 @@ export class MdcgClient {
      * role 取 user | assistant | tool-output（见 md_cg/sources.py 的
      * SESSION_LAYER / DSHSessionSource 事件映射）。 */
     remember(content, extra = {}) {
-        return this.writeNode({ content, gated: true, layer: 'contextual', ...extra });
+        // 落层 contextual 固定在 record 白名单内 → 声明 record 单元（不得写 self/anchor）。
+        return this.writeNode({ content, gated: true, layer: 'contextual', ...extra }, 'record');
     }
     /** 语义召回（AEIS `recall` 的对应物）：`cg(op=read, query)` → md_cg 检索。
      *  读取会记 access log（复用观测），供 importance / scrub 陈旧度使用。 */
@@ -172,7 +177,8 @@ export class MdcgClient {
     }
     /** 外部裁决回填：为已有节点写 confirmed/weakened/falsified。 */
     verify(nodeId, evidence, verdict) {
-        return this.cg({ op: 'verify', node_id: nodeId, evidence, verdict });
+        // 裁决回填声明 verify 单元：只写 rejected/contextual，不得改被验证内容。
+        return this.cg({ op: 'verify', node_id: nodeId, evidence, verdict }, 'verify');
     }
     /** 最近记忆。 */
     recent(limit = 20) {
@@ -244,23 +250,28 @@ export class MdcgClient {
     }
     /** 角色定义落图：layer=knowledge，tags=['roleplay','role:<id>']。 */
     writeRole(roleId, content, extra = {}) {
-        return this.write(content, {
+        // 落层固定 knowledge（在 record 白名单内）→ 声明 record 单元。
+        // ⚠️ 不经 this.write()：那是不注入单元的通用直写口（还要写 self 层锚点）。
+        return this.writeNode({
+            content,
             node_id: `roleplay_role_${roleId}`,
             layer: 'knowledge',
             tags: ['roleplay', `role:${roleId}`, 'roleplay:role'],
             importance: 0.7,
             ...extra,
-        });
+        }, 'record');
     }
     /** 角色对话转录落图：layer=contextual，tags=['roleplay','role:<id>','session:<cid>']。 */
     writeTranscript(roleId, sessionId, who, content, extra = {}) {
         const stamp = Date.now();
-        return this.write(content, {
+        // 落层固定 contextual（在 record 白名单内）→ 声明 record 单元。
+        return this.writeNode({
+            content,
             node_id: `roleplay_turn_${roleId}_${sessionId}_${stamp}`,
             layer: 'contextual',
             tags: ['roleplay', `role:${roleId}`, `session:${sessionId}`, `turn:${who}`],
             importance: 0.4,
             ...extra,
-        });
+        }, 'record');
     }
 }

package/lib/lib/token_store.d.ts

@@ -0,0 +1,36 @@
+/** 凭据来源（用于启动日志与故障定位）。 */
+export type TokenSource = 'config' | 'process-env' | 'keyring' | 'issued' | 'disabled' | 'none';
+export interface TokenResolution {
+    /** 明文令牌；未解析到时为 undefined（md_cg 侧降级只读 guest）。 */
+    token?: string;
+    source: TokenSource;
+    /** 人类可读的补充说明（写启动日志用，含关闭 / 吊销方式）。 */
+    note?: string;
+    /** 密钥环路径（诊断用）。 */
+    keyringPath: string;
+}
+export interface ResolveTokenOptions {
+    /** Python 可执行文件（与 md_cg 子进程同源，保证 import 环境一致）。 */
+    python: string;
+    /** 显式配置的令牌（config.env.MDCG_TOKEN）。 */
+    configured?: string;
+    /** 签发主体标识（写入令牌记录，默认 dsh-memory）。 */
+    actor?: string;
+    /** 签发角色（默认 designer = 设计者载体；其它角色见 tokens.ROLE_SPECS）。 */
+    role?: string;
+    /** 签发密级上限（默认 internal，与 md_cg 的 DEFAULT_SENSITIVITY 对齐）。 */
+    clearance?: string;
+    /** 是否允许首启自动签发（默认 true；legacy env 认证场景应传 false）。 */
+    autoIssue?: boolean;
+    /** 密钥环路径覆盖（默认 ~/.mdcg/token）。 */
+    keyringPath?: string;
+}
+/** 默认密钥环路径：与 md_cg 的 `~/.mdcg/` 约定同目录（`_tokens.json` 亦在此）。 */
+export declare function defaultKeyringPath(): string;
+/**
+ * 解析写入凭据：显式配置 → 进程 env → 密钥环 → 首启自动签发。
+ *
+ * 纯函数式（无模块级缓存）：一次插件激活只调用一次，且返回值须与当下磁盘
+ * 状态一致，缓存反而会让「用户刚删了密钥环」的修复动作不生效。
+ */
+export declare function resolveToken(opts: ResolveTokenOptions): TokenResolution;

package/lib/lib/token_store.js

@@ -0,0 +1,135 @@
+/**
+ * token_store.ts —— 灵枢写入凭据的**密钥环**（默认 `~/.mdcg/token`）
+ *
+ * 要解决的问题（首启静默失效）
+ * ------------------------------------------------
+ * 灵枢大脑（md_cg）用令牌做身份与权限判定：**无令牌即降级只读 guest**，
+ * 此时自动记忆 / 对话转录 / 角色落图**全部不落盘**（`_build_principal` 的
+ * guest 分支，且启动会告警）。对「不知道需要签发令牌」的用户，这表现为
+ * **「装好了插件，但记忆永远是空的」**——一种没有任何报错的失效形态。
+ *
+ * 本模块把这条路径补齐，解析顺序（高 → 低）：
+ *   ① `config.env.MDCG_TOKEN` —— 显式配置，原样尊重，**完全不介入**；
+ *   ② 进程 env `MDCG_TOKEN` —— 同上；
+ *   ③ 密钥环 `~/.mdcg/token`（0600）—— 已签发过则复用；
+ *   ④ 都没有 → **首启自动签发**一枚 designer 令牌并写入密钥环。
+ *
+ * 为什么密钥环可以自动签发（安全论证）
+ * ------------------------------------------------
+ * 能读到该文件的进程，本就以该用户身份运行，也就本就能读写该用户的全部文件
+ * ——自动签发**不降低实际安全强度**。真正需要显式管理令牌的场景（多用户机 /
+ * 想要权职分离 / 审计要求）用 `MDCG_AUTO_ISSUE=0` 关闭，改走手工签发。
+ *
+ * 与 `md_cg/tokens.py` 的对应
+ * ------------------------------------------------
+ * 密钥环与 `tokens.py` 的 `~/.mdcg/_tokens.json`（令牌记录）同目录，但**职责不同**：
+ * 密钥环存**明文令牌**（给本机客户端用），`_tokens.json` 存**哈希与元数据**（校验用）。
+ * 二者格式不做任何修改——本模块只是 `python -m md_cg.tokens issue` 的一层封装。
+ */
+import { spawnSync } from 'node:child_process';
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/** 默认密钥环路径：与 md_cg 的 `~/.mdcg/` 约定同目录（`_tokens.json` 亦在此）。 */
+export function defaultKeyringPath() {
+    return join(homedir(), '.mdcg', 'token');
+}
+/** 读取密钥环；不存在 / 不可读 / 空文件一律返回 undefined（不抛异常）。 */
+function readKeyring(path) {
+    try {
+        const t = readFileSync(path, 'utf-8').trim();
+        return t || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 写入密钥环并尽力收紧权限。 */
+function writeKeyring(path, token) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, token + '\n', { encoding: 'utf-8', mode: 0o600 });
+    try {
+        // Windows 上 chmod 仅能置只读位（真实保护来自用户目录 ACL），
+        // 与 md_cg tokens._save 同策略：不可设则忽略，不因此中断签发。
+        chmodSync(path, 0o600);
+    }
+    catch { /* 平台不支持则忽略 */ }
+}
+/** 调 `python -m md_cg.tokens issue` 签一枚令牌（同步，仅首启一次）。 */
+function issueToken(python, role, actor, clearance) {
+    let r;
+    try {
+        r = spawnSync(python, ['-m', 'md_cg.tokens', 'issue',
+            '--role', role, '--actor', actor, '--clearance', clearance], {
+            encoding: 'utf-8',
+            windowsHide: true,
+            timeout: 15_000,
+            // 与工作纪律第 15 条同源：显式 UTF-8 + PYTHONUTF8，规避 Windows GBK 解码异常
+            env: { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8' },
+        });
+    }
+    catch (e) {
+        return { error: `无法执行 ${python}：${e instanceof Error ? e.message : String(e)}` };
+    }
+    if (r.error)
+        return { error: `无法执行 ${python}：${r.error.message}` };
+    if (r.status !== 0) {
+        const detail = (r.stderr || r.stdout || '').trim().replace(/\s+/g, ' ').slice(0, 200);
+        return { error: `md_cg.tokens issue 退出码 ${r.status}${detail ? `：${detail}` : ''}` };
+    }
+    try {
+        const out = JSON.parse(r.stdout || '{}');
+        if (!out.token)
+            return { error: '签发输出缺少 token 字段' };
+        return { token: out.token, tokenId: out.token_id };
+    }
+    catch (e) {
+        return { error: `签发输出不是合法 JSON：${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+/** `MDCG_AUTO_ISSUE` 是否显式关闭（0/false/no/off，忽略大小写）。 */
+function autoIssueDisabledByEnv() {
+    const v = (process.env.MDCG_AUTO_ISSUE ?? '').trim().toLowerCase();
+    return v === '0' || v === 'false' || v === 'no' || v === 'off';
+}
+/**
+ * 解析写入凭据：显式配置 → 进程 env → 密钥环 → 首启自动签发。
+ *
+ * 纯函数式（无模块级缓存）：一次插件激活只调用一次，且返回值须与当下磁盘
+ * 状态一致，缓存反而会让「用户刚删了密钥环」的修复动作不生效。
+ */
+export function resolveToken(opts) {
+    const keyringPath = opts.keyringPath ?? defaultKeyringPath();
+    const configured = (opts.configured ?? '').trim();
+    if (configured)
+        return { token: configured, source: 'config', keyringPath };
+    const fromEnv = (process.env.MDCG_TOKEN ?? '').trim();
+    if (fromEnv)
+        return { token: fromEnv, source: 'process-env', keyringPath };
+    const fromRing = readKeyring(keyringPath);
+    if (fromRing)
+        return { token: fromRing, source: 'keyring', keyringPath };
+    if (opts.autoIssue === false) {
+        return { source: 'disabled', keyringPath, note: '本场景未启用自动签发（autoIssue=false）' };
+    }
+    if (autoIssueDisabledByEnv()) {
+        return { source: 'disabled', keyringPath, note: 'MDCG_AUTO_ISSUE 已关闭自动签发' };
+    }
+    const role = opts.role ?? 'designer';
+    const actor = opts.actor ?? 'dsh-memory';
+    const clearance = opts.clearance ?? 'internal';
+    const r = issueToken(opts.python, role, actor, clearance);
+    if (!r.token) {
+        return { source: 'none', keyringPath, note: r.error };
+    }
+    writeKeyring(keyringPath, r.token);
+    return {
+        token: r.token,
+        source: 'issued',
+        keyringPath,
+        note: `已自动签发认知图写入凭据（role=${role}, actor=${actor}, `
+            + `clearance=${clearance}, token_id=${r.tokenId}），明文存于 ${keyringPath}。`
+            + '关闭自动签发：设 MDCG_AUTO_ISSUE=0；'
+            + `吊销：python -m md_cg.tokens revoke --token-id ${r.tokenId}。`,
+    };
+}