@furongjun1999/dsh-memory 0.5.0 → 0.5.1

package/md_cg/test_p39_verify_flow.py

@@ -43,63 +43,103 @@ def main():
 
         # 派发原语：spec 落验证实例 jobs 目录（非阻塞）
         vjobs = os.path.join(tmp, "vjobs")
-        rep = dispatch_verify_job(vjobs, iter_id, subject_fingerprint="fp_main")
+        rep = dispatch_verify_job(vjobs, iter_id, subject_fingerprint="e" * 64)
         check("1b 派发写 spec+status 且非阻塞返回",
               rep.get("ok") is True
               and os.path.isfile(os.path.join(rep["dispatched"], "spec.json")))
 
         # runner 冒烟：env 注入轻量探针命令 + 身份/冻结/subject_fp
-        env = dict(os.environ)
-        env.update({
-            "HIVE_INSTANCE": "verifier", "HIVE_ROLE": "verifier",
-            "SUBJECT_FP": "fp_main", "ITER_ID": iter_id,
-        })
-        # freeze 的 digest 基于真判据面——runner 内 A3 用同一 digest，须一致：
-        # runner 在本 repo 内跑，判据面未变 → A3 成立
-        r = subprocess.run([sys.executable, os.path.join(repo, "hive",
-                                                         "verify_runner.py"),
-                            iter_id, "--smoke"], env=env, capture_output=True,
-                           text=True, encoding="utf-8", errors="replace",
-                           cwd=tmp)  # cwd≠repo：验证 runner 以自身位置锚定
-        out = json.loads(r.stdout)
-        check("2a runner 产出 verdict（ok 结构）",
-              out.get("ok") is True and "valid" in out, r.stdout[:160])
-        vp = os.path.join(repo, "hive", "interop", iter_id, "verdict.json")
-        v = json.load(open(vp, encoding="utf-8"))
-        check("2b 三断言全过 → valid=true 且 verdict=pass",
-              v.get("valid") is True and v.get("verdict") == "pass",
-              str(v.get("details"))[:160])
-        check("2c 套件计数经宽松解析累加（3+4=7）",
-              v.get("passed") == 7, f"passed={v.get('passed')}")
+        # hive/ 是**源码树子系统**（出货包 files 不含它）→ 依赖 runner 的 2a~3c
+        # 如实 SKIP，并改为钉住缺件时的**新契约**（2026-09-24 修复）：
+        # 派发必须透出 warning，冻结凭证必须记录缺失判据面组。
+        hive_runner = os.path.join(repo, "hive", "verify_runner.py")
+        if not os.path.isfile(hive_runner):
+            check("2* 缺 hive runner 时派发透出 warning（不假装能跑）",
+                  bool(rep.get("warning")), str(rep.get("warning"))[:160])
+            _fr = json.load(open(os.path.join(repo, "hive", "interop", iter_id,
+                                              "frozen.json"), encoding="utf-8"))
+            check("4* 冻结凭证记录缺失判据面组（不静默少算）",
+                  isinstance(_fr.get("missing_patterns"), list)
+                  and bool(_fr["missing_patterns"]),
+                  str(_fr.get("missing_patterns")))
+            print("  SKIP  2a~3c（需要 hive/verify_runner.py，源码树子系统）")
+        else:
+            env = dict(os.environ)
+            env.update({
+                "HIVE_INSTANCE": "verifier", "HIVE_ROLE": "verifier",
+                "SUBJECT_FP": "e" * 64, "ITER_ID": iter_id,
+            })
+            # freeze 的 digest 基于真判据面——runner 内 A3 用同一 digest，须一致：
+            # runner 在本 repo 内跑，判据面未变 → A3 成立
+            r = subprocess.run([sys.executable, hive_runner,
+                                iter_id, "--smoke"], env=env, capture_output=True,
+                               text=True, encoding="utf-8", errors="replace",
+                               cwd=tmp)  # cwd≠repo：验证 runner 以自身位置锚定
+            out = json.loads(r.stdout)
+            check("2a runner 产出 verdict（ok 结构）",
+                  out.get("ok") is True and "valid" in out, r.stdout[:160])
+            vp = os.path.join(repo, "hive", "interop", iter_id, "verdict.json")
+            v = json.load(open(vp, encoding="utf-8"))
+            check("2b 三断言全过 → valid=true 且 verdict=pass",
+                  v.get("valid") is True and v.get("verdict") == "pass",
+                  str(v.get("details"))[:160])
+            check("2c 套件计数经宽松解析累加（3+4=7）",
+                  v.get("passed") == 7, f"passed={v.get('passed')}")
 
