@furongjun1999/dsh-memory 0.4.9 → 0.4.11

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

@@ -1,50 +0,0 @@
-# -*- 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

@@ -1,96 +0,0 @@
-# -*- 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

@@ -1,39 +0,0 @@
-# -*- 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

@@ -1,96 +0,0 @@
-# -*- 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

@@ -1,184 +0,0 @@
-# -*- 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

@@ -1,91 +0,0 @@
-# -*- 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()