@furongjun1999/dsh-memory 0.7.5 → 0.8.0

package/docs/mdcg//345/217/221/345/270/203/351/227/250/347/246/201/351/223/276_v0.1.md

@@ -27,13 +27,20 @@
 > 两道互补（R3 只覆盖发布清单内的件，覆盖不到 hive/ 等非发布目录）。合成夹具（`X:/custom`、
 > `C:/Windows/win.ini` 等）与通用通例（Git/Docker 默认安装路径）不在判据面，避免平凡红；
 > 判据带 `--selftest`（正负样例 + 不命中自身源码）与注入探针红侧自证。
+>
+> **2026-10-06 更新（0.8.0 身体×脑对接 · 四条裁定之四：冒烟进发布链）**：门禁链再由 **11 条
+> 扩至 12 条腿**——链尾新增 `scripts/body_e2e_smoke.py`（**身体侧视角 MCP 全链冒烟**：身体侧
+> 进程逐行 JSON-RPC → 记账 `cg(op=state_event)` → 台账 → 投影 → 查询 `stg(op=state_chain)`；
+> 隔离库（临时根断言）、零在役写入、退出码判据、内嵌合成样本与 `--events` 真实序列两态）。
+> Linux 容器腿同步补登（python 套件清单新增守卫 + 本冒烟独立 record 行）；同批新增守卫
+> `md_cg/test_spatial_coords3d`（spatial 直存透传：15 断言 + 两处定点变异自证）入容器清单。
 
 ## 三层防线
 
 | 层 | 触发 | 跑什么 | 行为 |
 |---|---|---|---|
 | 本地 pre-commit | `git commit` | `python scripts/cogmap_sync.py build` + 认知图投影两道（建最小库 → `verify_discipline.py --cg-root`） | **自动重挂**行号并把两份投影文档一并暂存；投影判据体真跑，红了即拒提交（`--no-verify` 可绕） |
-| 发布链 | `npm publish` | `prepublishOnly`：build → test → **`npm run gate`**（十一道门禁，见下） | 任一步失败即阻断发布 |
+| 发布链 | `npm publish` | `prepublishOnly`：build → test → **`npm run gate`**（十二道门禁，见下） | 任一步失败即阻断发布 |
 | CI | push / PR | `cogmap-check.yml`：`cogmap_sync.py check` + `link_check.py` | 远端兜底红灯 |
 
 ## 为什么本地钩子跑 build 而不是 check
@@ -56,7 +63,7 @@ git config core.hooksPath scripts/git-hooks
 
 ## 发布门禁清单（`npm run gate`）
 
-`prepublishOnly` 在 build + test 之后调用 `npm run gate`，十一道门禁与 CI **同形但不完全同覆盖**：
+`prepublishOnly` 在 build + test 之后调用 `npm run gate`，十二道门禁与 CI **同形但不完全同覆盖**：
 
 | # | 命令 | 守什么 | 对应 CI |
 |---|---|---|---|
@@ -71,11 +78,15 @@ git config core.hooksPath scripts/git-hooks
 | 9 | `python scripts/gate_rust_crate_test.py` | `cargo test` @ `rust/`（Rust 侧口径漂移的回归保障） | **无**（`hive-check.yml` 只跑 `hive/Cargo.toml`，`rust/` 至今零 CI） |
 | 10 | `python scripts/gate_rust_parity.py` | `scripts/rank_parity.py` 逐位对拍（Python `search_rrf` vs Rust `mdcg-eval --serve`） | **无** |
 | 11 | `python scripts/check_local_paths.py` | **追踪面本机路径门禁**：`git ls-files` 全量公开面上不得有本机目录结构路径（npm 面由第 2 道 R3 另守；判据=机器实有前缀 8 族 + `--selftest` 正负样例 + 不命中自身源码） | `publish-artifact-check.yml`（同 workflow 内自检 + 扫描两步） |
+| 12 | `python scripts/body_e2e_smoke.py` | **身体×脑组合冒烟**（0.8.0 对接）：身体侧视角经 MCP 全链——记账 → 台账 → 投影 → 查询；隔离库、退出码判据、两态样本（内置/真实序列） | **无**（仅本地/发布链；Linux 容器腿同款一行） |
 
-> **第 11 道追加在链尾是有意的**：第 3 道的 C2 位序断言（smoke 腿紧随第 2 道）与
+> **第 11 道追加在链尾是有意的（2026-10-06 起其后又有第 12 道，位序意图不变）**：第 3 道的 C2 位序断言（smoke 腿紧随第 2 道）与
 > `test_gate_rust_legs.py` 的链尾等价复跑通道（自 Rust 腿①起截尾）都不受影响；
 > 路径违规是本机秒级可判面，位序不承担反馈距离职责。
 
+> **第 12 道追加在链尾同样是刻意的**：它是跨仓组合面冒烟（依赖 spawn 一个隔离 MCP 子进程，
+> 秒级）；C2 位序断言与 `test_gate_rust_legs.py` 链尾截尾逻辑均按「Rust 腿起点」定位，不受尾追加影响（实测 53/0 全过）。
+
 > **第 3 道的位序不是随意的**：它紧跟第 2 道（同为「发布件面」），且**必须在第 4 道
 > `cogmap_sync.py check` 之前**——前者的 `npm pack` 会触发 `prepare`（= 本仓的 `tsc` 构建，
 > 会重写 `lib/`），越靠近链首越能让「包面自检」与「包已定形」两件事挨着发生；塞在链尾则

package/docs/mdcg//347/235/241/347/234/240/345/221/250/346/234/237_/350/277/220/347/273/264/345/211/215/346/217/220/344/270/216/347/273/264/346/212/244/346/214/207/345/215/227_v1.0.md

@@ -288,10 +288,14 @@ python -X utf8 -m md_cg.sleep --status            # 只读：含 last_cycle（
 处置 = **人工重启常驻进程**（宿主侧重启 serve / 重新拉起灵枢插件）；重启后从
 心跳戳与 `<state_root>/sleep/_sleep.jsonl` 台账接着看。
 
