@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/docs/experiments/md-cg-gate-probe/run_l4b_rollback.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""L4b：演化的可回滚性（U 维「可回滚」判据）。
+
+首次测试失败根因：evolution_record 未记录 before 状态 → rollback 报「before 缺失」。
+本次显式传 before/after，验证回滚链路是否真的能恢复。
+"""
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+sys.path.insert(0, ROOT)
+from md_cg.mdcos import MdCGOS  # noqa: E402
+
+root = os.path.join(HERE, "_store", "l4b")
+shutil.rmtree(root, ignore_errors=True)
+os.makedirs(root, exist_ok=True)
+cg = MdCGOS(root, actor="probe")
+
+node = ("# 功能名：连接池取值\n"
+        "# 生效条件：observation_position=生产环境 MySQL；time_window=当前\n"
+        "# 子功能：确定连接池大小\n"
+        "# 执行：采用 32\n"
+        "# 验证方式：measurement\n"
+        "# 不适用条件：本地开发 SQLite\n"
+        "\n正文：生产环境 MySQL 连接池=32\n")
+cg.add("mem_X", node, layer="knowledge", verification_basis="measurement")
+
+ev = cg.evolution_record(node_id="mem_X", pattern="取值漂移", missing="压测数据",
+                         action="add", evidence="L4b 探针", source="probe",
+                         kind="condition_gap",
+                         before={"pool": 32, "text": "连接池=32"},
+                         after={"pool": 64, "text": "连接池=64"})
+print("record:", json.dumps(ev, ensure_ascii=False, default=str)[:400])
+eid = ev.get("entry_id") if isinstance(ev, dict) else None
+
+dry = cg.evolution_rollback(eid, dry_run=True)
+print("rollback dry :", json.dumps(dry, ensure_ascii=False, default=str)[:400])
+real = cg.evolution_rollback(eid)
+print("rollback real:", json.dumps(real, ensure_ascii=False, default=str)[:400])
+print("history:", json.dumps(cg.evolution_history(node_id="mem_X"),
+                             ensure_ascii=False, default=str)[:400])
+
+with open(os.path.join(HERE, "result_l4b.json"), "w", encoding="utf-8") as fh:
+    json.dump({"record": ev, "dry": dry, "real": real}, fh,
+              ensure_ascii=False, indent=1, default=str)
+cg.close()
+print("done")

package/docs/experiments/md-cg-gate-probe/run_l5_continuity.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+"""L5 门槛判别测试：跨会话/跨副本问「你是谁、相信什么、为什么改」。
+
+标尺 §2.3 L5：身份一致 + 能陈述变更与理由。
+阶段A（会话A）建立锚点/特质/观察 + 一条信念 + 一次变更记录；
+阶段B（新实例·同库）问四个问题；阶段C（库副本）问「你是谁」。
+"""
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+sys.path.insert(0, ROOT)
+from md_cg.mdcos import MdCGOS  # noqa: E402
+
+
+def brief(v, n=420):
+    s = json.dumps(v, ensure_ascii=False, default=str)
+    return s[:n] + ("…" if len(s) > n else "")
+
+
+def main():
+    store = os.path.join(HERE, "_store", "l5")
+    shutil.rmtree(store, ignore_errors=True)
+    os.makedirs(store, exist_ok=True)
+
+    # ---------- 阶段 A：会话 A ----------
+    cgA = MdCGOS(store, actor="session-A")
+    cgA.identity_anchor(
+        "self:lingshu",
+        "我是灵枢——dsh-memory 的认知图记忆系统，把工作纪律与经验沉淀为可路由的记忆节点")
+    cgA.identity_trait("self:lingshu", "坚持先取证再下结论，不猜测")
+    cgA.identity_observe("self:lingshu",
+                         "本会话在执行 md_cg 七维实测，采用四个门槛判别测试")
+    cgA.session_note("会话A：确立七维实测口径 = 标尺 §2.3 的 L2/L3/L4/L5 四个判别测试",
+                     session="s1")
+    cgA.add("belief_pool", "生产环境 MySQL 连接池=32", layer="knowledge",
+            verification_basis="measurement")
+    cgA.evolution_record(node_id="belief_pool", pattern="取值漂移",
+                         missing="压测数据", action="update",
+                         evidence="九月压测显示 QPS 翻倍需 64",
+                         before={"pool": 32}, after={"pool": 64},
+                         kind="condition_gap")
+    cgA.close()
+
+    # ---------- 阶段 B：会话 B（新实例·同库）----------
+    cgB = MdCGOS(store, actor="session-B")
+    out = {}
+    out["Q1_who_am_i"] = cgB.identity_profile("self:lingshu")
+    out["Q2_self_state"] = cgB.self_state_snapshot("self:lingshu")
+    out["Q3_cross_session_recall"] = cgB.session_recall(session="s1", limit=3)
+    out["Q4_why_changed"] = cgB.evolution_history(node_id="belief_pool")
+    out["Q5_self_state_audit"] = cgB.self_state_audit("self:lingshu")
+    out["Q6_identity_history"] = cgB.identity_history(limit=10)
+    cgB.close()
+
+    # ---------- 阶段 C：库副本 ----------
+    replica = os.path.join(HERE, "_store", "l5_replica")
+    shutil.rmtree(replica, ignore_errors=True)
+    shutil.copytree(store, replica)
+    cgC = MdCGOS(replica, actor="replica")
+    try:
+        out["Q7_replica_who_am_i"] = cgC.identity_profile("self:lingshu")
+        out["Q7_replica_self_state"] = cgC.self_state_snapshot("self:lingshu")
+    except Exception as exc:                                    # noqa: BLE001
+        out["Q7_replica_who_am_i"] = f"ERR {type(exc).__name__}: {exc}"
+    cgC.close()
+
+    blob = json.dumps(out, ensure_ascii=False, default=str)
+    checks = {
+        "Q1_identity_anchor_persist": "灵枢" in brief(out["Q1_who_am_i"], 4000),
+        "Q2_self_state_present": bool(out["Q2_self_state"]),
+        "Q3_cross_session_recall": bool(out["Q3_cross_session_recall"]),
+        "Q4_change_history_with_reason": "压测" in brief(out["Q4_why_changed"], 4000),
+        "Q5_audit_present": bool(out["Q5_self_state_audit"]),
+        "Q7_replica_identity": "灵枢" in brief(out.get("Q7_replica_who_am_i"), 4000),
+        "Q7_replica_state": bool(out.get("Q7_replica_self_state")),
+    }
+
+    print("=== CHECKS ===")
+    print(json.dumps(checks, ensure_ascii=False, indent=1))
+    for k in ("Q1_who_am_i", "Q2_self_state", "Q3_cross_session_recall",
+              "Q4_why_changed", "Q5_self_state_audit", "Q7_replica_who_am_i"):
+        print(f"--- {k} ---")
+        print(brief(out.get(k)))
+
+    with open(os.path.join(HERE, "result_l5.json"), "w", encoding="utf-8") as fh:
+        json.dump({"checks": checks, "raw": out}, fh, ensure_ascii=False,
+                  indent=1, default=str)
+    print("written:", os.path.join(HERE, "result_l5.json"))
+
+
+if __name__ == "__main__":
+    main()

package/docs/experiments/md-cg-gate-probe/run_l5b_selfstate.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""L5b：self_state 状态卡的建立与跨副本持久（I 维自我模型 + T 维审计）。
+
+L5 首测 self_state=null，审计根因明确：状态卡不存在，需先 refresh()。
+本脚本按审计指出的路径补建，并验证跨副本是否同样持久。
+"""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+sys.path.insert(0, ROOT)
+from md_cg.mdcos import MdCGOS  # noqa: E402
+
+
+def brief(v, n=800):
+    s = json.dumps(v, ensure_ascii=False, default=str)
+    return s[:n] + ("…" if len(s) > n else "")
+
+
+store = os.path.join(HERE, "_store", "l5")
+replica = os.path.join(HERE, "_store", "l5_replica")
+
+cg = MdCGOS(store, actor="self-refresh")
+ref = cg.self_state_refresh("self:lingshu")
+print("refresh  :", brief(ref, 500))
+snap = cg.self_state_snapshot("self:lingshu")
+print("snapshot :", brief(snap, 900))
+au = cg.self_state_audit("self:lingshu")
+print("audit    :", brief(au, 500))
+dim = cg.self_state_summary("self:lingshu")
+print("summary  :", brief(dim, 500))
+cg.close()
+
+with open(os.path.join(HERE, "result_l5b.json"), "w", encoding="utf-8") as fh:
+    json.dump({"refresh": ref, "snapshot": snap, "audit": au, "summary": dim},
+              fh, ensure_ascii=False, indent=1, default=str)
+print("done")

