@furongjun1999/dsh-memory 0.7.4 → 0.8.0

package/lib/lib/mdcg_client.js

@@ -19,6 +19,8 @@
  *   外部裁决回填  → MdcgClient.verify()     → MCP cg(op=verify)
  *   最近记忆时间线 → MdcgClient.timeline()  → MCP stg(op=timeline)
  *   近期事件窗口  → MdcgClient.recent()     → MCP cg(op=recent)
+ *   窗口追加事件  → MdcgClient.recentAdd()  → MCP cg(op=recent, action=add)
+ *   会话续接包    → MdcgClient.sessionRecall() → MCP cg(op=session, action=recall)
  *   身份读取      → MdcgClient.identity()   → MCP cg(op=identity)
  *   白箱能力验证  → MdcgClient.whitebox()   → MCP cg(op=whitebox)
  *   服务信息      → MdcgClient.serviceInfo()→ MCP cg(op=info)
@@ -215,6 +217,48 @@ export class MdcgClient {
     recent(limit = 20) {
         return this.cg({ op: 'recent', limit });
     }
+    /** 追加一条**近期事件窗口**记录（`cg(op=recent, action=add)` →
+     *  `md_cg` 的 `remember_event(role, text, tags, meta, window)`）。
+     *
+     *  这是「滑动窗口」写侧：事件落 `_recent.jsonl`（**运行态面**），按窗口滚动
+     *  淘汰（服务端缺省 200 条，`mdcg.py:91 DEFAULT_RECENT_WINDOW`）——它**不是
+     *  知识节点**：不占 knowledge 层、不进检索正排，与 `remember()` 的知识面沉淀
+     *  是两条独立的轨道（见 src/hooks.ts 文件头的 contextWindow 头注）。
+     *
+     *  ⚠️ **不注入 as_unit**（与 `write()` 同款理由的反面）：本调用不写任何层的
+     *  节点（服务端 `remember_event` 不做层白名单校验），收窄单元无收益且可能压低
+     *  事件密级（缺省 internal）；`meta.session` 由调用方显式给出（沿本文件
+     *  `remember()` 的 sessionTag 口径）。
+     *
+     *  ⚠️ 服务端对 `meta` 做 `setdefault`（tenant/session/harness/unit，见
+     *  `mdcos.py:5057 remember_event`）：调用方已写的键**不被覆盖**。 */
+    recentAdd(role, text, meta = {}, tags = []) {
+        return this.cg({ op: 'recent', action: 'add', role, text, meta, tags });
+    }
+    /** **会话续接包**（`cg(op=session, action=recall)` → `md_cg` 的
+     *  `session_recall`）：一次取回 notes / goals / tasks / **recent 事件窗口** /
+     *  unresolved / self_state，按 `budget_tokens` 整包裁剪（服务端
+     *  `mdcos.py:3351-3362`：交替丢 recent / notes 尾部）。
+     *
+     *  本插件消费其中的 `recent` 段——滑动窗口的**注入面**（见 src/hooks.ts）。
+     *  `recent_limit` 语义 = 近期事件**条数**（非「轮数」）；服务端读取时会按
+     *  `max(1, recent_limit or 10)` 归一（`mdcos.py:3309`）。
+     *
+     *  ⚠️ 两条服务端事实（决定注入侧的可达性，勿据本方法名臆测）：
+     *   ① `recent` 段取 `recent_events(limit=recent_limit)` —— **不按 session
+     *      过滤**（近期事件是运行态滚动窗口，会话归属只写在每条事件的 meta 里）；
+     *   ② budget 是**整包**预算：库内 notes/tasks/self_state 占位越多，同样
+     *      budget 下 recent 段被裁得越短（实测：空库 + 10 条窗口条目，
+     *      budget_tokens=600 → recent 8 条；1200 → 10 条）。
+     *
+     *  只读调用，不注入 as_unit（同其它读路径：读无副作用，收窄只会压低 owner
+     *  的 private 读能力）。 */
+    sessionRecall(session, recentLimit, budgetTokens) {
+        return this.cg({
+            op: 'session', action: 'recall',
+            session, recent_limit: recentLimit, budget_tokens: budgetTokens,
+        });
+    }
     /** 最近记忆**时间线**（AEIS `timeline` 的对应物）：`stg(op=timeline)` →
      *  `{count, limit, items:[{id, layer, start, end, preview}]}`，按时间倒序。
      *

package/md_cg/audit.py

@@ -456,11 +456,17 @@ def _verify_code(payload, ctx):
         # 被测命令只要输出非 gbk 字节，读取线程就抛 UnicodeDecodeError →
         # p.stdout/p.stderr 可能为空 → 下一行的失败证据丢失，
         # 「实测失败」会退化成一句没有依据的 REJECT（对齐 whitebox.py 的写法）。
+        # stdin=subprocess.DEVNULL（issue #63 同批加固）：不指定 stdin 时子进程
+        # 继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道），读 stdin 的测试
+        # 命令会悬挂到 timeout 才被 kill——形态对齐 `md_cg/run_tests.py:105`。
         p = subprocess.run(argv, cwd=ctx.get("cwd"), capture_output=True,
                            text=True, encoding="utf-8", errors="replace",
-                           shell=False,
+                           shell=False, stdin=subprocess.DEVNULL,
                            timeout=int(os.environ.get("MDCG_CODE_TEST_TIMEOUT", "60")))
     except (OSError, subprocess.SubprocessError) as exc:
+        # TimeoutExpired（SubprocessError 子类）也走这里：DEFER + 文案带异常
+        # 名与原文（如 "TimeoutExpired: Command '…' timed out after 60 seconds"）
+        # ——超时**不吞**（issue #63）。
         return _verdict(DEFER, "code", f"测试无法执行：{type(exc).__name__}: {exc}")
     if p.returncode == 0:
         return _verdict(ACCEPT, "code", f"实测通过：{cmd}")

package/md_cg/bench_governance.py

@@ -315,9 +315,12 @@ def run(root=None, keep=False):
 
 def _git_head():
     try:
+        # timeout=10 既有；stdin=subprocess.DEVNULL 为 issue #63 同批加固——
+        # 不指定 stdin 时子进程继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道）。
         out = subprocess.run(["git", "rev-parse", "--short", "HEAD"],
                              capture_output=True, text=True, encoding="utf-8",
-                             errors="replace", shell=False, timeout=10)
+                             errors="replace", shell=False, timeout=10,
+                             stdin=subprocess.DEVNULL)
         return (out.stdout or "").strip() or "unknown"
     except Exception:                                     # noqa: BLE001
         return "unknown"

package/md_cg/bench_locomo_zh.py

@@ -303,6 +303,9 @@ ROW_RE = re.compile(
     r"([\d.]+)%\s+([\d.]+)%\s+([\d.]+)\s*$", re.M)
 GATE_RE = re.compile(r"拒答率：([\d.]+)%")
 LINE_RE = re.compile(r"拒答线（正例 hit@1 题 Top-1 分 p10）：([\d.]+)")
+#: 单臂评测子进程的超时（秒）——issue #63 同批加固：评测跑批比 git 长，按
+#: 「一臂为分钟级」给 1800s（30min）为安全上界；超时即 kill（不再是无限等待）。
+_EVAL_TIMEOUT_S = 1800
 
 
 # 生效条件：RUST_BIN 经 os.path.exists 为假时抛 SystemExit；否则以 argv 列表 [RUST_BIN, "--dataset", "lc", "--tag", name, "--lib", lib, "--qfile", qfile]（extra 为真值时追加其元素）执行 subprocess.run，返回码非 0 或 stdout 未匹配 ROW_RE 时抛 SystemExit，成功时返回 (got, neg, line)，其中 GATE_RE/LINE_RE 未命中时对应值为 None。
@@ -320,8 +323,15 @@ def run_one(name, lib, qfile, extra=None):
     if extra:
         argv += list(extra)
     env = dict(os.environ, PYTHONUTF8="1")
-    p = subprocess.run(argv, capture_output=True, text=True,
-                       encoding="utf-8", errors="replace", env=env, cwd=HERE)
+    try:
+        # timeout + stdin=DEVNULL（issue #63 同批加固）：评测跑批有界化，
+        # 且不继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道）。
+        p = subprocess.run(argv, capture_output=True, text=True,
+                           encoding="utf-8", errors="replace", env=env, cwd=HERE,
+                           timeout=_EVAL_TIMEOUT_S,
+                           stdin=subprocess.DEVNULL)
+    except subprocess.TimeoutExpired:
+        raise SystemExit(f"[失败] {name}：评测超时（>{_EVAL_TIMEOUT_S}s）已被 kill")
     if p.returncode != 0:
         raise SystemExit(f"[失败] {name}：{(p.stderr or '')[-900:]}")
     got = {}

package/md_cg/bench_zh_mad.py

@@ -481,6 +481,9 @@ ROW_RE = re.compile(
     r"^\s*(precise|temporal|interference|reference)\s+(\d+)\s+"
     r"([\d.]+)%\s+([\d.]+)%\s+([\d.]+)\s*$", re.M)
 GROUPS = ["precise", "temporal", "interference", "reference"]
+#: 单臂评测子进程的超时（秒）——issue #63 同批加固：评测跑批比 git 长，按
+#: 「一臂为分钟级」给 1800s（30min）为安全上界；超时即 kill（不再是无限等待）。
+_EVAL_TIMEOUT_S = 1800
 
 
 # 生效条件：os.path.exists(RUST_BIN) 为真时以 argv=[RUST_BIN,"--dataset","mad","--tag",name,"--lib",lib]（extra 为真值时追加 list(extra)）执行 subprocess，返回码非 0 或 ROW_RE 在 stdout 未匹配到任何组时 raise SystemExit，否则返回 {组:(n,hit@1,hit@5,MRR)}。
@@ -498,8 +501,15 @@ def run_one(name, lib, extra=None):
     if extra:
         argv += list(extra)
     env = dict(os.environ, PYTHONUTF8="1")
-    p = subprocess.run(argv, capture_output=True, text=True,
-                       encoding="utf-8", errors="replace", env=env, cwd=HERE)
+    try:
+        # timeout + stdin=DEVNULL（issue #63 同批加固）：评测跑批有界化，
+        # 且不继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道）。
+        p = subprocess.run(argv, capture_output=True, text=True,
+                           encoding="utf-8", errors="replace", env=env, cwd=HERE,
+                           timeout=_EVAL_TIMEOUT_S,
+                           stdin=subprocess.DEVNULL)
+    except subprocess.TimeoutExpired:
+        raise SystemExit(f"[失败] {name}：评测超时（>{_EVAL_TIMEOUT_S}s）已被 kill")
     if p.returncode != 0:
         raise SystemExit(f"[失败] {name}：{(p.stderr or '')[-900:]}")
     got = {}

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/interop.py

@@ -47,6 +47,11 @@ _FORBIDDEN_RES = [
 ]
 _FORBIDDEN_KEYS = {"prompt", "content", "spec", "api_key", "base", "model",
                    "system_prompt", "user_prompt", "content_head"}
+#: git add/commit 子进程的超时（秒）——issue #63 同批加固：本机 git 为秒级
+#: 操作，120s 为安全上界；超时即 kill。**stdin=subprocess.DEVNULL 同加**：
+#: 不指定 stdin 时子进程继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道），
+#: 读 stdin 的子进程会悬挂（先例形态 `md_cg/run_tests.py:105`）。
+_GIT_TIMEOUT_S = 120
 
 
 class InteropSanityError(ValueError):
@@ -323,15 +328,26 @@ def write_verdict_to_repo(verdict: dict, repo: str = HERE,
     out = {"ok": True, "path": fp}
     if do_commit:
         import subprocess
-        r1 = subprocess.run(["git", "add", os.path.relpath(fp, repo)],
-                            cwd=repo, capture_output=True, text=True,
-                            encoding="utf-8", errors="replace")
-        r2 = subprocess.run(
-            ["git", "commit", "-q", "-m",
-             f"interop(verifier): iter={it} verdict={verdict.get('verdict')} "
-             f"passed={verdict.get('passed')} failed={verdict.get('failed')}"],
-            cwd=repo, capture_output=True, text=True,
-            encoding="utf-8", errors="replace")
+        try:
+            r1 = subprocess.run(["git", "add", os.path.relpath(fp, repo)],
+                                cwd=repo, capture_output=True, text=True,
+                                encoding="utf-8", errors="replace",
+                                timeout=_GIT_TIMEOUT_S,
+                                stdin=subprocess.DEVNULL)
+            r2 = subprocess.run(
+                ["git", "commit", "-q", "-m",
+                 f"interop(verifier): iter={it} verdict={verdict.get('verdict')} "
+                 f"passed={verdict.get('passed')} failed={verdict.get('failed')}"],
+                cwd=repo, capture_output=True, text=True,
+                encoding="utf-8", errors="replace",
+                timeout=_GIT_TIMEOUT_S, stdin=subprocess.DEVNULL)
+        except subprocess.TimeoutExpired:
+            # 超时**不吞**：如实记进既有错误面（与 rc≠0 同一条 commit_err），
+            # 不假装提交成功（issue #63）。
+            out["committed"] = False
+            out["commit_err"] = ("git 超时（%ss）已被 kill：%s" %
+                                 (_GIT_TIMEOUT_S, out_dir))
+            return out
         out["committed"] = r2.returncode == 0
         if r2.returncode != 0:
             out["commit_err"] = (r2.stderr or r1.stderr)[:200]

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 {}