-**残留锁（已知边界，如实记）**：git 子进程被 kill 后可能留下 `index.lock`
-——本模块**不自动删**（可能是他进程的锁，误删更糟）。超时消息里会点名
-`<git_dir>/index.lock`；后续 git 操作报 lock 时，**人工核对无他进程在用后核删**。
-是否加自动清理：待裁（见 issue #63 台账）。
+**残留锁（有界自清，2026-10-06 落地）**：git 子进程被 kill 后可能留下 `index.lock`
+——现由 `sleep._clear_git_lock` **有界**自清（三闸口径）：①只碰本模块影子仓
+（单属仓，无第三方合法持锁面）；②时机两处——`_git` 每次调用**前置巡检**清
+**超龄锁**（mtime ≥ 300s ≫ 全调用 120s 超时上界，即崩溃残留），超时 kill 后
+**force 清**当场残留（此刻仓内锁只可能来自被 kill 进程）；③其余一律不动——
+超时消息如实带「已自动清理 / 未动，若后续报 lock 请人工核删」处置读数。
+清理动作记一行 `git_lock_cleared` 台账（含 age_s/force）。守卫
+`python -X utf8 -m md_cg.test_sleep_gitlock`（8 断言，含「新锁不误删」反向腿）。
 
 ### 4. issue #63 的现场判据（四条，引录）
 
@@ -327,6 +331,7 @@ T3 循环续走回归 / T4 进度面 / T5 审计面）＋ `--mutate` 定点变
 
 | 日期 | 要点 |
 |---|---|
+| 2026-10-06 | **v1.3**（退役/锁裁定批）：残留锁**有界自清**落地（`_clear_git_lock` 三闸＋`_git` 两时机：前置巡检清超龄、超时 kill 后 force 清；台账 `git_lock_cleared`；守卫 `md_cg.test_sleep_gitlock` 8 断言）——原「是否自动清理待裁（issue #63 台账）」收口 |
 | 2026-10-06 | **v1.2**（issue #63）：常驻循环三层无界收口——①`sleep._git` 加 `timeout=120s` + `stdin=subprocess.DEVNULL`（超时抛 `SleepGitTimeout`，与 rc≠0 失败文案分开、物化超时另支文案）②六档进/出刷既有心跳戳（`current_tick` / `last_tick_done` / `last_tick_error`）+ `stale_tick` 告警（只上报不杀线程，处置=人工重启）③同批加固 interop / audit / units / bench×3（whitebox Popen 不在加固面）——见 §十 |
 | 2026-10-06 | **v1.1**（issue #60/#61）：①物化 `ok` 拆为「物化成功」+ `face_stable` 读数，**物化成功即迭代**（真源面漂移交并发闸、主库优先）②新增手动入口 `--once` / `--once --dry-run`（零落盘预览）与 `--status` 的 `last_cycle` 读数 ③台账 skip 文案区分「门拦」与「物化未完成」——见 §三.5 / §四 / §六 / §九 |
 | 2026-10-01 | v1.0 首版：版本库位置 / 维护动作（看历史·看改动·只 revert 的回退·冲突挂起）/ 开关与自动边界 / P2·P4 发版披露（§一–§八） |

package/docs/plans//347/201/265/346/236/242/350/272/253/344/275/223/303/227/350/204/221_/344/270/226/347/225/214/346/250/241/345/236/213/345/257/271/346/216/245/350/256/276/350/256/241_v0.1.md

@@ -2,7 +2,8 @@
 
 > 任务来源：使用者 2026-10-06「0.8.0 版本工作就是和之前的身体核心组合。让世界模型真正端到端可用。」
 > 三步流程：**测试验证成功 → 脱敏 → 全部公开**（本稿完成第一步并出读数）。
-> 状态：v0.1 未签收；本稿**不改一行码**（smoke 件为已验收验证工具，见 §一）。
+> 状态：**v0.2——四条已裁并落地**（使用者 2026-10-06「0.8.0 对接设计四条 开始吧」，
+> 按各条推荐执行）；M1/M2 最小闭环已贯通，落地记录见 §七。
 
 ---
 
@@ -51,15 +52,22 @@
 
 两条路线共用同一验证工具：`python -X utf8 scripts/body_e2e_smoke.py`（隔离库、零在役写入、退出码判据）。
 
-## 四、待裁清单（请逐条裁决）
+## 四、四条裁决（2026-10-06 已裁，按各条推荐执行）
 
 1. **适配器归属侧**：身体侧件（`lingshu/world/brain_store.py`，聚合仓工具面）vs 脑侧件（本仓）。
    推荐：**身体侧适配器**——章程口径"脑为包依赖、身侧件进身仓"，且 `scene_model` 零改动即插。
+   → **已裁/已落地**：`lingshu` 仓 `fb4b98b`（含 intake 登记与双清单审计）。
 2. **3D 坐标方案**：推荐 **`spatial.coords3d` 自定义键直存米制＋可选 bbox 投影**（不改既有
    `spatial.bbox` 的 2D 语义、stg 四 op 零位移）；不建议扩 bbox 为 3D（破坏既有语义）。
+   → **已裁/已落地**：本仓 `e5d7f0c1`——`mdcg_remember` 两分支经单点 `_spatial_kw` 透传
+   （**缺省不落键**，既有 fm 形态逐位不变）；守卫 `md_cg/test_spatial_coords3d.py`（15 断言，
+   两处定点变异各自恰好命中 1 项）。
 3. **tag 过滤读（缺口①）**：脑侧给 `read/search` 加 tag 维（小活，进脑）vs 适配器侧读后过滤
    （零脑改、性能略差）。推荐：**先适配器侧**（探针验证后再决定是否进脑）。
+   → **已裁/已落地**：适配器侧过滤（`BrainStore.get_nodes_by_tag`：`cg(op=read)` 候选 →
+   按 tags 过滤）；探针实测读面召回充足（三种 query 全命中场景节点且 tags 在场）。
 4. **smoke 进门禁**：是否把 `scripts/body_e2e_smoke.py` 纳入发布链附加腿（与《秤》探针同列）。
+   → **已裁：进**——`npm run gate` 链尾第 12 腿 + Linux 容器腿同步补登（发布门禁链文档已更新）。
 
 ## 五、边界
 
@@ -71,6 +79,41 @@
 **测试验证 ✓（§一）** → 脱敏（readiness 扫描已 CLEAN；正式步骤＝组合件入库时过双清单并登记）→
 全部公开（转公开时机属使用者操作；公开前终检清单可随时编制）。
 
