@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/test_en_pipeline.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""原子级中英归一管线（lexicon + semantic + mdcg 集成）· 设计态验收。
+
+管线四件套：
+  lexicon/build_standard_en.py  英文标准库构建器（牛肉→cow_meat，构建即验证）
+  lexicon/standard_en.json      词条真源（语素拼接自洽 + snake_case）
+  semantic/en_normalizer.py     英文 query → 中文语素序列（时态归零→停用词→映射→专有词保留）
+  semantic/zh_en_atoms.py       中文文本 → 标准英文原子序列（反方向序列化）
+
+集成面（mdcg.en_zh_terms → expand_query_terms）：
+  英→中语素追加为召回词+打分 bigram（en_zh_bigrams）；默认关闭
+  （双语双路裁定：md_cg 主链路英文走独立 Jaccard 路，见 semantic/REPRODUCE.md），
+  MDCG_EN_ATOMS=1 显式开启；纯中文 query 零触发；
+  mdcos 四路 RRF 的 lexical 路同源复用 expand_query_terms，自动受益。
+
+运行：python -m md_cg.test_en_pipeline
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import shutil
+import tempfile
+
+from . import mdcg
+from .semantic import en_normalizer, zh_en_atoms
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, name=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(name)
+
+
+# ---- 1 · en_normalizer：屈折归零 ----
+ok(en_normalizer.strip_tense("Ate") == "eat", "irregular ate→eat")
+ok(en_normalizer.strip_tense("went") == "go", "irregular went→go")
+ok(en_normalizer.strip_tense("regretted") == "regret", "-ed 剥离+双辅音还原")
+ok(en_normalizer.strip_tense("running") == "run", "-ing 剥离+双辅音还原")
+ok(en_normalizer.strip_tense("stopped") == "stop", "stopped→stop")
+ok(en_normalizer.strip_tense("crossed") == "cross", "ss 保留（正字法例外）")
+ok(en_normalizer.strip_tense("called") == "call", "ll 保留（正字法例外）")
+ok(en_normalizer.strip_tense("dogs") == "dog", "-s 复数剥离")
+ok(en_normalizer.strip_tense("class") == "class", "-ss 例外不剥")
+ok(en_normalizer.strip_tense("be") == "be", "短词不动")
+
+# ---- 2 · en_normalizer：停用词 / 专有词 / 复合词 ----
+t, d = en_normalizer.normalize_en_query("I eat beef yesterday")
+ok(t == ["我", "吃", "牛肉", "昨天"], "端到端映射 beef→牛肉: %s" % t)
+t2, _ = en_normalizer.normalize_en_query("Caroline went to Paris")
+ok("Caroline" in t2 and "Paris" in t2, "专有词保留原名: %s" % t2)
+ok(en_normalizer.normalize_en_query("soul hub")[0] == ["灵枢"], "短语级复合 soul hub→灵枢")
+ok(en_normalizer.normalize_en_query("beef")[0] == ["牛肉"], "单词级复合 beef→牛肉")
+ok(en_normalizer.normalize_en_query("xyzzy")[0] == ["xyzzy"], "未知词 unknown_keep")
+t3, _ = en_normalizer.normalize_en_query("The dogs were running")
+ok("the" not in [x.lower() for x in t3] and "were" not in [x.lower() for x in t3],
+   "停用词剔除: %s" % t3)
+
+# ---- 2b · 置信分层与第三方暴露面修正（2026-09-15，第三方 LoCoMo 报告发现 5）----
+# 置信信号：mapped 词带 source（manual=人工校对层 / cedict=机械反查层）与
+# low_confidence（cedict 层=True——第一义项直译语境失配风险，警告不拒绝）
+t4, d4 = en_normalizer.normalize_en_query("The scavenger hunt was fun")
+ok("寻宝游戏" in t4, "内嵌短语扫描 scavenger hunt→寻宝游戏（长文本内生效）: %s" % t4)
+ok(d4 and d4[0].get("action") == "phrase_inline", "phrase_inline 留痕: %s" % d4[:1])
+ok(en_normalizer.normalize_en_query("scared")[0] == ["害怕"],
+   "手工层修正 scared→害怕（错切链路 scar×CEDICT 创痕）")
+ok(en_normalizer.normalize_en_query("shelter")[0] == ["收容所"], "手工层修正 shelter→收容所")
+ok(en_normalizer.normalize_en_query("tough")[0] == ["坚强"], "手工层修正 tough→坚强")
+ok(en_normalizer.normalize_en_query("three times a week")[0] == ["每周三次"],
+   "短语 three times a week→每周三次")
+ok(en_normalizer.normalize_en_query("times")[0] == ["次"], "手工层修正 times→次")
+t6, d6 = en_normalizer.normalize_en_query("great and thanks")
+lowc = [dd for dd in d6 if dd.get("action") == "mapped"]
+ok(lowc and all(dd.get("source") == "cedict" and dd.get("low_confidence") is True
+                for dd in lowc), "CEDICT 机械层命中=低置信: %s" % d6)
+t7, d7 = en_normalizer.normalize_en_query("pottery was great")
+mfd = [dd for dd in d7 if dd.get("orig", "").lower() == "pottery"]
+ok(mfd and mfd[0].get("source") == "manual" and mfd[0].get("low_confidence") is False,
+   "人工校对层=高置信+来源透出: %s" % mfd)
+ok(en_normalizer.low_confidence_terms(d6) == ["great", "thanks"],
+   "low_confidence_terms 审计提取（去重保序）: %s" % en_normalizer.low_confidence_terms(d6))
+
+# ---- 3 · zh_en_atoms：中文→标准英文原子序列 ----
+ok(zh_en_atoms.serialize("我昨天吃牛肉") == "i yester day eat cow meat",
+   "serialize 复合词拆原子")
+ok(zh_en_atoms.serialize("灵枢记忆库") == "soul hub memory store", "serialize 灵枢记忆库")
+ok(zh_en_atoms.segment("吃牛肉") == ["吃", "牛肉"], "贪心最长匹配")
+
+# ---- 4 · mdcg.en_zh_terms：集成单元（双态：默认关 / MDCG_EN_ATOMS=1 开） ----
+ok(mdcg.en_zh_terms("I eat beef yesterday") == [],
+   "默认关闭：en_zh_terms 不触发（双语双路裁定）")
+os.environ["MDCG_EN_ATOMS"] = "1"
+ok(mdcg.en_zh_terms("I eat beef yesterday") == ["吃", "牛肉", "昨天"],
+   "开启：en_zh_terms 三语素（代词剔除）: %s" % mdcg.en_zh_terms("I eat beef yesterday"))
+ok(mdcg.en_zh_terms("我昨天吃了牛肉面") == [], "纯中文零触发")
+ok(all(t not in mdcg._EN_ZH_PRONOUNS for t in mdcg.en_zh_terms("She saw my dog")),
+   "代词全剔除、实词保留")
+os.environ["MDCG_EN_ATOMS"] = "0"
+ok(mdcg.en_zh_terms("I eat beef") == [], "显式关闭回退 legacy")
+del os.environ["MDCG_EN_ATOMS"]
+
+# ---- 5 · expand_query_terms：召回词融合 + 纯中文回归守卫 ----
+os.environ["MDCG_EN_ATOMS"] = "1"
+et = mdcg.expand_query_terms("I ate beef yesterday")
+ok("牛肉" in et and "昨天" in et, "开启：英文 query 产出中文召回词: %s" % et)
+ok("eat" in et, "形态归一仍在（ate→eat）")
+del os.environ["MDCG_EN_ATOMS"]
+ok("牛肉" not in mdcg.expand_query_terms("I ate beef yesterday"),
+   "默认关闭：expand_query_terms 回 legacy（无中文语素）")
+_zc = "抑制剂怎么选择效果好"
+os.environ["MDCG_EN_ATOMS"] = "1"
+zc_on = mdcg.expand_query_terms(_zc)
+del os.environ["MDCG_EN_ATOMS"]
+zc_off = mdcg.expand_query_terms(_zc)
+ok(zc_on == zc_off, "纯中文 query 开关前后零差异（回归守卫）")
+
+# ---- 6 · 端到端：英文 query 召回中文记忆 ----
+tmp = tempfile.mkdtemp(prefix="mdcg_en_pipe_")
+try:
+    cg = mdcg.MdCG(root=tmp)
+    cg.add("n_beef", "昨天中午我在家里吃了牛肉面，配了可乐。",
+           layer="contextual", verification_basis="data")
+    cg.add("n_unrel", "我喜欢在雨天听爵士乐。",
+           layer="contextual", verification_basis="data")
+    cg.flush()
+    os.environ["MDCG_EN_ATOMS"] = "1"
+    res, _meta = cg.search("I ate beef yesterday", judge=False)
+    ids = [r[0].get("id") for r in res]
+    del os.environ["MDCG_EN_ATOMS"]
+    ok(len(res) >= 1 and ids[0] == "n_beef", "开启：英文 query top1 召回中文牛肉节点 %s" % ids)
+    res0, _m0 = cg.search("I ate beef yesterday", judge=False)   # 默认未设=关闭
+    ok(not res0 or all(r[1] <= 0 for r in res0),
+       "默认关闭：词面零重叠召回归零（跨语断点复现）")
+finally:
+    shutil.rmtree(tmp, ignore_errors=True)
+
+# ---- 7 · 构建自洽：standard_en.json / search_index.json ----
+_here = os.path.dirname(os.path.abspath(__file__))
+std = json.load(io.open(os.path.join(_here, "lexicon", "standard_en.json"), encoding="utf-8"))
+entries = {e["zh"]: e for e in std["entries"]}
+ok(len(entries) == 62, "词条数 62（真源守卫）")
+ok(entries["牛肉"]["standard_en"] == "cow_meat" and "beef" in entries["牛肉"]["legacy_en"],
+   "牛肉=cow_meat（legacy 别名 beef）")
+ok(entries["火山"]["standard_en"] == "fire_mountain", "语素序直拼 火山=fire_mountain")
+ok(sum(1 for e in std["entries"] if e["class"] == "opaque") == 5, "opaque 化石词 5 条")
+si = json.load(io.open(os.path.join(_here, "semantic", "search_index.json"), encoding="utf-8"))
+ok(si["meta"]["atom_count"] == 815 and si["meta"]["zh_terms"] == 815,
+   "search_index 与 atoms 数一致")
+ok(si["en_index"].get("meat") and "牛肉" in si["en_index"]["meat"],
+   "en_index 倒排 meat→牛肉")
+
+# ---- 8 · mdcos lexical 路同源受益 ----
+from .mdcos import MdCGOS
+from .mdcg import expand_query_terms as _eqt
+ok(_eqt is mdcg.expand_query_terms, "mdcos 复用同一 expand_query_terms（同源单实现）")
+
+print("en_pipeline: %d assertions all green" % PASS if not FAIL
+      else "en_pipeline: %d passed, %d FAILED: %s" % (PASS, FAIL, FAILS))
+raise SystemExit(1 if FAIL else 0)

