@furongjun1999/dsh-memory 0.4.10 → 0.4.11

package/docs/experiments/orch_mem_parallel/parallel_test.py

@@ -1,190 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""多子代理真进程并行写同一记忆库 · 双端对照实验（Linux WSL2 = 主场）。
-
-背景：fsutil.FileLock 已有跨进程锁（Win=msvcrt / Unix=fcntl），
-append_jsonl 自述「Windows 并发丢记录、POSIX O_APPEND 原子」，
-但「N 个真进程并行持有独立 OrcMemory 写同一 root」的端到端从未实测。
-
-实验组：
-  A 完整性压测：--procs 8 进程 × 各 --cards 3 卡（条件唯一互不触发冲突）
-  B 并行冲突检测：--conflict 4 进程同条件不同结论同时 submit
-校验项 V1-V9 + 计时。可重跑：
-  python3 docs/experiments/orch_mem_parallel/parallel_test.py
-"""
-import argparse
-import io
-import multiprocessing as mp
-import os
-import shutil
-import sys
-import tempfile
-import time
-import traceback
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-REPO = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
-sys.path.insert(0, REPO)
-sys.path.insert(0, os.path.join(REPO, "test"))
-sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
-
-PASS, FAIL = [], []
-
-
-def check(name, cond, detail=""):
-    (PASS if cond else FAIL).append(name)
-    print(f"    [{'PASS' if cond else 'FAIL'}] {name}" + (f"  |  {detail}" if detail else ""))
-
-
-def worker(sub, n_cards, cond_mode, root, q):
-    """子进程体：独立 OrcMemory 实例，向同一 root 并行写卡片。"""
-    try:
-        from orchestrator_memory import OrcMemory
-        om = OrcMemory(root, repo_path=REPO)
-        t0 = time.time()
-        out = []
-        try:
-            for i in range(n_cards):
-                if cond_mode == "unique":
-                    feat, subfeat = f"并行压测{sub}", f"任务{i}"
-                    cond = f"并行压测 {sub} 任务{i}"
-                    concl = f"{sub} 第{i}张卡片结论：完成"
-                else:  # same：同条件不同结论——测并行冲突检测
-                    feat, subfeat = "并行压测", "冲突组"
-                    cond = "并行压测 冲突组"
-                    concl = f"{sub} 认为方案{i}更优"
-                r = om.submit(sub, feat, subfeat, conclusion=concl,
-                              condition=cond,
-                              detail=f"{sub} 的细节过程记录，仅供 drill_down。{sub}{i} " * 8)
-                out.append({"card": r["card_id"], "verdict": r["conflict"].get("verdict")})
-        finally:
-            om.close()  # 实证：不 flush 分片则索引无记录，「在盘上但不可见」
-        q.put({"ok": True, "sub": sub, "cards": out,
-               "t": round(time.time() - t0, 3)})
-    except Exception as e:
-        q.put({"ok": False, "sub": sub, "err": f"{type(e).__name__}: {e}",
-               "tb": traceback.format_exc()})
-
-
-def run_group(name, n_proc, n_cards, cond_mode, root):
-    print(f"\n== {name}：{n_proc} 进程 × 各 {n_cards} 卡（{cond_mode}） ==")
-    ctx = mp.get_context()  # Linux 默认 fork / Windows spawn——各端真实形态
-    q = ctx.Queue()
-    procs = [ctx.Process(target=worker,
-                         args=(f"sub{i:02d}", n_cards, cond_mode, root, q))
-             for i in range(n_proc)]
-    t0 = time.time()
-    for p in procs:
-        p.start()
-    results = {}
-    deadline = time.time() + 300
-    got = 0
-    while got < n_proc and time.time() < deadline:
-        try:
-            r = q.get(timeout=5)
-            results[r["sub"]] = r
-            got += 1
-        except Exception:
-            pass
-    wall = time.time() - t0
-    for p in procs:            # 先给自然退出机会（收结果≠进程已退出）
-        p.join(timeout=60)
-    hung = [p.name for p in procs if p.is_alive()]
-    for p in procs:
-        if p.is_alive():
-            p.terminate()
-        p.join(5)
-    return results, wall, hung
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--procs", type=int, default=8)
-    ap.add_argument("--cards", type=int, default=3)
-    ap.add_argument("--conflict", type=int, default=4)
-    a = ap.parse_args()
-
-    root = tempfile.mkdtemp(prefix="orch_par_")
-    print(f"root = {root}  (pid={os.getpid()}, mp start method 按平台默认)")
-    try:
-        from orchestrator_memory import OrcMemory
-        om = OrcMemory(root, repo_path=REPO)
-        om.anchor_global("多子代理并行压测")
-
-        # ---- A 组：完整性压测 ----
-        ra, wall_a, hung_a = run_group("A 完整性压测", a.procs, a.cards, "unique", root)
-        om.refresh()  # 实证：index 是进程内快照，不重载则 collect 0/24
-        bad = {s: r for s, r in ra.items() if not r["ok"]}
-        check("V1 全部子进程无异常退出", not bad,
-              "; ".join(f"{s}:{r.get('err')}" for s, r in bad.items())[:200])
-        exp_a = a.procs * a.cards
-        ids = [c["card"] for r in ra.values() for c in r.get("cards", [])]
-        check("V2 卡 ID 数量正确且无撞车",
-              len(ids) == exp_a and len(set(ids)) == exp_a,
-              f"收 {len(ids)}/{exp_a} 唯一 {len(set(ids))}")
-        cards = om.collect_cards()
-        concl_ok = sum(1 for c in cards if "卡片结论：完成" in c["content"])
-        check("V3 主代理收口收全卡片且内容完好",
-              len(cards) == exp_a and concl_ok == exp_a,
-              f"collect {len(cards)}/{exp_a}，content 完好 {concl_ok}")
-        st = om.stats()
-        check("V4 三层统计一致（A 组口径）",
-              st["L1_card"] == exp_a and st["L2_detail"] == exp_a
-              and st["L0_global"] == 1, str(st))
-        g = om.cg.recall("细节过程记录", budget_tokens=6000, k=100, session="main")
-        leak = [n for n in g["pack"] if "细节过程记录" in str(n.get("content", ""))]
-        check("V5 L2 细节不泄漏进 main 召回", not leak, f"main 命中 {len(g['pack'])} 条，泄漏 {len(leak)}")
-        idx_n = len(om.cg.index["nodes"])
-        check("V6 索引节点数=落盘总数（A 组口径）", idx_n == 1 + 2 * exp_a,
-              f"index {idx_n} / 期望 {1 + 2 * exp_a}")
-
-        # ---- B 组：并行冲突检测（同条件不同结论） ----
-        rb, wall_b, hung_b = run_group("B 并行冲突检测", a.conflict, 1, "same", root)
-        om.refresh()  # V4/V6 校验含 B 组写入
-        badb = {s: r for s, r in rb.items() if not r["ok"]}
-        check("V7 冲突组无异常退出", not badb,
-              "; ".join(f"{s}:{r.get('err')}" for s, r in badb.items())[:200])
-        verdicts = {s: r["cards"][0]["verdict"] for s, r in rb.items() if r.get("ok")}
-        legal = all(v in ("ACCEPT", "DEFER") for v in verdicts.values())
-        ndefer = sum(1 for v in verdicts.values() if v == "DEFER")
-        check("V8 并行冲突判定合法（ACCEPT/DEFER，无 BLINDSPOT）", legal, str(verdicts))
-        print(f"    [INFO] 冲突组时序观察：{ndefer}/{len(verdicts)} 触发 DEFER"
-              f"（并行下 check 先于他人写入则 ACCEPT——时序敏感，两种均合法）")
-        st2 = om.stats()
-        idx2 = len(om.cg.index["nodes"])
-        exp_all = exp_a + a.conflict
-        check("V11 终态统计（A+B 全量）",
-              st2 == {"L0_global": 1, "L1_card": exp_all, "L2_detail": exp_all}
-              and idx2 == 1 + 2 * exp_all,
-              f"stats={st2} index={idx2} 期望 L1/L2={exp_all} index={1 + 2 * exp_all}")
-
-        # ---- V12：收口检查点（final_check）必须补上并行盲区 ----
-        # B 组卡在子进程侧因 init 索引快照互不可见（V8 实证 0~4 DEFER 不定），
-        # 主代理收口 refresh 后重查，同条件异值卡必须全部检出。
-        co = om.closeout()
-        det_cards = {d["card"] for d in co["final_check"]["detections"]}
-        b_ids = {r["cards"][0]["card"] for s, r in rb.items() if r.get("ok")}
-        miss = b_ids - det_cards
-        check("V12 收口检查点检出全部并行冲突（B 组全检出）", not miss,
-              f"检出 {len(det_cards & b_ids)}/{len(b_ids)}，漏 {sorted(miss)[:4]}"
-              f"；指纹 {co['fingerprint']}")
-
-        # ---- 环境卫生 ----
-        tmps = [f for f in os.listdir(root) if ".tmp-" in f]
-        check("V9 原子写临时文件零残留", not tmps, f"残留 {len(tmps)}: {tmps[:4]}")
-        hung_all = hung_a + hung_b
-        check("V10 无挂死进程（300s 看门狗内全部退出）", not hung_all, f"hung={hung_all}")
-
-        per_card = (wall_a / max(exp_a, 1))
-        print(f"\n计时：A 组 wall={wall_a:.2f}s（{per_card*1000:.0f} ms/卡），"
-              f"B 组 wall={wall_b:.2f}s")
-    finally:
-        shutil.rmtree(root, ignore_errors=True)
-
-    print("=" * 60)
-    print(f"汇总：{len(PASS)} PASS / {len(FAIL)} FAIL")
-    sys.exit(1 if FAIL else 0)
-
-
-if __name__ == "__main__":
-    main()

package/docs/experiments/orch_mem_verify/verify_orch.py

@@ -1,209 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""《主代理子代理记忆架构设计》声称清单 · 独立复现实测（不采信文档自述）。
-可重跑：python "docs/experiments/orch_mem_verify/verify_orch.py"
-"""
-import io, os, shutil, sys, tempfile, traceback
-REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-sys.path.insert(0, REPO)
-sys.path.insert(0, os.path.join(REPO, "test"))
-sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
-from md_cg.mdcos import MdCGOS
-from orchestrator_memory import OrcMemory, CARD_TEMPLATE
-
-PASS, FAIL, TMP = [], [], []
-def check(name, cond, detail=""):
-    (PASS if cond else FAIL).append(name)
-    print(f"    [{'PASS' if cond else 'FAIL'}] {name}" + (f"  |  {detail}" if detail else ""))
-
-def newroot():
-    d = tempfile.mkdtemp(prefix="orch_verify_"); TMP.append(d); return d
-def cleanup():
-    for d in TMP: shutil.rmtree(d, ignore_errors=True)
-
-def add_card(cg, nid, cond_kw, conclusion, session, importance=0.7,
-             with_hash=False, sentence_cond=False):
-    cond = "缓存选型决策时" if sentence_cond else cond_kw
-    if with_hash:
-        body = (f"# 功能名：缓存选型\n# 子功能：Redis 使用决策\n"
-                f"# 生效条件：{cond}\n# 结论：{conclusion}\n# 证据：x.md:1\n")
-    else:
-        body = CARD_TEMPLATE.format(feature="缓存选型", subfeature="Redis 使用决策",
-            condition=cond, conclusion=conclusion, evidence="x.md:1", impact="无", pending="无")
-    cg.add(nid, body, layer="knowledge", verification_basis="other",
-           importance=importance, session=session)
-
-# ============ T1/T13 参考实现端到端 ============
-print("\n== T1/T13 OrcMemory 四阶段端到端 ==")
-try:
-    om = OrcMemory(newroot(), repo_path=REPO)
-    r = om.anchor_global("重构认证模块：JWT→session")
-    check("T1a 锚定全局态（新会话创建）", not r["recovered"] and r.get("node_id"))
-    p = om.dispatch_prompt("subA", "迁移 login/logout", need=["认证"])
-    check("T1b 派发 prompt 含规范+裁剪上下文", "结论：" in p and "认证" in p and "subA" in p)
-    a = om.submit("subA", "认证重构", "迁移 login/logout", conclusion="已迁移，改 3 文件",
-                  evidence="auth/login.py:20-60", impact="调用方 2 处", pending="refresh_token 未处理",
-                  detail="完整过程……pytest 12 passed", derived_from=[r.get("node_id")])
-    check("T1c 产出卡片+细节+冲突预检", bool(a["card_id"] and a["detail_id"] and "conflict" in a))
-    b = om.submit("subB", "认证重构", "refresh_token 处理",
-                  conclusion="refresh_token 与 session 冲突",
-                  pending="需主代理裁决：保留还是废弃")
-    check("T1d 收口只读卡片", len(om.collect_cards()) == 2, f"实收 {len(om.collect_cards())}")
-    check("T1e 未决项清单", len(om.pending_items()) == 2)
-    gid = om.merge_global("重构认证模块：JWT→session", "subA 完成；subB 待裁决",
-                          derived_from=[a["card_id"], b["card_id"]])
-    check("T1f 合并进全局态", bool(gid))
-    st = om.stats()
-    check("T1g 三层统计 L0=2/L1=2/L2=1", st == {"L0_global": 2, "L1_card": 2, "L2_detail": 1}, str(st))
-    g = om.cg.recall("完整 过程 命令 输出", budget_tokens=3000, k=50, session="main")
-    leak = [n for n in g["pack"] if "pytest 12 passed" in str(n.get("content", ""))]
-    check("T13 细节不泄漏进 main 召回", not leak,
-          f"main 命中 {len(g['pack'])} 条，L2 泄漏 {len(leak)}"
-          f"（文档 selftest 注释称应为 3，实际 L0={st['L0_global']}，注释失准）")
-except Exception:
-    traceback.print_exc(); check("T1 无异常", False)
-
-# ============ T2 session 硬隔离 ============
-print("\n== T2 session 硬隔离（声称 None=16/main=1/subA=5） ==")
-try:
-    cg = MdCGOS(newroot())
-    cg.add("glob_main", "# 功能名：全局态\n# 生效条件：本任务进行期间\n结论：根全局态。",
-           layer="knowledge", verification_basis="other", importance=0.95, session="main")
-    for sub in ("subA", "subB", "subC"):
-        for i in range(5):
-            cg.add(f"{sub}_card_{i}", f"# 功能名：任务{sub}\n# 子功能：子任务{i}\n"
-                   f"# 生效条件：任务{sub} 期间\n\n结论：{sub} 第{i}项完成。",
-                   layer="knowledge", verification_basis="other", importance=0.7, session=sub)
-    n = {s: len(cg.recall("子任务 结论", k=50, session=s)["pack"]) for s in (None, "main", "subA")}
-    check("T2 None→16 / main→1 / subA→5", (n[None], n["main"], n["subA"]) == (16, 1, 5), str(n))
-except Exception:
-    traceback.print_exc(); check("T2 无异常", False)
-
-# ============ T3 预算硬截断 ============
-print("\n== T3 预算硬截断（声称 200 节点利用率 90-99%） ==")
-try:
-    cg = MdCGOS(newroot())
-    for i in range(200):
-        cg.add(f"bulk_{i:03d}", f"# 功能名：细节{i:03d}\n# 生效条件：批量测试期间\n\n"
-               f"结论：第 {i:03d} 条产出。" + "负载填充文本。" * 8,
-               layer="knowledge", verification_basis="other", importance=0.5, session="bulk")
-    uts = []
-    for budget in (300, 800, 1200, 2000):
-        o = cg.recall("子代理 产出 结论 负载", budget_tokens=budget, k=200, session="bulk")
-        used, skip, util = o["tokens_used"], len(o["skipped"]), o["tokens_used"] / budget
-        uts.append(util)
-        check(f"T3 budget={budget} 截断+溢出进 skipped", used <= budget and skip > 0,
-              f"实耗 {used} 跳过 {skip} 利用率 {util:.1%}")
-    check("T3 利用率 85-100% 区间", all(0.85 <= u <= 1.0 for u in uts),
-          " ".join(f"{u:.1%}" for u in uts))
-except Exception:
-    traceback.print_exc(); check("T3 无异常", False)
-
-# ============ T4/T5/T6 冲突检测 ============
-print("\n== T4/T5/T6 冲突检测：修正模板检出 + 两漏检盲区 ==")
-try:
-    cg = MdCGOS(newroot())   # T4 修正模板
-    add_card(cg, "old_card", "缓存选型 决策", "选择 Redis 作为缓存后端", "subX")
-    vd = cg.check_consistency(CARD_TEMPLATE.format(feature="缓存选型", subfeature="Redis 使用决策",
-        condition="缓存选型 决策", conclusion="放弃 Redis，改用本地内存缓存",
-        evidence="y.md:2", impact="无", pending="无"), layer="knowledge", auto_flywheel=True)
-    c0 = (vd.get("conflicts") or [{}])[0]
-    check("T4 修正模板同条件异值 → DEFER", vd.get("verdict") == "DEFER",
-          f"type={c0.get('type')} same_cond={c0.get('same_condition')} "
-          f"slot={c0.get('slot_overlap')} concl={c0.get('conclusion_overlap')}")
-    cg = MdCGOS(newroot())   # T5 全带#漏检
-    add_card(cg, "old_bad", "缓存选型 决策", "选择 Redis 作为缓存后端", "subX", with_hash=True)
-    vd = cg.check_consistency("# 功能名：缓存选型\n# 子功能：Redis 使用决策\n"
-        "# 生效条件：缓存选型 决策\n# 结论：放弃 Redis，改用本地内存缓存\n# 证据：y.md:2\n",
-        layer="knowledge", auto_flywheel=True)
-    # 文档声称漏检（ACCEPT）；实测当前代码 fail-closed 恒 DEFER（L465 空正文兜底 0.0）
-    check("T5 初版全带# → 实测 DEFER（与文档声称的 ACCEPT 漏检不符）",
-          vd.get("verdict") == "DEFER", f"verdict={vd.get('verdict')}"
-          f"（安全但结论取值信息丢失，卡片规范理由=防比对退化而非防漏检）")
-    cg = MdCGOS(newroot())   # T6 条件句子化漏检
-    add_card(cg, "old_sent", "缓存选型 决策", "选择 Redis 作为缓存后端", "subX")
-    vd = cg.check_consistency(CARD_TEMPLATE.format(feature="缓存选型", subfeature="Redis 使用决策",
-        condition="缓存选型决策时", conclusion="放弃 Redis，改用本地内存缓存",
-        evidence="y.md:2", impact="无", pending="无"), layer="knowledge", auto_flywheel=True)
-    check("T6 条件句子化 → 漏检", vd.get("verdict") != "DEFER", f"verdict={vd.get('verdict')}")
-except Exception:
-    traceback.print_exc(); check("T4-T6 无异常", False)
-
-# ============ T7 裁决闭环 ============
-print("\n== T7 propose → review_decide → 审计留痕 ==")
-try:
-    cg = MdCGOS(newroot())
-    pid = cg.propose("fix_node", "# 功能名：缓存选型\n# 生效条件：修复方案确认期间\n\n结论：放弃 Redis。",
-                     layer="knowledge", tags=["test"])
-    check("T7a propose 返回 pid", isinstance(pid, str) and pid.startswith("prop_"), str(pid))
-    check("T7b 队列可见", any(r.get("pid") == pid for r in cg.review_list()))
-    res = cg.review_decide(pid, "accept", reason="主代理确认：对旧决策的更正")
-    rh = res.get("record_hash") or (res.get("record") or {}).get("hash")
-    check("T7c accept 成功+record_hash", bool(res.get("ok")) and bool(rh),
-          f"ok={res.get('ok')} hash={str(rh)[:16]}…")
-    check("T7d 节点落盘", "fix_node" in cg.index["nodes"])
-except Exception:
-    traceback.print_exc(); check("T7 无异常", False)
-
-# ============ T8-T12 ============
-print("\n== T8-T12 溯源/白名单/嵌套坑/ID 撞车/自动保护 ==")
-try:
-    cg = MdCGOS(newroot())                                        # T8 溯源
-    cg.add("parent_L0", "# 功能名：全局态\n# 生效条件：任务期间\n结论：根。",
-           layer="knowledge", verification_basis="other", importance=0.95, session="main")
-    kids = [cg.add(f"child_{i}", f"# 功能名：任务{i}\n# 生效条件：任务期间\n结论：产出{i}。",
-            layer="knowledge", verification_basis="other", importance=0.7,
-            session=f"sub{i}", derived_from=["parent_L0"]) for i in range(3)]
-    derived = [nid for nid, e in cg.index["nodes"].items()
-               if "parent_L0" in (e.get("derived_from") or [])]
-    fm0, _ = cg._read(cg.index["nodes"][kids[0]])
-    check("T8 derived_from 落盘+反查全链", sorted(derived) == sorted(kids)
-          and fm0.get("derived_from") == ["parent_L0"], f"反查 {derived}")
-
-    try:                                                          # T9 白名单
-        cg.add("bad_basis", "# 功能名：x\n结论：y。", layer="knowledge",
-               verification_basis="user_request")
-        check("T9 非法 basis 抛 ValueError", False, "未抛异常")
-    except ValueError as e:
-        check("T9 非法 basis 抛 ValueError", True, str(e)[:60])
-
-    cg.add("n_nested", "# 功能名：嵌套\n结论：x。", layer="knowledge",     # T10 嵌套坑
-           verification_basis="other", importance=0.5, extra={"session": "subN"})
-    cg.add("n_toplevel", "# 功能名：顶层\n结论：x。", layer="knowledge",
-           verification_basis="other", importance=0.5, session="subP")
-    n_nest = len(cg.recall("嵌套", k=10, session="subN")["pack"])
-    n_top = len(cg.recall("顶层", k=10, session="subP")["pack"])
-    check("T10 嵌套写法失效 / 顶层生效", n_nest == 0 and n_top == 1,
-          f"嵌套召回 {n_nest}（应为 0），顶层召回 {n_top}（应为 1）")
-
-    cg.add("dup_det", "# 功能名：撞名\n结论：第一版。", layer="knowledge",  # T11 ID 撞车
-           verification_basis="other", importance=0.4)
-    cg.add("dup_det", "# 功能名：撞名\n结论：第二版覆盖。", layer="knowledge",
-           verification_basis="other", importance=0.4)
-    _, body = cg._read(cg.index["nodes"]["dup_det"])
-    check("T11a 同 ID 低重要度 → 后写覆盖前写", "第二版" in body,
-          f"库内 {len(cg.index['nodes'])} 节点，内容已换版")
-    cg.add("dup_card", "# 功能名：撞卡\n结论：A。", layer="knowledge",
-           verification_basis="other", importance=0.7)
-    cg.add("dup_card", "# 功能名：撞卡\n结论：B。", layer="knowledge",
-           verification_basis="other", importance=0.7)
-    _, body2 = cg._read(cg.index["nodes"]["dup_card"])
-    check("T11b 同 ID 高重要度(0.7) → 静默覆盖（文档声称成立）", "结论：B" in body2,
-          "0.7 只触发『不可遗忘』，不触发『不可覆盖』（is_immutable 窄判定）——"
-          "ID 撞车风险真实存在，序号去重是硬要求")
-
-    cg.add("prot_card", "# 功能名：保护\n结论：x。", layer="knowledge",     # T12
-           verification_basis="other", importance=0.7, session="subZ")
-    fm, _ = cg._read(cg.index["nodes"]["prot_card"])
-    check("T12 importance=0.7 → 自动 protected", fm.get("protected") is True,
-          f"reason={fm.get('protection_reason')}")
-except Exception:
-    traceback.print_exc(); check("T8-T12 无异常", False)
-
-# ============ 汇总 ============
-print("\n" + "=" * 62)
-print(f"汇总：{len(PASS)} PASS / {len(FAIL)} FAIL")
-if FAIL:
-    print("失败项：", *FAIL, sep="\n  - ")
-cleanup()
-sys.exit(1 if FAIL else 0)