+## 七、落地记录（2026-10-06 当日，四条按推荐执行）
+
+### 脑侧（本仓，提交 `e5d7f0c1` 已推送）
+
+- `mdcg_remember` 两分支（gated / 非 gated add）经**单点** `_spatial_kw(a)` 透传 `spatial`：
+  声明则 `frontmatter.spatial` 直存；**缺省不落键**（既有写入 fm 形态逐位不变——首版实现曾
+  引入 `spatial: null` 落键，守卫 B2 当场钉出后改为条件传参）；复现 meta 同键（入队后
+  accept 与直接落盘元数据等价）；TOOLS schema 同步声明。
+- 守卫 `md_cg/test_spatial_coords3d.py`：**18 断言全绿**（A–E 组，含 gated 闸门路径行为断言）
+  + `--mutate` 两处定点变异（M1 行为变异剥 `add` 的 spatial ⇒ 直写面与 gated 面**恰好各 1 红=2**；
+  M2 源码变异删一处 `_spatial_kw` 调用 ⇒ 恰好 1 红）。独立复核（子代理）全项 PASS、
+  零推翻，6 条观察中两条已当场收口（本断言补强 + 沙箱扩键）。
+- **smoke 进门禁**：`npm run gate` 链尾第 12 腿（`scripts/body_e2e_smoke.py`）＋
+  Linux 容器腿同步补登；`npm run gate` **12 腿全绿**（含新腿 VERDICT=PASS 读数）；
+  发布门禁链文档（第 12 道）与容器套件清单（+`test_spatial_coords3d` 及其 `--mutate` 自证）同步。
+
+### 身侧（`lingshu` 仓，提交 `fb4b98b`／订正 `2d05e6d` 已推送）
+
+- `lingshu/world/brain_store.py`：最小 MCP stdio 客户端 + `BrainStore`（`get_nodes_by_tag`
+  适配器侧 tag 过滤 + 状态取槽位投影）+ `BrainEngine`（`add_perception` → `mdcg_remember`，
+  `spatial.coords3d` 直存）+ **`_ConnShim`**（legacy `ingest_scene` 的
+  `UPDATE nodes SET state_attributes` 直写语句 → `cg(op=state_event)` 记账翻译）+
+  `connect()`（连接参数零本机字面量；缺省剔除继承 `MDCG_*`、fail-closed）。
+- **零改动对接实证**：`scene_model.ingest_scene` 与 `load_world_from_memory` 一行未改；
+  `tests/test_brain_store.py` 隔离库端到端 **10/10**（S1 握手 / S2 写入 3 实体 /
+  S3–S7 实体·类别·坐标·状态逐项 / S8 状态更新重载现算 / S9 tag 过滤对照）。
+- intake 登记：`docs/intake/brain-store-v0.1/`（README + AUDIT：机械扫描 2 文件 0 命中
+  CLEAN）＋ 章程引入登记表行。
+
+### 组合读数（发布面）
+
+- 组合冒烟两态（内置 3 条→2 槽位；真实 25 条→11 槽位）保持 **VERDICT=PASS**（两遍复跑）；
+- 读面召回探针：`cg(op=read)` 对 `query=场景实体 / world_model / spatial` 三式**全命中**
+  场景节点且 tags 在场——适配器侧过滤无缺口①阻塞。
+
 ---
 
 *v0.1 · 2026-10-06 · 编排侧编制（读码：身体侧 scene_model/semantic_anchor_graph/seven_layer_loop 等；脑侧 stg/state_slots）*

package/md_cg/chain.py

@@ -158,8 +158,8 @@ def node_conditions(cg, nid):
     return pos
 
 
-# 生效条件：cg 已有 _chain_adj 且其 [0] 等于 bool(include_hierarchy)、[1] 等于可见性闸存在位时直接返回缓存的 [2]；否则以 cg.index["nodes"]（无 index 或无该键时视为无节点）逐节点收集 frontmatter.edges 中 edge_target 非空的出边，include_hierarchy 为真时再为 subgraph.nodes 各合成一条 relation_type="part_of"、confidence=1.0 的层级边，仅对有出边的 nid 建表，写回 cg._chain_adj=(bool(include_hierarchy), 闸存在位, adj) 后返回 adj；cg 提供 _chain_visible(nid) 谓词（读隔离，MdCGSecure 注入）时不可见 nid 的出边整体不入表、指向不可见目标的边（含层级合成边）截断——不可见节点 id、其边条件与下游拓扑对调用方不存在（walk/explain/causal_path/expand_from_seeds 全部消费者同闸）；
-def adjacency(cg, include_hierarchy=True):
+# 生效条件：cg 已有 _chain_adj 且其 [0] 等于 bool(include_hierarchy)、[1] 等于可见性闸存在位、[2] 等于 bool(skip_archived) 时直接返回缓存的 [3]；否则以 cg.index["nodes"]（无 index 或无该键时视为无节点）逐节点收集 frontmatter.edges 中 edge_target 非空的出边（skip_archived=False 时该轮退役过滤整体旁路——维护面全量口径），include_hierarchy 为真时再为 subgraph.nodes 各合成一条 relation_type="part_of"、confidence=1.0 的层级边，仅对有出边的 nid 建表，写回 cg._chain_adj=(bool(include_hierarchy), 闸存在位, bool(skip_archived), adj) 后返回 adj；skip_archived=True（缺省）时 lifecycle.is_archived 为真的节点出边整体不入表、指向退役目标的边（含层级合成边）截断（判据单点 lifecycle.is_archived，缺键=active fail-open；退役不删除、可显式恢复）；cg 提供 _chain_visible(nid) 谓词（读隔离，MdCGSecure 注入）时不可见 nid 的出边整体不入表、指向不可见目标的边（含层级合成边）截断——不可见节点 id、其边条件与下游拓扑对调用方不存在（walk/explain/causal_path/expand_from_seeds 全部消费者同闸）；
+def adjacency(cg, include_hierarchy=True, skip_archived=True):
     """出邻接表：nid → [(target_id, edge_dict)]。
 
     来源两处：
@@ -172,8 +172,8 @@ def adjacency(cg, include_hierarchy=True):
     （`cg.index["nodes"]`），不是「只碰种子邻域」。故契约 S3「不走全表」这一句
     对**本函数不成立**，正确表述是「不读正文；邻接构建为 O(N) 索引条目级」。
     代价读数（`scripts/p2p4_probe.py` R7，400 条目确定性小库）：冷建 ~0.24ms、
-    缓存命中 ~1µs；缓存键 `(include_hierarchy, 闸存在位)` 存于 `cg._chain_adj`，
-    写入/删除后由 `invalidate_cache` 作废。
+    缓存命中 ~1µs；缓存键 `(include_hierarchy, 闸存在位, skip_archived)` 存于
+    `cg._chain_adj`，写入/删除后由 `invalidate_cache` 作废。
     （可选硬化路径 (b1)：在索引快照的**边集合**上增量构建邻接——本轮未做，
     如需做见 P3 遗留 B 的二选一。）
 
@@ -184,17 +184,29 @@ def adjacency(cg, include_hierarchy=True):
     目标的边截断；谓词缺席（基类）行为零变化。缓存键含闸存在位；闸语义
     实例内稳定（_readable 绑定档判定恒用 principal.session，见 mdcos
     _readable），同一实例不会跨身份串台。
+
+    退役纪律（《秤》v2.1 §5.2；2026-10-06 接线）：`skip_archived=True`（缺省）时
+    archived 节点出边整体不入表、指向 archived 目标的边截断——`cg(op=causal,
+    action=chain)` 等**读/预测面**（chain()／predict.*）由此不再扩散进退役节点；
+    **维护面显式旁路**：`scrub`（去污染抽查，按度数排序的维护写面）传
+    `skip_archived=False` 取全量表——退役节点仍可被抽查（判据面 = 默认读/注入
+    面必消费、维护/管理面直读，见运维文档 §九.5 面的判据）。判据单点
+    `lifecycle.is_archived`（缺键=active fail-open）。
     """
     cached = getattr(cg, "_chain_adj", None)
     vis = getattr(cg, "_chain_visible", None)
     vis_on = vis is not None
     if (cached is not None and cached[0] == bool(include_hierarchy)
-            and cached[1] == vis_on):
-        return cached[2]
+            and cached[1] == vis_on
+            and cached[2] == bool(skip_archived)):
+        return cached[3]
     from . import subgraph as _sg
