@furongjun1999/dsh-memory 0.7.2 → 0.7.4

package/lib/lib/session_state.d.ts

@@ -0,0 +1,56 @@
+/**
+ * session_state.ts —— 插件侧「运行期会话状态」单点（观测 → 写归因注入）
+ *
+ * 为什么有这个模块（B 治本批，2026-10-06）
+ * ----------------------------------------
+ * DSH 单进程多会话：宿主的会话标识只经 `session/event` 到达插件。此前它只被
+ * 用在 hooks 面（自动记忆的 remember / read 带 extra.session）；**agent 直调
+ * 工具面**（src/tools.ts 的 execute → bridge.callTool）转发时**不带会话**——
+ * 而部署侧 `MDCG_SESSION` env 一旦取消/为空，`md_cg/mcp_server.py` 的
+ * `_declared_session`（:3823-3850）就以**请求声明**为归因来源
+ * （优先级：env > 请求声明 > 进程身份），不传即落回进程身份——md_cg 的
+ * `Principal.__init__` 会为假值 session 生成**进程级随机** `sess_<hex>`
+ * （md_cg/security.py:117）：归属在审计上既读不出是谁、跨进程也对不上，
+ * 是静默的归属丢失。
+ *
+ * 本模块把「观测会话」与「写归因注入」收成**单点**：
+ *   · hooks 面：每收到 session/event 就 `noteSession(sid)`——调用点仍在 H1
+ *     子代理闸**之后**（子代理会话不得污染会话状态的位置不变量保持）；
+ *   · 工具面：写归因调用注入 `currentSession() || UNASSIGNED_SESSION`
+ *     （判据矩阵见 `attributeSession`，只注入写面；读面一律不注入）。
+ *
+ * 模块级状态（`lastSession`）是**进程级**的：同一进程内多个会话共享它，
+ * 「最近一次观测」即当前活动会话——与 hooks 面的既有口径一致（见
+ * test/session-attribution.test.ts ④「取值每步稳定」）。
+ */
+/** 会话归属未知时的**显式占位**（H2③，2026-09-30；原定义在 src/hooks.ts，
+ *  B 治本批迁入本单点——注释要点保真搬迁）。
+ *
+ *  ⚠️ 不可退回「不传 session 键」：md_cg 的 `Principal.__init__` 在 session 为假值时
+ *  生成**进程级随机** `sess_<hex>`（md_cg/security.py:117）——插件不传，等于让一个
+ *  进程内所有「宿主未给标识」的会话共用一个**不可辨认**的随机桶：归属在审计上既
+ *  读不出是谁、跨进程也对不上，是静默的归属丢失。
+ *  本常量把这一态写成**显式值**：跨进程一致、可辨认、可审计，且不是伪造的宿主
+ *  会话 id（非 DSH 形态，服务端 `_normalize_session` 原样采用、不会被改写成别的桶）。
+ *  要读这个桶：`stg(op=timeline, session="unassigned")`。 */
+export declare const UNASSIGNED_SESSION = "unassigned";
+/** 记录一次会话观测（H2③ 观测面单点）。
+ *
+ *  trim 后非空才写入——空串/纯空白**不覆盖**旧值（否则「宿主给了一次空标识」
+ *  会把已观测到的真会话抹掉，后续注入退化为 unassigned）。 */
+export declare function noteSession(sid: string): void;
+/** 当前运行期会话标识（空串 = 未观测到；调用方按 `|| UNASSIGNED_SESSION` 兜底）。 */
+export declare function currentSession(): string;
+/** 把**运行期会话**注入**写归因调用**（args 的 session 键不可用时才注入）。
+ *
+ *  注入条件：`session` 键缺失 / 非 string 类型 / trim 后空串 ⇒ 注入
+ *  （`null`/`''`/空白一律视为「未声明」——服务端 `_declared_session` 对假值
+ *  同样解析为无归属声明，原样转发只会落回进程级随机 sess_* 兜底桶）；
+ *  显式非空声明一律**不覆盖**（调用方自报优先——插件不替调用方改归属）。
+ *
+ *  注入值：`currentSession() || UNASSIGNED_SESSION`（未观测到会话时用
+ *  'unassigned' 显式占位——与 hooks 面 H2③ 同口径）。
+ *
+ *  命中且需注入 → 返回**新对象** `{ ...args, session: v }`（绝不 mutate 输入）；
+ *  否则**原样返回**（同一引用）——未命中的调用零开销、零可观察差异。 */
+export declare function attributeSession(toolName: string, args: Record<string, unknown>): Record<string, unknown>;

package/lib/lib/session_state.js