package/docs/hive//347/234/237/345/256/236/345/272/223/347/253/257/345/210/260/347/253/257/345/256/236/346/265/213_S1b/344/270/216/345/217/254/345/233/236/346/235/203/350/241/241_v0.1.md

@@ -1,57 +0,0 @@
-# 真实库端到端实测：S1b 的收益与召回权衡（2026-09-19）
-
-> 方法：把真实库 **完整拷贝**到临时目录（12,249 文件 / 1,446 MB，源库零写入），在拷贝上做开关对照实测。
-> 库：`D:/Program Files/2_ai/AEIS/data/mdcg` → 拷贝 `C:/Users/FuRongJun/.mdcg/_store_copy`（12,149 节点）。
-
-## 1. 基线（全关）：每个查询都扫全库
-
-| 查询 | scanned | tier | 用时 |
-| --- | --- | --- | --- |
-| 感知系统 记忆 节点 | 12,149 | T2_global_like | 2.87s |
-| graphrag 图谱 检索 | 12,149 | T2_global_like | 2.14s |
-| whitebox 白箱 条件 | 12,149 | T2_global_like | 3.70s |
-| 贝塞尔 曲线 工程 应力 | 12,149 | T2_global_like | 2.05s |
-
-→ **外部审计的「全表扫描」在生产库上被实测复现**（每查询 2–3.7 秒、12,149 节点全读）。
-
-## 2. S1b 开启（无需回填、零写入）：5.5–10.4 倍更少节点、3–8 倍更快
-
-| 查询 | scanned | 减少 | S1b 用时 | 命中的桶 |
-| --- | --- | --- | --- | --- |
-| 感知系统 记忆 节点 | 2,217 | 5.5× | 0.86s | cond_感知系统 / cond_复杂系统 / cond_动力学系统 |
-| graphrag 图谱 检索 | 1,733 | 7.0× | 0.55s | cond_graphrag / cond_graphiti |
-| whitebox 白箱 条件 | 1,497 | 8.1× | 0.60s | cond_whitebox_kb / cond_whitebox_py / cond_条件论 |
-| 贝塞尔 曲线 工程 应力 | 1,170 | 10.4× | 0.25s | cond_工程学 |
-
-**这是 S1b 的核心价值，而且不需要任何写入/回填**（桶在写入侧已建好，91.1% 节点有桶）。
-
-## 3. 但：召回集合发生了变化（必须如实报告）
-
-以「全关的全表扫描 top-10」为参照，S1b 的 **召回一致率只有 1/4**：4 个查询里 3 个的 top-10 组成不同
-（条数相同，但成员不同）——**被丢弃的异桶节点里，确实有词法高分命中**。
-
-**速度/召回权衡曲线（在拷贝上实测）**：
-
-| topk / min_sim | 平均 scanned | 召回一致 | 平均用时 |
-| --- | --- | --- | --- |
-| 1 / 0.20 | 1,579 | 1/4 | 0.55s |
-| 1 / 0.50 | 1,579 | 1/4 | 0.55s |
-| 3 / 0.34（默认） | 1,654 | 1/4 | 0.56s |
-| 6 / 0.20 | 1,686 | 1/4 | 0.57s |
-| 10 / 0.20 | 1,687 | 1/4 | 0.57s |
-
-结论：**放宽 topk / 降低 min_sim 几乎不改善召回一致，也不明显增加扫描** —— 说明丢掉的命中不在「更大的桶集合」里，
-而在**桶键推断没匹配上的桶**里（`domain_similarity` 对「查询词 ↔ 桶键」的匹配能力有限），且 kept 集合被
-**orphan/无桶兜底池**主导（本库 orphan 约 1,086 节点）。
-
-## 4. 诚实结论与建议
-
-1. **S1b 是一个「快模式」**：约 **7–8 倍更少扫描、4–6 倍更快**，但**不保证与全表扫描同结果**。
-   因此它必须保持 flag 默认关（现状如此），且**不建议**作为唯一检索路径启用——
-   这正是「域收敛不得丢召回」这条不变量在真实库上的边界。
-2. **要同时拿到速度与等价召回**，缺的是一层**廉价高精度候选生成器**：即把「词 → 命中节点」做成
-   **倒排/发布表**（词项索引），这样不必读遍所有文件就能取出词法命中，再交给既有路径排序。
-   契约 §7 允许「倒排只作 S1/S3 之后的候选内加速」——这是该层的正确定位（不是用它替代认知路径）。
-3. 该倒排层的建设成本在**索引 schema + 写入/重建维护**，属下一个里程碑级别的工作；
-   在它落地前，建议 S1b 只作为**可选加速**（默认关），并在启用时把 `meta.gates.s1b` 与
-   `covered_neg` 一并暴露给调用方，让调用方知道「本次是加速模式」。

