@furongjun1999/dsh-memory 0.4.6 → 0.4.7

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

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""L2 门槛判别测试：1000 条历史会话中检索「某月修过的某组件问题」→ hit@1/hit@5。
+
+标尺 §2.3 L2：hit@1 ≥ 80%。
+设计：10 个唯一目标埋点 + 990 条同桶干扰（部分与目标共享月份或组件），
+10 个查询各对应 1 个目标，统计 hit@1 / hit@5 比率。
+所有节点同层（knowledge）、同桶（不给 condition_space），考验纯检索（R 维）。
+"""
+import argparse
+import json
+import os
+import random
+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
+
+MONTHS = ["一月", "二月", "三月", "四月", "五月", "六月",
+          "七月", "八月", "九月", "十月", "十一月", "十二月"]
+COMPONENTS = ["JWT", "订单", "缓存", "数据库连接池", "消息队列", "分页查询", "文件上传",
+              "限流", "定时任务", "灰度发布", "支付", "搜索", "通知", "权限", "日志",
+              "监控", "报表", "导出", "同步", "推荐"]
+PROBLEMS = ["过期导致登录失败", "超卖", "穿透", "连接泄漏", "重复消费", "深分页慢",
+            "大文件超时", "误伤正常用户", "重复触发", "配置不生效", "回调丢失",
+            "索引失效", "内存泄漏", "死锁", "乱序", "限流过严", "数据不一致",
+            "任务堆积", "精度丢失", "权限绕过"]
+REASONS = ["校验顺序写反了", "补偿逻辑缺失", "边界判断漏了空值", "并发下没有加锁",
+           "超时时间配置太小", "缓存与库双写不一致", "重试没有幂等", "索引选择器选错",
+           "内存没及时释放", "锁顺序不一致", "按时间戳排序丢了时区",
+           "阈值拍脑袋定的", "事务边界划大了", "队列积压没告警",
+           "浮点运算丢精度", "前置校验被绕过"]
+
+# 10 个唯一目标埋点（(月份, 组件, 问题) 各不相同）
+TARGETS = [
+    ("三月", "JWT", "过期导致登录失败"),
+    ("五月", "订单", "超卖"),
+    ("七月", "缓存", "穿透"),
+    ("二月", "数据库连接池", "连接泄漏"),
+    ("八月", "消息队列", "重复消费"),
+    ("四月", "分页查询", "深分页慢"),
+    ("六月", "文件上传", "大文件超时"),
+    ("九月", "限流", "误伤正常用户"),
+    ("十一月", "定时任务", "重复触发"),
+    ("一月", "灰度发布", "配置不生效"),
+]
+
+
+def text_of(month, comp, prob, reason):
+    return f"{month}修复过 {comp} 的 {prob} 问题，原因是{reason}"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--n", type=int, default=1000)
+    ap.add_argument("--seed", type=int, default=20260912)
+    ap.add_argument("--strict", action="store_true",
+                    help="排除「把目标组件词当作问题词」的歧义干扰")
+    args = ap.parse_args()
+
+    rnd = random.Random(args.seed)
+    root = os.path.join(HERE, "_store", "l2_strict" if args.strict else "l2")
+    if os.path.isdir(root):
+        shutil.rmtree(root)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root, actor="probe")
+
+    # 目标埋点
+    tset = set(TARGETS)
+    for i, (m, c, p) in enumerate(TARGETS):
+        cg.add(f"target_{i:02d}", text_of(m, c, p, REASONS[i % len(REASONS)]),
+               layer="knowledge")
+
+    # 干扰：一半「同月或同组件」的高相似干扰，一半随机
+    used = set(TARGETS)
+    n_filler = args.n - len(TARGETS)
+    written = 0
+    while written < n_filler:
+        if written < n_filler // 2:
+            base = rnd.choice(TARGETS)
+            if rnd.random() < 0.5:
+                m, c, p = rnd.choice(MONTHS), base[1], rnd.choice(PROBLEMS)
+            else:
+                m, c, p = base[0], rnd.choice(COMPONENTS), rnd.choice(PROBLEMS)
+        else:
+            m, c, p = rnd.choice(MONTHS), rnd.choice(COMPONENTS), rnd.choice(PROBLEMS)
+        if args.strict and any(tc in p for _tm, tc, _tp in TARGETS):
+            continue
+        if (m, c, p) in used:
+            continue
+        used.add((m, c, p))
+        cg.add(f"filler_{written:04d}", text_of(m, c, p, rnd.choice(REASONS)),
+               layer="knowledge")
+        written += 1
+    cg.flush()
+
+    total = len(TARGETS) + written
+    rows = []
+    for i, (m, c, p) in enumerate(TARGETS):
+        q = f"{m}修过的 {c} 问题"
+        res = cg.search(q, k=5, judge=False)
+        items = res[0] if (isinstance(res, tuple) and res and isinstance(res[0], list)) else res
+        order = []
+        for it in items:
+            if isinstance(it, dict):
+                nd = it
+            elif isinstance(it, (list, tuple)):
+                nd = next((x for x in it if isinstance(x, dict)), {})
+            else:
+                nd = {}
+            order.append(nd.get("id"))
+        tid = f"target_{i:02d}"
+        rows.append({"q": q, "target": tid, "order": order,
+                     "rank": (order.index(tid) + 1) if tid in order else 0})
+        print(f"  {q} → {order} (target {tid} rank={rows[-1]['rank']})")
+
+    n = len(rows)
+    summary = {
+        "n_nodes": total, "n_queries": n, "K": 5,
+        "hit1": round(sum(1 for r in rows if r["rank"] == 1) / n, 3),
+        "hit5": round(sum(1 for r in rows if 0 < r["rank"] <= 5) / n, 3),
+        "miss": [r["q"] for r in rows if r["rank"] == 0],
+        "rows": rows,
+    }
+    print("=== SUMMARY L2 ===")
+    print(json.dumps({k: v for k, v in summary.items() if k != "rows"},
+                     ensure_ascii=False, indent=1))
+    out = os.path.join(HERE, "result_l2_strict.json" if args.strict else "result_l2.json")
+    with open(out, "w", encoding="utf-8") as fh:
+        json.dump(summary, fh, ensure_ascii=False, indent=1)
+    print("written:", out)
+    cg.close()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""L3 门槛判别测试：20 组「关键词相似但能力不同」对抗对 → 负条件拒绝率。
+
+语料 = **复用** deja-vu-negcond/corpus.py 的同一批 GROUPS（同口径，不复制文本）。
+三口径：
+  A 裸文本（无 CCG 结构，仅 query）      —— 最接近 deja-vu 的任务形态
+  B 完整 CCG（仅 query，不给 context）    —— 结构齐备但情境未显式给出
+  C 完整 CCG + context（md_cg 原生用法）  —— 条件路由上限
+判定（与 deja-vu 同口径）：
+  neg_reject_loose = (bait 未进 topK) 或 (bait 被判 REJECT) 的组数 / 20
+  neg_reject_strict = bait 被判 REJECT 的组数 / 20
+  hit1_correct = correct 排第 1 的组数 / 20
+"""
+import argparse
+import importlib.util
+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
+
+ENV_TERMS = ["生产环境", "线上", "本地开发", "本地", "开发环境", "测试环境", "预发", "压测",
+             "MySQL", "SQLite", "PostgreSQL", "Redis", "MongoDB",
+             "gRPC", "HTTP", "HTTPS", "WebSocket", "TCP", "UDP",
+             "浏览器", "服务端", "客户端", "网关", "移动端", "桌面端",
+             "单实例", "集群", "主从", "分片", "文件锁"]
+
+K = 10
+
+
+def load_groups():
+    dv = os.path.join(ROOT, "docs", "experiments", "deja-vu-negcond", "corpus.py")
+    spec = importlib.util.spec_from_file_location("dvcorpus", dv)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod.GROUPS
+
+
+def env_terms(text):
+    return [t for t in ENV_TERMS if t in text]
+
+
+def ccg_content(gid, side, text, cs_text, na):
+    return (
+        f"# 功能名：{gid}-{side} {text.split('，')[0]}\n"
+        f"# 生效条件：{cs_text}\n"
+        f"# 子功能：支撑 {gid} 场景下的取值决策\n"
+        f"# 执行：在 {cs_text} 下采用此取值\n"
+        f"# 验证方式：measurement\n"
+        f"# 不适用条件：{'；'.join(na) if na else '无'}\n"
+        f"\n正文：{text}\n"
+    )
+
+
+def qual_of(rec):
+    for key in ("qualification", "qual", "judge"):
+        if key in rec:
+            return rec[key]
+    return None
+
+
+def _split(item):
+    """search 单项 = [node_dict, score, qual_dict] → (node, qual, score)。"""
+    node, qual, score = {}, None, None
+    if isinstance(item, dict):
+        return item, None, None
+    if isinstance(item, (list, tuple)):
+        for x in item:
+            if not isinstance(x, dict):
+                continue
+            if "state" in x and "content" not in x:
+                qual = x
+            else:
+                node = x
+        if len(item) > 1 and isinstance(item[1], (int, float)):
+            score = item[1]
+    return node, qual, score
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--smoke", action="store_true")
+    ap.add_argument("--mode", default="C", choices=["A", "B", "C"])
+    args = ap.parse_args()
+
+    groups = load_groups()
+    if args.smoke:
+        groups = groups[:1]
+
+    root = os.path.join(HERE, "_store", f"l3_{args.mode}")
+    if os.path.isdir(root):
+        shutil.rmtree(root)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root, actor="probe")
+
+    rows = []
+    for g in groups:
+        gid, q = g["gid"], g["query"]
+        ce, be = env_terms(g["correct"]), env_terms(g["bait"])
+        ctx = {
+            "observation_position": " ".join(ce) or g["correct"][:16],
+            "observation_tool": ce[0] if ce else "未指定",
+            "time_window": "当前",
+            "existence_constraint": "生产约束" if "生产环境" in g["correct"] else "常规",
+        }
+        cs_text = "；".join(f"{k}={v}" for k, v in ctx.items())
+
+        cid, bid = f"{gid}_correct", f"{gid}_bait"
+        if args.mode == "A":
+            cg.add(cid, g["correct"], layer="knowledge")
+            cg.add(bid, g["bait"], layer="knowledge")
+        else:
+            cs_correct = dict(ctx)
+            cs_bait = {
+                "observation_position": " ".join(be) or g["bait"][:16],
+                "observation_tool": be[0] if be else "未指定",
+                "time_window": "当前",
+                "existence_constraint": "常规",
+            }
+            cg.add(cid, ccg_content(gid, "correct", g["correct"], cs_text, be),
+                   layer="knowledge", condition_space=cs_correct,
+                   verification_basis="measurement", non_applicable_conditions=be or None)
+            cg.add(bid, ccg_content(gid, "bait", g["bait"],
+                                    "；".join(f"{k}={v}" for k, v in cs_bait.items()), ce),
+                   layer="knowledge", condition_space=cs_bait,
+                   verification_basis="measurement", non_applicable_conditions=ce or None)
+        cg.flush()
+
+        use_ctx = ctx if args.mode == "C" else None
+        res = cg.search(q, k=K, context=use_ctx, judge=True)
+        items = res[0] if (isinstance(res, tuple) and res and isinstance(res[0], list)) else res
+        order, quals = [], {}
+        for it in items:
+            nd, qq, _sc = _split(it)
+            nid = nd.get("id")
+            order.append(nid)
+            quals[nid] = (qq or {}).get("state")
+        if args.smoke:
+            print("RAW TYPE:", type(res), "ITEMS:", len(items))
+            for it in items:
+                nd, qq, sc = _split(it)
+                print("  -", nd.get("id"), "score=", round(sc, 4) if sc else sc,
+                      "qual=", (qq or {}).get("state"), "path=", nd.get("path"))
+        bait_in = bid in order
+        cor_rank = order.index(cid) + 1 if cid in order else 0
+        rows.append({
+            "gid": gid, "core": g["core"], "order": order, "quals": quals,
+            "bait_in_topk": bait_in, "bait_qual": quals.get(bid),
+            "correct_rank": cor_rank, "correct_qual": quals.get(cid),
+        })
+        if args.smoke:
+            print("=== SMOKE", gid, "mode", args.mode, "===")
+            print("query:", q)
+            print("ctx:", json.dumps(ctx, ensure_ascii=False))
+            print(json.dumps(rows[-1], ensure_ascii=False, indent=1)[:2500])
+
+    n = len(rows)
+    strict = sum(1 for r in rows if r["bait_qual"] == "REJECT")
+    loose = sum(1 for r in rows if (not r["bait_in_topk"]) or r["bait_qual"] == "REJECT")
+    hit1 = sum(1 for r in rows if r["correct_rank"] == 1)
+    summary = {
+        "mode": args.mode, "n": n, "K": K,
+        "neg_reject_strict": round(strict / n, 3),
+        "neg_reject_loose": round(loose / n, 3),
+        "hit1_correct": round(hit1 / n, 3),
+        "rows": rows,
+    }
+    print("=== SUMMARY mode", args.mode, "===")
+    print(json.dumps({k: v for k, v in summary.items() if k != "rows"},
+                     ensure_ascii=False, indent=1))
+    out = os.path.join(HERE, f"result_l3_{args.mode}.json")
+    with open(out, "w", encoding="utf-8") as fh:
+        json.dump(summary, fh, ensure_ascii=False, indent=1)
+    print("written:", out)
+    cg.close()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""L3 负条件拒绝 · v2（手工精确标注 + 双向判别）
+
+v1 用词表规则抽条件，20 组里 15 组抽取不合格（为空或重叠），结论不硬。
+v2 改为**手工标注**每组 correct/bait 的作用主体（20 组主体两两互斥），并补
+**D 镜像口径**：单向"bait 被拒"可被"无脑拒一切"骗过，必须双向对称才算条件路由。
+
+四口径：
+  A 裸文本（无 CCG） + query only
+  B 完整 CCG        + query only            —— 结构齐备但情境未给
+  C 完整 CCG        + context(correct 侧)   —— 正向
+  D 完整 CCG        + context(bait 侧)      —— 镜像（期望 correct 被拒、bait 被收）
+指标：reject_rate(应被拒者被拒/不入池)、accept_rate(应被收者被收)、hit1。
+"""
+import argparse
+import importlib.util
+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
+
+K = 10
+
+# gid -> (correct 侧作用主体, bait 侧作用主体)；20 组两两互斥，无子串包含关系
+POS = {
+    "g01": ("生产环境 MySQL", "本地开发 SQLite"),
+    "g02": ("gRPC 服务端", "HTTP 网关"),
+    "g03": ("Redis 集群", "本地内存"),
+    "g04": ("支付回调", "通知推送"),
+    "g05": ("日志查询", "用户列表"),
+    "g06": ("传输层", "静态存储"),
+    "g07": ("时间序列表", "用户表"),
+    "g08": ("登录接口", "数据导出"),
+    "g09": ("生产环境", "开发环境"),
+    "g10": ("图片上传", "报表生成"),
+    "g11": ("长连接", "集群选举"),
+    "g12": ("消息消费", "数据库写入"),
+    "g13": ("管理后台", "移动端"),
+    "g14": ("归档冷数据", "实时日志"),
+    "g15": ("链路追踪", "指标采集"),
+    "g16": ("核心库", "分析库"),
+    "g17": ("视频上传", "固件升级"),
+    "g18": ("退款消息", "对账消息"),
+    "g19": ("用户昵称", "内部编码"),
+    "g20": ("交易库", "配置库"),
+}
+
+
+def load_groups():
+    dv = os.path.join(ROOT, "docs", "experiments", "deja-vu-negcond", "corpus.py")
+    spec = importlib.util.spec_from_file_location("dvcorpus", dv)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod.GROUPS
+
+
+def ctx_for(pos):
+    return {"observation_position": pos, "observation_tool": "未指定",
+            "time_window": "当前", "existence_constraint": f"{pos} 约束"}
+
+
+def cs_text(ctx):
+    return "；".join(f"{k}={v}" for k, v in ctx.items())
+
+
+def ccg(gid, side, text, ctx, na):
+    return (
+        f"# 功能名：{gid}-{side} {text.split('，')[0]}\n"
+        f"# 生效条件：{cs_text(ctx)}\n"
+        f"# 子功能：支撑 {gid} 场景下的取值决策\n"
+        f"# 执行：在 {ctx['observation_position']} 下采用此取值\n"
+        f"# 验证方式：measurement\n"
+        f"# 不适用条件：{'；'.join(na) if na else '无'}\n"
+        f"\n正文：{text}\n"
+    )
+
+
+def split(item):
+    node, qual, score = {}, None, None
+    if isinstance(item, dict):
+        return item, None, None
+    if isinstance(item, (list, tuple)):
+        for x in item:
+            if not isinstance(x, dict):
+                continue
+            if "state" in x and "content" not in x:
+                qual = x
+            else:
+                node = x
+        if len(item) > 1 and isinstance(item[1], (int, float)):
+            score = item[1]
+    return node, qual, score
+
+
+def run(cg, q, ctx):
+    res = cg.search(q, k=K, context=ctx, judge=True)
+    items = res[0] if (isinstance(res, tuple) and res and isinstance(res[0], list)) else res
+    order, quals = [], {}
+    for it in items:
+        nd, qq, _sc = split(it)
+        nid = nd.get("id")
+        order.append(nid)
+        quals[nid] = (qq or {}).get("state")
+    return order, quals
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", required=True, choices=["A", "B", "C", "D"])
+    args = ap.parse_args()
+
+    groups = load_groups()
+    root = os.path.join(HERE, "_store", f"l3v2_{args.mode}")
+    if os.path.isdir(root):
+        shutil.rmtree(root)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root, actor="probe")
+
+    rows = []
+    for g in groups:
+        gid = g["gid"]
+        cpos, bpos = POS[gid]
+        assert cpos in g["query"], f"{gid} query 未含 correct 主体"
+        cctx, bctx = ctx_for(cpos), ctx_for(bpos)
+        cid, bid = f"{gid}_correct", f"{gid}_bait"
+
+        if args.mode == "A":
+            cg.add(cid, g["correct"], layer="knowledge")
+            cg.add(bid, g["bait"], layer="knowledge")
+        else:
+            cg.add(cid, ccg(gid, "correct", g["correct"], cctx, [bpos]),
+                   layer="knowledge", condition_space=cctx,
+                   verification_basis="measurement", non_applicable_conditions=[bpos])
+            cg.add(bid, ccg(gid, "bait", g["bait"], bctx, [cpos]),
+                   layer="knowledge", condition_space=bctx,
+                   verification_basis="measurement", non_applicable_conditions=[cpos])
+        cg.flush()
+
+        if args.mode == "A":
+            q, ctx, exp_rej, exp_acc = g["query"], None, bid, cid
+        elif args.mode == "B":
+            q, ctx, exp_rej, exp_acc = g["query"], None, bid, cid
+        elif args.mode == "C":
+            q, ctx, exp_rej, exp_acc = g["query"], cctx, bid, cid
+        else:
+            q = f"{bpos}的{g['core']}设多少"
+            ctx, exp_rej, exp_acc = bctx, cid, bid
+
+        order, quals = run(cg, q, ctx)
+        rows.append({
+            "gid": gid, "mode": args.mode,
+            "rej_id": exp_rej, "acc_id": exp_acc,
+            "rej_in_pool": exp_rej in order, "rej_qual": quals.get(exp_rej),
+            "acc_in_pool": exp_acc in order, "acc_qual": quals.get(exp_acc),
+            "acc_rank": (order.index(exp_acc) + 1) if exp_acc in order else 0,
+            "order": order,
+        })
+        if args.mode == "D":
+            print(f"  D {gid}: q={q} | correct(应拒)in={rows[-1]['rej_in_pool']} "
+                  f"qual={rows[-1]['rej_qual']} | bait(应收)qual={rows[-1]['acc_qual']}")
+
+    n = len(rows)
+    rej = sum(1 for r in rows if (not r["rej_in_pool"]) or r["rej_qual"] == "REJECT")
+    rej_strict = sum(1 for r in rows if r["rej_qual"] == "REJECT")
+    acc = sum(1 for r in rows if r["acc_qual"] == "ACCEPT")
+    hit1 = sum(1 for r in rows if r["acc_rank"] == 1)
+
+    summary = {"mode": args.mode, "n": n, "K": K,
+               "reject_rate_loose": round(rej / n, 3),
+               "reject_rate_strict": round(rej_strict / n, 3),
+               "accept_rate": round(acc / n, 3),
+               "hit1": round(hit1 / n, 3),
+               "rows": rows}
+    print("=== SUMMARY", args.mode, "===")
+    print(json.dumps({k: v for k, v in summary.items() if k != "rows"},
+                     ensure_ascii=False, indent=1))
+    out = os.path.join(HERE, f"result_l3v2_{args.mode}.json")
+    with open(out, "w", encoding="utf-8") as fh:
+        json.dump(summary, fh, ensure_ascii=False, indent=1)
+    print("written:", out)
+    cg.close()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+"""L4 门槛判别测试：矛盾反馈 → 「新增条件分支」而非「追加矛盾条目」。
+
+标尺 §2.3 L4：给一个与已有记忆矛盾的反馈，应新增条件分支而非追加矛盾条目。
+场景：
+  S1 同条件空间·不同取值（真矛盾：32 vs 64）  → 期望不静默追加
+  S2 不同条件空间（正确的新分支）              → 期望 ACCEPT 且可共存
+  S3 负条件互斥（条件级真冲突）                → 期望 DEFER/REJECT + 写 unresolved
+  S4 自否定（负条件命中自身生效条件）          → 期望 REJECT
+另测 evolution_record / evolution_rollback 的可回滚性。
+"""
+import glob
+import inspect
+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
+from md_cg import consistency as CONS     # noqa: E402
+
+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):
+    txt = "；".join(f"{k}={v}" for k, v in cs.items())
+    return (
+        f"# 功能名：{pid} 连接池取值\n"
+        f"# 生效条件：{txt}\n"
+        f"# 子功能：确定连接池大小\n"
+        f"# 执行：在 {cs['observation_position']} 下采用该取值\n"
+        f"# 验证方式：memory\n"
+        f"# 不适用条件：{'；'.join(na) if na else '无'}\n"
+        f"\n正文：{text}\n"
+    )
+
+
+def main():
+    print("SIG evolution_record:", inspect.signature(MdCGOS.evolution_record))
+    print("SIG evolution_rollback:", inspect.signature(MdCGOS.evolution_rollback))
+    print("SIG check_consistency:", inspect.signature(MdCGOS.check_consistency))
+
+    root = os.path.join(HERE, "_store", "l4")
+    if os.path.isdir(root):
+        shutil.rmtree(root)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root, actor="probe")
+
+    A = body("A", "生产环境 MySQL 的连接池大小设为 32，因为单实例要扛 800 QPS",
+             CS_PROD, ["本地开发 SQLite"])
+    B = body("B", "生产环境 MySQL 的连接池大小设为 64，因为上线后 QPS 翻倍",
+             CS_PROD, ["本地开发 SQLite"])
+    C = body("C", "本地开发 SQLite 的连接池大小设为 1，因为文件锁不支持并发写",
+             CS_DEV, ["生产环境 MySQL"])
+    D = body("D", "本地开发 SQLite 的连接池大小设为 2，因为单测要并发",
+             CS_DEV, ["生产环境 MySQL"])
+    E = body("E", "生产环境 MySQL 的连接池大小设为 8", CS_PROD, ["生产环境 MySQL"])
+
+    cg.add("mem_A", A, layer="knowledge", condition_space=CS_PROD,
+           verification_basis="measurement", non_applicable_conditions=["本地开发 SQLite"])
+
+    out = {}
+
+    # S1 同条件空间·不同取值
+    vd = CONS.check(cg, B, layer="knowledge", condition_space=CS_PROD,
+                    non_applicable_conditions=["本地开发 SQLite"], auto_flywheel=True)
+    out["S1_same_cond_diff_value"] = {"verdict": vd["verdict"], "reason": vd["reason"],
+                                      "strength": vd["conflict_strength"]}
+    try:
+        cg.add("mem_B", B, layer="knowledge", condition_space=CS_PROD,
+               verification_basis="measurement", non_applicable_conditions=["本地开发 SQLite"],
+               consistency=True, on_conflict="record")
+        out["S1_same_cond_diff_value"]["written"] = True
+    except Exception as exc:                                   # noqa: BLE001
+        out["S1_same_cond_diff_value"]["written"] = f"blocked:{type(exc).__name__}"
+
+    # S2 不同条件空间（正确新分支）
+    vd = CONS.check(cg, C, layer="knowledge", condition_space=CS_DEV,
+                    non_applicable_conditions=["生产环境 MySQL"], auto_flywheel=True)
+    cg.add("mem_C", C, layer="knowledge", condition_space=CS_DEV,
+           verification_basis="measurement", non_applicable_conditions=["生产环境 MySQL"])
+    out["S2_diff_cond"] = {"verdict": vd["verdict"], "reason": vd["reason"],
+                           "strength": vd["conflict_strength"]}
+
+    # S3 负条件互斥
+    vd = CONS.check(cg, D, layer="knowledge", condition_space=CS_DEV,
+                    non_applicable_conditions=["生产环境 MySQL"], auto_flywheel=True)
+    out["S3_neg_mutex"] = {"verdict": vd["verdict"], "reason": vd["reason"],
+                           "strength": vd["conflict_strength"],
+                           "unresolved_id": vd.get("unresolved_id")}
+
+    # S4 自否定
+    vd = CONS.check(cg, E, layer="knowledge", condition_space=CS_PROD,
+                    non_applicable_conditions=["生产环境 MySQL"], auto_flywheel=True)
+    out["S4_self_negation"] = {"verdict": vd["verdict"], "reason": vd["reason"]}
+
+    cg.flush()
+
+    # 结构观测
+    def node_ids(layer):
+        got = []
+        for f in glob.glob(os.path.join(root, "**", "*.md"), recursive=True):
+            rel = os.path.relpath(f, root).replace("\\", "/")
+            if rel.startswith(layer + "/"):
+                got.append(os.path.basename(f)[:-3])
+        return sorted(got)
+
+    unresolved = node_ids("unresolved")
+    rejected = node_ids("rejected")
+    out["structure"] = {"unresolved": unresolved, "rejected": rejected,
+                        "mem_B_exists": os.path.exists(
+                            os.path.join(root, "knowledge", "orphan", "mem_B.md"))
+                        or bool(glob.glob(os.path.join(root, "**", "mem_B.md"),
+                                          recursive=True)),
+                        "mem_C_exists": bool(glob.glob(os.path.join(root, "**", "mem_C.md"),
+                                                       recursive=True))}
+
+    # 分离边（distinct_from）= 条件分支标记
+    seps = []
+    for f in glob.glob(os.path.join(root, "**", "*.md"), recursive=True):
+        with open(f, encoding="utf-8") as fh:
+            t = fh.read()
+        if "distinct_from" in t:
+            seps.append(os.path.basename(f)[:-3])
+    out["structure"]["distinct_from_nodes"] = sorted(seps)
+
+    # S1b 同 id 覆盖（对照：系统预期的「更正」路径）
+    try:
+        cg.add("mem_A", A.replace("32", "48"), layer="knowledge",
+               condition_space=CS_PROD, verification_basis="measurement",
+               non_applicable_conditions=["本地开发 SQLite"], override=True)
+        out["S1b_override_same_id"] = {"ok": True}
+    except Exception as exc:                                   # noqa: BLE001
+        out["S1b_override_same_id"] = {"error": f"{type(exc).__name__}: {exc}"}
+
+    # 可回滚性
+    try:
+        ev = cg.evolution_record(node_id="mem_A", pattern="条件误用",
+                                 missing="生产环境约束", action="add",
+                                 evidence="L4 探针", source="probe")
+        out["evolution"] = {"recorded": str(ev)[:300]}
+        eid = ev.get("entry_id") if isinstance(ev, dict) else ev
+        cg.add("mem_A_v2", A.replace("32", "48"), layer="knowledge",
+               condition_space=CS_PROD, verification_basis="measurement",
+               non_applicable_conditions=["本地开发 SQLite"])
+        rb = cg.evolution_rollback(eid, note="L4 回滚探针")
+        out["evolution"]["rollback"] = str(rb)[:300]
+        out["evolution"]["entries"] = str(cg.evolution_entries(limit=5))[:300]
+    except Exception as exc:                                   # noqa: BLE001
+        out["evolution"] = {"error": f"{type(exc).__name__}: {exc}"}
+
+    print(json.dumps(out, ensure_ascii=False, indent=1))
+    with open(os.path.join(HERE, "result_l4.json"), "w", encoding="utf-8") as fh:
+        json.dump(out, fh, ensure_ascii=False, indent=1)
+    cg.close()
+
+
+if __name__ == "__main__":
+    main()