-        # 角色守卫：非 verifier 拒跑
-        env2 = dict(env)
-        env2["HIVE_ROLE"] = "primary"
-        r2 = subprocess.run([sys.executable, os.path.join(repo, "hive",
-                                                          "verify_runner.py"),
-                             iter_id], env=env2, capture_output=True,
-                            text=True, encoding="utf-8", errors="replace")
-        check("2d 角色守卫：primary 拒跑互验（§7.1）",
-              r2.returncode == 3 and "角色守卫" in r2.stdout,
-              f"rc={r2.returncode} out={r2.stdout[:120]} err={r2.stderr[:120]}")
+            # 角色守卫：非 verifier 拒跑
+            env2 = dict(env)
+            env2["HIVE_ROLE"] = "primary"
+            r2 = subprocess.run([sys.executable, hive_runner, iter_id],
+                                env=env2, capture_output=True,
+                                text=True, encoding="utf-8", errors="replace")
+            check("2d 角色守卫：primary 拒跑互验（§7.1）",
+                  r2.returncode == 3 and "角色守卫" in r2.stdout,
+                  f"rc={r2.returncode} out={r2.stdout[:120]} err={r2.stderr[:120]}")
 
-        # 脱敏纵深 + 入库（不 commit）
-        bad = dict(v)
-        bad["details"] = [{"leak": r"E:\private\node.log"}]
-        try:
-            sanity_check_verdict(bad)
-            check("3a 落盘前脱敏纵深拦截", False, "违规未拦")
-        except Exception:
-            check("3a 落盘前脱敏纵深拦截", True)
-        w = write_verdict_to_repo(v, repo=repo, do_commit=False)
-        check("3b verdict 入受版本控制目录（hive/interop/<iter>/）",
-              w.get("ok") is True
-              and "hive" in w["path"] and "interop" in w["path"], w.get("path"))
-        try:
-            write_verdict_to_repo({**v, "iter_id": "../evil"}, repo=repo)
-            check("3c iter_id 路径注入拒绝", False, "未抛")
-        except ValueError:
-            check("3c iter_id 路径注入拒绝", True)
+            # iter_id 白名单（v2 N5/N11，2026-09-25）：CLI 直跑 + 自设
+            # HIVE_ROLE=verifier 骗过角色守卫（它只查 env 值）时，穿越形态
+            # 必须拒跑且不触盘——fail-closed 在任何路径拼接之前，与姊妹入口
+            # write_verdict_to_repo（interop.py:316）同模板统一防御。
+            probe = f"evil_probe_n5_{os.getpid()}"
+            evil_rel = os.path.join("..", "..", "..", probe)
+            # REPO/hive/interop/<evil_rel>/frozen.json 三级上跳 → REPO 父目录
+            tgt = os.path.join(os.path.dirname(repo), probe)
+            r3 = subprocess.run([sys.executable, hive_runner, evil_rel,
+                                 "--smoke"], env=env, capture_output=True,
+                                text=True, encoding="utf-8", errors="replace")
+            check("2e iter_id 穿越形态拒跑且不触盘（N5/N11）",
+                  r3.returncode == 2 and "iter_id 非法" in r3.stdout
+                  and not os.path.exists(tgt),
+                  f"rc={r3.returncode} out={r3.stdout[:120]} "
+                  f"tgt_exists={os.path.exists(tgt)}")
+            evil_abs = os.path.join(tempfile.gettempdir(),
+                                    f"evil_abs_n5_{os.getpid()}")
+            r4 = subprocess.run([sys.executable, hive_runner, evil_abs,
+                                 "--smoke"], env=env, capture_output=True,
+                                text=True, encoding="utf-8", errors="replace")
+            check("2f iter_id 绝对路径注入拒跑且不触盘",
+                  r4.returncode == 2 and "iter_id 非法" in r4.stdout
+                  and not os.path.exists(evil_abs),
+                  f"rc={r4.returncode} out={r4.stdout[:120]} "
+                  f"abs_exists={os.path.exists(evil_abs)}")
+
+            # 脱敏纵深 + 入库（不 commit）
+            bad = dict(v)
+            bad["details"] = [{"leak": r"E:\private\node.log"}]
+            try:
+                sanity_check_verdict(bad)
+                check("3a 落盘前脱敏纵深拦截", False, "违规未拦")
+            except Exception:
+                check("3a 落盘前脱敏纵深拦截", True)
+            w = write_verdict_to_repo(v, repo=repo, do_commit=False)
+            check("3b verdict 入受版本控制目录（hive/interop/<iter>/）",
+                  w.get("ok") is True
+                  and "hive" in w["path"] and "interop" in w["path"], w.get("path"))
+            try:
+                write_verdict_to_repo({**v, "iter_id": "../evil"}, repo=repo)
+                check("3c iter_id 路径注入拒绝", False, "未抛")
+            except ValueError:
+                check("3c iter_id 路径注入拒绝", True)
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
         shutil.rmtree(os.path.join(repo, "hive", "interop", iter_id),

package/md_cg/test_p47_session_view.py

@@ -84,9 +84,12 @@ def _restore(old):
             os.environ[k] = v
 
 
-def _p(actor, session):
-    return Principal(actor=actor, clearance=DEFAULT_SENSITIVITY,
-                     can_write=True, can_admin=True, role="designer",
+def _p(actor, session, clearance=None, can_admin=True):
+    # 会话隔离用例（D/E 段）需非 admin 身份（admin 对绑定档豁免）；
+    # 其余段维持原口径（designer + 默认密级 + admin）。
+    return Principal(actor=actor,
+                     clearance=clearance or DEFAULT_SENSITIVITY,
+                     can_write=True, can_admin=can_admin, role="designer",
                      session=session, harness="test-harness")
 
 
@@ -101,10 +104,16 @@ def _ids(tl):
 
 def _mk(root):
     """两个会话各写一条（带 temporal → timeline 可见）。"""
-    cga = MdCGSecure(root, principal=_p("alice", "sess_A"))
+    cga = MdCGSecure(root, principal=_p("alice", "sess_A",
+                                        clearance="private", can_admin=False))
     cga.add("n_a", "阿尔法 属于 会话A 的知识点", layer="knowledge", temporal=1000.0)
-    cgb = MdCGSecure(root, principal=_p("bob", "sess_B"))
+    cga.add("n_pa", "贝塔 会话A 的私有知识点", layer="knowledge",
+            sensitivity="private")
+    cgb = MdCGSecure(root, principal=_p("bob", "sess_B",
+                                        clearance="private", can_admin=False))
     cgb.add("n_b", "阿尔法 属于 会话B 的知识点", layer="knowledge", temporal=2000.0)
+    cgb.add("n_pb", "贝塔 会话B 的私有知识点", layer="knowledge",
+            sensitivity="private")
     return cgb
 
 
@@ -119,7 +128,8 @@ def test_ab(cgb):
 
     print("\n[B] timeline 会话视图三态")
     all_tl = stg.timeline(cgb, limit=100)
-    check("B1 缺省读遍所有会话", all_tl["count"] == 2, all_tl["count"])
+    check("B1 缺省读遍所有会话（可见面=共享档+本会话绑定档）",
+          all_tl["count"] == 3, all_tl["count"])
     check("B2 缺省返回体 session=None（跨会话视图）",
           all_tl["session"] is None, all_tl["session"])
     check("B3 items 逐条回带会话归属（看遍≠丢归属）",
@@ -135,11 +145,13 @@ def test_ab(cgb):
           and cross_tl["session"] is None, cross_tl["session"])
 
     a_tl = stg.timeline(cgb, limit=100, session="sess_A")
-    check("B6 具体值只取本会话", _ids(a_tl) == ["n_a"], _ids(a_tl))
+    check("B6 具体值只取本会话（他人 private 经授权面剔除）",
+          _ids(a_tl) == ["n_a"], _ids(a_tl))
     check("B7 返回体 session=生效值（非跨会话）",
           a_tl["session"] == "sess_A", a_tl["session"])
     b_tl = stg.timeline(cgb, limit=100, session="sess_B")
-    check("B8 另一会话只取它的节点", _ids(b_tl) == ["n_b"], _ids(b_tl))
+    check("B8 另一会话只取它的节点（含其绑定档）",
+          set(_ids(b_tl)) == {"n_b", "n_pb"}, _ids(b_tl))
 
     z_tl = stg.timeline(cgb, limit=100, session="sess_Z")
     check("B9 未知会话为空（不因缺省而放行）", z_tl["count"] == 0, z_tl["count"])
@@ -154,15 +166,27 @@ def test_c(cgb):
     a_tl = stg.timeline(cgb, limit=100, session="sess_A")
     check("C3 rebuild 后按会话过滤不静默全空", _ids(a_tl) == ["n_a"], _ids(a_tl))
     all_tl = stg.timeline(cgb, limit=100)
-    check("C4 rebuild 后跨会话仍读全", all_tl["count"] == 2, all_tl["count"])
+    check("C4 rebuild 后跨会话仍读全（可见面 3）",
+          all_tl["count"] == 3, all_tl["count"])
 
 
 def test_d(cgb):
-    print("\n[D] 候选层会话过滤（search / recall）")
+    print("\n[D] 候选层会话过滤（search / recall）——issue #35 定稿：分档判定")
+    # 视角=bob（sess_B）。共享档（internal 默认）跨会话可见：传不传 session
+    # 都能看到 alice 的共享节点；绑定档（private）按身份（principal.session）
+    # 判定，查询参数自报的会话不构成豁免。
     res, _ = cgb.search("阿尔法", session="sess_A", judge=False, record=False)
     ids = {_row(r).get("id") for r in res}
-    check("D1 search 本会话仅命中本会话节点",
-          "n_a" in ids and "n_b" not in ids, ids)
+    check("D1a 共享档（internal 默认）跨会话可见",
+          {"n_a", "n_b"} <= ids, ids)
+    res_p, _ = cgb.search("贝塔", judge=False, record=False)
+    pids = {_row(r).get("id") for r in res_p}
+    check("D1b 绑定档（private）仅归属会话（bob 只见自己的）",
+          "n_pb" in pids and "n_pa" not in pids, pids)
+    res_h, _ = cgb.search("贝塔", session="sess_A", judge=False, record=False)
+    hids = {_row(r).get("id") for r in res_h}
+    check("D1c 查询参数自报他人会话不越权（仍只见自己的 private）",
+          "n_pb" in hids and "n_pa" not in hids, hids)
 
     res_x, _ = cgb.search("阿尔法", session="*", judge=False, record=False)
     ids_x = {_row(r).get("id") for r in res_x}
@@ -174,8 +198,12 @@ def test_d(cgb):
 
     pack = cgb.recall("阿尔法", session="sess_A")
     hid = {_row(h).get("id") for h in (pack.get("pack") or [])}
-    check("D4 recall（RRF 主链）本会话仅命中本会话",
-          "n_a" in hid and "n_b" not in hid, hid)
+    check("D4a recall（RRF 主链）共享档跨会话",
+          {"n_a", "n_b"} <= hid, hid)
+    pack_p = cgb.recall("贝塔")
+    hid_p = {_row(h).get("id") for h in (pack_p.get("pack") or [])}
+    check("D4b recall 绑定档仅归属会话",
+          "n_pb" in hid_p and "n_pa" not in hid_p, hid_p)
 
     pack_x = cgb.recall("阿尔法", session="*")
     hid_x = {_row(h).get("id") for h in (pack_x.get("pack") or [])}
@@ -183,24 +211,29 @@ def test_d(cgb):
 
 
 def test_e(cgb):
-    print("\n[E] 图扩展二次过滤（跨会话串台守卫）")
-    # 图扩散会绕过 _candidates：这里直接把父类 RRF 结果替换成「两个会话各一条」，
-    # 验证 MdCGSecure.search_rrf 的二次过滤能按会话把别的会话节点剔掉。
+    print("\n[E] 图扩展二次过滤（跨会话串台守卫）——分档口径")
+    # 图扩散会绕过 _candidates：直接把父类 RRF 结果替换成「两共享 + 两绑定」，
+    # 验证 MdCGSecure.search_rrf 的二次过滤按档判定——视角 bob：共享档
+    # （n_a/n_b）互可见，绑定档仅自己的 n_pb 能回来；session 参数三态
+    # （他人会话 / "*" / 缺省）不影响绑定档结果（身份不可自报）。
     crafted = [({"id": "n_a"}, 1.0, None, None),
-               ({"id": "n_b"}, 0.9, None, None)]
+               ({"id": "n_b"}, 0.9, None, None),
+               ({"id": "n_pa"}, 0.8, None, None),
+               ({"id": "n_pb"}, 0.7, None, None)]
     orig = MdCGOS.search_rrf
     MdCGOS.search_rrf = lambda self, *a, **kw: (list(crafted), {"tier": "RRF"})
     try:
         kept, _ = cgb.search_rrf("q", session="sess_A")
         ids = [r[0]["id"] for r in kept]
-        check("E1 别的会话节点不得顺边回来", ids == ["n_a"], ids)
+        check("E1 绑定档按身份：他人 private 不得顺边回来（共享档保留）",
+              {"n_a", "n_b", "n_pb"} <= set(ids) and "n_pa" not in ids, ids)
         kept_x, _ = cgb.search_rrf("q", session="*")
-        check("E2 \"*\" 跨会话两条都在",
-              {r[0]["id"] for r in kept_x} == {"n_a", "n_b"},
+        check("E2 \"*\" 同口径（绑定档不受查询参数影响）",
+              {r[0]["id"] for r in kept_x} == {"n_a", "n_b", "n_pb"},
               [r[0]["id"] for r in kept_x])
         kept_all, _ = cgb.search_rrf("q")
-        check("E3 缺省不过滤（兼容）",
-              {r[0]["id"] for r in kept_all} == {"n_a", "n_b"},
+        check("E3 缺省同口径（兼容）",
+              {r[0]["id"] for r in kept_all} == {"n_a", "n_b", "n_pb"},
               [r[0]["id"] for r in kept_all])
     finally:
         MdCGOS.search_rrf = orig
@@ -251,10 +284,12 @@ def test_g(cgb):
 
     cross = ms.call_tool(cgb, "stg",
                          {"op": "timeline", "limit": 100, "session": "*"})
-    check("G4 MCP 面 \"*\" 跨会话读全", cross.get("count") == 2, cross.get("count"))
+    check("G4 MCP 面 \"*\" 跨会话读全（可见面 3）",
+          cross.get("count") == 3, cross.get("count"))
 
     default = ms.call_tool(cgb, "stg", {"op": "timeline", "limit": 100})
-    check("G5 缺省读全（兼容旧调用）", default.get("count") == 2, default.get("count"))
+    check("G5 缺省读全（兼容旧调用，可见面 3）",
+          default.get("count") == 3, default.get("count"))
 
 
 def main():

package/md_cg/test_propose_tail_index.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""propose 尾部增量对账守卫（issue：propose 每条全量重读 inbox+decisions）。
+
+缺陷形态（缺陷报告实测）：propose 每条在 strict 排它锁内
+read_jsonl(inbox_log) + read_jsonl(decisions_log) 全量逐条 json.loads
+（O(M+D)/条，批量累计 O(M²)），存量无 payload_hash 还逐条现算 sha1。
+万条存量单条 ~26ms、批量 O(M²) 分钟级。
+
+本守卫断言（调用计数/复杂度形态，非时间阈值）：
+  T1 二次 propose 零全量读：同实例第 2 次 propose（无外部写）期间
+     mdcos.read_jsonl 对 inbox/decisions 的调用数为 0（旧代码每条各 1 次
+     全量 → 红）；
+  T2 批量 O(M)：500 条连续 propose 全程，首条装载后 read_jsonl 调用数为 0
+     （旧代码 2×499 次 → 红）；
+  T3 增量不漏账（跨进程 append 可见）：外部 append 同内容提案（他进程形态）
+     → 本实例 propose 同内容 dedup 命中新 pid；
+  T4 已裁决优先语义保持：外部裁决（accepted）后 propose 同内容 →
+     返回已裁决 pid + status；
+  T5 旧格式兼容：无 payload_hash 存量行 → 同内容 propose 命中（装载期
+     现算一次，不每条重算）；
+  T6 幂等保形：同内容两次 propose 返回同 pid、不重复入队；
+  T7 决策增量可见：外部 append decisions 后 _closed_pids 即含该 pid。
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import md_cg.mdcos as mdcos_mod           # noqa: E402
+from md_cg.fsutil import append_jsonl     # noqa: E402
+from md_cg.mdcos import MdCGOS, _sig      # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def count_full_reads(fn):
+    """打桩 mdcos.read_jsonl 计数（propose/_pid_status 的全量读入口）。"""
+    n = 0
+    real = mdcos_mod.read_jsonl
+
+    def _spy(path, *a, **kw):
+        nonlocal n
+        n += 1
+        return real(path, *a, **kw)
+
+    mdcos_mod.read_jsonl = _spy
+    try:
+        return fn(), n
+    finally:
+        mdcos_mod.read_jsonl = real
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_prop_guard_")
+    try:
+        cg = MdCGOS(root)
+        # T1 二次 propose 零全量读（预热完成首装——inbox 文件由首条 propose
+        # 创建，创建后第一次访问做一次全量装载属预期，装载后稳态零全量读）
+        print("== T1 稳态 propose 零全量读 ==")
+        cg.propose("t1w1", "T1 预热 甲")     # 创建 inbox + 装载（不计数）
+        cg.propose("t1w2", "T1 预热 乙")     # 装载水位已建立（不计数）
+        _, n1 = count_full_reads(lambda: cg.propose("t1", "T1 内容 甲"))
+        print(f"  (稳态首次计数窗 full_reads={n1})")
+        _, n2 = count_full_reads(lambda: cg.propose("t1b", "T1 内容 乙"))
+        check("T1a 稳态 propose 全量 read_jsonl 调用 == 0（旧默认 2 次/条）",
+              n1 == 0 and n2 == 0, f"full_reads={n1},{n2}")
+
+        # T2 批量 O(M)：500 条连续 propose，装载完成后全量读为 0
+        print("== T2 批量 500 条 O(M) ==")
+        cg2_root = tempfile.mkdtemp(prefix="mdcg_prop_guard2_")
+        cg2 = MdCGOS(cg2_root)
+        try:
+            cg2.propose("warm1", "预热 占位一")   # 创建 inbox + 装载（不计）
+            cg2.propose("warm2", "预热 占位二")   # 水位建立（不计）
+            _, nb = count_full_reads(lambda: [
+                cg2.propose("b%03d" % i, "批量守卫 %d 各异 %d" % (i, i * 3))
+                for i in range(500)])
+            check("T2a 500 条批量 propose 全量 read_jsonl 调用 == 0"
+                  "（旧代码 2×499=998 次，O(M²) 解析）", nb == 0,
+                  f"full_reads={nb}")
+        finally:
+            shutil.rmtree(cg2_root, ignore_errors=True)
+
+        # T3 增量不漏账：外部（他进程形态）append 同内容提案
+        print("== T3 跨进程 append 可见（增量不漏账）==")
+        content = "T3 同内容 蜂群调度"
+        pid_ext = "prop_ext_abc123"
+        append_jsonl(cg.inbox_log,
+                     {"t": 1.0, "pid": pid_ext, "id": "ext_n",
+                      "content": content, "layer": "knowledge",
+                      "tags": [], "condition_space": {}, "verify": {},
+                      "payload_hash": _sig(content), "actor": "ext"})
+        r3 = cg.propose("t3", content, info=True)
+        check("T3a 外部 append 后同内容 dedup 命中新 pid",
+              r3["dedup"] and r3["pid"] == pid_ext, f"r={r3}")
+
+        # T4 已裁决优先：外部裁决 accepted → propose 返回已裁决 pid
+        print("== T4 已裁决优先 ==")
+        append_jsonl(cg.decisions_log,
+                     {"t": 2.0, "pid": pid_ext, "decision": "accept",
+                      "status": "accepted", "round": 1, "actor": "ext"})
+        r4 = cg.propose("t4", content, info=True)
+        check("T4a 外部裁决后同内容返回已裁决 pid（accepted 优先）",
+              r4["dedup"] and r4["pid"] == pid_ext
+              and r4["dup_status"] == "accepted", f"r={r4}")
+        check("T4b 外部裁决进入 _closed_pids（增量可见）",
+              pid_ext in cg._closed_pids())
+
+        # T5 旧格式兼容：无 payload_hash 存量行
+        print("== T5 旧格式（无 payload_hash）==")
+        legacy = "T5 旧格式内容 星云编译"
+        append_jsonl(cg.inbox_log,
+                     {"t": 3.0, "pid": "prop_legacy_001", "id": "lg_n",
+                      "content": legacy, "layer": "knowledge",
+                      "tags": [], "verify": {}, "actor": "old"})  # 无 hash
+        r5 = cg.propose("t5", legacy, info=True)
+        check("T5a 旧格式行同内容命中（装载期现算，兼容旧账）",
+              r5["dedup"] and r5["pid"] == "prop_legacy_001", f"r={r5}")
+        _, n5 = count_full_reads(lambda: cg.propose("t5b", legacy, info=True))
+        check("T5b 旧格式行不触发每条重算全量读（==0）", n5 == 0,
+              f"full_reads={n5}")
+
+        # T6 幂等保形：同内容两次 propose 同 pid
+        print("== T6 幂等保形 ==")
+        p_a = cg.propose("t6", "T6 幂等内容")
+        p_b = cg.propose("t6r", "T6 幂等内容")
+        check("T6a 同内容两次 propose 返回同 pid（不重复入队）",
+              p_a == p_b and p_a, f"{p_a} vs {p_b}")
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())