package/docs/experiments/md-cg-gate-probe/run_probe_samecond.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+"""同条件分歧判据探针 v3：改用 CCG 结论槽（功能名/子功能）判「是否同一件事」。
+
+v1/v2 结论：任何「正文覆盖率」口径都区分不了「同属性不同值」与「异属性」——
+因为两者与旧正文的通用词重合度相当（N1 0.612 vs N2 0.623，负样本反超）。
+根因：是否「同一属性」是语义问题，词面覆盖率测的是「整条像不像」。
+故改用 CCG 结构自带的结论槽字段（`# 功能名` / `# 子功能`）作代理。
+"""
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+sys.path.insert(0, ROOT)
+from md_cg.mdcos import (MdCGOS, _weighted_coverage as _cov, _ccg_field,
+                         _declared_conditions as _decl)
+from md_cg import consistency as CONS
+from md_cg.mdcg import expand_query_terms_weighted as EQ
+
+CS_PROD = {"observation_position": "生产环境 MySQL", "observation_tool": "压测",
+           "time_window": "当前", "existence_constraint": "生产约束"}
+CS_DEV = {"observation_position": "本地开发 SQLite", "observation_tool": "单测",
+          "time_window": "当前", "existence_constraint": "开发约束"}
+
+
+def body(pid, text, cs, na, func="连接池取值", sub="确定连接池大小"):
+    txt = "；".join("%s=%s" % (k, v) for k, v in cs.items())
+    return ("# 功能名：%s %s\n# 生效条件：%s\n# 子功能：%s\n"
+            "# 执行：在 %s 下采用该取值\n# 验证方式：memory\n# 不适用条件：%s\n\n正文：%s\n"
+            % (pid, func, txt, sub, cs["observation_position"], "；".join(na), text))
+
+
+def slots(fm, content):
+    """结论槽：功能名 + 子功能（结构声明，非正文词面）。"""
+    return (_ccg_field(content, "功能名"), _ccg_field(content, "子功能"))
+
+
+def main():
+    root = os.path.join(HERE, "_store", "probe_sc")
+    shutil.rmtree(root, ignore_errors=True)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root, actor="probe")
+    A = body("A", "生产环境 MySQL 的连接池大小设为 32，因为单实例要扛 800 QPS",
+             CS_PROD, ["本地开发 SQLite"])
+    cg.add("mem_A", A, layer="knowledge", condition_space=CS_PROD,
+           verification_basis="measurement", non_applicable_conditions=["本地开发 SQLite"])
+    cg.flush()
+    n = cg.get("mem_A") or {}
+    ep, en = _decl(n.get("frontmatter") or {}, n.get("content") or "")
+    efull = n.get("content") or ""
+    ebody = CONS._body_text(efull)
+    efn, esub = slots(n.get("frontmatter") or {}, efull)
+
+    P, NA = CS_PROD, ["本地开发 SQLite"]
+    D, DNA = CS_DEV, ["生产环境 MySQL"]
+    cases = [
+        ("M1_真矛盾_同槽不同值", "连接池取值", "确定连接池大小",
+         "生产环境 MySQL 的连接池大小设为 64，因为上线后 QPS 翻倍", P, NA),
+        ("M2_负样本_异属性", "慢查询日志阈值", "设置慢查询阈值",
+         "生产环境 MySQL 的慢查询日志开启阈值为 1 秒，因为要排查慢 SQL", P, NA),
+        ("M3_重复_同槽同义", "连接池取值", "确定连接池大小", None, P, NA),
+        ("M4_负样本_异条件空间", "连接池取值", "确定连接池大小",
+         "本地开发 SQLite 的连接池大小设为 1，因为文件锁不支持并发写", D, DNA),
+        ("M5_同槽同值异措辞", "连接池取值", "确定连接池大小",
+         "生产环境 MySQL 连接池设置为 32，因为单机需支撑 800 QPS", P, NA),
+        ("M6_边界_同主语异属性", "连接池空闲数", "确定空闲连接数",
+         "生产环境 MySQL 的连接池最大空闲连接数设为 8，避免空转", P, NA),
+        ("M7_负样本_异主题", "JVM 堆外内存调优", "调优堆外内存",
+         "生产环境 MySQL 的连接池参数需要配合 JVM 堆外内存调优", P, NA),
+    ]
+    out = {}
+    for name, func, sub, text, cs, na in cases:
+        t = A if text is None else body("X", text, cs, na, func, sub)
+        pos, neg = CONS._new_terms(t, cs, na)
+        fn, sb = slots({}, t)
+        tw_pos = EQ(" ".join(pos)) if pos else {}
+        tw_neg = EQ(" ".join(neg)) if neg else {}
+        same = max(_cov(tw_pos, " ".join(ep)) if (tw_pos and ep) else 0.0,
+                   _cov(tw_neg, " ".join(en)) if (tw_neg and en) else 0.0)
+        out[name] = {
+            "same_cond": round(same, 4),
+            "slot_func": round(_cov(EQ(fn), efn), 4) if fn else 0.0,
+            "slot_sub": round(_cov(EQ(sb), esub), 4) if sb else 0.0,
+            "c_bb": round(_cov(EQ(CONS._body_text(t)), ebody), 4),
+            "fn_new": fn, "fn_old": efn}
+    print(json.dumps(out, ensure_ascii=False, indent=1))
+    with open(os.path.join(HERE, "result_probe_samecond.json"), "w",
+              encoding="utf-8") as f:
+        json.dump(out, f, ensure_ascii=False, indent=1)
+    cg.close()
+
+
+if __name__ == "__main__":
+    main()