@@ -0,0 +1,124 @@
+/**
+ * session_state.ts —— 插件侧「运行期会话状态」单点（观测 → 写归因注入）
+ *
+ * 为什么有这个模块（B 治本批，2026-10-06）
+ * ----------------------------------------
+ * DSH 单进程多会话：宿主的会话标识只经 `session/event` 到达插件。此前它只被
+ * 用在 hooks 面（自动记忆的 remember / read 带 extra.session）；**agent 直调
+ * 工具面**（src/tools.ts 的 execute → bridge.callTool）转发时**不带会话**——
+ * 而部署侧 `MDCG_SESSION` env 一旦取消/为空，`md_cg/mcp_server.py` 的
+ * `_declared_session`（:3823-3850）就以**请求声明**为归因来源
+ * （优先级：env > 请求声明 > 进程身份），不传即落回进程身份——md_cg 的
+ * `Principal.__init__` 会为假值 session 生成**进程级随机** `sess_<hex>`
+ * （md_cg/security.py:117）：归属在审计上既读不出是谁、跨进程也对不上，
+ * 是静默的归属丢失。
+ *
+ * 本模块把「观测会话」与「写归因注入」收成**单点**：
+ *   · hooks 面：每收到 session/event 就 `noteSession(sid)`——调用点仍在 H1
+ *     子代理闸**之后**（子代理会话不得污染会话状态的位置不变量保持）；
+ *   · 工具面：写归因调用注入 `currentSession() || UNASSIGNED_SESSION`
+ *     （判据矩阵见 `attributeSession`，只注入写面；读面一律不注入）。
+ *
+ * 模块级状态（`lastSession`）是**进程级**的：同一进程内多个会话共享它，
+ * 「最近一次观测」即当前活动会话——与 hooks 面的既有口径一致（见
+ * test/session-attribution.test.ts ④「取值每步稳定」）。
+ */
+/** 会话归属未知时的**显式占位**（H2③，2026-09-30；原定义在 src/hooks.ts，
+ *  B 治本批迁入本单点——注释要点保真搬迁）。
+ *
+ *  ⚠️ 不可退回「不传 session 键」：md_cg 的 `Principal.__init__` 在 session 为假值时
+ *  生成**进程级随机** `sess_<hex>`（md_cg/security.py:117）——插件不传，等于让一个
+ *  进程内所有「宿主未给标识」的会话共用一个**不可辨认**的随机桶：归属在审计上既
+ *  读不出是谁、跨进程也对不上，是静默的归属丢失。
+ *  本常量把这一态写成**显式值**：跨进程一致、可辨认、可审计，且不是伪造的宿主
+ *  会话 id（非 DSH 形态，服务端 `_normalize_session` 原样采用、不会被改写成别的桶）。
+ *  要读这个桶：`stg(op=timeline, session="unassigned")`。 */
+export const UNASSIGNED_SESSION = 'unassigned';
+/** 最近一次观测到的宿主会话标识（空串 = 未观测到会话）。
+ *
+ *  ⚠️ 本状态是**模块级（进程级）单点**：hooks 面观测写入（src/hooks.ts 的
+ *  session/event），工具面读它做写归因注入（src/tools.ts 的转发面）——两处必须
+ *  同源，否则注入的会话与写入的归属对不上（B 治本批的目的即在此）。
+ *
+ *  「本实例是否观测过」的**实例级门不在本模块**，在 src/hooks.ts 的
+ *  installMemoryHooks 内（局部 `observedSession`）：即「本实例观测到会话之后」
+ *  才用本单点值回落召回过滤。这是**经 owner 裁定的契约字面偏离（dwfq-7b3a555e-1）**
+ *  ——契约建议的形态是 hooks 侧字面 `|| currentSession()`，但字面形态与硬边界
+ *  「test/session-attribution.test.ts 逐字未动且全绿」互斥（该守卫 ② 以
+ *  「新建 harness = 未观测」为前提，字面回落会读成前一实例的 sess_B）。保留
+ *  实例门的两条理由：
+ *    ① 「新实例 = 干净状态」是原闭包变量 `lastSession` 的**有意属性**（新装的钩子
+ *       在观测到会话前，自动召回不加过滤）——实例隔离语义在测试面被真实保留；
+ *    ② 与既有冻结守卫 ② 相容（守卫逐字未动且全绿是本批硬边界）。
+ *  真机单实例下两者**逐位等价**：唯一差异窗口是「本实例未观测 ∧ 模块单点非空」，
+ *  而模块值只由本实例的 hooks 观测写入，单实例下该窗口不可达；HMR 重载场景下新
+ *  实例回落 '' 而非上一会话值，属更保守的防御行为（已由 owner 裁定接受）。 */
+let lastSession = '';
+/** 记录一次会话观测（H2③ 观测面单点）。
+ *
+ *  trim 后非空才写入——空串/纯空白**不覆盖**旧值（否则「宿主给了一次空标识」
+ *  会把已观测到的真会话抹掉，后续注入退化为 unassigned）。 */
+export function noteSession(sid) {
+    const s = sid.trim();
+    if (s)
+        lastSession = s;
+}
+/** 当前运行期会话标识（空串 = 未观测到；调用方按 `|| UNASSIGNED_SESSION` 兜底）。 */
+export function currentSession() {
+    return lastSession;
+}
+/** 写归因面判据：本次调用是否属于「要注入运行期会话」的写归因调用。
+ *
+ *  **恰两条命中路径**（不得放宽、不得收窄出契约外）：
+ *    ① `mdcg_remember` —— md_cg 细粒度写入口（插件侧自动记忆/落图的写通道）；
+ *    ② `cg` 且 `op === 'write'` —— 认知图基元的带审核写路径。
+ *
+ *  为什么**只**这两个面（判据出处：md_cg/mcp_server.py）：
+ *    · **读面一律不注入**——`mdcg_recall` / `mdcg_search` / `mdcg_get` / `stg`
+ *      以及 `cg` 的其它 op，其 `session` 是**视图过滤**：服务端 schema 描述原文
+ *      「会话归属过滤（frontmatter.session；…缺省不过滤）」
+ *      （md_cg/mcp_server.py:218-219 / :251-252 / :908-912 / :1074-1077）。
+ *      注入会把文档化的「缺省跨会话」翻转成「本会话视图」——那是功能收窄，
+ *      不是本批目标（读面要跨会话视图请显式 `stg(op=timeline, session="*")`）。
+ *    · **op 特化语义不动**——`cg` 的 `sustain`/`session` 等 op 的 `session` 是
+ *      特化语义（resume/note 的**目标会话**），注入即污染其目标参数。
+ *    · 归因与授权正交（issue #35 定稿）：`call_tool` 的请求级 session **只做
+ *      归因**（写入归属/`_attribution` 取它），**不**改 `principal.session`
+ *      （md_cg/mcp_server.py:3261-3264）——绑定档（private/secret）的读授权
+ *      锚定连接级身份，调用方自报的会话不构成看他人 private 的授权。
+ *      绑定档可见性判定 `MdCGSecure._readable`（md_cg/mdcos.py:5009-5053）
+ *      的会话绑定分支恒用 `nsess == self.principal.session`（:5051-5052），
+ *      can_admin（设计者）豁免（:5045）——故本注入对绑定档无回归。
+ *
+ *  ⚠️ 禁止把本判据放宽成「所有带 session 参数的工具」：那会把上面两类语义
+ *  （读面视图过滤 / op 特化目标）一并改写，属越权改契约。
+ */
+function isWriteAttributionCall(toolName, args) {
+    if (toolName === 'mdcg_remember')
+        return true;
+    return toolName === 'cg' && args['op'] === 'write';
+}
+/** 请求是否已显式声明会话（string 且 trim 后非空 → 保留调用方声明，绝不覆盖）。 */
+function hasDeclaredSession(args) {
+    const v = args['session'];
+    return typeof v === 'string' && v.trim() !== '';
+}
+/** 把**运行期会话**注入**写归因调用**（args 的 session 键不可用时才注入）。
+ *
+ *  注入条件：`session` 键缺失 / 非 string 类型 / trim 后空串 ⇒ 注入
+ *  （`null`/`''`/空白一律视为「未声明」——服务端 `_declared_session` 对假值
+ *  同样解析为无归属声明，原样转发只会落回进程级随机 sess_* 兜底桶）；
+ *  显式非空声明一律**不覆盖**（调用方自报优先——插件不替调用方改归属）。
+ *
+ *  注入值：`currentSession() || UNASSIGNED_SESSION`（未观测到会话时用
+ *  'unassigned' 显式占位——与 hooks 面 H2③ 同口径）。
+ *
+ *  命中且需注入 → 返回**新对象** `{ ...args, session: v }`（绝不 mutate 输入）；
+ *  否则**原样返回**（同一引用）——未命中的调用零开销、零可观察差异。 */
+export function attributeSession(toolName, args) {
+    if (!isWriteAttributionCall(toolName, args))
+        return args;
+    if (hasDeclaredSession(args))
+        return args;
+    return { ...args, session: currentSession() || UNASSIGNED_SESSION };
+}

