@furongjun1999/dsh-memory 0.4.7 → 0.4.9

package/md_cg/test_codeindex.py

@@ -0,0 +1,338 @@
+# -*- coding: utf-8 -*-
+"""代码索引（codeindex）验收 · Phase 0 契约裁决 + 行序压制修复。
+
+对应计划 docs/mdcg/全库代码评审与条件化注释_计划_v0.1.md 的
+codeindex-render-fix / codeindex-tests；契约为
+docs/mdcg/代码评审与条件化注释_契约_v0.1.md。
+
+验收口径（改造前 → 改造后）：
+1. 行序压制：源码里人工写的生效条件行曾被合成行（同名字段、且排在源码注释
+   之前）永久压制——检索侧 mdcos._ccg_field 取首个匹配，人工声明不可见。
+   现在合成区与源码区**分区**、源码区**置首**，人工声明胜出并逐字保留。
+2. 字段零重名：机械推导的索引元条件不再占用生效条件字段，改由
+   nodefile.INDEX_META_MARK 承载；合成区字段名与 CCG 六要素的交集必须是空集
+   （机械判据 nodefile.is_ccg_mark）。
+3. 诚实缺证据：源码未声明生效条件的条目，ccg_completeness 必须
+   complete=False 且**恰缺**「生效条件」——不许用索引元条件冒充。这是 Phase 0
+   的**预期代价面**：真实库既有 2930 条代码节点在重索引后由 DEFER 降为
+   BLINDSPOT，待环二补注释闸门逐步补回（代价面见契约 §四）。
+4. extract / condition_space 既有契约不回归；index_dir 确定性排序与截断显式
+   上报维持（index-dir-integrity 属 Phase 1，本文件只建基线护栏）。
+"""
+from __future__ import annotations
+
+import ast
+import os
+import sys
+import tempfile
+import traceback
+
+from . import codeindex, nodefile
+from .mdcos import _ccg_field
+
+_ok = 0
+_bad = []
+_skip = 0
+
+
+def _check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("  ok   %s" % name)
+    else:
+        _bad.append("%s %s" % (name, detail))
+        print("  FAIL %s %s" % (name, detail))
+
+
+PY_SRC = '''"""示例模块。"""
+import os
+
+
+# 生效条件：入参 path 为已存在的本地文件
+# 子功能：读取文件首行
+def first_line(path):
+    """读取首行。"""
+    return open(path, encoding="utf-8").readline()
+
+
+def bare(name):
+    """无源码 CCG 注释。"""
+    return name
+'''
+
+JS_SRC = '''/** 弱提取样本 */
+export function ping(url) {
+  return url;
+}
+'''
+
+HUMAN_COND = "# 生效条件：入参 path 为已存在的本地文件"
+
+# 两窗口样本（裁决 A）：leading 在定义行之上，body 在定义行之下/体首语句之前
+BODY_SRC = '''"""两窗口样本。"""
+
+
+# 生效条件：外层声明（leading 窗口）
+def with_body(seq):
+    # 生效条件：入参 seq 为可迭代且元素可比较（body 窗口）
+    # 子功能：返回排序副本
+    out = sorted(seq)
+    return out
+
+
+def body_trap(seq):
+    out = sorted(seq)
+    # 实现注释：位于体首语句【之后】→ 不属于声明头窗口，不应被收
+    return out
+'''
+
+
+def _item_of(src, path, name):
+    items = codeindex.extract(src, path)
+    return next((x for x in items if x["name"] == name), None)
+
+
+def main():
+    print("=" * 68)
+    print("md_cg codeindex 验收 · Phase 0（行序压制修复 + 契约裁决）")
+    print("=" * 68)
+    tmp = tempfile.mkdtemp(prefix="mdcg_codeidx_")
+    try:
+        # ---------------- ① 契约常量 ----------------
+        print()
+        print("【1】契约常量：合成区字段名与 CCG 零重名")
+        _check("索引元条件字段名不在 CCG 六要素内",
+               nodefile.INDEX_META_MARK not in nodefile.CCG_MARKS
+               and not nodefile.is_ccg_mark(nodefile.INDEX_META_MARK),
+               nodefile.INDEX_META_MARK)
+        _check("is_ccg_mark 对六要素逐一为真",
+               all(nodefile.is_ccg_mark(m) for m in nodefile.CCG_MARKS))
+        _check("is_ccg_mark 对元条件与位置为假",
+               not nodefile.is_ccg_mark(nodefile.INDEX_META_MARK)
+               and not nodefile.is_ccg_mark("位置"))
+
+        # ---------------- ② 分区与行序：人工优先 ----------------
+        print()
+        print("【2】render 三分区：源码区置首，人工声明不被压制")
+        it_ann = _item_of(PY_SRC, "demo.py", "first_line")
+        _check("extract 命中带注释的函数", bool(it_ann))
+        r_ann = codeindex.render(it_ann)
+        _check("源码注释逐字保留（不被丢弃）", HUMAN_COND in r_ann)
+        r_lines = r_ann.splitlines()
+        cond_i = r_lines.index(HUMAN_COND)
+        head_i = next(i for i, ln in enumerate(r_lines)
+                      if ln.startswith("# 功能名："))
+        _check("源码区先于合成区（人工优先的确定性序）", cond_i < head_i,
+               "cond@" + str(cond_i) + " head@" + str(head_i))
+        _check("检索侧取到人工条件（行序压制已修）",
+               _ccg_field(r_ann, "生效条件") == "入参 path 为已存在的本地文件",
+               _ccg_field(r_ann, "生效条件"))
+        _check("生效条件行恰一条（合成区不再产出该行）",
+               sum(1 for ln in r_lines
+                   if ln.startswith("# 生效条件：")) == 1)
+        _check("补了注释 → 五要素齐备（complete=True）",
+               nodefile.ccg_completeness(r_ann)["complete"] is True,
+               str(nodefile.ccg_completeness(r_ann)["required_present"]))
+
+        it_bare = _item_of(PY_SRC, "demo.py", "bare")
+        r_bare = codeindex.render(it_bare)
+        _check("未声明生效条件的条目：合成区不冒充该字段",
+               "# 生效条件：" not in r_bare)
+        cpl = nodefile.ccg_completeness(r_bare)
+        missing = [m for m in nodefile.CCG_REQUIRED
+                   if m not in cpl["required_present"]]
+        _check("未声明 → 恰缺生效条件（诚实缺证据，非整体失效）",
+               cpl["complete"] is False and missing == ["生效条件"],
+               str(missing))
+        _check("合成区其余 5 要素仍齐备",
+               all(m in cpl["required_present"] for m in nodefile.CCG_MARKS
+                   if m != "生效条件"), str(cpl["required_present"]))
+
+        # ---------------- ③ 索引元信息区：零重名 + 同源 ----------------
+        print()
+        print("【3】索引元信息区（非 CCG 字段名，与 frontmatter 同源）")
+        meta_head = "# " + nodefile.INDEX_META_MARK + "："
+        meta_line = next((ln for ln in r_lines if ln.startswith(meta_head)), "")
+        _check("索引元条件独立成行", bool(meta_line), meta_line[:60])
+        cs = codeindex.condition_space(it_ann)
+        _check("元条件 = condition_space 四槽同源（require_full=False）",
+               meta_line == meta_head + nodefile.condition_space_text(
+                   cs, require_full=False), meta_line[:90])
+        _check("元条件行不被误判为旧口径单槽冒充",
+               not nodefile.is_legacy_position_condition(meta_line))
+        heads = []
+        for ln in r_bare.splitlines():
+            if not ln.startswith("#"):
+                continue
+            body = ln.lstrip("#").strip()
+            heads.append(body.split("：")[0].split(":")[0].strip())
+        used = sorted({h for h in heads if nodefile.is_ccg_mark(h)})
+        allowed = sorted(m for m in nodefile.CCG_MARKS if m != "生效条件")
+        _check("合成区用到的 CCG 字段名 = 其余五要素（排除生效条件）",
+               used == allowed, str(used))
+        _check("合成区非 CCG 字段名 = 索引元条件 + 位置",
+               sorted(h for h in heads if not nodefile.is_ccg_mark(h))
+               == sorted([nodefile.INDEX_META_MARK, "位置"]), str(heads))
+
+        # ---------------- ④ condition_space 既有契约不回归 ----------------
+        print()
+        print("【4】condition_space（四槽/全时窗）不回归")
+        _check("四槽齐备",
+               set(cs) == set(nodefile.CONDITION_SLOTS_REQUIRED),
+               str(sorted(cs)))
+        _check("时间槽用全时窗哨兵（不把写入时刻伪造成条件）",
+               nodefile.is_full_time_window(cs.get("time_window")),
+               str(cs.get("time_window")))
+        js_it = _item_of(JS_SRC, "sample.js", "ping")
+        weak = codeindex.condition_space(js_it)
+        _check("弱提取在方法槽诚实降级（不冒充编译器）",
+               codeindex.LANG_WEAK in weak["observation_tool"]
+               and codeindex.LANG_COMPILER not in weak["observation_tool"],
+               weak["observation_tool"])
+
+        # ---------------- ⑤ extract / 幂等 / 确定性 ----------------
+        print()
+        print("【5】extract 分派 / 幂等 / node_id / region_hash")
+        _check("Python → AST 精确（precise=True / basis=compiler）",
+               it_ann["precise"] is True and it_ann["basis"] == "compiler")
+        _check("JS → 弱提取（precise=False / basis=other）",
+               js_it["precise"] is False and js_it["basis"] == "other")
+        raised = False
+        try:
+            codeindex.extract("x = 1", "foo.xyz")
+        except ValueError as exc:
+            raised = "无提取器" in str(exc)
+        _check("无提取器后缀显式报错（不静默降级成 Python 解析）", raised)
+        _check("render 幂等（两次逐字节相同）",
+               codeindex.render(it_ann) == r_ann)
+        _check("node_id 稳定（path::name 短哈希，重复索引幂等）",
+               codeindex.node_id(it_ann) == codeindex.node_id(dict(it_ann)))
+        _check("region_hash 为 12 位十六进制（索引/回读共用口径）",
+               len(it_ann["hash"]) == 12
+               and all(c in "0123456789abcdef" for c in it_ann["hash"]),
+               it_ann["hash"])
+
+        # ---------------- ⑥ index_dir 基线护栏（Phase 1 前只建基线） -------
+        print()
+        print("【6】index_dir：确定性排序 + 截断显式上报（基线护栏）")
+        d = os.path.join(tmp, "pkg")
+        os.makedirs(d)
+        for fn, body in (("a.py", PY_SRC), ("b.js", JS_SRC)):
+            with open(os.path.join(d, fn), "w", encoding="utf-8") as f:
+                f.write(body)
+        _i1, _er1, s1 = codeindex.index_dir(d)
+        _i2, _er2, s2 = codeindex.index_dir(d)
+        _check("两次运行条目序逐项一致（walk/文件名确定性排序）",
+               [x["name"] for x in _i1] == [x["name"] for x in _i2],
+               str([x["name"] for x in _i1]))
+        _check("相同输入 stats 一致（幂等）", s1 == s2)
+        _check("未越限 → truncated=False", s1["truncated"] is False)
+        _check("skipped_suffixes 上报（无提取器后缀可见）",
+               isinstance(s1["skipped_suffixes"], list))
+        _i3, _er3, s3 = codeindex.index_dir(d, max_files=1)
+        _check("越限 → truncated=True 且原因非空（显式上报，不静默）",
+               s3["truncated"] is True and bool(s3["truncated_reason"]),
+               str(s3.get("truncated_reason")))
+        _check("越限时仍返回已索引条目（不丢已有产出）",
+               isinstance(_i3, list) and len(_i3) >= 1
+               and len(s3["skip_dirs"]) == len(s1["skip_dirs"]),
+               "items=" + str(len(_i3)))
+        # ---- index-dir-integrity（Phase 1）：截断可复算 + 目录序确定 ----
+        _check("截断计数可复算：hit_files/indexed_items 就位且与条目数一致",
+               s1.get("hit_files", 0) >= 1 and s1.get("indexed_items") == len(_i1),
+               "hit=%s items=%s len=%s" % (s1.get("hit_files"),
+                                           s1.get("indexed_items"), len(_i1)))
+        _check("越限快照同样带 hit_files/indexed_items（与 files 同源）",
+               s3.get("hit_files", 0) >= 1 and s3.get("indexed_items") == len(_i3),
+               "hit=%s items=%s len=%s" % (s3.get("hit_files"),
+                                           s3.get("indexed_items"), len(_i3)))
+        nested = os.path.join(tmp, "nested")
+        for sub in ("z_sub", "a_sub"):
+            os.makedirs(os.path.join(nested, sub))
+            with open(os.path.join(nested, sub, "x.py"), "w", encoding="utf-8") as f:
+                f.write(PY_SRC)
+        _n1, _ne1, sn1 = codeindex.index_dir(nested)
+        _n2, _ne2, sn2 = codeindex.index_dir(nested)
+        _p1 = [x["path"] for x in _n1]
+        _p2 = [x["path"] for x in _n2]
+        _check("嵌套目录：两次运行条目路径序逐项一致（dirnames 已排序）",
+               _p1 == _p2 and len(_p1) > 1, str(_p1)[:120])
+        _check("嵌套目录：a_sub 先于 z_sub（与文件系统返回序无关）",
+               _p1.index(next(p for p in _p1 if p.startswith("a_sub/")))
+               < _p1.index(next(p for p in _p1 if p.startswith("z_sub/"))),
+               str(_p1)[:140])
+        _check("嵌套目录 stats 幂等（同输入两次一致）", sn1 == sn2)
+
+        # ---------------- ⑦ 载体两窗口（裁决 A） ----------------
+        print()
+        print("【7】注释载体两窗口：leading + body（裁决 A · 索引侧收口）")
+        _check("codeindex._body_comments 存在（历史悬空引用由此坐实）",
+               callable(getattr(codeindex, "_body_comments", None))
+               and callable(getattr(codeindex, "_symbol_comments", None)))
+        it2 = _item_of(BODY_SRC, "demo2.py", "with_body")
+        want_cmts = ["# 生效条件：外层声明（leading 窗口）",
+                     "# 生效条件：入参 seq 为可迭代且元素可比较（body 窗口）",
+                     "# 子功能：返回排序副本"]
+        _check("两窗口按物理行序合并（leading 在前、body 在后）",
+               it2["comments"] == want_cmts, repr(it2["comments"])[:200])
+        r2w = codeindex.render(it2)
+        _check("body 窗口的 CCG 注释在正文可见（不再是索引盲区）",
+               "# 生效条件：入参 seq 为可迭代且元素可比较（body 窗口）" in r2w)
+        _check("冲突时靠前者胜出（_ccg_field 取首匹配 = 物理序）",
+               _ccg_field(r2w, "生效条件") == "外层声明（leading 窗口）",
+               _ccg_field(r2w, "生效条件"))
+        _check("补了 body 注释 → 五要素齐备（complete=True）",
+               nodefile.ccg_completeness(r2w)["complete"] is True,
+               str(nodefile.ccg_completeness(r2w)["required_present"]))
+        # 非循环断言：窗口产物**逐字**固定（不依赖 verifier 委托是否成功）
+        # 期望值**写死**：体首语句行号不得臆测（上一版写成 lineno+1 即为反例）
+        _fnode = next(n for n in ast.parse(BODY_SRC).body
+                      if isinstance(n, ast.FunctionDef) and n.name == "with_body")
+        _check("body 窗口产物逐字固定（期望值写死，非自证）",
+               codeindex._body_comments(BODY_SRC.splitlines(), _fnode.lineno,
+                                        _fnode.body[0].lineno) == [
+                   "# 生效条件：入参 seq 为可迭代且元素可比较（body 窗口）",
+                   "# 子功能：返回排序副本"],
+               repr(codeindex._body_comments(
+                   BODY_SRC.splitlines(), _fnode.lineno,
+                   _fnode.body[0].lineno))[:160])
+        it3 = _item_of(BODY_SRC, "demo2.py", "body_trap")
+        _check("体首语句【之后】的注释不入声明头窗口（边界不越界）",
+               it3["comments"] == [] and "实现注释" not in repr(it3["comments"]),
+               repr(it3["comments"])[:120])
+        # verifier 是否已收敛为「委托唯一真源」——等价断言不可静默跳过
+        try:
+            from .whitebox_kb.wisdom import verifier as Vmod
+            vobj = Vmod.Verifier.__new__(Vmod.Verifier)
+            tree = ast.parse(BODY_SRC)
+            fnode = next(n for n in tree.body if isinstance(n, ast.FunctionDef)
+                         and n.name == "with_body")
+            src_lines = BODY_SRC.splitlines()
+            got, _doc = vobj._ccg_block(fnode, src_lines)
+            want = [s.lstrip("#").strip() for s in codeindex._body_comments(
+                src_lines, fnode.lineno, fnode.body[0].lineno)]
+            _check("verifier 已收敛为委托唯一真源（_ci_body_comments 可达）",
+                   Vmod._ci_body_comments() is not None)
+            _check("verifier 窗口与 codeindex._body_comments 逐字等价",
+                   got == want, repr([got, want])[:180])
+            _check("verifier 窗口只收 body 窗口（不误收 leading）",
+                   got == want and all("外层声明" not in x for x in got),
+                   repr(got)[:140])
+        except Exception as exc:  # noqa: BLE001
+            global _skip
+            _skip += 1
+            print("  SKIP verifier 委托等价断言（模块不可导入）：%r" % (exc,))
+
+        print()
+        print("PASS %d / FAIL %d / SKIP %d" % (_ok, len(_bad), _skip))
+        for b in _bad:
+            print("  - " + b)
+        return 1 if _bad else 0
+    except Exception:  # noqa: BLE001
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_comment_gate.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+"""comment_gate 验收（环二入口）。
+
+验收口径：
+1. 唯一真源：阈值取 refine.GATE_MIN_PASS_RATE（本模块不再定义一份）
+2. 候选判据机械：只有「代码节点且正文缺生效条件」入池（有注释的那条不入池）
+3. 工单：确定性抽样（同 seed 同工单）+ 带源码落点（code_ref 坐标 + 落点规则）
+4. 只读纪律：apply 只落留痕，**不改任何节点**（改前改后内容 sha 相同）
+5. 闸门：<0.90 不放行、>=0.90 放行、无批次不放行
+6. 分派：run(action=comment_gate) 走只读工单；comment_gate_verdict 走闸门
+"""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+
+from . import codeindex, comment_gate, refindex, refine
+from .mdcos import MdCGSecure
+from .security import Principal
+
+_ok = 0
+_bad = []
+
+
+def _check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("  ok   %s" % name)
+    else:
+        _bad.append("%s %s" % (name, detail))
+        print("  FAIL %s %s" % (name, detail))
+
+
+ANNOTATED = ('"""样本。"""' + chr(10) + chr(10) + chr(10) +
+             "# 生效条件：入参 x 为整数" + chr(10) +
+             "def with_cond(x):" + chr(10) + "    return x + 1" + chr(10))
+PLAIN = ('"""样本。"""' + chr(10) + chr(10) + chr(10) +
+         "def no_cond(x):" + chr(10) + "    return x + 2" + chr(10))
+
+
+def _mk_graph(root):
+    p = Principal(tenant="default", actor="t_test", role="designer",
+                  can_write=True, can_admin=True)
+    return MdCGSecure(root, principal=p)
+
+
+def main():
+    print("=" * 68)
+    print("md_cg comment_gate 验收（代码符号条件化注释抽样闸门）")
+    print("=" * 68)
+    tmp = tempfile.mkdtemp(prefix="mdcg_comment_gate_")
+    root = os.path.join(tmp, "root")
+    code = os.path.join(tmp, "code")
+    os.makedirs(code)
+    with open(os.path.join(code, "a.py"), "w", encoding="utf-8") as f:
+        f.write(ANNOTATED)
+    with open(os.path.join(code, "b.py"), "w", encoding="utf-8") as f:
+        f.write(PLAIN)
+    cg = _mk_graph(root)
+    items, errors, stats = refindex.index_dir(code, kind="code_ref",
+                                             ledger=refindex.Ledger(cg.root))
+    ids, _sens = refindex.add_items(cg, items, kind="code_ref", root=code)
+    cg.flush()
+    print("索引条目=%d 节点=%d 错误=%d" % (len(items), len(ids), len(errors)))
+
+    _check("阈值唯一真源=refine.GATE_MIN_PASS_RATE",
+           comment_gate.GATE_MIN_PASS_RATE == refine.GATE_MIN_PASS_RATE,
+           str(comment_gate.GATE_MIN_PASS_RATE))
+    by_name = {it["name"]: codeindex.node_id(it) for it in items}
+    cands, cmeta = comment_gate.candidates(cg)
+    # 注：模块级条目同样缺生效条件 → 也是合法候选；故按符号名判定而非计条数
+    _check("候选判据机械：缺生效条件者入池、已注释者不入池",
+           by_name["no_cond"] in cands and by_name["with_cond"] not in cands,
+           "cands=%s no=%s with=%s" % (len(cands), by_name["no_cond"],
+                                       by_name["with_cond"]))
+    _check("候选池状态如实上报（pool/candidates 与实取一致）",
+           cmeta.get("pool", 0) == len(items) and cmeta.get("candidates") == len(cands),
+           str(cmeta))
+    p1 = comment_gate.plan(cg, n=20, seed="cmt-1")
+    p2 = comment_gate.plan(cg, n=20, seed="cmt-1")
+    _check("同 seed 工单确定性（sample 与 sha 一致）",
+           p1["sample"] == p2["sample"] and p1["sample_sha"] == p2["sample_sha"],
+           str(p1["sample"]))
+    _check("工单只读（dry_run=True，不改节点）", p1["dry_run"] is True and p1["readonly"] is True)
+    it = next((x for x in p1["items"]
+               if (x.get("code_ref") or {}).get("name") == "no_cond"), {})
+    ref = (it.get("code_ref") or {})
+    _check("工单带源码落点坐标（path/lineno/end）",
+           ref.get("path") == "b.py" and ref.get("lineno") and ref.get("end"),
+           str(ref))
+    _check("工单带落点规则（两窗口，契约 §三.2）",
+           "leading" in str(it.get("landing_rule") or "")
+           and "body" in str(it.get("landing_rule") or ""),
+           str(it.get("landing_rule"))[:80])
+    _check("工单缺项口径=缺生效条件",
+           it.get("ccg_missing") == ["生效条件"], str(it.get("ccg_missing")))
+    _check("SPEC 四项核对清单与 0.90 闸门口径在案",
+           len(comment_gate.SPEC["review_items"]) == 4
+           and comment_gate.SPEC["gate"]["min_pass_rate"] == 0.90)
+
+    nid = by_name["no_cond"]
+    before = (cg.get(nid) or {}).get("content") or ""
+    r = comment_gate.apply(cg, n=20, seed="cmt-1", verdicts=["忠实"],
+                           actor="t_test", note="自测")
+    after = (cg.get(nid) or {}).get("content") or ""
+    _check("apply 落留痕且通过率=1.0", r["ok"] and r["gate"]["pass_rate"] == 1.0,
+           str(r.get("gate")))
+    _check("apply 之后放行（>=0.90）", r["gate"]["expand_allowed"] is True)
+    _check("apply 不改节点（内容逐字相同）", before == after and before != "")
+    _check("留痕文件已落盘", os.path.exists(os.path.join(root, comment_gate.LOG_NAME)))
+    g1 = comment_gate.gate(cg)
+    _check("gate 复算通过率=1.0 且放行", g1["pass_rate"] == 1.0 and g1["expand_allowed"] is True,
+           str(g1))
+    r2 = comment_gate.apply(cg, n=20, seed="cmt-1", verdicts=[False, False, False],
+                            actor="t_test", batch="low")
+    _check("低通过率（0/3）不放行且给原因",
+           r2["gate"]["expand_allowed"] is False and "rate" in str(r2["gate"]["reason"]),
+           str(r2["gate"]))
+    g2 = comment_gate.gate(cg, batch="low")
+    _check("gate(batch=low) 复算为不放行", g2["expand_allowed"] is False, str(g2))
+    g3 = comment_gate.gate(cg, batch="不存在")
+    _check("无批次 → no_batch 不放行", g3["expand_allowed"] is False
+           and g3["reason"] == "no_batch", str(g3))
+    run1 = comment_gate.run(cg, "comment_gate", n=5)
+    _check("run(comment_gate) 走只读工单", run1["dry_run"] is True
+           and run1["action"] == "comment_gate")
+    from . import mcp_server
+    d1 = mcp_server._maintain_call(cg, {"op": "maintain", "action": "comment_gate", "n": 5})
+    _check("经 maintain 分派可达（op 面接线）",
+           d1.get("action") == "comment_gate" and d1.get("dry_run") is True
+           and d1.get("readonly") is True, str(d1.get("action")))
+    d2 = mcp_server._maintain_call(cg, {"action": "comment_gate_gate"})
+    _check("经 maintain 分派可取闸门（comment_gate_gate）",
+           "expand_allowed" in d2, str(sorted(d2.keys()))[:90])
+    from .mdcos import MdCGSecure as _S
+    from .security import AccessDenied as _AD
+    cg_low = _S(root, principal=Principal(tenant="default", actor="t_low",
+                                          role="record", can_write=True,
+                                          can_admin=False))
+    denied = False
+    try:
+        comment_gate.apply(cg_low, n=5, seed="cmt-1", verdicts=["忠实"])
+    except _AD:
+        denied = True
+    except Exception:
+        denied = False
+    _check("apply 需管理权（闸门自持在模块内，分发面不漏挂）", denied)
+    d3 = mcp_server._maintain_call(cg, {"action": "comment_gate_verdict"})
+    _check("经 maintain 分派可取闸门（别名 comment_gate_verdict）",
+           "expand_allowed" in d3, str(sorted(d3.keys()))[:90])
+    run2 = comment_gate.run(cg, "comment_gate_verdict")
+    _check("run(comment_gate_verdict) 走闸门", "expand_allowed" in run2)
+    raised = False
+    try:
+        comment_gate.run(cg, "nope")
+    except ValueError:
+        raised = True
+    _check("未知 action fail-closed", raised)
+    # ---- 源级候选枚举（绕开重索引代价；不依赖认知图）----
+    sp1 = comment_gate.plan_sources(code, n=20, seed="src-1")
+    _check("源级枚举可见未注释符号（不依赖认知图）",
+           sp1["examined"] >= 1 and sp1["candidates"] >= 1 and sp1["sampled"] >= 1,
+           "examined=%s cands=%s sampled=%s" % (sp1["examined"], sp1["candidates"],
+                                                sp1["sampled"]))
+    src_names = [it["name"] for it in sp1["items"]]
+    _check("源级工单排除已注释符号（no_cond 在、with_cond 不在）",
+           "no_cond" in src_names and "with_cond" not in src_names, str(src_names))
+    _check("源级工单带源码坐标（path/lineno/end）",
+           all((it["code_ref"].get("path") and it["code_ref"].get("lineno")
+                and it["code_ref"].get("end")) for it in sp1["items"]))
+    _check("源级抽样确定性（同 seed 同工单）",
+           comment_gate.plan_sources(code, n=20, seed="src-1")["items"] == sp1["items"])
+    _check("源级工单只读且声明模式",
+           sp1["dry_run"] is True and sp1["mode"] == "source_level")
+    _check("源级枚举经 run 分派可达",
+           comment_gate.run(cg, "comment_gate_sources", n=5)["mode"] == "source_level")
+    print()
+    print("PASS %d / FAIL %d" % (_ok, len(_bad)))
+    for b in _bad:
+        print("  - " + b)
+    return 1 if _bad else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_cond_compose_anchors.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+"""cond_compose 行为锚点（在途 WIP 并集解）探针：脚本式，exit code 定成败。
+
+背景：2026-09-19 收口两线时，工作区残留一处 stash-pop 冲突（md_cg/cond_compose.py）：
+  ours(HEAD)=compose 的「生效条件」注释；theirs(stash)=新增 behavior_anchors()。
+两侧新增互不重叠 → 并集解（本分支）。该函数当前**全库无调用**，故本探针只把
+「冲突解正确 + 函数行为与文档一致」钉住，配线与否由使用者裁决。
+
+用法：python -X utf8 -m md_cg.test_cond_compose_anchors
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import cond_compose as cc  # noqa: E402
+
+passed = 0
+failed = 0
+
+
+def check(name, cond, detail=""):
+    global passed, failed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        failed += 1
+        print("  [FAIL] " + name + "  " + detail)
+
+
+def main():
+    # 1) 并集完整性：冲突两侧的东西都在，且文件里没有冲突标记
+    src = open(cc.__file__, encoding="utf-8").read()
+    check("并集：compose 与 behavior_anchors 同时在",
+          hasattr(cc, "compose") and hasattr(cc, "behavior_anchors"))
+    check("并集：无冲突标记", "<<<<<<<" not in src and ">>>>>>>" not in src)
+    check("并集：compose 的生效条件注释未丢", "调用 compose 时必须提供 rec" in src)
+
+    # 2) behavior_anchors 行为（按实现口径逐条断言）
+    rec = {"name": "f", "doc_head": "  计算 a 的摘要  ",
+           "guards": [{"early": True, "cond": "a"},
+                      {"early": False, "cond": "a"},
+                      {"early": True, "cond": "a and b"}],
+           "returns": ["a.strip()", "LIMIT + 1", "local_only"]}
+    doc, guards, rets = cc.behavior_anchors(rec, {"a"})
+    check("doc 取 doc_head 并去空白", doc == "计算 a 的摘要", repr(doc))
+    # explained_guards 的两道筛：early 必须为真；cond 内标识符必须全在 allowed∪BUILTINS∪self/cls
+    # （故 "a" 入选、"a and b" 因 b 不在 allowed 被剔、"a is None" 会因 is 不是 builtins 被剔）
+    check("guards 只留 early 且标识符合规者（走 explained_guards）",
+          [g.get("cond") for g in guards] == ["a"], str(guards))
+    check("returns 只留含 allowed 标识符者", rets == ["a.strip()"], str(rets))
+    _d2, _g2, rets2 = cc.behavior_anchors(rec, {"a", "LIMIT"})
+    check("allowed 含模块常量时其返回表达式入选（调用方负责传 入参∪常量）",
+          rets2 == ["a.strip()", "LIMIT + 1"], str(rets2))
+
+    # 3) 「只有形参清单、无任何行为锚点」→ 三元组全空（调用方据此可判 BLINDSPOT）
+    empty = cc.behavior_anchors({"name": "g", "guards": [], "returns": []}, {"x"})
+    check("无形为锚点时返回空三元组", empty == ("", [], []), str(empty))
+    check("缺失 doc_head/returns 键不抛异常",
+          cc.behavior_anchors({"name": "h"}, {"x"}) == ("", [], []))
+
+    # 4) 未回归：compose 仍能产出以「。」结尾的条件串
+    s = cc.compose({"name": "f", "required": ["a"], "optional": [], "externals": [],
+                    "guards": [], "returns": ["a.strip()"], "doc_head": "摘要"})
+    check("compose 未回归（非空且以「。」结尾）",
+          isinstance(s, str) and s.endswith("。") and len(s) > 4, s[:60])
+
+    print("\ntest_cond_compose_anchors: %d 通过 / %d 失败" % (passed, failed))
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())