package/docs/experiments/md-cg-gate-probe/run_t2_probe.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+"""T 维写保护/遗忘闭环 + 密级阶梯读隔离 + I 维真实版本链（自包含可重跑）。
+
+源码取证修正：forget 在 MdCGOS 无管理闸门，MdCGSecure 才有 require_admin 与 _readable；
+受保护 forget 无 override 时 raise ProtectionError；restore 不加 force 拒绝且不抹墓碑；
+上轮 result_ct.json 的 chain_linked=true 是 null==null 假阳性（幂等跳过时返回无 state_hash）。
+"""
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+sys.path.insert(0, ROOT)
+from md_cg.mdcos import MdCGOS, MdCGSecure          # noqa: E402
+from md_cg.security import Principal                # noqa: E402
+from md_cg import identity as ID                    # noqa: E402
+from md_cg import protect as PROT                   # noqa: E402
+
+MK = b"0" * 32          # 显式主密钥，避免写 ~/.mdcg/master.key
+
+
+def brief(v, n=300):
+    s = json.dumps(v, ensure_ascii=False, default=str)
+    return s[:n] + ("…" if len(s) > n else "")
+
+
+def ids(res):
+    items = res[0] if (isinstance(res, tuple) and res and isinstance(res[0], list)) else res
+    got = []
+    for it in items:
+        nd = it if isinstance(it, dict) else next((x for x in it if isinstance(x, dict)), {})
+        got.append(nd.get("id"))
+    return got
+
+
+def fresh(name):
+    p = os.path.join(HERE, "_store", name)
+    shutil.rmtree(p, ignore_errors=True)
+    os.makedirs(p, exist_ok=True)
+    return p
+
+
+out = {}
+
+# ---- 1) 遗忘 -> 墓碑 -> 恢复 ----
+try:
+    cg = MdCGOS(fresh("t2_t"), actor="probe")
+    cg.add("keep_1", "保留条目：模块 A 的经验", layer="knowledge")
+    cg.add("del_1", "待删除条目：过期的临时结论", layer="knowledge")
+    cg.flush()
+    b = ids(cg.search("待删除条目", k=3, judge=False))
+    fg = cg.forget("del_1")
+    t1 = cg.is_tombstoned("del_1")
+    gone = ids(cg.search("待删除条目", k=3, judge=False))
+    r_no = cg.restore("del_1")
+    t2 = cg.is_tombstoned("del_1")
+    r_fo = cg.restore("del_1", force=True)
+    t3 = cg.is_tombstoned("del_1")
+    back = ids(cg.search("待删除条目", k=3, judge=False))
+    out["T_forget_restore"] = {
+        "before_ids": b, "forget": brief(fg, 150),
+        "tombstoned_after_forget": t1, "excluded_from_search": "del_1" not in gone,
+        "restore_no_force": brief(r_no, 150), "reject_keeps_tombstone": t2 is True,
+        "restore_force": brief(r_fo, 150), "back_in_search": "del_1" in back,
+        "tombstone_persists_after_restore": t3,
+        "note": "墓碑不随恢复消除=删除史不可抹除（防静默复活）"}
+    cg.close()
+except Exception as exc:                                        # noqa: BLE001
+    out["T_forget_restore"] = f"ERR {type(exc).__name__}: {exc}"
+
+# ---- 2) self 层锚点不可遗忘 ----
+try:
+    cg = MdCGOS(fresh("t2_p"), actor="probe")
+    cg.identity_anchor("self:probe", "我是探针主体，用于验证 self 层不可遗忘保护")
+    nid = ID.subject_node_id("self:probe")
+    cg.flush()
+    is_prot, why = PROT.is_protected(cg, nid)
+    blocked, err = False, None
+    try:
+        cg.forget(nid)
+    except PROT.ProtectionError as e:
+        blocked, err = True, str(e)
+    stats = cg.protect_stats()
+    ov = None
+    try:
+        ov = cg.forget(nid, reason="受控验证：经 override 显式删除", override=True)
+    except Exception as e:                                      # noqa: BLE001
+        ov = f"ERR {type(e).__name__}: {e}"
+    audit_p = os.path.join(cg.root, PROT.AUDIT_FILE)
+    n_audit = 0
+    if os.path.exists(audit_p):
+        with open(audit_p, encoding="utf-8", errors="replace") as fh:
+            n_audit = sum(1 for _ in fh)
+    out["T_protected_forget"] = {
+        "anchor_node": nid, "is_protected": is_prot, "why": why,
+        "forget_without_override_blocked": blocked, "error": brief(err, 200),
+        "protect_stats": brief(stats, 600), "forget_with_override": brief(ov, 220),
+        "snapshot_history": PROT.history(cg, nid), "protect_audit_lines": n_audit}
+    cg.close()
+except Exception as exc:                                        # noqa: BLE001
+    out["T_protected_forget"] = f"ERR {type(exc).__name__}: {exc}"
+
+# ---- 3) 密级阶梯读隔离 ----
+try:
+    root = fresh("t2_sec")
+    cg_hi = MdCGSecure(root, principal=Principal(
+        "probe", "hi", clearance="private", can_admin=True), master_key=MK)
+    written = {}
+    for nid, sens in (("sec_pub", "public"), ("sec_int", "internal"), ("sec_priv", "private")):
+        try:
+            cg_hi.add(nid, f"密级验证条目 {nid}：口令轮换与密钥托管的内部流程说明",
+                      layer="knowledge", sensitivity=sens)
+            written[nid] = sens
+        except Exception as e:                                  # noqa: BLE001
+            written[nid] = f"ERR {type(e).__name__}: {e}"
+    cg_hi.flush()
+    w_hi, se_hi = cg_hi.whoami(), ids(cg_hi.search("密级验证条目", k=5, judge=False))
+    cg_hi.close()
+    cg_lo = MdCGSecure(root, principal=Principal("probe", "lo", clearance="internal"),
+                       master_key=MK)
+    w_lo, se_lo = cg_lo.whoami(), ids(cg_lo.search("密级验证条目", k=5, judge=False))
+    cg_lo.close()
+    cg_pu = MdCGSecure(root, principal=Principal("probe", "pub", clearance="public"),
+                       master_key=MK)
+    w_pu, se_pu = cg_pu.whoami(), ids(cg_pu.search("密级验证条目", k=5, judge=False))
+    cg_pu.close()
+
+    def w(who):
+        return {"clearance": who["principal"]["clearance"],
+                "readable": who["readable_sensitivities"],
+                "visible_nodes": f'{who["nodes_visible"]}/{who["nodes_total"]}'}
+
+    priv_ok = written.get("sec_priv") == "private"
+    out["SEC_read_isolation"] = {
+        "written": written, "hi": w(w_hi), "lo": w(w_lo), "pub": w(w_pu),
+        "search_hi": se_hi, "search_lo": se_lo, "search_pub": se_pu,
+        "priv_visible_to_internal": "sec_priv" in se_lo,
+        "internal_visible_to_public": "sec_int" in se_pu,
+        "verdict": ("PASS 阶梯隔离" if (not priv_ok or (
+            "sec_priv" not in se_lo and "sec_int" not in se_pu)) else "FAIL 越级可见")}
+except Exception as exc:                                        # noqa: BLE001
+    out["SEC_read_isolation"] = f"ERR {type(exc).__name__}: {exc}"
+
+# ---- 4) I 维：自我状态真实版本链 ----
+try:
+    cg5 = MdCGOS(fresh("t2_v"), actor="v-probe")
+    cg5.identity_anchor("self:probe2", "我是版本链验证主体")
+    r1 = cg5.self_state_refresh("self:probe2")
+    s1 = cg5.self_state_snapshot("self:probe2")
+    r2 = cg5.self_state_refresh("self:probe2")
+    s2 = cg5.self_state_snapshot("self:probe2")
+    r3 = cg5.self_state_refresh("self:probe2", force=True)
+    s3 = cg5.self_state_snapshot("self:probe2")
+    r4 = cg5.self_state_refresh("self:probe2", force=True)
+    s4 = cg5.self_state_snapshot("self:probe2")
+    r5 = cg5.self_state_refresh("self:probe2", dimensions={"task": ["补测指纹变化"]})
+    s5 = cg5.self_state_snapshot("self:probe2")
+    au = cg5.self_state_audit("self:probe2")
+
+    def card(s, r):
+        return {"version": (s or {}).get("state_version"), "hash": (s or {}).get("state_hash"),
+                "prev": (s or {}).get("prev_state_hash"), "changed": r.get("changed")}
+    c1, c2, c3, c4 = card(s1, r1), card(s2, r2), card(s3, r3), card(s4, r4)
+    c5 = card(s5, r5)
+    out["I_version_chain"] = {
+        "step1_refresh": c1, "step2_idempotent_noop": c2,
+        "step3_force": c3, "step4_force": c4, "step5_content_change": c5,
+        "link_3_to_1": c3["prev"] is not None and c3["prev"] == c1["hash"],
+        "link_4_to_3": c4["prev"] is not None and c4["prev"] == c3["hash"],
+        "link_5_to_4": c5["prev"] is not None and c5["prev"] == c4["hash"],
+        "fingerprint_changed_on_content": c5["hash"] != c1["hash"],
+        "version_sequence": [c1["version"], c2["version"], c3["version"],
+                             c4["version"], c5["version"]],
+        "audit_verdict": au.get("verdict"), "audit_issues": au.get("n_issues")}
+    cg5.close()
+except Exception as exc:                                        # noqa: BLE001
+    out["I_version_chain"] = f"ERR {type(exc).__name__}: {exc}"
+
+print(json.dumps(out, ensure_ascii=False, indent=1)[:4200])
+with open(os.path.join(HERE, "result_t2.json"), "w", encoding="utf-8") as fh:
+    json.dump(out, fh, ensure_ascii=False, indent=1, default=str)
+print("written:", os.path.join(HERE, "result_t2.json"))