package/lib/tools.js

@@ -5,6 +5,10 @@
  * 动态拉取意味着灵枢库升级新增工具后，DSH 侧零改动即可获得新能力。
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
+// B 治本批（2026-10-06）：写归因注入单点（运行期会话 → 写归因调用）。
+// 运行时导入写 `.js`（本仓口径：type-only 才写 `.ts`，tsconfig 未开
+// allowImportingTsExtensions —— 值导入写 `.ts` 会 TS5097 编译失败）。
+import { attributeSession } from './lib/session_state.js';
 /** 默认暴露的核心工具集合：**记忆面已基元化**，只注册 `cg` / `stg` 两个认知基元。
  *
  * 三层拆分 S4 收敛后，插件工具面真源是 `md_cg.mcp_server`（不再是 pip aeis）；
@@ -173,7 +177,14 @@ export async function registerLingshuTools(ctx, bridge, opts) {
                 async execute(args, exec) {
                     if (exec.signal.aborted)
                         throw new Error(`灵枢 ${tool.name} 已取消`);
-                    const result = await bridge.callTool(tool.name, args, exec.signal);
+                    // B 治本批（2026-10-06）：agent 直调工具的转发面把**运行期会话**注入
+                    // **写归因调用**——env（MDCG_SESSION）取消后，请求声明即归因唯一来源
+                    // （md_cg/mcp_server.py 的 _declared_session：env > 请求声明 > 进程身份）。
+                    // 判据单点在 lib/session_state.ts 的 attributeSession：只注入
+                    // mdcg_remember 与 cg(op=write) 两个写面；读面（视图过滤）/ op 特化语义
+                    // 一律不动。命中且未显式声明时返回新对象，否则原样透传。
+                    const forwarded = attributeSession(tool.name, args);
+                    const result = await bridge.callTool(tool.name, forwarded, exec.signal);
                     if (exec.signal.aborted)
                         throw new Error(`灵枢 ${tool.name} 已取消`);
                     if (result.isError) {

package/md_cg/auditview.py

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+"""L5 证据审计面：只读组装器（路线 C）——「现值＋出处链＋两存/备择＋盲区＋退役史」。
+
+多主体世界模型对齐 v0.1 §4 路线 C：「给节点 id 输出『现值＋出处链＋两存/备择＋
+盲区＋退役史』。**纯读、零写路径改动**」。命名约束（设计稿复核修订）：**不得
+复用 `view` 参数名**（已被 roleviews 占用，mdcos._candidates 的 view 面）。
+
+五面数据源（全部只读）：
+  · 现值       —— `cg.get` 的 fm + 正文（层/生命态/验证态/时效/A1 检验强度/
+                 A2 幽灵标记/归属面）；
+  · 出处链     —— fm.derived_from（血缘）+ fm.edges（它引用谁）+ **反查**
+                 索引条目 edges（谁引用它，内存扫描免读盘）+ provenance 台账
+                 `_link.jsonl` 相关行；
+  · 两存/备择   —— `cg.check_consistency(..., auto_flywheel=False, exclude=<自身>)`
+                 的**只读复用**（与写入链同一判据）：同条件空间分歧/对照数/
+                 截断如实透出（「两存之为默认、冲突一等」的可见化）；
+  · 盲区       —— negative/positive evidence 计数、非适用条件、A2 幽灵标记、
+                 trust.validity 判定（未生效/已过期/未知）、verification_state；
+  · 退役史     —— fm.state_history / fm.verification_history（lifecycle/trust
+                 的既有 HISTORY_FIELD 快照）+ `evolution.history` 台账。
+
+成本如实：备择面复用一致性检查，大库上有候选截断（截断计数如实带出，hint
+与写入面同款）；本组装器**不落盘、不改任何状态**。超出 cap 的面截断并计数。
+"""
+from __future__ import annotations
+
+import os
+
+__all__ = ["build"]
+
+#: 各面截断上限（超限计数并如实带出 truncated）。
+DEFAULT_CAP = 8
+
+
+def _readable_guard(cg):
+    """读隔离谓词（与 linkref.known_ids 同口径）：不可调用时全放行。"""
+    fn = getattr(cg, "_readable", None)
+    return fn if callable(fn) else (lambda _e: True)
+
+
+def _referenced_by(cg, node_id, cap):
+    """反查：谁引用了本节点（索引条目 edges 的内存扫描；免读盘）。
+
+    **读隔离**（2026-10-05 复核 R3）：扫描按 `cg._readable` 过滤——不可读
+    节点的 id 与其引用关系不得经本面泄漏（与 linkref.known_ids /
+    evolution.entries 同口径：「不可见即不存在」）。
+    """
+    # H-4 纪律（test_h4_sustain_snapshot G1a）：从 cg.index 取回的 nodes
+    # 须先取**快照**再迭代——并发写者 flush 时裸迭代会撞「字典变更」。
+    _live = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    nodes = dict(_live)
+    guard = _readable_guard(cg)
+    out, total = [], 0
+    for nid, e in nodes.items():
+        if nid == node_id:
+            continue
+        try:
+            if not guard(e):
+                continue
+        except Exception:                                 # noqa: BLE001 —— fail-closed
+            continue
+        for ed in (e.get("edges") or []):
+            if str(ed.get("target")) == node_id:
+                total += 1
+                if len(out) < cap:
+                    out.append({"from": nid, "relation": ed.get("relation_type"),
+                                "confidence": ed.get("confidence"),
+                                "source": ed.get("source")})
+                break
+    return {"items": out, "total": total, "truncated": total > len(out)}
+
+
+def _link_rows(cg, node_id, cap):
+    """provenance 台账（`_link.jsonl`）里与本节点相关的行。
+
+    **schema 对齐 provenance.make_edge**（2026-10-05 复核 R1 修）：真字段是
+    `child/parent/rel/t/actor`（原实现按 `target/source/relation/at` 匹配
+    ⇒ 恒读空，整面死）。「与本节点相关」＝ child==本节点（它派生自谁）或
+    parent==本节点（谁派生自它）。
+
+    **行级读隔离**（2026-10-05 复验 R4 修）：行是否可见取决于**另一端**——
+    「不可见即不存在」的口径下，verify 身份不得经本面看到不可读 secret
+    节点的 id 与其派生关系（复验实证：修复前与 designer 视角逐位相同）。
+    另一端条目不在索引或不可读 ⇒ **整行不出**（fail-closed，与
+    `_referenced_by` 的 guard 同口径；自身端必可读——本函数只在本节点
+    已可读[build 的 cg.get 成功]之后被调用）。
+    """
+    try:
+        from . import provenance
+        path = provenance.ledger_file(getattr(cg, "root", None))
+    except Exception:                                     # noqa: BLE001
+        return {"items": [], "total": 0, "truncated": False}
+    if not path or not os.path.exists(path):
+        return {"items": [], "total": 0, "truncated": False}
+    _live = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    nodes = dict(_live)                    # H-4 快照纪律（迭代前取快照）
+    guard = _readable_guard(cg)
+    out, total = [], 0
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    import json
+                    rec = json.loads(line)
+                except Exception:                         # noqa: BLE001
+                    continue
+                if not isinstance(rec, dict):
+                    continue
+                c, p = str(rec.get("child")), str(rec.get("parent"))
+                if c == node_id:
+                    other = p
+                elif p == node_id:
+                    other = c
+                else:
+                    continue
+                e_other = nodes.get(other)
+                if e_other is None:
+                    continue                       # 另一端不在索引（含已删）→ 不出
+                try:
+                    if not guard(e_other):
+                        continue                   # 另一端不可读 → 整行不出
+                except Exception:                  # noqa: BLE001 —— fail-closed
+                    continue
+                total += 1
+                if len(out) < cap:
+                    out.append({k: rec.get(k) for k in
+                                ("child", "parent", "rel", "t", "actor", "note")})
+    except Exception:                                     # noqa: BLE001 —— 只读面不抛
+        pass
+    return {"items": out, "total": total, "truncated": total > len(out)}
+
+
+def build(cg, node_id, cap=DEFAULT_CAP) -> dict:
+    """组装五面只读视图。node_id 不存在 ⇒ {"ok": False, "error": "node_not_found"}。
+
+    cap 防御（2026-10-05 复核 Y2）：非数/None 回落缺省、钳 [1, 64]——
+    直调面与 MCP 面同语义（MCP 面的钳制在分发层，直调 API 不得裸抛 TypeError）。
+    """
+    try:
+        cap = int(cap)
+    except (TypeError, ValueError):
+        cap = DEFAULT_CAP
+    cap = max(1, min(64, cap))
+    nid = str(node_id or "").strip()
+    if not nid:
+        return {"ok": False, "error": "node_not_found", "node_id": node_id}
+    rec = cg.get(nid)
+    if not rec:
+        return {"ok": False, "error": "node_not_found", "node_id": nid}
+    fm = rec.get("frontmatter") or {}
+    content = rec.get("content") or ""
+    from . import evolution, lifecycle, nodefile, trust
+
+    # ---- 面一：现值 ----
+    try:
+        _validity = trust.validity(fm)
+    except Exception as exc:                              # noqa: BLE001
+        _validity = "%s: %s" % (type(exc).__name__, exc)
+    present = {
+        "layer": fm.get("layer"),
+        "lifecycle_state": lifecycle.state_of(fm),
+        "verification_state": trust.state_of(fm),
+        "validity": _validity,
+        "importance": fm.get("importance"),
+        "sensitivity": fm.get("sensitivity"),
+        "created_at": fm.get("created_at"),
+        "tags": fm.get("tags"),
+        "verification_basis": fm.get("verification_basis"),
+        nodefile.CHECK_STRENGTH_FIELD: fm.get(nodefile.CHECK_STRENGTH_FIELD),
+        nodefile.UNCERTAIN_REFS_FIELD: fm.get(nodefile.UNCERTAIN_REFS_FIELD),
+        "writer": fm.get("writer"), "harness": fm.get("harness"),
+        "session": fm.get("session"),
+        "content_chars": len(content),
+    }
+
+    # ---- 面二：出处链 ----
+    _edges = list(fm.get("edges") or [])
+    sources = {
+        "derived_from": fm.get("derived_from"),
+        "derived_relation": fm.get("derived_relation"),
+        "refers_to": {"items": _edges[:cap], "total": len(_edges),
+                      "truncated": len(_edges) > cap},
+        "referenced_by": _referenced_by(cg, nid, cap),
+        "link_ledger": _link_rows(cg, nid, cap),
+    }
+
+    # ---- 面三：两存/备择（一致性只读复用；不建单、不落盘）----
+    alternatives = {"comparable": None, "verdict": None, "conflicts": [],
+                    "missing": [], "truncated": None, "scanned": None}
+    try:
+        # log_write=False（复核 R2 修）：只读消费面——判定照常、台账不写
+        #（consistency.log 原为无条件追加，审计会变成隐式写）。
+        cvd = cg.check_consistency(
+            content, layer=fm.get("layer") or "knowledge",
+            condition_space=fm.get("condition_space"),
+            non_applicable_conditions=fm.get("non_applicable_conditions"),
+            tags=fm.get("tags"), exclude=nid, auto_flywheel=False,
+            log_write=False)
+        if isinstance(cvd, dict):
+            cf = list(cvd.get("conflicts") or [])
+            alternatives = {
+                "verdict": cvd.get("verdict"), "reason": cvd.get("reason"),
+                "conflict_strength": cvd.get("conflict_strength"),
+                "comparable": cvd.get("comparable"),
+                "scanned": cvd.get("scanned"), "truncated": cvd.get("truncated"),
+                "conflicts": cf[:cap],
+                "conflicts_total": len(cf), "conflicts_truncated": len(cf) > cap,
+                "missing": list(cvd.get("missing") or [])[:cap],
+                "hint": cvd.get("hint"),
+            }
+    except Exception as exc:                              # noqa: BLE001 —— 只读面不抛
+        alternatives["error"] = "%s: %s" % (type(exc).__name__, exc)
+
+    # ---- 面四：盲区 ----
+    blindspots = {
+        "negative_evidence": fm.get("negative_evidence", 0),
+        "positive_evidence": fm.get("positive_evidence", 0),
+        "non_applicable_conditions": fm.get("non_applicable_conditions"),
+        nodefile.UNCERTAIN_REFS_FIELD: fm.get(nodefile.UNCERTAIN_REFS_FIELD),
+        "verification_state": trust.state_of(fm),
+        "validity": _validity,
+        "note": ("未决不进二值：DEFER/unresolved 痕迹在『两存/备择』与 "
+                 "negative_evidence 面；本面只呈现，不下判断。"),
+    }
+
+    # ---- 面五：退役史 ----
+    _sh = list(fm.get(lifecycle.HISTORY_FIELD) or [])
+    _vh = list(fm.get(trust.HISTORY_FIELD) or [])
+    _ev = []
+    try:
+        _ev = list((evolution.history(cg, nid, limit=cap) or {}).get("entries") or [])
+    except Exception:                                     # noqa: BLE001
+        pass
+    history = {
+        lifecycle.HISTORY_FIELD: _sh[-cap:],
+        trust.HISTORY_FIELD: _vh[-cap:],
+        "evolution": _ev[:cap],
+        "totals": {lifecycle.HISTORY_FIELD: len(_sh),
+                   trust.HISTORY_FIELD: len(_vh), "evolution_scanned": len(_ev)},
+    }
+
+    return {"ok": True, "node_id": nid, "cap": cap,
+            "present": present, "sources": sources,
+            "alternatives": alternatives, "blindspots": blindspots,
+            "history": history}

package/md_cg/bench_e2e_judge.py

@@ -40,7 +40,8 @@
   python -X utf8 -m md_cg.bench_e2e_judge --quick        # 冒烟 20题×level 0,1×无LLM
   python -X utf8 -m md_cg.bench_e2e_judge                # 全量 120题×4级×3臂+LLM两轮
   python -X utf8 -m md_cg.bench_e2e_judge --skip-llm     # 只跑确定性两臂
-环境：DEEPSEEK_API_KEY（LLM 臂）；数据落 --data-root（默认 D:/program/test/e2e_judge）
+环境：DEEPSEEK_API_KEY（LLM 臂）；数据落 --data-root（默认 <仓根父目录>/test/e2e_judge，
+可用 MDCG_E2E_JUDGE_ROOT 覆盖）
 """
 from __future__ import annotations
 
@@ -64,7 +65,8 @@ from md_cg.mdcos import MdCGOS                             # noqa: E402
 from md_cg import nodefile                                 # noqa: E402
 
 DATA_SRC = os.path.join(HERE, "data", "benchmarks", "locomo-zh-500")
-DEFAULT_ROOT = r"D:\program\test\e2e_judge"
+DEFAULT_ROOT = os.environ.get("MDCG_E2E_JUDGE_ROOT") or os.path.join(
+    os.path.dirname(HERE), "test", "e2e_judge")
 FUSION_KW = dict(paths=("lexical", "bucket", "entity", "graph", "fuzzy"),
                  fusion="sum")
 LEVELS_DEFAULT = (0, 1, 2, 4)

package/md_cg/branches.py

@@ -111,6 +111,12 @@ def fork(cg, node_ids, branch_id=None, note=None) -> dict:
                condition_space=fm.get("condition_space"),
                importance=float(fm.get("importance", 0.5)),
                verification_basis=fm.get("verification_basis") or "test",
+               # A1（2026-10-05，复核补）：断言质量字段随副本携带（与
+               # verification_basis 同族；缺省 None 时 add 不落键，零行为变化）。
+               check_strength=fm.get("check_strength"),
+               # A2（2026-10-05）：幽灵引用标记随副本携带（正文属性——副本
+               # 正文与主支一致则标记有效；缺省 None 不落键）。
+               uncertain_refs=fm.get("uncertain_refs"),
                non_applicable_conditions=fm.get("non_applicable_conditions"),
                consistency=False,
                derived_from=[nid], relation="split_from",
@@ -156,8 +162,16 @@ def rewrite(cg, node_id, content, tags=None, importance=None,
     if isinstance(content, dict) or content is None:
         return {"ok": False, "error": "content 须为字符串"}
     for k in ("branch_id", "branched_from", "branch_note", "derived_from",
-              "relation", "merged_from_branch", "override", "consistency"):
-        extra.pop(k, None)   # 归属/血缘/写法闸不可经 extra 篡改
+              "relation", "merged_from_branch", "override", "consistency",
+              "uncertain_refs"):
+        extra.pop(k, None)   # 归属/血缘/写法闸/检测产物不可经 extra 篡改
+    # A2（2026-10-05，复核 yellow-1 修）：标记按**新正文**重算——本函数是
+    # 「改正文的唯一正路」，携带旧标记会与正文脱节（干净正文带陈旧标记 /
+    # 幽灵正文漏标，双向都错）；与 mdcg.add「正文属性、按当次检测重算」
+    # 的声明同口径。
+    from . import ghostref as _ghostref
+    _ur = _ghostref.find_ghost_phrases(
+        str(content or ""), known=set((cg.index.get("nodes") or {}).keys()))
     cg.add(nid, str(content or ""),
            layer=fm.get("layer") or e.get("layer") or "knowledge",
            tags=list(tags if tags is not None else (fm.get("tags") or [])),
@@ -165,6 +179,10 @@ def rewrite(cg, node_id, content, tags=None, importance=None,
                             else (fm.get("importance") or 0.5)),
            condition_space=fm.get("condition_space"),
            verification_basis=fm.get("verification_basis") or "test",
+           # A1（2026-10-05，复核补）：断言质量字段随重写携带（同上）。
+           check_strength=fm.get("check_strength"),
+           # A2（2026-10-05）：幽灵引用标记按新正文重算（见上）。
+           uncertain_refs=_ur or None,
            non_applicable_conditions=fm.get("non_applicable_conditions"),
            override=True, consistency=False,
            derived_from=list(fm.get("derived_from") or []),
@@ -203,13 +221,21 @@ def merge(cg, branch_id, reason=None) -> dict:
         chain = list(old_fm.get("derived_from") or [])
         if nid not in chain:
             chain.append(nid)
-        cg.add(orig, (src or {}).get("content") or "",
+        # A2（2026-10-05，复核 yellow-2① 修）：主支正文 = 分支正文 ⇒ 标记按
+        # 该正文重算（此前不携带 = 幽灵正文回写后无标记，方向与「宁标勿漏」
+        # 相反；fork/rewrite 已接线，此处补齐同族）。
+        from . import ghostref as _ghostref
+        _mcontent = (src or {}).get("content") or ""
+        _mur = _ghostref.find_ghost_phrases(
+            _mcontent, known=set((cg.index.get("nodes") or {}).keys()))
+        cg.add(orig, _mcontent,
                layer=old_fm.get("layer") or e.get("layer") or "knowledge",
                tags=list(old_fm.get("tags") or e.get("tags") or []),
                condition_space=src_fm.get("condition_space"),
                importance=float(old_fm.get("importance", 0.5)),
                verification_basis=old_fm.get("verification_basis") or "test",
                non_applicable_conditions=old_fm.get("non_applicable_conditions"),
+               uncertain_refs=_mur or None,
                override=True, consistency=False,
                derived_from=chain, relation="merged_from",
                merged_from_branch=bid, actor="branch_merge")

package/md_cg/consistency.py

@@ -51,6 +51,7 @@ import os
 import time
 
 from .mdcg import expand_query_terms_weighted
+from . import nodefile
 
 # --------------------------------------------------------------------------
 # 常量（全部可审计、可调）
@@ -250,21 +251,28 @@ def _ban_hit(content, neg_texts):
     return False
 
 
-# 生效条件：content 为真时按行过滤，跳过 strip 后以 "#" 开头且含全角或半角冒号的行，其余原行以换行连接返回；content 假值按空串返回 ""；
+# 生效条件：委托 nodefile._strip_ccg_segments(content, nodefile.CCG_MARKS)（剥除算法单点）——命中 CCG 要素标题行（判据单点 nodefile._ccg_heading_rest，`^#\s*<要素>` 冒号可有可无）即整段剥除：行内带值（`# 生效条件：v`／前缀式）只剥该行，裸标题（`# 不适用条件`）连同其后首个非空、非标题行（该字段的值行，取值口径同 nodefile.ccg_field_value）一并剥除；其余原行以换行连接返回；content 假值按空串返回 "";
 def _body_text(content):
-    """去掉 CCG 声明行（`# 字段：值`）后的正文。
+    """去掉 CCG 声明**整段字段**后的正文。
 
     自否定看的是「正文/生效条件是否与不适用条件矛盾」，不能把节点自己声明的
     `# 不适用条件：X` 当成 X 出现在正文里——否则**每个**声明了不适用条件的
     正常节点都会被误判为自相矛盾（真实 CCG 条目普遍带该字段）。
+
+    N238：判据复用**单点** `nodefile._ccg_heading_rest`（与写入闸门
+    data/policy.json 同一行语义、`mdcos._ccg_field` / `ccg_mark_present` 同源），
+    并连同**无冒号形态的值行**一起剥。此前本地判据是「以 # 开头**且含冒号**」，
+    裸标题 `# 不适用条件` 与其值行双双残留正文：同内容写成带冒号时
+    `_body_text == ''`（不命中），写成无冒号时 body 含禁令短语 ⇒ `_ban_hit`
+    恒中 ⇒ self_negation / strength=1.0 ⇒ REJECT（writepipe 下合法节点被拦入
+    review_queue 并自动建飞轮工单）。「冒号可有可无」已由
+    `nodefile.ccg_mark_present` / `ccg_field_value` 定案（test_ccg_form_parity
+    验收 PASS），本处是漏网的分叉。
+
+    A3 追认：剥除算法本身也已收单点 `nodefile._strip_ccg_segments`（六要素全剥）
+    ——本处不再自持循环，避免与 `nodefile.positive_body` 各写一份而再次漂移。
     """
-    out = []
-    for line in (content or "").splitlines():
-        s = line.strip()
-        if s.startswith("#") and ("：" in s or ":" in s):
-            continue
-        out.append(line)
-    return "\n".join(out)
+    return nodefile._strip_ccg_segments(content, nodefile.CCG_MARKS)
 
 
 # 生效条件：text 假值时按空串处理，返回把任意连续空白（半角/全角空格、\t、\r、\n）折叠为单个半角空格并去掉首尾空白后的字符串；纯空白文本返回空串 "";
@@ -484,16 +492,21 @@ def _recursive_reflect(cg, seeds, tw_pos, tw_neg, max_depth=MAX_DEPTH,
 # 主入口：三级决策
 # --------------------------------------------------------------------------
 
-# 生效条件：以 cg.index.nodes 为既有节点、content（假值按 ""）经 _new_terms 得 pos/neg 并算 tw_pos/tw_neg（non_applicable_conditions 入参先按 mdcos._is_null_condition 剔除空值语义哨兵——⑧ 漏斗单点）；选面（cons200；收口轮①加面内例外）：快照级预筛剔「tw_pos 与 tw_neg 皆空（新节点未声明可展开条件）时的非纪律候选」，且**剔除永不触及修前扫描面**（过滤后索引序前 limit 内候选一律保留——面内例外；「修后检出 ⊇ 修前」由此成为与「条目 tags 与盘面 fm.tags 同源」无关的结构保证），候选超 limit 时精比面＝相关面（_sift_score 序）前 limit ∪ 保底面（过滤后索引序前 limit ∩ 候选），记 scanned（候选数）/kept（精比数）/truncated（scanned>kept）/hint；按循环中 hard（自否定或纪律命中）→ divergences（同条件槽且 concl < CONCLUSION_SAME）→ strength ≥ CLASH_HIGH → strength ≥ CLASH_LOW → comparable==0 且 (pos or neg) → 否则 ACCEPT 的顺序定 verdict；DEFER 且 int(depth)>0 且 emo["bias"] != "approaching" 时调 _recursive_reflect 补 recursion，auto_flywheel 且 verdict == REJECT 时加 unresolved_id，最后 log 并返回 rec；
+# 生效条件：以 cg.index.nodes 为既有节点、content（假值按 ""）经 _new_terms 得 pos/neg 并算 tw_pos/tw_neg（non_applicable_conditions 入参先按 mdcos._is_null_condition 剔除空值语义哨兵——⑧ 漏斗单点）；选面（cons200；收口轮①加面内例外）：快照级预筛剔「tw_pos 与 tw_neg 皆空（新节点未声明可展开条件）时的非纪律候选」，且**剔除永不触及修前扫描面**（过滤后索引序前 limit 内候选一律保留——面内例外；「修后检出 ⊇ 修前」由此成为与「条目 tags 与盘面 fm.tags 同源」无关的结构保证），候选超 limit 时精比面＝相关面（_sift_score 序）前 limit ∪ 保底面（过滤后索引序前 limit ∩ 候选），记 scanned（候选数）/kept（精比数）/truncated（scanned>kept）/hint；按循环中 hard（自否定或纪律命中）→ divergences（同条件槽且 concl < CONCLUSION_SAME）→ strength ≥ CLASH_HIGH → strength ≥ CLASH_LOW → comparable==0 且 (pos or neg) → 否则 ACCEPT 的顺序定 verdict；DEFER 且 int(depth)>0 且 emo["bias"] != "approaching" 时调 _recursive_reflect 补 recursion，auto_flywheel 且 verdict == REJECT 时加 unresolved_id，最后 log_write 为真时 log 并返回 rec；N276：精比环的索引代际探针循环外单探一次（环内 cg.get(nid, probe=False)；无探活面载体回落 cg.get(nid)，行为零变）；
 def check(cg, content, layer=None, condition_space=None,
           non_applicable_conditions=None, tags=None, exclude=None,
           limit=MAX_SCAN, depth=MAX_DEPTH, auto_flywheel=False,
-          query=None):
+          query=None, log_write=True):
     """节点间自动冲突检测（L0 情绪 → L1 反思 → L2 递归反思）。
 
     返回完整判据（可审计）：
       verdict / reason / conflict_strength / emotional / conflicts[] /
       recursion{} / missing[] / unresolved_id（若触发飞轮）
+
+    log_write（路线 C，2026-10-05）：缺省 True＝原行为（每次判定落
+    `_consistency.jsonl` 台账）。**只读消费面**（如 auditview 的证据审计）
+    须传 False——判定结果照常返回，但不写台账（复核 R2：审计面承诺
+    「纯读、不落盘」，而 log() 无条件追加会把每次审计变成一次写）。
       + 选面读数 scanned / kept / truncated（超限时另附 hint）
 
     verdict：
@@ -619,9 +632,20 @@ def check(cg, content, layer=None, condition_space=None,
     scanned = len(cand)                  # 预筛后候选数（截断前）
     kept = len(scan_face)                # 实际精比数（相关面 ∪ 保底面）
     truncated = scanned > kept
+    # N276（第 32 轮性能面）：scan_face 精比环内逐节点 cg.get 会各自重探索引
+    # 签名（快照 stat + listdir + 逐分片 stat，单点实测 ~38µs；本库 200 次/
+    # 调用全同签名重探）——循环外单探一次、环内 probe=False；语义窗口=本批
+    # 读期间「他进程写入」不被探知（毫秒级，与读缓存已声明的进程内一致性
+    # 边界同款）；无探活面的载体（测试桩）回落原 cg.get(nid)，行为零变。
+    _probe = getattr(cg, "_maybe_reload_index", None)
+    if callable(_probe):
+        _probe()
+    else:
+        _probe = None
     seeds = []
     for nid, e in scan_face:
-        node = cg.get(nid) or {}
+        node = (cg.get(nid, probe=False) if _probe is not None
+                else cg.get(nid)) or {}
         fm = node.get("frontmatter") or {}
         body = node.get("content") or ""
         e_pos, e_neg = _declared(fm, body)
@@ -769,7 +793,8 @@ def check(cg, content, layer=None, condition_space=None,
     if auto_flywheel and verdict in FLYWHEEL_TRIGGERS:
         rec["unresolved_id"] = _fire_flywheel(cg, query or content, verdict,
                                               reason, missing, allc)
-    log(cg, rec)
+    if log_write:
+        log(cg, rec)
     return rec