package/md_cg/test_gain_gate.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""信息增益门槛（P-T-40④）+ 价值链筛选（#37）验证。
+
+断言面：
+  ① 首探放行：无探索历史 → σ=1.0, gain=None（无证据不否决）
+  ② 停滞冷却：连续 2 次终态无变化（DEFER_EXHAUSTED）→ σ=0；冷却过期 → σ=1.0
+  ③ 证据不足：仅 1 次记录不冷却；有变化（carried→resolved）→ σ=1.0
+  ④ 集成：proposals 端 σ 筛选拦截 → deferred 可审计；enforce_gain=False 放行
+  ⑤ explore 留痕 outcomes 实现值（下轮 gain_gate 的裁决输入）
+  ⑥ 预算豁免：bypass_gain=True 冷却中照常探索且留痕 bypass_gain
+
+运行：python -m md_cg.test_gain_gate
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import time
+
+from . import autonomy, metacognition
+from .fsutil import append_jsonl
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _sig(cg, t, query, d2, states):
+    append_jsonl(cg.reflection_log,
+                 {"t": t, "query": query, "d_prev": 1.0, "d_curr": 1.0,
+                  "d_delta": 0.0, "d2": d2, "states": states,
+                  "n_results": 3, "feedback": None})
+
+
+def _hist(cg, bid, terminals, t0=None, step=5.0):
+    t0 = time.time() - 10.0 if t0 is None else t0
+    for i, tml in enumerate(terminals):
+        append_jsonl(autonomy._explore_log_path(cg),
+                     {"type": "explore", "t": t0 + i * step,
+                      "actor": "test", "outcomes": {bid: tml}, "bids": [bid]})
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_gain_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+        bid = metacognition._key("反应堆冷却方案")
+
+        # ---------- ① 首探放行 ----------
+        g0 = autonomy.gain_gate(cg, bid, now=250.0)
+        ok(g0["sigma"] == 1.0 and g0["gain"] is None,
+           "①无探索历史 → σ=1.0, gain=None（Gain 是筛选器，无证据不否决）")
+
+        # ---------- ② 停滞冷却（DEFER_EXHAUSTED） ----------
+        _hist(cg, bid, ["carried", "carried"])
+        g1 = autonomy.gain_gate(cg, bid, now=time.time())
+        ok(g1["sigma"] == 0.0 and g1["gain"] == 0
+           and "DEFER_EXHAUSTED" in g1["reason"],
+           "②连续 2 次 carried 且冷却内 → σ=0（P-T-40 增益门槛）")
+        g2 = autonomy.gain_gate(cg, bid,
+                                now=(g1["last_t"] or 0.0) + 3600.0 + 1.0)
+        ok(g2["sigma"] == 1.0,
+           "②b冷却过期（now>last_t+3600）→ σ=1.0（不永久冻结）")
+
+        # ---------- ③ 证据不足 / 有变化 ----------
+        cg2_root = os.path.join(tmp, "root2")
+        os.makedirs(cg2_root, exist_ok=True)
+        cg2 = MdCGOS(cg2_root)
+        _hist(cg2, bid, ["carried"])
+        ok(autonomy.gain_gate(cg2, bid, now=250.0)["sigma"] == 1.0,
+           "③仅 1 次记录（< GAIN_WINDOW=2）不冷却（证据不足放行）")
+        cg3_root = os.path.join(tmp, "root3")
+        os.makedirs(cg3_root, exist_ok=True)
+        cg3 = MdCGOS(cg3_root)
+        _hist(cg3, bid, ["carried", "resolved"])
+        g3 = autonomy.gain_gate(cg3, bid, now=250.0)
+        ok(g3["sigma"] == 1.0 and g3["gain"] == 1,
+           "③b终态有变化（carried→resolved）→ 有增益 σ=1.0")
+
+        # ---------- ④ proposals 集成：σ 筛选拦截 ----------
+        cg4_root = os.path.join(tmp, "root4")
+        os.makedirs(cg4_root, exist_ok=True)
+        cg4 = MdCGOS(cg4_root)
+        _sig(cg4, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        _hist(cg4, bid, ["carried", "carried"])
+        pr = autonomy.proposals(cg4)
+        ok(not pr["proposals"] and len(pr["deferred"]) == 1
+           and pr["deferred"][0]["status"] == "deferred_exhausted",
+           "④冷却中盲区被 σ 筛选拦截 → deferred 可审计（不静默丢弃）")
+        ok(pr["deferred"][0]["score"] > 0,
+           "④b被拦提案的 ΔD 定价仍在（被拦原因=σ=0 非 score 低）")
+        ok("σ(Gain)" in pr["value_chain"],
+           "④c价值链口径声明（score 定价排序 + σ 资格筛选）")
+        pr2 = autonomy.proposals(cg4, enforce_gain=False)
+        ok(len(pr2["proposals"]) == 1 and not pr2["deferred"],
+           "④denforce_gain=False 放行（预算豁免入口）")
+
+        # ---------- ⑤ explore 留痕 outcomes ----------
+        cg5_root = os.path.join(tmp, "root5")
+        os.makedirs(cg5_root, exist_ok=True)
+        cg5 = MdCGOS(cg5_root)
+        cg5.add("k1", "# 功能名：反应堆冷却知识\n"
+                     "# 生效条件：问反应堆冷却方案\n"
+                     "# 子功能：知识片段\n"
+                     "# 执行：陈述知识\n"
+                     "# 验证方式：test\n"
+                     "# 不适用条件：无\n"
+                     "反应堆冷却方案概述。\n",
+               layer="knowledge", verification_basis="test")
+        _sig(cg5, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        ex = autonomy.explore(cg5, actor="test")
+        with open(autonomy._explore_log_path(cg5), encoding="utf-8") as f:
+            rec = [__import__("json").loads(x) for x in f if x.strip()][-1]
+        ok(rec.get("outcomes") and set(rec["outcomes"]) == set(rec["bids"]),
+           "⑤explore 留痕 outcomes（实现值，下轮 gain_gate 裁决输入）")
+        ok(all(t in ("unknowable", "no_anchor", "unresolved", "carried",
+                     "resolved") for t in rec["outcomes"].values()),
+           "⑤b实现值为诚实五态（不编造）")
+        ok(rec.get("bypass_gain") is False, "⑤c留痕 bypass_gain=False")
+
+        # ---------- ⑥ 预算豁免 ----------
+        cg6_root = os.path.join(tmp, "root6")
+        os.makedirs(cg6_root, exist_ok=True)
+        cg6 = MdCGOS(cg6_root)
+        cg6.add("k1", "# 功能名：反应堆冷却知识\n"
+                     "# 生效条件：问反应堆冷却方案\n"
+                     "# 子功能：知识片段\n"
+                     "# 执行：陈述知识\n"
+                     "# 验证方式：test\n"
+                     "# 不适用条件：无\n"
+                     "反应堆冷却方案概述。\n",
+               layer="knowledge", verification_basis="test")
+        _sig(cg6, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        _hist(cg6, bid, ["carried", "carried"])
+        ex2 = autonomy.explore(cg6, actor="test", bypass_gain=True)
+        ok(bool(ex2["steps"]) and ex2["steps"][0]["blindspot_id"] == bid,
+           "⑥预算豁免：冷却中盲区 bypass_gain=True 仍照常探索（2.9.3.1）")
+        with open(autonomy._explore_log_path(cg6), encoding="utf-8") as f:
+            rec6 = [__import__("json").loads(x) for x in f if x.strip()][-1]
+        ok(rec6.get("bypass_gain") is True,
+           "⑥b豁免留痕可审计（bypass_gain=True）")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\ngain_gate: {PASS} passed, {FAIL} failed")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_health_scale.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""体检读数规模纪律验证（O(1) 元数据口径，替代全量扫描）。
+
+背景（第 4 条取证）：审计日志无上界增长（实测 ~2 条/s、累计 ~21.5 M 条 / 4.0 GB），
+而健康度只需要「量级」这一 O(1) 信息。旧实现 `len(list(read_jsonl(p)))` 把只读体检
+绑到 O(n) 全量解析上（4.0 GB → RSS 5 GB+、数十分钟不返回、整条 MCP 通道被一次调用
+堵死）；改用流式数行仍要 O(n) 磁盘 IO，随运行时长线性劣化——同属「指标与代价错配」。
+
+断言面：
+  ① 缺失文件：零读数不炸（bytes=0 / events=0 / exact=True）
+  ② 阈值内：events 精确 == 日志行数（口径与物化读一致，改造不丢读数）
+  ③ 超阈值：只读元数据 + 尾部估算，exact=False，且**不触发任何全量计数**（O(n) 守卫）
+  ④ 估算忠于量级：与真实行数相对误差 < 20%（可用但不假装精确）
+  ⑤ health_os 集成：审计面走 _log_scale，**read_jsonl/count_jsonl 都不得再碰审计路径**
+     （防退回物化读/全量扫的核心回归守卫）
+  ⑥ 口径连续：小审计文件下 health_os 仍给出精确条数 + exact=True
+
+运行：python -m md_cg.test_health_scale
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+
+from . import mdcos as mdcos_mod
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _write_log(path, n, pad=100):
+    with open(path, "w", encoding="utf-8") as f:
+        for i in range(n):
+            f.write(json.dumps({"t": float(i), "op": "add", "i": i,
+                                "pad": "x" * pad}) + "\n")
+    return os.path.getsize(path)
+
+
+class _Spy:
+    """记录 mdcos 模块级 read_jsonl / count_jsonl 的调用路径（探针）。"""
+
+    def __enter__(self):
+        self.read, self.count = [], []
+        self._read, self._count = mdcos_mod.read_jsonl, mdcos_mod.count_jsonl
+        spy = self
+
+        def _r(p, *a, **k):
+            spy.read.append(p)
+            return spy._read(p, *a, **k)
+
+        def _c(p, *a, **k):
+            spy.count.append(p)
+            return spy._count(p, *a, **k)
+
+        mdcos_mod.read_jsonl, mdcos_mod.count_jsonl = _r, _c
+        return self
+
+    def __exit__(self, *exc):
+        mdcos_mod.read_jsonl, mdcos_mod.count_jsonl = self._read, self._count
+        return False
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_scale_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+        audit = cg.audit_log
+
+        # ---------- ① 缺失文件 ----------
+        s = cg._log_scale(os.path.join(root, "_nope.jsonl"))
+        ok(s["bytes"] == 0 and s["events"] == 0 and s["exact"] is True,
+           "①缺失日志 → 零读数不炸（bytes=0/events=0/exact=True）")
+
+        # ---------- ② 阈值内精确 ----------
+        n = 200
+        size = _write_log(audit, n)
+        cg.AUDIT_COUNT_MAX_BYTES = size + 1
+        s = cg._log_scale(audit)
+        ok(s["exact"] is True and s["events"] == n and s["bytes"] == size,
+           "②规模在阈值内 → 精确条数（%d 行，与物化读口径一致）" % n)
+
+        # ---------- ③ 超阈值：O(1)，不触发全量计数 ----------
+        cg.AUDIT_COUNT_MAX_BYTES = 1024          # 人工压低阈值，等价于 GB 级日志
+        with _Spy() as spy:
+            s = cg._log_scale(audit)
+        ok(s["exact"] is False and s["bytes"] == size,
+           "③超阈值 → exact=False，bytes 仍为 O(1) 精确元数据")
+        ok(s["events"] is not None and s["events"] > 0,
+           "③b超阈值仍给读数（尾部采样估算），不是拒不回答")
+        ok(not spy.count and not spy.read,
+           "③c超阈值分支零全量调用（未 count_jsonl / 未 read_jsonl）——O(n) 守卫")
+
+        # ---------- ④ 估算忠于量级 ----------
+        rel = abs(s["events"] - n) / float(n)
+        ok(rel < 0.20,
+           "④估算与真实行数相对误差 %.1f%% < 20%%（量级可用，不假装精确）" % (rel * 100))
+
+        # ---------- ⑤ health_os 集成：审计路径零全量读 ----------
+        with _Spy() as spy:
+            h = cg.health_os()
+        o = h["os"]
+        ok(o["audit_events_exact"] is False and o["audit_bytes"] == size
+           and o["audit_events"] == s["events"],
+           "⑤health_os 透出审计量级（exact=False/bytes 精确/events=估算）")
+        ok(not any("_audit.jsonl" in p for p in spy.read),
+           "⑤bhealth_os 不再对审计日志做物化读（read_jsonl 未被以审计路径调用）")
+        ok(not any("_audit.jsonl" in p for p in spy.count),
+           "⑤chealth_os 不再对审计日志做全量计数（count_jsonl 未被以审计路径调用）")
+
+        # ---------- ⑥ 口径连续：小日志仍精确 ----------
+        cg.AUDIT_COUNT_MAX_BYTES = 64 << 20
+        root2 = os.path.join(tmp, "root2")
+        os.makedirs(root2, exist_ok=True)
+        cg2 = MdCGOS(root2)
+        _write_log(cg2.audit_log, 37)
+        o2 = cg2.health_os()["os"]
+        ok(o2["audit_events"] == 37 and o2["audit_events_exact"] is True,
+           "⑥小日志 → health_os 仍给精确条数（37 行，改造不丢读数）")
+
+        # ---------- ⑦ 真实写入风格：流式行数 == 物化条数（口径等价） ----------
+        import random
+
+        from .fsutil import append_jsonl, read_jsonl
+        real = os.path.join(root, "_real.jsonl")
+        for i in range(50):
+            append_jsonl(real, {"i": i, "pad": "y" * random.randint(1, 80)})
+        n_real = len(list(read_jsonl(real)))
+        s_real = cg._log_scale(real)
+        ok(s_real["events"] == n_real == 50 and s_real["exact"] is True,
+           "⑦完整写入日志：流式行数 %s == 物化条数 %d（口径逐位相等）"
+           % (s_real["events"], n_real))
+        os.remove(real)
+
+        # ---------- ⑧ 半截尾行边界：下界口径，最多差 1 行 ----------
+        bad = os.path.join(root, "_bad.jsonl")
+        with open(bad, "w", encoding="utf-8") as f:
+            f.write('{"ok": 1}\nnot-json\n{"ok": 2}')      # 末行未终止 + 非法 JSON
+        sb = cg._log_scale(bad)
+        n_material = len(list(read_jsonl(bad)))
+        ok(sb["events"] == 2 and sb["exact"] is True,
+           "⑧半截尾行不计入（换行数 2 vs 物化条数 %d）——下界口径，差 1 行在量级容差内"
+           % n_material)
+        os.remove(bad)
+
+        cg.close()
+        cg2.close()
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\nhealth_scale: {PASS} pass / {FAIL} fail")
+    if FAILS:
+        for f in FAILS:
+            print(f" - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_identity_attribution.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+"""test_identity_attribution · 写入归属（writer/session/harness）与检索会话过滤
+
+背景：多会话共用一个 root 时，读取记忆无法区分「本会话写的」与「其他会话写的」。
+修复：写入自动归属（MdCGSecure 写路径注入 writer/session/harness）+ 检索
+session= 过滤（_candidates 一处生效：search/search_rrf/recall 全链路）+
+审计/提案入队补 session + MDCG_SESSION env（部署侧固定会话归属）。
+边界：归属是归因维度不参与授权；MCP 面不透传写入归属入参（客户端不得伪造），
+库层调用方可显式覆盖（setdefault）；writer 语义=最后写入者。
+"""
+import glob
+import json
+import shutil
+import sys
+import tempfile
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Windows cmd 默认 GBK 代码页：带圈数字 ⑪⑫⑬ 等不在 GBK 内，打印即
+# UnicodeEncodeError，且崩在断言之后、报告之前 —— 同一测试「因环境而异」。
+# 测试自带 UTF-8 兜底，不依赖调用方记得加 -X utf8（可复现性纪律）。
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+from md_cg.mdcg import MdCG
+from md_cg.mdcos import MdCGSecure
+from md_cg.security import DEFAULT_SENSITIVITY, Principal
+
+_ok = 0
+_fail = []
+
+
+def check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("[PASS] " + name)
+    else:
+        _fail.append(name)
+        print("[FAIL] %s  · %s" % (name, str(detail)[:240]))
+
+
+def _p(actor, session):
+    return Principal(actor=actor, clearance=DEFAULT_SENSITIVITY,
+                     can_write=True, can_admin=True, role="designer",
+                     session=session, harness="test-harness")
+
+
+def _last_jsonl(pattern):
+    rec = None
+    for path in glob.glob(pattern, recursive=True):
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                if line.strip():
+                    rec = json.loads(line)
+    return rec
+
+
+def _row(r):
+    """search 原生返回 (node, score, qual, prov) tuple；dict 则原样。"""
+    return r if isinstance(r, dict) else (r[0] if r else {})
+
+
+root = tempfile.mkdtemp(prefix="mdcg_attr_")
+try:
+    cg = MdCGSecure(root, principal=_p("alice", "sess_A"))
+
+    # ① 写入自动归属
+    nid1 = cg.add("n1", "甲会话写的知识条目", layer="knowledge")
+    fm1 = cg.get(nid1)["frontmatter"]
+    check("①写入自动归属 writer/session",
+          fm1.get("writer") == "alice" and fm1.get("session") == "sess_A", fm1)
+    check("①b harness 归属落盘", fm1.get("harness") == "test-harness", fm1)
+
+    # ② 索引同步（_stage 透传）
+    e1 = cg.index["nodes"].get(nid1) or {}
+    check("②索引带归属", e1.get("session") == "sess_A", e1)
+
+    # ③ 显式覆盖（库层调用方可传；MCP 面不透传）
+    nid2 = cg.add("n2", "显式会话标签条目", layer="knowledge", session="sess_custom")
+    fm2 = cg.get(nid2)["frontmatter"]
+    check("③显式覆盖尊重调用方", fm2.get("session") == "sess_custom", fm2)
+
+    # ④ 更新刷新为最后写入者（另一身份写同 id）
+    cg2 = MdCGSecure(root, principal=_p("bob", "sess_B"))
+    cg2.add("n1", "乙会话更新了这条", layer="knowledge")
+    fm1b = cg.get("n1")["frontmatter"]
+    check("④更新刷新 writer/session",
+          fm1b.get("writer") == "bob" and fm1b.get("session") == "sess_B", fm1b)
+
+    # ⑤ 检索透出归属（node.frontmatter 零改动自动生效）
+    res, _meta = cg2.search("乙会话更新")
+    hit = next((_row(r) for r in res if _row(r).get("id") == "n1"), None)
+    check("⑤检索透出归属",
+          bool(hit) and (hit.get("frontmatter") or {}).get("session") == "sess_B",
+          [_row(r).get("id") for r in res])
+
+    # ⑥ search 会话过滤
+    res_b, _ = cg2.search("知识", session="sess_B")
+    ids_b = {_row(r).get("id") for r in res_b}
+    check("⑥search 会话过滤", "n1" in ids_b and "n2" not in ids_b, ids_b)
+
+    # ⑦ recall 会话过滤（RRF 主链）
+    pack = cg2.recall("知识", session="sess_custom")
+    hits = pack.get("pack") if isinstance(pack, dict) else None
+    hid = {_row(h).get("id") for h in (hits or [])}
+    check("⑦recall 会话过滤", "n2" in hid and "n1" not in hid,
+          list(hid) or (list(pack.keys()) if isinstance(pack, dict) else type(pack)))
+
+    # ⑧ 审计带 session
+    last_audit = _last_jsonl(os.path.join(root, "**", "*audit*.jsonl"))
+    check("⑧审计带 session",
+          bool(last_audit) and last_audit.get("session") == "sess_B", last_audit)
+
+    # ⑨ propose 入队带 session
+    cg2.propose("n_prop", "提案内容", layer="knowledge")
+    rec_inbox = _last_jsonl(os.path.join(root, "**", "*inbox*.jsonl"))
+    check("⑨提案入队带 session",
+          bool(rec_inbox) and rec_inbox.get("session") == "sess_B", rec_inbox)
+
+    # ⑩ 旧节点兼容（基类写入、无归属字段）
+    cg0 = MdCG(root)
+    cg0.add("legacy", "旧库无归属节点的知识", layer="knowledge")
+    cgs = MdCGSecure(root, principal=_p("carol", "sess_C"))
+    res_all, _m = cgs.search("旧库无归属")
+    check("⑩旧节点默认检索不受影响",
+          any(_row(r).get("id") == "legacy" for r in res_all),
+          [_row(r).get("id") for r in res_all])
+    res_f, _ = cgs.search("旧库无归属", session="sess_C")
+    check("⑩b 旧节点被会话过滤排除（不炸）",
+          all(_row(r).get("id") != "legacy" for r in res_f),
+          [_row(r).get("id") for r in res_f])
+
+    # ⑪⑫ 负记忆归属
+    rn = cg2.add_rejected("假设X", "已被证伪")
+    fm_r = cg2.get(rn)["frontmatter"]
+    check("⑪负记忆归属", fm_r.get("writer") == "bob"
+          and fm_r.get("session") == "sess_B", fm_r)
+    ru = cg2.add_unresolved("问题Y", "已有线索若干")
+    fm_u = cg2.get(ru)["frontmatter"]
+    check("⑫未解清单归属", fm_u.get("session") == "sess_B", fm_u)
+
+    print("\n通过 %d / 失败 %d" % (_ok, len(_fail)))
+    sys.exit(1 if _fail else 0)
+finally:
+    shutil.rmtree(root, ignore_errors=True)