package/docs/experiments/md-cg-gate-probe/run_verify_samecond.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+"""L1-c（同条件空间·结论槽取值分歧）验证：正例 + 假阳性 + 回归 + 飞轮送达。"""
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+sys.path.insert(0, ROOT)
+from md_cg.mdcos import MdCGOS
+from md_cg import consistency as CONS
+
+CS_PROD = {"observation_position": "生产环境 MySQL", "observation_tool": "压测",
+           "time_window": "当前", "existence_constraint": "生产约束"}
+CS_DEV = {"observation_position": "本地开发 SQLite", "observation_tool": "单测",
+          "time_window": "当前", "existence_constraint": "开发约束"}
+
+
+def body(pid, text, cs, na, func="连接池取值", sub="确定连接池大小"):
+    txt = "；".join("%s=%s" % (k, v) for k, v in cs.items())
+    return ("# 功能名：%s %s\n# 生效条件：%s\n# 子功能：%s\n"
+            "# 执行：在 %s 下采用该取值\n# 验证方式：memory\n# 不适用条件：%s\n\n正文：%s\n"
+            % (pid, func, txt, sub, cs["observation_position"], "；".join(na), text))
+
+
+def main():
+    root = os.path.join(HERE, "_store", "verify_sc")
+    shutil.rmtree(root, ignore_errors=True)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root, actor="verify")
+    A = body("A", "生产环境 MySQL 的连接池大小设为 32，因为单实例要扛 800 QPS",
+             CS_PROD, ["本地开发 SQLite"])
+    cg.add("mem_A", A, layer="knowledge", condition_space=CS_PROD,
+           verification_basis="measurement", non_applicable_conditions=["本地开发 SQLite"])
+    cg.flush()
+
+    def case(name, txt, cs, na, expect, flywheel=False):
+        r = CONS.check(cg, txt, layer="knowledge", condition_space=cs,
+                       non_applicable_conditions=na, auto_flywheel=flywheel,
+                       query=txt[:120])
+        div = [c for c in r["conflicts"]
+               if c.get("type") == "same_condition_divergence"]
+        return {"case": name, "verdict": r["verdict"], "expect": expect,
+                "ok": r["verdict"] == expect, "n_div": len(div),
+                "div": div, "missing": r.get("missing"),
+                "unresolved_id": r.get("unresolved_id")}
+
+    P, NA = CS_PROD, ["本地开发 SQLite"]
+    D, DNA = CS_DEV, ["生产环境 MySQL"]
+    ctx = CS_PROD
+    out = []
+    out.append(case("P1_S1真矛盾_同槽不同值",
+                    body("B", "生产环境 MySQL 的连接池大小设为 64，因为上线后 QPS 翻倍",
+                         P, NA), ctx, NA, "DEFER", flywheel=True))
+    out.append(case("P2_同槽同值异措辞",
+                    body("B2", "生产环境 MySQL 连接池设置为 32，因为单机需支撑 800 QPS",
+                         P, NA), ctx, NA, "DEFER"))
+    out.append(case("N1_同条件异属性",
+                    body("Y", "生产环境 MySQL 的慢查询日志开启阈值为 1 秒，因为要排查慢 SQL",
+                         P, NA, "慢查询日志阈值", "设置慢查询阈值"), ctx, NA, "ACCEPT"))
+    out.append(case("N2_完全重复", A, ctx, NA, "ACCEPT"))
+    out.append(case("N3_同主语异属性",
+                    body("Z", "生产环境 MySQL 的连接池最大空闲连接数设为 8，避免空转",
+                         P, NA, "连接池空闲数", "确定空闲连接数"), ctx, NA, "ACCEPT"))
+    out.append(case("N4_异条件空间_跨侧回归",
+                    body("C", "本地开发 SQLite 的连接池大小设为 1，因为文件锁不支持并发写",
+                         D, DNA), D, DNA, "DEFER"))
+    bad = ("# 功能名：自否定样例\n# 生效条件：生产环境 MySQL\n# 子功能：x\n"
+           "# 执行：y\n# 验证方式：memory\n# 不适用条件：生产环境 MySQL\n\n正文：生产环境 MySQL 下不成立\n")
+    out.append(case("R_自否定回归", bad, ctx, ["本地开发 SQLite"], "REJECT"))
+
+    un = {}
+    uid = out[0].get("unresolved_id")
+    if uid:
+        node = cg.get(uid) or {}
+        un = {"id": uid, "content": node.get("content", "")}
+
+    res = {"cases": out,
+           "all_ok": all(c["ok"] for c in out),
+           "unresolved": un,
+           "has_scene": "# 现场：" in (un.get("content") or "")}
+    print(json.dumps(res, ensure_ascii=False, indent=1))
+    with open(os.path.join(HERE, "result_verify_samecond.json"), "w",
+              encoding="utf-8") as f:
+        json.dump(res, f, ensure_ascii=False, indent=1)
+    cg.close()
+
+
+if __name__ == "__main__":
+    main()