package/docs/hive//347/234/237/345/256/236/345/272/223/347/253/257/345/210/260/347/253/257/345/256/236/346/265/213_S7/345/200/222/346/216/222/345/200/231/351/200/211/345/261/202_v0.1.md

@@ -1,126 +0,0 @@
-# 真实库端到端实测：S7 倒排候选层（候选内加速 + 零召回损失）（2026-09-19）
-
-> 方法：**真实库直连** `D:/Program Files/2_ai/AEIS/data/mdcg`（12,150 节点 / 1,446 MB），
-> 只写派生索引 `_postings.json` + `_postings_meta.json`，**不改任何节点内容**。
-> 旧的全库拷贝 `_store_copy` 已删除（不再使用拷贝）。
-> 实测期间该库正被注释补全流水线**持续改写**（1 分钟内 1,395 个节点文件 mtime 变化），
-> 这恰好把「快照过期」语义一起测了。
-
-## 1 基线（全关）：每个查询都扫全库
-
-| 查询 | scanned | tier | 用时 |
-| --- | --- | --- | --- |
-| 感知系统 记忆 节点 | 12,150 | T2_global_like | 2.76s |
-| graphrag 图谱 检索 | 12,150 | T2_global_like | 2.10s |
-| whitebox 白箱 条件 | 12,150 | T2_global_like | 3.60s |
-| 贝塞尔 曲线 工程 应力 | 12,150 | T2_global_like | 2.00s |
-| 泽塔欧米伽轴不存在的词 | 12,150 | T2_global_like | 3.19s |
-| 阿 | 12,150 | T2_global_like | 1.74s |
-
-构建发布表：**12,150 节点 / 201,650 词项 / 3,125,856 倒排条目 / 75.7 MB JSON / 6.5s**（幂等）。
-快照指纹校验开销：**0.064s**（1,074 个节点目录 + 索引文件各一次 stat，不重读节点）。
-
-## 2 候选窄化（`MDCG_S7_FRESHNESS=skip`，离线对照：假设快照新鲜）
-
-| 查询 | scanned | 缩减 | 用时 | S7 审计 |
-| --- | --- | --- | --- | --- |
-| 感知系统 记忆 节点 | 12,150 | 1.0× | 2.70s | `single_char_term` 回退 |
-| graphrag 图谱 检索 | 933 | 13.0× | 1.49s | `cands=933` |
-| whitebox 白箱 条件 | 11,499 | 1.06× | 3.65s | `cands=11499` |
-| 贝塞尔 曲线 工程 应力 | 723 | 16.8× | **0.45s（4.4× 快）** | `cands=723` |
-| 泽塔欧米伽轴不存在的词 | 7,167 | 1.7× | 2.62s | `cands=7167` |
-| 阿 | 12,150 | 1.0× | 1.81s | `single_char_term` 回退 |
-
-## 3 等价证据（这是 S7 存在的理由）
-
-以「逐条 (id, 分数, 次序)」为判据：
-
-- **`RESULT_PARITY 6/6`**：`results` 与全表扫描**逐条相同，含次序**。
-- `pre_cap`（命中集规模）与 `cap/candidates/tier/cut_order` 亦一致。
-- 唯一允许的差异是 `scanned`（正是加速本身）。
-
-两个必须点名的**真实缺陷**（均已在本次落地中修掉，并有不通过即红的用例）：
-
-1. **并列同分的次序**：候选曾按`集合`迭代序取出，而集合迭代序随进程哈希随机化而变
-   → 同分同重要性的条目次序会与全表不一致、甚至**逐个进程不同**。
-   修法：窄化时**保持索引原序**（候选集是过滤，不是重排）。
-   *证据*：`test_retr_s7` 第 12 节（3 个同内容同重要性节点，断言次序一致）。
-2. **组合退化（S7×S3）**：S7 曾把`窄化后的 entries`当作 S3 扩散的 allowed 集，
-   而 S3 的目标恰恰是「词面无交集、只沿 edges 可达」的节点 → S7+S3 会把 S3 的扩散清空。
-   修法：S3 的 allowed 恒取「S1/S2 门控后的全量候选」；S7 只做 T2 的加速器。
-   *证据*：`test_retr_s7` 第 11 节（临时还原该行 → 用例立即红：`expanded 2→0`）。
-
-**独立复核（编外验证单元）REJECT 的三条，均已修并补直接证据：**
-
-3. **组合退化（S7×语义路）**：`MDCG_SEMANTIC=1` 时「frontmatter 有 semantic 的节点」在
-   `_like` 之外**无条件入池**，而该标志**只在节点文件里**（索引快照无此键）→
-   候选阶段无法识别 → 窄化会漏读语义节点、丢召回。
-   修法：语义路开启时 S7 一律不窄化（`reason=semantic_on`，审计可见）。
-   *证据*：`test_retr_s7` 第 13b 节（含"无词面交集的语义节点 s2 仍入池"断言）。
-4. **自证式断言**：第 7 节原有一句 `check(..., True)`（恒真，等于没断言）。
-   修法：改为真断言「全量有命中 ∧ 0 < 候选数 < 全量命中数」——
-   该用例必须真的走在"窄化后命中不足 → T3 恢复全量"的路径上。
-5. **根目录自污染（根级节点）**：`_postings*.json` 就写在库根目录；
-   若用"根目录 mtime"判过期，快照刚建就被自己的写入改旧。
-   修法：根级路径（path 无目录）改为**逐文件记 mtime**（`file_mtimes`），
-   `dir_mtimes` 不再含空目录键。*证据*：`test_retr_s7` 第 15 节
-   （自身派生文件写入后仍新鲜；改写根级节点 → `root_file_touched`）。
-   （注：现行 `_scan_nodes` 只扫 `<layer>/**.md`，根级节点本不会进索引；
-   此修复是**防御性**的，成本为零。）
-
-## 4 真实行为（`MDCG_S7_FRESHNESS=auto`，默认）：过期即回退，绝不丢召回
-
-| 查询 | scanned（基线→skip→auto） | auto 的 s7 审计 |
-| --- | --- | --- |
-| graphrag 图谱 检索 | 12,150 → 933 → **933** | 快照仍新鲜 → 窄化 |
-| whitebox 白箱 条件 | 12,150 → 11,499 → 12,150 | `stale_index:dir_touched` → 回退 |
-| 贝塞尔 曲线 工程 应力 | 12,150 → 723 → 12,150 | `stale_index:dir_touched` → 回退 |
-
-**auto 模式下逐条一致仍是 6/6。** 语义是「宁可慢，不可丢召回」：
-注释流水线正在批量改写节点时，发布表秒级过期，查询自动落回全量；
-库安静下来后立即恢复窄化。
-
-## 5 设计要点
-
-1. **候选 ⊇ 真命中**：每词取其**全部 bigram 的发布列表交集**，各词并集；
-   再交既有 `_like` 精确过滤 → 召回与全表一致（契约 §7「候选内加速」定位）。
-   实测反证：某查询 `cands=934`、真命中 873，`hits - cands = 0`。
-2. **快照指纹**（节点数 + 节点目录 mtime + 索引文件 mtime / 0.064s）：
-   节点写入走 `fsutil.atomic_write`（temp + `os.replace`），目录 mtime 必然变化，
-   故 O(目录数) 次 stat 即可判定过期。
-3. **T3 兜底还原**：T2 未达阈值时强制恢复全量候选，并把 `scanned` 口径还原为
-   「从未窄化」（弃读量另记 `attempted`，诚实计量）。
-4. **抽样构建不算新鲜**：`--limit` 只索引部分节点，故**不写**快照指纹
-   → 检索一律回退（防「静默漏召回」）。
-
-## 6 诚实结论与局限
-
-1. **收益与查询选择性成正比**：`贝塞尔 曲线 工程 应力` 4.4× 更快（0.45s vs 2.00s）、
-   `graphrag 图谱 检索` 1.4×；而 `whitebox 白箱 条件` 只降 6%（该查询含极常见 2-gram
-   「条件」，11,499 个节点确实含它——候选集**本来就是**真命中集，不是实现问题）。
-2. **无 IDF 加权**：候选是「各词并集」，任一常见词就会把候选推到接近全库。
-   下一步可加「按词稀有度分层 + 提前剪枝」，但**不得**改为交集（`_like` 是任一词命中）。
-3. **单字词会让整条查询回退**：如「感知系统 记忆 节点」经同义词组展开得到单字词「库」
-   → 无法用 bigram 表达 → 整查询回退全量（安全但不加速）。
-   要覆盖单字词，需要字符级索引（下一里程碑）。
-4. **持续写入的库上会频繁过期**：批量改写期间 S7 落回基线；这是**正确性优先**的取舍，
-   不是失效。要长期吃到加速，需要**写入路径的增量维护（dirty 集）**——v1 未接
-   （每次写都 load+save 75MB 不可接受），当前用 `--if-stale` 重建守候。
-
-## 7 开关与审计
-
-| 环境变量 | 默认 | 作用 |
-| --- | --- | --- |
-| `MDCG_RETRIEVAL_PIPELINE` | 关 | 父开关（不开则 S7 代码路径不进入） |
-| `MDCG_GATE_S7_POSTINGS` | 关 | S7 子开关，**必须显式 =1** |
-| `MDCG_S7_FRESHNESS` | `auto` | `skip` 仅供离线对照实测（跳过指纹校验） |
-| `MDCG_SEMANTIC` | 关 | =1 时 S7 自动让位（`reason=semantic_on`）：语义节点面无法在候选阶段识别 |
-
-审计：`meta.gates.s7`，键位 `cands`（窄化后候选数）/ `in`（门控后全量）/ `terms`（查询词数）
-/ `reason`（`single_char_term` / `no_index` / `no_module` / `no_snapshot` / `no_candidate`
-/ `semantic_on`（`MDCG_SEMANTIC=1` 时不窄化）
-/ `stale_index:<dir_touched|node_count_changed|dirs_changed|index_touched|no_meta|root_file_touched|root_files_changed>`）
-/ `fallback`（`full_scan` / `no_candidate` / `t3_full`）/ `attempted`（T3 兜底时被弃读量）。
-
-运维：`python -X utf8 -m md_cg.build_postings --root <库根> --if-stale`（过期才重建，供守候环调用）；
-`--stats` 打印规模与 `stale_reason`。发布表是**派生索引**，可随时删除/重建，不影响节点。