+    from . import lifecycle as _lc
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
     adj = {}
     for nid in list(nodes):
+        if skip_archived and _lc.is_archived(nodes.get(nid)):
+            continue          # 退役节点：其出边与条件整体不入表（不解析 fm）
         if vis is not None and not vis(nid):
             continue          # 不可见节点：其出边与条件整体不可见（不解析 fm）
         fm = _sg._fm(cg, nid)
@@ -202,11 +214,15 @@ def adjacency(cg, include_hierarchy=True):
         for e in (fm.get("edges") or []):
             tgt = edge_target(e)
             if tgt:
+                if skip_archived and _lc.is_archived(nodes.get(tgt)):
+                    continue  # 拓扑边界：指向退役目标的边径直截断
                 if vis is not None and not vis(tgt):
                     continue  # 拓扑边界：指向不可见目标的边对调用方不存在
                 out.append((tgt, e if isinstance(e, dict) else {"target": tgt}))
         if include_hierarchy:
             for ch in _sg.declared(fm)["nodes"]:
+                if skip_archived and _lc.is_archived(nodes.get(ch)):
+                    continue
                 if vis is not None and not vis(ch):
                     continue
                 out.append((ch, {"target": ch, "relation_type": "part_of",
@@ -214,7 +230,7 @@ def adjacency(cg, include_hierarchy=True):
         if out:
             adj[nid] = out
     try:
-        cg._chain_adj = (bool(include_hierarchy), vis_on, adj)
+        cg._chain_adj = (bool(include_hierarchy), vis_on, bool(skip_archived), adj)
     except Exception:
         pass
     return adj

package/md_cg/consolidate.py

@@ -25,11 +25,17 @@
     闸门 1 · grounding 支撑度（确定性）：候选短语必须能在节点正文里找到字符级依据，
         否则判为幻觉 → REJECT。（对应「不猜测」）
     闸门 2 · replay 回放（确定性）：把候选条件当作查询，回放生产检索路径的判定：
-         · pos_recall    以「生效条件」为查询 → 本节点应被召回，且不被自身负条件挡住；
+         · pos_recall    以「生效条件」为查询 → 本节点应被召回（issue #64：原式另带
+                         「负条件一票否决」因子，过严误杀共享主题词的合格负条件，
+                         已撤销——自否定职责由 no_conflict 承担）；
          · neg_separated 以「不适用条件」为查询 → 应触发条件级负路由，且负条件与正文
                          低相关（负条件必须是「域外」的，不能把知识本身否定掉）；
          · no_conflict   生效条件与不适用条件不得互相覆盖。
        三者同时成立才算「条件稳定」。（对应「回放 / 断言 / 回归」）
+       闸门 2 前另设**负条件两态拦截**（issue #64，见 consolidate 主流程）：
+       候选未产出负条件（neg_absent）/ 负条件被 grounding 删光（neg_dropped_all）
+       → 直接 REJECT，不进 replay、不进验证单元、不落盘——「负条件被删光」不得
+       被 replay 的空集短路翻译成「通过」（否则缺「不适用条件」要素的节点仍会落盘）。
     闸门 3 · 验证单元（GLM，独立模型）：逐条核验候选是否有正文依据、负条件是否真域外。
         硬约束：**验证单元只能否决，不能新增/改写**——它没有产出权，
         否则验证环节自己就成了新的幻觉源。
@@ -284,6 +290,8 @@ def http_llm(prompt: str, model: str = None, base: str = None, key: str = None,
     max_tokens=None 走三级解析（显式 > MDCG_LLM_MAX_TOKENS > DEFAULT_MAX_TOKENS）；
     历史 bug（issue #24）：曾硬编码 1200——思考模型 reasoning 吃光预算，
     content 空串静默落成 parse_failed，离线固化 100% DEFER。
+    timeout 由调用方注入（CLI --timeout / --reflect-timeout / --verify-timeout，
+    默认 120 秒）——issue #64：此前 CLI 两 lambda 均未传，恒为硬默认、不可配。
     """
     if role:
         model, base, key = role_config(role, model, base, key)
@@ -496,20 +504,25 @@ def grounding_filter(cand: dict, body: str, thresholds: dict = None):
     return kept, detail
 
 
-# 生效条件：给定 pos_terms、neg_terms、body，返回含 pos_recall、neg_separated、no_conflict、ok 的回放判定字典。
+# 生效条件：给定 pos_terms、neg_terms、body，返回含 pos_recall、neg_separated、no_conflict、ok 的回放判定字典；pos_recall 只认「生效条件在正文上有覆盖率」，不含负条件一票否决。
 def replay_check(pos_terms, neg_terms, body: str) -> dict:
     """回放生产判定：正例召回 + 负例剔除 + 无自相矛盾。
 
     复用 _path_semantic 的同一批原语，保证与生产路同源（P6 与真实路做一致性回归）。
+
+    issue #64（2026-10-06）：pos_recall 原式带 `and not _neg_hit(tw_pos, neg_terms)`
+    一票否决——「生效条件任一词整词出现在不适用条件里」即判负；而负条件描述的正是
+    **邻近易混情境**，与生效条件共享领域主题词是结构必然（不共享主题词就谈不上「邻近」），
+    该因子把大量合格负条件误杀为「正例召回失败」。自否定职责已由第 3 条 no_conflict
+    以覆盖率口径（<0.5 才算互相覆盖）承担——本因子与它同意图且更严，故撤销。
     """
     pos_text = " ".join(pos_terms or [])
     neg_text = " ".join(neg_terms or [])
     tw_pos = expand_query_terms_weighted(pos_text) if pos_text else {}
     tw_neg = expand_query_terms_weighted(neg_text) if neg_text else {}
 
-    # 1. 正例：以生效条件为查询，本节点正文应被命中，且不被自身负条件挡住
-    pos_recall = bool(pos_text) and _weighted_coverage(tw_pos, body) > 0.0 \
-        and not _neg_hit(tw_pos, neg_terms)
+    # 1. 正例：以生效条件为查询，本节点正文应被命中（不含负条件一票否决，见 docstring）
+    pos_recall = bool(pos_text) and _weighted_coverage(tw_pos, body) > 0.0
 
     # 2. 负例：以不适用条件为查询，应触发条件级负路由；且负条件与正文低相关
     #    （负条件必须是「域外」的，若与正文强相关，等于让知识否定自己）
@@ -652,7 +665,7 @@ def _apply_node(cg, e, fm: dict, content: str, kept: dict, prov: dict,
         before=before, after=evolution.state_of(cg, nid) or {})
 
 
-# 生效条件：给定 root，扫描正排层节点并执行反思→白箱闸门→验证→固化，返回报表 rep；require_verify=True 且无 verify_fn 时全部 DEFER。
+# 生效条件：给定 root，扫描正排层节点并执行反思→白箱闸门（含负条件两态拦截）→验证→固化，返回报表 rep；require_verify=True 且无 verify_fn 时全部 DEFER。
 def consolidate(root: str, layer: str = None, limit: int = None, apply: bool = False,
                 overwrite: bool = False, llm_fn=None, reflect_fn=None,
                 verify_fn=None, reflect_model: str = "", verify_model: str = "",
@@ -663,6 +676,10 @@ def consolidate(root: str, layer: str = None, limit: int = None, apply: bool = F
 
     llm_fn 是 reflect_fn 的旧名（向后兼容，单模型模式）。
     require_verify=True 且无 verify_fn → 一律 DEFER（纪律 5：未经验证不固化）。
+    白箱闸门内先过**负条件两态拦截**（issue #64）：候选未产出负条件 → reasons
+    记 neg_absent；负条件被 grounding 删光 → reasons 记 neg_dropped_all；两态
+    都直接 REJECT（不进 replay / 不进验证单元 / 不落盘）——缺「不适用条件」
+    要素的节点不得因空集短路被判「通过」。
     """
     reflect_fn = reflect_fn or llm_fn
     cg = MdCGOS(root)
@@ -728,6 +745,36 @@ def consolidate(root: str, layer: str = None, limit: int = None, apply: bool = F
         kept, gdetail = grounding_filter(cand, body, thresholds)
         pos = kept.get("生效条件") or []
         neg = kept.get("不适用条件") or []
+
+        # 2a) 负条件两态拦截（issue #64，2026-10-06）：「不适用条件」是 CCG 必需要素，
+        #     候选**未产出**（neg_absent）或**产出了但被 grounding 删光**（neg_dropped_all）
+        #     时都必须 REJECT——不进 replay、不进验证单元、不落盘。
+        #     修复前把空 neg 交给 replay_check，命中其 `else: neg_separated = True` 短路，
+        #     「负条件被删光/未产出」被翻译成「通过」，缺要素节点照常落盘并携带
+        #     verification_basis 声明（B 类实测：accepted=1/written=1，正文无
+        #     「# 不适用条件」行）。两态各自计数，便于报表区分「模型没产出」与
+        #     「产出被 grounding 判为幻觉丢弃」。
+        neg_cand = cand.get("不适用条件") or []
+        if not isinstance(neg_cand, list):
+            neg_cand = [neg_cand]
+        neg_cand = [t for t in neg_cand if str(t).strip()]
+        if not neg_cand:
+            rep["rejected"] += 1
+            _bump("neg_absent")
+            if verbose and len(rep["samples"]) < 8:
+                rep["samples"].append({"id": nid, "verdict": "REJECT",
+                                       "stage": "whitebox", "reason": "neg_absent",
+                                       "grounding": gdetail, "replay": None})
+            continue
+        if not neg:
+            rep["rejected"] += 1
+            _bump("neg_dropped_all")
+            if verbose and len(rep["samples"]) < 8:
+                rep["samples"].append({"id": nid, "verdict": "REJECT",
+                                       "stage": "whitebox", "reason": "neg_dropped_all",
+                                       "grounding": gdetail, "replay": None})
+            continue
+
         replay = replay_check(pos, neg, body)
         if not kept or not replay["ok"]:
             rep["rejected"] += 1
@@ -1477,9 +1524,21 @@ def _cli(argv=None) -> int:
     ap.add_argument("--min-grounding", type=float, default=None,
                     help="统一 grounding 阈值（默认按字段 0.5 / 不适用条件 0.34）")
     ap.add_argument("--max-tokens", type=int, default=None,
-                    help=f"LLM 输出预算（含思考模型 reasoning_tokens；默认 "
+                    help=f"LLM 输出预算共用缺省（含思考模型 reasoning_tokens；默认 "
                          f"{DEFAULT_MAX_TOKENS}，可 env {MAX_TOKENS_ENV} 覆盖；"
-                         "子代理配置标准 v0.5 §1）")
+                         "子代理配置标准 v0.5 §1）；两角色可分别用 "
+                         "--reflect-max-tokens / --verify-max-tokens 单设")
+    ap.add_argument("--reflect-max-tokens", type=int, default=None,
+                    help="反思单元输出预算（缺省回落 --max-tokens）")
+    ap.add_argument("--verify-max-tokens", type=int, default=None,
+                    help="验证单元输出预算（缺省回落 --max-tokens）")
+    ap.add_argument("--timeout", type=float, default=120,
+                    help="LLM HTTP 超时秒数（缺省 120）；两角色可分别用 "
+                         "--reflect-timeout / --verify-timeout 单设")
+    ap.add_argument("--reflect-timeout", type=float, default=None,
+                    help="反思单元 HTTP 超时（缺省回落 --timeout）")
+    ap.add_argument("--verify-timeout", type=float, default=None,
+                    help="验证单元 HTTP 超时（缺省回落 --timeout）")
     ap.add_argument("--no-llm", action="store_true",
                     help="不调用 LLM，只做四要素完整性普查")
     ap.add_argument("--check", action="store_true",
@@ -1530,16 +1589,28 @@ def _cli(argv=None) -> int:
                   f"（{_ROLE_ENV[REFLECT_ROLE][2]} / DEEPSEEK_API_KEY）→ 退化为普查模式",
                   file=sys.stderr)
         else:
+            # 单值 --max-tokens / --timeout 继续作两角色共用缺省；角色级参数缺省
+            # None → 回落共用缺省。issue #64：此前单值被同时喂 reflect/verify，
+            # timeout 恒为 http_llm 默认 120 不可配（生产两 lambda 均未传）——
+            # 两侧预算/超时需求可不同，须能分别单设。
+            refl_mt = (a.reflect_max_tokens if a.reflect_max_tokens is not None
+                       else a.max_tokens)
+            refl_to = (a.reflect_timeout if a.reflect_timeout is not None
+                       else a.timeout)
             reflect_fn = (lambda p: http_llm(p, role=REFLECT_ROLE,   # noqa: E731
                                              model=a.reflect_model,
-                                             max_tokens=a.max_tokens))
+                                             max_tokens=refl_mt, timeout=refl_to))
             if a.self_verify:
                 verify_fn = reflect_fn
             elif not a.no_verify:
                 if v_key:
+                    ver_mt = (a.verify_max_tokens
+                              if a.verify_max_tokens is not None else a.max_tokens)
+                    ver_to = (a.verify_timeout if a.verify_timeout is not None
+                              else a.timeout)
                     verify_fn = (lambda p: http_llm(p, role=VERIFY_ROLE,  # noqa: E731
                                                     model=a.verify_model,
-                                                    max_tokens=a.max_tokens))
+                                                    max_tokens=ver_mt, timeout=ver_to))
                 else:
                     print(f"[consolidate] 验证单元未配置 key"
                           f"（{_ROLE_ENV[VERIFY_ROLE][2]} / ZHIPU_API_KEY / GLM_API_KEY）"

package/md_cg/lifecycle.py

@@ -280,6 +280,13 @@ def set_state(cg, node_id: str, dst: str, reason: str = None,
     cg._write_node(node_id, os.path.join(cg.root, node["path"]), fm,
                    node.get("content") or "")
     _sync_index(cg, node_id, fm)
+    # 退役接线（2026-10-06）：状态迁移改变 `is_archived` 读数 ⇒ 依赖该判据的
+    # 邻接缓存（`chain.adjacency` 的 skip_archived 过滤）必须**同点作废**——
+    # 此前只有本地写路径（add/_stage 尾三连）清缓存，set_state 后旧缓存会让
+    # 退役节点继续沿因果链/图面扩散（本批探针实证：归档后 causal_chain 仍含
+    # 目标）。懒导入避免模块环；`invalidate_cache` 内部自吞异常，不阻断推进。
+    from . import chain as _chain
+    _chain.invalidate_cache(cg)
     try:
         append_jsonl(os.path.join(cg.root, AUDIT_FILE), {
             "t": at, "action": "set_state", "node_id": node_id,

package/md_cg/mcp_server.py

@@ -189,6 +189,9 @@ TOOLS = [
                           consistency=_p("boolean", "写入前节点间自动冲突检测（三级决策，默认 true）"),
                           on_conflict=_p("string", "冲突处置：reject（默认，抛错）|defer（不写）|record（记录放行）"),
                           condition_space=_p("object", "条件空间"),
+                          spatial=_p("object", "3D 空间锚（0.8.0 身体×脑对接约定，四条裁定之二）："
+                                               "{\"coords3d\": {x,y,z}} 自定义键直存米制；"
+                                               "可选 bbox 投影后补（不改既有 bbox 2D 语义）"),
                           verification_basis=_p("string", "验证基底"),
                           non_applicable_conditions=_p("array", "不适用条件")),
                           },
@@ -1591,6 +1594,15 @@ def _split_ids(value):
     return out
 
 
+# 生效条件：a 为 MCP 参数字典时——`a["spatial"]` 非 None 返回 {"spatial": ...}，否则返回 {}
+# （**缺省不传**：未声明 spatial 的写入零落键，既有 fm 形态逐位不变；0.8.0 身体×脑对接
+# 四条裁定之二引入，gated 分支与非 gated add 两处共用本单点）。
+def _spatial_kw(a):
+    if a.get("spatial") is not None:
+        return {"spatial": a["spatial"]}
+    return {}
+
+
 # 生效条件：始终构造 ex（verify=a.get("verify")、importance=float(a["importance"]) 当 a.get("importance") is not None 否则 None、verification_basis=a.get("verification_basis") or (verdict or {}).get("basis")、non_applicable_conditions、role、derived_from=_split_ids(a.get("derived_from")) or None、relation），返回其中值不属于 (None, [], '', {}) 的键值对。
 def _proposal_extras(a, verdict=None):
     """入队时保全 write 的落盘要素，避免裁决 accept 后退化成默认值。
@@ -3446,6 +3458,11 @@ def _dispatch(cg, name, args):
                 # A1 补接（2026-10-05）：检验强度同族透传（remember_gated 内部
                 # add(**kw) 直达；此前声明在 gated 分支静默丢弃）。
                 check_strength=a.get("check_strength"),
+                # 0.8.0 身体×脑对接（四条裁定之二，2026-10-06）：`spatial`
+                # 自定义键**直存**——约定 {"coords3d": {x,y,z}} 米制（可选 bbox
+                # 投影后补）；不改既有 fm.spatial.bbox 的 2D 语义。
+                # 缺省不传（_spatial_kw）——未声明时零落键，既有 fm 形态逐位不变。
+                **_spatial_kw(a),
                 non_applicable_conditions=a.get("non_applicable_conditions"),
                 importance_hint=hint, override=bool(a.get("override")),
                 consistency=bool(a.get("consistency", True)),
@@ -3498,6 +3515,9 @@ def _dispatch(cg, name, args):
                       # A1 补接（2026-10-05）：检验强度入复现 meta——与
                       # writepipe._AUTONOMY_META_KEYS 同款（两条路径元数据等价）。
                       "check_strength",
+                      # 0.8.0 对接：spatial 同样随单落复现 meta（入队后
+                      # accept 落盘与直接落盘**元数据等价**，判据不分叉）。
+                      "spatial",
                       "role", "importance") if a.get(k) is not None}
             # 直写面的裁决参数（本分支的 add 会自己跑冲突闸）：随单落进复现 meta，
             # 否则「确认后落盘」与「直接落盘」两条路径的判据不等价。
@@ -3526,6 +3546,8 @@ def _dispatch(cg, name, args):
                          verification_basis=a.get("verification_basis"),
                          # A1 补接（2026-10-05）：检验强度透传（同 B2）。
                          check_strength=a.get("check_strength"),
+                         # 0.8.0 对接：spatial 直存透传（同 B2）；缺省不传（零落键）。
+                         **_spatial_kw(a),
                          non_applicable_conditions=a.get("non_applicable_conditions"),
                          override=bool(a.get("override")),
                          consistency=bool(a.get("consistency", True)),

package/md_cg/mdcg.py

@@ -3690,7 +3690,12 @@ class MdCG:
                    # （非法视图 ValueError——fail-closed 只针对调用方误用）
                    and (view is None or roleviews.matches(e, view))
                    # 时效：只在显式启用时排除已过期（not_yet 保留）
-                   and not (validity and trust.is_expired(e, now=now))):
+                   and not (validity and trust.is_expired(e, now=now))
+                   # 退役纪律（《秤》v2.1 §5.2；2026-10-06 接线）：archived
+                   # 不进默认检索候选——判据单点 lifecycle.is_archived
+                   # （缺键=active fail-open），与生产路径 `MdCGOS._candidates`
+                   # 同一口径（此前基类面未接，属已登记的已知未覆盖面）。
+                   and not lifecycle.is_archived(e)):
                 entries.append(e)
 
         # 默认关：索引里可能残留门控字段（曾开启过 / 回填过）→ 返回前剥离，

package/md_cg/scrub.py

@@ -115,11 +115,13 @@ def _access(cg):
         return {}, {}
 
 
-# 生效条件：`from . import chain` 成功且 chain.adjacency(cg) 正常返回时返回该 dict，导入或调用抛任何异常时返回 {}。
+# 生效条件：`from . import chain` 成功且 chain.adjacency(cg, skip_archived=False) 正常返回时返回该 dict，导入或调用抛任何异常时返回 {}。
 def _adjacency(cg) -> dict:
     try:
         from . import chain
-        return chain.adjacency(cg)
+        # 维护面全量口径（2026-10-06 退役接线批次）：去污染抽查是维护写面，
+        # 退役节点仍可被抽查 ⇒ 显式旁路退役过滤（度数口径与接线前逐位一致）。
+        return chain.adjacency(cg, skip_archived=False)
     except Exception:
         return {}
 

package/md_cg/sleep.py

@@ -78,11 +78,15 @@ DEFAULT_LOCK_TIMEOUT = 30.0
 #: 单条 git 子进程的**硬超时**（秒）——issue #63 主修（单点可调）。
 #: 取值依据：本机 git 操作为秒级（init / add / commit / rev-parse / worktree /
 #: merge / revert 全是单库本地动作），120s 为安全上界；超时即 kill
-#: （`subprocess.run(timeout=)` 语义），异常消息里带「若是残留锁则人工核删」的
-#: 指引（本模块**不自动删** index.lock——可能是他进程的锁，误删更糟）。
+#: （`subprocess.run(timeout=)` 语义）；残留锁处置见 `_clear_git_lock`
+#: （有界自清，2026-10-06 落地原「是否自动清理」待裁项）。
 _GIT_TIMEOUT_S = 120
-#: git 子进程超时后可能的残留锁名（仅用于异常消息里的核删指引，不自动删）。
+#: git 超时被 kill 后可能的残留锁名（有界自清的**唯一**对象名）。
 _GIT_LOCK_NAME = "index.lock"
+#: 残留锁的**超龄阈值**（秒）——有界自清的第二闸：本模块全部 git 调用都带
+#: `_GIT_TIMEOUT_S` 超时，合法操作结构性不可能持锁超过它；300s（≈2.5×）之上
+#: 仍存在的锁只可能是崩溃/被 kill 的残留。
+_GIT_LOCK_STALE_S = 300
 #: 睡眠轮次的**台账**（append-only JSONL）——落 `sleep_root()` 侧（状态面，
 #: **不是数据根**）：台账是运行态，不该成为真源面的一部分、也不该进版本库。
 SLEEP_LEDGER = "_sleep.jsonl"
@@ -284,6 +288,47 @@ def face_delta(before: dict, after: dict) -> dict:
 
 
 # 生效条件：git_dir_path 与 work_tree 给定时以 ["git", "--git-dir=<git_dir_path>", "--work-tree=<work_tree>", *args] 调 subprocess.run（capture_output + text + 显式 utf-8/errors=replace + env 带 PYTHONUTF8=1 + shell=False + **timeout=_GIT_TIMEOUT_S** + **stdin=DEVNULL**）并返回 CompletedProcess；returncode 非零不抛（由调用方判）；TimeoutExpired **不吞**——单点转 SleepGitTimeout（消息含「超时（_GIT_TIMEOUT_S）已被 kill」+ 命令名 + 残留锁人工核删指引）。
+# 生效条件：git_dir_path 下存在 index.lock 且（force 为真 或 其 mtime 距今 ≥ _GIT_LOCK_STALE_S 秒）时删除该文件、记一行 `git_lock_cleared` 台账（写入失败不阻断）并返回 "cleared"；锁不存在返回 "absent"；存在但未达清理条件、或删除失败（OSError）返回 "left"（保持既有的人工核删指引面）。
+def _clear_git_lock(git_dir_path: str, *, force: bool = False) -> str:
+    """有界自清影子仓的 git 残留锁（三闸口径，2026-10-06 落地待裁项）。
+
+    背景（issue #63 台账「是否自动清理」）：`_git` 超时 kill 自己的 git 后，
+    影子仓可能留下 `index.lock`，此前只给人工核删指引。现**有界**自清：
+
+      ① **范围闸**：只碰本模块影子仓的 `<git_dir>/index.lock`——该仓由本模块
+         单属、轮级独占，无第三方 git 的合法持锁面。（**调用约定面**：影子仓
+         归属由调用方传入的 git_dir 保证；本函数机械面只保证对象名恒为
+         `<git_dir>/index.lock` 且须过②闸——独立复核 2026-10-06 观察 1 如实
+         标注。）
+      ② **时机/年龄闸**：`force=True` 仅在本模块**刚 kill 掉自己超时的 git
+         子进程**后调用（此刻仓内任何锁只可能来自该进程或其更早残留）；
+         非 force（每次 git 调用前的巡检）只在锁 **mtime 距今 ≥
+         `_GIT_LOCK_STALE_S`** 时清理（≫ 全部调用的 120s 超时上界，合法操作
+         结构性不可能持锁这么久）；
+      ③ **其余一律不删**（返回 "left"），异常消息保留人工核删指引。
+
+    返回 "cleared" / "left" / "absent"。
+    """
+    lock = os.path.join(git_dir_path, _GIT_LOCK_NAME)
+    try:
+        st = os.stat(lock)
+    except OSError:
+        return "absent"
+    age = max(0.0, time.time() - st.st_mtime)
+    if not force and age < _GIT_LOCK_STALE_S:
+        return "left"
+    try:
+        os.remove(lock)
+    except OSError:
+        return "left"
+    try:
+        _append_ledger({"event": "git_lock_cleared", "lock": lock,
+                        "age_s": round(age, 1), "force": bool(force)})
+    except OSError:               # 台账失败不阻断 git 主链（与审计面同风格）
+        pass
+    return "cleared"
+
+
 def _git(git_dir_path: str, work_tree: str, *args: str) -> subprocess.CompletedProcess:
     """git 调用的**唯一出口**：`--git-dir` 与 `--work-tree` 一律显式给。
 
@@ -291,7 +336,7 @@ def _git(git_dir_path: str, work_tree: str, *args: str) -> subprocess.CompletedP
     两个工作树，靠这两个显式开关切换，**不依赖进程 cwd**（`hive/wm.py` 用 `-C`
     是因为它的工作树就是版本库本身；这里两者分居，故用分裂形态）。
 
-    **有界化（issue #63）**——三件套缺一不可：
+    **有界化（issue #63）**——四件套缺一不可：
 
       ① `timeout=_GIT_TIMEOUT_S`：子进程**无界等待**是常驻循环停摆的直接成因
          （实测停 9.5 小时：`SustainLoop` 单线程串行六档，任一档挂住即全停）。
@@ -300,14 +345,16 @@ def _git(git_dir_path: str, work_tree: str, *args: str) -> subprocess.CompletedP
          任何读 stdin 的子进程会永久悬挂（实测：活管道下 6s 仍 poll=None；
          DEVNULL 下 0.02s 立即 EOF）。先例形态：`md_cg/run_tests.py:105`。
       ③ `TimeoutExpired` **不吞**：转 `SleepGitTimeout`（`SleepError` 子类，
-         既有 `except SleepError` 面照旧收得住），消息带命令名与残留锁核删
-         指引——`subprocess.run(timeout=)` kill 子进程后 git 可能留下
-         `index.lock`；**本模块不自动删**（可能是他进程的锁，误删更糟），
-         是否自动清理列入待裁（见 issue #63 台账）。
+         既有 `except SleepError` 面照旧收得住），消息带命令名与残留锁处置读数。
+      ④ **残留锁有界自清**（2026-10-06 落地待裁项）：调用前置巡检清超龄残留
+         （崩溃场景），超时 kill 后 `force` 清当前残留（见 `_clear_git_lock`
+         三闸口径）——消息里如实带「已清理/未清理」。
     """
     argv = ["git", "--git-dir=" + git_dir_path, "--work-tree=" + work_tree]
     argv.extend(args)
     env = dict(os.environ, PYTHONUTF8="1")
+    # 前置巡检：清超龄残留锁（有界自清第一时机——崩溃残留，无 handler 可依）
+    _clear_git_lock(git_dir_path)
     try:
         return subprocess.run(argv, capture_output=True, text=True,
                               encoding="utf-8", errors="replace",
@@ -315,11 +362,14 @@ def _git(git_dir_path: str, work_tree: str, *args: str) -> subprocess.CompletedP
                               timeout=_GIT_TIMEOUT_S,
                               stdin=subprocess.DEVNULL)
     except subprocess.TimeoutExpired as exc:
+        # 第二时机：本模块刚 kill 自己的 git——此刻仓内任何锁只可能是残留
+        _lock_state = _clear_git_lock(git_dir_path, force=True)
         raise SleepGitTimeout(
             "git %s 超时（%ss）已被 kill（命令：git %s）——"
-            "本次 git 操作未完成；若后续 git 操作报 lock，请人工核删 "
-            "%s（可能是被 kill 的进程留下的残留锁，本模块不自动删）"
+            "本次 git 操作未完成；残留锁处置：%s（%s）"
             % (" ".join(args[:2]), _GIT_TIMEOUT_S, " ".join(args[:6]),
+               {"cleared": "已自动清理", "left": "未动，若后续报 lock 请人工核删",
+                "absent": "无残留锁"}.get(_lock_state, _lock_state),
                os.path.join(git_dir_path, _GIT_LOCK_NAME))) from exc