@furongjun1999/dsh-memory 0.7.1 → 0.7.3

package/md_cg/test_sleep_p1.py

@@ -34,6 +34,14 @@
   G7 冲突挂起——主库/影子同 id 并发改动 ⇒ 该 id 进 `conflicts`、**未写进主库**、
      也未进影子分支的树；另一条（未冲突的）正常合并。
   G8 回滚——对合并提交 `revert`：主库真源面回到合并前，历史不丢（只增不减）。
+  G9 物化窗口内漂移（issue #60）——`ok` 与 `face_stable` 拆开后，活跃工作区
+     （每轮都有真源面改动）**照常迭代**：phases 含 iterate、②③④ 不再记
+     「本轮未迭代」、台账落一条含 iterate 的记录。
+  G10 手动入口（issue #61）——`--once` 不等 tick 即落台账并打印与台账同源的
+     「本轮未迭代原因」；`--once --dry-run` 只预览（零台账新增、零物化）；
+     `--dry-run` 单独使用报错；`--status` 带 `last_cycle` 段。
+  G11 物化未完成（父进程持根级锁 ⇒ busy）——②③④ 记「物化未完成：…」，
+     与门拦 gate_reason **可区分**（`rec["skipped"]` 为空、两处文案同源）。
 
 运行：python -X utf8 -m md_cg.test_sleep_p1
       python -X utf8 -m md_cg.test_sleep_p1 --mutate         # 定点变异自证
@@ -59,6 +67,7 @@ import types
 
 from . import sleep as SL
 from . import sustain as SUS
+from .fsutil import FileLock
 
 _PASS = []
 _FAIL = []
@@ -611,7 +620,203 @@ def g8_revert():
        "G8e 历史只增不减（revert 自身也进历史）")
 
 
-_GROUPS = (g0, g8, g1, g2, g3, g4, g5, g6, g7, g8_revert)
+# ---------------------------------------------------------------- G9
+class _Cap(io.StringIO):
+    """捕获 `_main` 的输出——它开头会调 `sys.stdout.reconfigure`，纯 StringIO
+    没有这个方法（真 stdout 才有），故补一个空实现。"""
+
+    def reconfigure(self, **_kw):                     # noqa: D102 —— 空实现
+        pass
+
+
+def _drift_probe(S, *, at=2, rel="knowledge/n_drift.md"):
+    """物化窗口内漂移模拟（补丁就地装上）：第 `at` 次调用 `source_face_hashes` 时
+    多返回一条新增路径（其余调用照真源）；返回**还原函数**。
+
+    补丁打在**函数实际读取的命名空间**上（`materialize.__globals__`）而不是模块
+    属性：变异自证时 `SL` 是 exec 出来的模块，其函数读 exec 命名空间，而模块对象
+    的 `__dict__` 只是它的副本——打在模块属性上，变异后的模块内部调用看不到补丁
+    （本机实测：G9 会在变异下空转）。真源码下两者是同一个 dict。
+    """
+    ns = S.materialize.__globals__
+    real = ns["source_face_hashes"]
+    seen = {"n": 0}
+
+    def _wrap(r):
+        seen["n"] += 1
+        d = dict(real(r))
+        if seen["n"] == at:
+            d[rel] = "0" * 64
+        return d
+
+    ns["source_face_hashes"] = _wrap
+
+    def _restore():
+        ns["source_face_hashes"] = real
+
+    return _restore
+
+
+def g9():
+    print("== G9 物化窗口内漂移 ⇒ 照常迭代（#60：不再自我否决）==")
+    S = globals()["SL"]
+    gen, root, state = _fixture(contextual_hot=1, unverified=1)
+    from .mdcos import MdCGOS
+    cg = MdCGOS(root)
+    n0 = len(S.read_ledger())
+    restore = _drift_probe(S)
+    try:
+        r = S.run_cycle(cg, batch="G9B1", round_index=1, now="03:00")
+    finally:
+        restore()
+    ph = r["steps"][6]["phases"]
+    mat = ph.get("materialize") or {}
+    ok(mat.get("ok") is True and mat.get("face_stable") is False,
+       "G9a 漂移窗口内物化仍记 ok=True、face_stable=False", mat)
+    ok(bool(ph.get("iterate")),
+       "G9b **物化成功即迭代**：phases 含 iterate 读数（非 None）", sorted(ph))
+    ok(all(not s.get("skipped") for s in r["steps"][1:4]),
+       "G9c 九步 ②③④ 不再是「本轮未迭代」（裁在门拦或物化未完成，二者皆非）",
+       [s.get("skipped") for s in r["steps"][1:4]])
+    ok(len(S.read_ledger()) == n0 + 1, "G9d 本轮记账（台账 +1）",
+       (n0, len(S.read_ledger())))
+    led = S.read_ledger()[-1]
+    ok(led.get("batch") == "G9B1"
+       and "iterate" in ((led.get("steps") or [{}] * 7)[6].get("phases") or {}),
+       "G9e 台账落一条**含 iterate** 的记录（可回看「上次为何迭代/未迭代」）",
+       (led.get("batch"), sorted((((led.get("steps") or [{}] * 7)[6]
+                                   .get("phases") or {})))))
+
+
+# ---------------------------------------------------------------- G10
+def g10():
+    print("== G10 手动入口：--once / --once --dry-run / --status（#61 不等 tick）==")
+    S = globals()["SL"]
+    import time as _t
+    gen, root, state = _fixture(contextual_hot=1, unverified=1)
+    lt = _t.localtime()
+    cur = lt.tm_hour * 60 + lt.tm_min
+    a0, b0 = (cur + 120) % 1440, (cur + 180) % 1440
+    win = "%02d:%02d-%02d:%02d" % (a0 // 60, a0 % 60, b0 // 60, b0 % 60)
+    ok(S.in_window(win, None) is False,
+       "G10 前置：构造出的窗口确定性地不含当前时刻（%s）" % win)
+    # ① --once --dry-run（窗口内）：零台账新增、零物化，打印「将执行…」
+    os.environ["MDCG_SLEEP_WINDOW"] = ""
+    n0 = len(S.read_ledger())
+    cap = _Cap()
+    with contextlib.redirect_stdout(cap):
+        rc = S._main(["--root", root, "--once", "--dry-run"])
+    txt = cap.getvalue()
+    ok(rc == 0 and len(S.read_ledger()) == n0,
+       "G10a --once --dry-run **零台账新增**", (rc, n0, len(S.read_ledger())))
+    ok("将执行物化→迭代→对账→合并" in txt,
+       "G10b 预览打印「将执行物化→迭代→对账→合并」",
+       [l for l in txt.splitlines() if l.startswith("预览")])
+    ok(not os.path.isdir(os.path.join(state, "sleep", "shadow"))
+       and not os.path.isdir(os.path.join(state, "sleep", "lib.git")),
+       "G10c dry-run **不物化**（影子与版本库都没建出来）")
+    # ② --dry-run 单独使用 → 报错
+    cap2, err2 = _Cap(), io.StringIO()
+    with contextlib.redirect_stdout(cap2), contextlib.redirect_stderr(err2):
+        rc2 = S._main(["--root", root, "--dry-run"])
+    ok(rc2 == 2 and "--dry-run" in err2.getvalue(),
+       "G10d --dry-run 单独使用给出报错（返回 2，不执行任何动作）",
+       (rc2, err2.getvalue().strip()))
+    # ③ --once（窗口外，确定性构造）：落台账 + 打印与台账同源的原因
+    os.environ["MDCG_SLEEP_WINDOW"] = win
+    n1 = len(S.read_ledger())
+    cap3 = _Cap()
+    with contextlib.redirect_stdout(cap3):
+        rc3 = S._main(["--root", root, "--once"])
+    txt3 = cap3.getvalue()
+    led = S.read_ledger()
+    ok(rc3 == 0 and len(led) == n1 + 1 and len(led) > n0,
+       "G10e --once 不等 tick 即落一条台账记录", (rc3, n1, len(led)))
+    rec = led[-1]
+    ok("窗口外" in (rec.get("skipped") or ""),
+       "G10e2 台账记门拦原因（窗口外）", rec.get("skipped"))
+    ok("本轮未迭代原因：" in txt3 and (rec.get("skipped") or "") in txt3,
+       "G10e3 --once 显式打印「本轮未迭代原因」，文案与台账同源",
+       [l for l in txt3.splitlines() if l.startswith("本轮未迭代原因")])
+    ok(all(s.get("skipped") == rec.get("skipped") for s in rec["steps"][1:4]),
+       "G10e4 台账 ②③④ 的 skip 文案 == 同一门拦原因（不静默）",
+       [s.get("skipped") for s in rec["steps"][1:4]])
+    # ④ --status：last_cycle = 最近一条台账记录
+    def _status():
+        capx = _Cap()
+        with contextlib.redirect_stdout(capx):
+            rcx = S._main(["--root", root, "--status"])
+        return rcx, json.loads(capx.getvalue())
+
+    rcx, doc = _status()
+    lc = doc.get("last_cycle") or {}
+    ok(rcx == 0 and lc.get("batch") == rec.get("batch")
+       and lc.get("round") == rec.get("round")
+       and lc.get("candidates") == rec.get("candidates")
+       and lc.get("skipped") == rec.get("skipped"),
+       "G10f --status 的 last_cycle = 最近一条台账记录（t/batch/round/"
+       "candidates/skipped）", lc)
+    ok(lc.get("not_iterated_reason") == rec.get("skipped")
+       and "窗口外" in (lc.get("not_iterated_reason") or ""),
+       "G10f2 last_cycle 带「上次为何没迭代」的一致原因",
+       lc.get("not_iterated_reason"))
+    ok(lc.get("steps_skip") == {s.get("step"): s.get("skipped")
+                                for s in rec["steps"][1:4]},
+       "G10f3 last_cycle 带 ②③④ 的 skip 文案", lc.get("steps_skip"))
+    # ⑤ --once（窗口内）：真跑一轮（物化→迭代→对账→合并）后再看 --status
+    os.environ["MDCG_SLEEP_WINDOW"] = ""
+    cap4 = _Cap()
+    with contextlib.redirect_stdout(cap4):
+        rc4 = S._main(["--root", root, "--once"])
+    rec4 = S.read_ledger()[-1]
+    ok(rc4 == 0 and rec4.get("skipped") is None
+       and (rec4.get("candidates") or 0) > 0,
+       "G10g 窗口内 --once 真迭代（非只记账）",
+       {k: rec4.get(k) for k in ("skipped", "candidates", "merged")})
+    rcx2, doc2 = _status()
+    lc2 = doc2.get("last_cycle") or {}
+    mz = lc2.get("materialize") or {}
+    ok(isinstance(mz, dict) and all(k in mz for k in ("ok", "busy", "face_stable"))
+       and mz.get("ok") is True and mz.get("busy") is False
+       and mz.get("face_stable") is True,
+       "G10h last_cycle 带 phases.materialize 摘要（ok/busy/face_stable）", mz)
+    ok(lc2.get("not_iterated_reason") is None,
+       "G10h2 迭代过的一轮不报「未迭代原因」", lc2.get("not_iterated_reason"))
+    os.environ.pop("MDCG_SLEEP_WINDOW", None)
+
+
+# ---------------------------------------------------------------- G11
+def g11():
+    print("== G11 物化未完成（根级锁被占）⇒ ②③④ 记**可区分**的 skip 文案 ==")
+    S = globals()["SL"]
+    gen, root, state = _fixture(contextual_hot=1, unverified=1)
+    from .mdcos import MdCGOS
+    cg = MdCGOS(root)
+    lp = S.lock_path()
+    with FileLock(lp, timeout=5.0, strict=False) as lk:
+        ok(lk.acquired is True, "G11 前置：父进程已持根级锁", lp)
+        r = S.run_cycle(cg, batch="G11B1", round_index=1, now="03:00",
+                        timeout=0.3)
+    ph = r["steps"][6]["phases"].get("materialize") or {}
+    ok(ph.get("ok") is False and ph.get("busy") is True,
+       "G11a 取不到根级锁 ⇒ 物化 ok=False、busy=True（早退路径语义不变）", ph)
+    texts = [s.get("skipped") for s in r["steps"][1:4]]
+    ok(all(t and t.startswith("物化未完成：") for t in texts),
+       "G11b ②③④ 记「物化未完成：…」——与门拦 gate_reason **可区分**", texts)
+    ok(r.get("skipped") is None,
+       "G11c 四道门全过 ⇒ rec['skipped'] 为空：两类未迭代原因不混同",
+       r.get("skipped"))
+    ok(S.cycle_not_iterated_reason(r) == texts[0],
+       "G11d 「本轮未迭代原因」== 台账 ②③④ 的同一文案（CLI 与台账同源）",
+       S.cycle_not_iterated_reason(r))
+    led = S.read_ledger()[-1]
+    ok(led.get("batch") == "G11B1"
+       and all((s.get("skipped") or "").startswith("物化未完成：")
+               for s in led["steps"][1:4]),
+       "G11e 物化未完成的一轮同样落台账（可回看）", led.get("batch"))
+
+
+_GROUPS = (g0, g8, g1, g2, g3, g4, g5, g6, g7, g8_revert, g9, g10, g11)
 
 
 def _run_groups() -> int:
@@ -639,8 +844,14 @@ _MUTATIONS = (
     ("窗口跨午夜判据写反", "md_cg/sleep.py",
      "    return t >= start or t < end",
      "    return t >= start and t < end"),
+    # 锚点同步（2026-10-06）：本条此前锚在裁定⑰之前的旧 parse_window 形态上，实现
+    # 改了而表未同步 ⇒ `--mutate` 恒以 ANCHOR-MISS 退出 2（**先存**缺陷，非本批引入；
+    # 判据 scripts/run_tests.py 不跑 --mutate，故一直未被门禁兜住）。此处按当前实现
+    # 重新锚定**同一意图**的变异（留空/非法不再当作全时段，回落 (0,1) 窄窗）——不放宽
+    # 也不删除任何既有断言。实测红集 7 项 = G1f/G1h/G1h3 ＋ 依赖空窗全时段入口的新
+    # 断言组 G10b/G10g/G10h（编排侧 --mutate 亲跑读数）。
     ("留空/非法窗口不再视作全时段", "md_cg/sleep.py",
-     "    s = str(spec or \"\").strip()\n    if not s or \"-\" not in s:\n        return None",
+     "    s = str(spec or \"\").strip()\n    if not s:\n        return None                      # 留空 = 全时段（唯一显式入口）",
      "    s = str(spec or \"\").strip()\n    if not s or \"-\" not in s:\n        return (0, 1)"),
     ("密文项不再被闸拦下（会随分支入册）", "md_cg/sleep.py",
      '                                 "reason": ("影子侧为密文节点（无密钥不重放、"\n'
@@ -676,6 +887,11 @@ _MUTATIONS = (
      "                    pass                       # 睡眠周期失败不中断常驻\n"
      "                next_sleep = now + self.sleep_interval\n",
      ""),
+    # issue #60：物化 ok 语义回退成旧「真源面未变才算成功」——活跃工作区（每轮
+    # 都有真源面改动）将永不自迭代；预期红集 = 断言组 G9（G9b/G9c/G9e）。
+    ("物化 ok 语义回退（漂移即不迭代）", "md_cg/sleep.py",
+     '        if m.get("ok"):\n            # **物化成功即迭代**（issue #60）',
+     '        if m.get("ok") and m.get("face_stable"):\n            # **物化成功即迭代**（issue #60）'),
     ("两入口不再共用 sleep 读取器（写死 auto）", "md_cg/mcp_server.py",
      "        sleep_interval=_sleep.sleep_interval(),\n"
      "        auto_sleep=_sleep.sleep_enabled(),\n"

package/md_cg/test_state_events.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+"""test_state_events · 状态事件账本（append-only）＋检验强度字段（check_strength）
+
+多主体世界模型对齐 v0.1 §2（L0「事件必记账」/ L1「检验强度」）落地的行为守卫。
+
+运行：python -m md_cg.test_state_events
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+
+from . import state_events
+from .mdcos import MdCGOS
+from .writepipe import _AUTONOMY_META_KEYS, default_pipeline
+
+_ok = 0
+_fail = []
+
+
+def check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("[ok] " + name)
+    else:
+        _fail.append(name)
+        print("[FAIL] %s  · %s" % (name, str(detail)[:240]))
+
+
+def _dump(r):
+    return json.dumps(r, sort_keys=True, ensure_ascii=False)
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_se_test_")
+    cg = MdCGOS(os.path.join(tmp, "root"))
+
+    # ---- 1. append 与读回（落盘序）----
+    state_events.append(cg, "鲸娘", "住所", old="帐篷", new="海景别墅",
+                        kind="migration", seq=553, evidence="用户侧 r0553")
+    state_events.append(cg, "鲸娘", "房贷", old="有", new=None,
+                        kind="retraction", seq=577, evidence="用户侧 r0577")
+    state_events.append(cg, "鲸娘", "烤箱", old=None, new="已启用",
+                        kind="enablement", seq=595, evidence="AI 侧 r0595")
+    recs = state_events.read(cg)
+    check("append 3 条 → read 回 3 条", len(recs) == 3, len(recs))
+    check("落盘序保持（首条=迁移）", recs and recs[0]["kind"] == "migration",
+          recs[0] if recs else None)
+    check("五元在场", bool(recs) and all(
+        k in recs[0] for k in ("subject", "slot", "old", "new", "seq", "evidence")),
+        sorted(recs[0].keys()) if recs else None)
+
+    # ---- 2. append-only 不覆盖（连写后旧记录逐条原样）----
+    before = [_dump(r) for r in recs]
+    state_events.append(cg, "鲸娘", "住所", old="海景别墅", new="海边小屋",
+                        kind="migration", seq=700, evidence="r0700")
+    after = state_events.read(cg)
+    check("追加不覆盖（4 条）", len(after) == 4, len(after))
+    check("旧 3 条逐条原样", [_dump(r) for r in after[:3]] == before)
+
+    # ---- 3. 重启（新实例）读回 ----
+    cg2 = MdCGOS(cg.root)
+    check("新实例读回 4 条", len(state_events.read(cg2)) == 4)
+
+    # ---- 4. 过滤与 limit ----
+    check("按 slot 过滤", len(state_events.read(cg, slot="住所")) == 2)
+    check("按 kind 过滤", len(state_events.read(cg, kind="retraction")) == 1)
+    check("limit 取末 2 条", len(state_events.read(cg, limit=2)) == 2)
+    check("limit 末条为最后写入", state_events.read(cg, limit=1)[0]["seq"] == 700)
+
+    # ---- 5. 参数校验（fail-closed）----
+    # 注：空 subject/空白 slot 两用例须带 new="v"——否则同时命中「old/new 同空」
+    # 校验（2026-10-05 复核：无判别力断言，删目标校验后仍照绿）。
+    # 独立库：拒绝用例若在某处校验被误删的变异态下真落盘，只污染本库，
+    # 不波及第 6 段条数统计（编排侧变异自证：1 变异 → 1 红的干净定点）。
+    bad_root = MdCGOS(os.path.join(tmp, "bad_root"))
+    for bad, nm in [
+        (dict(subject="", slot="x", new="v"), "空 subject 拒绝"),
+        (dict(subject="x", slot=" ", new="v"), "空白 slot 拒绝"),
+        (dict(subject="x", slot="y", old=None, new=None), "old/new 同空拒绝"),
+    ]:
+        try:
+            state_events.append(bad_root, **bad)
+            check(nm, False, "未抛 ValueError")
+        except ValueError:
+            check(nm, True)
+    try:
+        state_events.append(bad_root, "x", "y", new="v", kind="teleport")
+        check("未知 kind 拒绝", False, "未抛 ValueError")
+    except ValueError:
+        check("未知 kind 拒绝", True)
+
+    # ---- 6. 坏行容忍（跳过 + 记账 + 不中断 + 样本有界）----
+    # 坏行数（12）须**越过** _BAD_ROW_SAMPLE_CAP（8）：只造 2 行时
+    # `len(samples) <= cap` 是平凡真（空列表也满足），且删掉记录逻辑后
+    # 仍全绿——无判别力（2026-10-05 复核 NEW-red 实证）。故断言取
+    # **精确等式** `min(前值+12, cap)` 且要求 >0：既抓「不记录」也抓「无界」。
+    p = state_events.ledger_path(cg)
+    bad_lines = 12
+    with open(p, "a", encoding="utf-8") as f:
+        f.write("{broken json\n")
+        f.write("[1, 2, 3]\n")
+        for i in range(bad_lines - 2):
+            f.write("not-json-%d\n" % i)
+    n0 = state_events.BAD_ROWS
+    s0 = len(state_events._BAD_ROW_SAMPLES)
+    recs2 = state_events.read(cg)
+    check("坏行跳过后好行全在", len(recs2) == 4, len(recs2))
+    check("坏行记账（+%d）" % bad_lines, state_events.BAD_ROWS == n0 + bad_lines,
+          state_events.BAD_ROWS - n0)
+    _cap = state_events._BAD_ROW_SAMPLE_CAP
+    _want = min(s0 + bad_lines, _cap)
+    check("坏行样本有界（cap %d，期望 %d，实际 %d）"
+          % (_cap, _want, len(state_events._BAD_ROW_SAMPLES)),
+          len(state_events._BAD_ROW_SAMPLES) == _want
+          and len(state_events._BAD_ROW_SAMPLES) > 0,
+          len(state_events._BAD_ROW_SAMPLES))
+
+    # ---- 7. check_strength 字段（缺省零迁移 / 非法拒绝）----
+    cg.add("cs_a", "# 功能名：断言甲\n# 生效条件：测\n", layer="knowledge",
+           verification_basis="test", check_strength="hoop")
+    fm_a = (cg.get("cs_a") or {}).get("frontmatter") or {}
+    check("带 check_strength 落 fm", fm_a.get("check_strength") == "hoop",
+          fm_a.get("check_strength"))
+    cg.add("cs_b", "# 功能名：断言乙\n# 生效条件：测\n", layer="knowledge",
+           verification_basis="test")
+    fm_b = (cg.get("cs_b") or {}).get("frontmatter") or {}
+    check("缺省不落键（存量零迁移）", "check_strength" not in fm_b,
+          fm_b.get("check_strength"))
+    try:
+        cg.add("cs_c", "# 功能名：断言丙\n# 生效条件：测\n", layer="knowledge",
+               verification_basis="test", check_strength="nuke")
+        check("非法强度拒绝", False, "未抛 ValueError")
+    except ValueError:
+        check("非法强度拒绝", True)
+
+    # ---- 8. 覆写继承（全量重建 fm 的坑）----
+    cg.add("cs_a", "# 功能名：断言甲\n# 生效条件：测（覆写）\n", layer="knowledge",
+           verification_basis="test", override=True)
+    fm_a2 = (cg.get("cs_a") or {}).get("frontmatter") or {}
+    check("覆写默认继承", fm_a2.get("check_strength") == "hoop",
+          fm_a2.get("check_strength"))
+    cg.add("cs_a", "# 功能名：断言甲\n# 生效条件：测（再覆写）\n",
+           layer="knowledge", verification_basis="test", override=True,
+           check_strength="doubly_decisive")
+    fm_a3 = (cg.get("cs_a") or {}).get("frontmatter") or {}
+    check("覆写显式改值", fm_a3.get("check_strength") == "doubly_decisive",
+          fm_a3.get("check_strength"))
+
+    # ---- 9. 写链透传（A1 补接，2026-10-05：经路线 C 的 audit 现值面发现
+    # 写链实参表漏传 check_strength——经 MCP op=write 声明一律静默丢弃，
+    # 与 B2 sensitivity 漏传同族。此处钉住「写链透传」与「变更单载荷白名单」
+    # 两个面，防复发。）----
+    _pipe = default_pipeline()
+    _o = _pipe.execute(cg, {
+        "op": "write", "node_id": "cs_wire",
+        "content": "# 功能名：写链透传\n# 生效条件：测\n# 子功能：无\n"
+                   "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n",
+        "layer": "knowledge", "content_kind": "text",
+        "verification_basis": "test", "check_strength": "smoking_gun"})
+    fm_w = (cg.get("cs_wire") or {}).get("frontmatter") or {}
+    check("写链透传 check_strength（A1 补接）",
+          _o.get("committed") is True
+          and fm_w.get("check_strength") == "smoking_gun",
+          (_o.get("committed"), fm_w.get("check_strength")))
+    check("变更单载荷白名单含 check_strength（A1 补接）",
+          "check_strength" in _AUTONOMY_META_KEYS,
+          list(_AUTONOMY_META_KEYS))
+
+    print("\ntest_state_events: %d 通过 / %d 失败" % (_ok, len(_fail)))
+    if _fail:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_time_core_lint.py

@@ -631,7 +631,9 @@ def g9():
                                            "confidence": 0.8}],
               "subgraph": {"nodes": ["n2"]},
               "valid_from": ts - 100, "valid_until": ts + 100000,
-              "effective_from": ts - 100, "effective_until": ts + 100000},
+              "effective_from": ts - 100, "effective_until": ts + 100000,
+              # A1（2026-10-05）：检验强度键存活断言（G9f）的夹具值。
+              "check_strength": "hoop"},
              body="# 功能名：n1\n# 生效条件：无条件\n# 子功能：无\n"
                   "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n\n"
                   "上游条件 葡萄 触发。\n")
@@ -651,6 +653,11 @@ def g9():
     for k in ("valid_from", "valid_until", "effective_from", "effective_until"):
         ok(k in e1 and e1.get(k) == e0.get(k),
            "G9d 双时间轴键 %s 存活（trust.validity 免读盘判定面）" % k)
+    ok(nodefile.CHECK_STRENGTH_FIELD in e1
+       and e1.get(nodefile.CHECK_STRENGTH_FIELD)
+       == e0.get(nodefile.CHECK_STRENGTH_FIELD),
+       "G9f 检验强度键存活（check_strength，A1 新键；与 G9b–d 同族防漂移，"
+       "2026-10-05 复核补）")
     # 端到端：搬迁后因果路仍能经边召到下游（新路不再静默拿不到边）
     # 种子 = 词法命中 n1（上游），目标 n2 词面无重叠 —— 正是因果路的靶区。
     _r, m = cg.search_rrf("葡萄", k=5, record=False, paths=("lexical", "chain"))

package/md_cg/test_writepipe.py

@@ -135,12 +135,15 @@ def _run(tmp):
                                  "content": "PASSED SKIPME",
                                  "layer": "knowledge"})
     _check("移除即恢复(核心文件零改动)", out.get("committed") is True, repr(out))
-    # 默认 before 链含 linkref→deps→audit→consistency→gated→autonomy
-    # （2026-09-19 deps 闸门新增；2026-10-02 三档自治批次② 档位闸**恒在链尾**
-    # ——档位判定必须晚于全部既有资格闸，见 writepipe._gate_autonomy docstring。
-    # 断言意图不变：默认链的注册表与执行序 = 这一串。）
+    # 默认 before 链含 linkref→ghostref→deps→audit→consistency→gated→autonomy
+    # （2026-09-19 deps 闸门新增；2026-10-05 A2 幽灵引用闸插 linkref 之后——
+    # 消费 ctx["linkref_targets"] 免重解析、永不短路；2026-10-02 三档自治
+    # 批次② 档位闸**恒在链尾**——档位判定必须晚于全部既有资格闸，见
+    # writepipe._gate_autonomy docstring。断言意图不变：默认链的注册表与执行序
+    # = 这一串。）
     _check("单例默认链", singleton.names()["before"]
-           == ["linkref", "deps", "audit", "consistency", "gated", "autonomy"],
+           == ["linkref", "ghostref", "deps", "audit", "consistency", "gated",
+               "autonomy"],
            repr(singleton.names()))
     _check("单例默认after链", singleton.names()["after"]
            == ["linkref", "trust"],

package/md_cg/tokens.py

@@ -90,7 +90,14 @@ ALL_OPS = ("help", "info", "route", "read", "write", "goal", "task", "recent", "
            #        —— 「这条记忆从哪来 / 谁由它派生」的读面；真源
            #        md_cg/provenance.py（find_edges）。**只读 op**：不含任何
            #        写入 path，故读面角色一律放行（与 status 同档）
-           "ccg", "status", "edges")
+           "ccg", "status", "edges",
+           # 路线 C（2026-10-05，多主体世界模型对齐 v0.1 §4）：证据审计面
+           #   audit  只读组装器（现值/出处链/两存备择/盲区/退役史）
+           #        —— 真源 md_cg/auditview.py；只读、零写路径。角色白名单
+           #        缺省不给（fail-closed，新增 op 默认不在任何清单内）；
+           #        本轮开给：designer（* 自动含）+ verify（证据审计＝验证
+           #        单元的本职读面，见其 ROLE_SPECS 注释）。
+           "audit")
 
 
 class TokenError(Exception):
@@ -166,8 +173,10 @@ ROLE_SPECS = OrderedDict([
         # 豁免被分型取代（同日裁定迭代）。
         "can_write": True, "can_admin": False, "clearance_cap": "internal",
         "layers_allow": ["rejected", "contextual"],
+        # audit（2026-10-05 路线 C）：证据审计视图＝验证单元的本职读面
+        #（现值/出处链/两存备择/盲区/退役史），只读、无写路径。
         "ops_allow": ["info", "route", "read", "write", "verify", "insight",
-                      "status", "edges"],
+                      "status", "edges", "audit"],
         "delegable": False,
         "forbidden": ["knowledge/self/anchor 层（不得改被验证内容）",
                       "private/secret 密级（restricted 错误处置标记属本职，"

package/md_cg/writepipe.py

@@ -422,6 +422,45 @@ def _gate_gated(ctx):
     return out
 
 
+# 生效条件：a.get("ghostref") 为 False 时跳过（opt-out，与 linkref=False 同款）；否则对 a["content"]
+# 做幽灵引用检测（ghostref.check：短语层 + id 层），结果非空时分别写入 ctx["ghost_phrases"] /
+# ctx["late_refs"] 供链尾执行器落 fm 与出口告警消费；**恒返回 None（永不短路）**——本闸是标记/告警级，
+# 不参与拒收判定。
+def _gate_ghostref(ctx):
+    """幽灵引用闸（before 链：linkref 之后、deps 之前）：标记 + 降级告警，**不拒收**。
+
+    两条防线（对齐评估 v0.1 §2 L1「转引不得升级」；CD-WHALE-01 发现 C）：
+      ① 短语层：回指短语（「上次的/之前的/明明讲过」）且句内无可解析出处
+         ⇒ ctx["ghost_phrases"] → 落 fm.uncertain_refs（A2 标记面）；
+      ② id 层：引用目标创建时刻晚于本文档声明的生效起点（valid_from/
+         effective_from）⇒ ctx["late_refs"] → 出口降级告警（不改建边判定）。
+
+    为何不短路（与 deps 硬拒的边界）：回指是现实写作的常态——「上次的帐篷」
+    在对话记忆里天然存在，缺失的是**出处记录**而非内容本身。拒收会把正常
+    记忆挡在门外；标记让「出处不确定」这事可见、可裁决（未决不进二值）。
+
+    为何消费 ctx["linkref_targets"] 而非重算：linkref 是 targets 的唯一
+    写入点（同一次解析的两个面）；重算会引入「两次解析结果漂移」的可能。
+    """
+    a = ctx["a"]
+    if a.get("ghostref") is False:
+        return None
+    from . import ghostref as _ghostref
+    # own_from 取显式声明（**is None 判定**：0/空串不做假值跳转——
+    # 与 budget_tokens「显式 0 也是显式」同款口径）。
+    _own = a.get("valid_from")
+    if _own is None:
+        _own = a.get("effective_from")
+    rep = _ghostref.check(ctx["cg"], a.get("content") or "",
+                          linkref_targets=ctx.get("linkref_targets"),
+                          own_from=_own)
+    if rep["ghost_phrases"]:
+        ctx["ghost_phrases"] = rep["ghost_phrases"]
+    if rep["late_refs"]:
+        ctx["late_refs"] = rep["late_refs"]
+    return None
+
+
 # 生效条件：ctx["a"]["content"] 的「# 子功能：」行含显式跨节点引用（`@<节点 id>`）且 depends_on 解析为空时返回 ok=False/error="E050" 的终态；depends_on 含库中不存在的 id 时返回 ok=False/error="E051" 的终态；其余（无该行 / 哨兵 / 自然语言自述 / 声明且目标齐备）返回 None 放行；
 def _gate_deps(ctx):
     """依赖声明闸（before 链：linkref 之后、audit 之前）：**硬拒条件缺失**。
@@ -578,11 +617,38 @@ def _executor(ctx):
            depends_on=trust.as_deps(a.get("depends_on")),
            valid_from=a.get("valid_from"), valid_until=a.get("valid_until"),
            verification_state=a.get("verification_state"),
+           # A1 补接（2026-10-05，路线 C 动工时经 audit 现值面发现）：检验强度
+           # 透传。此前 add 层已支持该形参，但**写链实参表漏传**——经 MCP
+           # op=write 声明 check_strength 一律静默丢弃（与 B2 sensitivity 漏传
+           # 同族：上游声明、落盘面丢字段，比报错难发现）。
+           check_strength=a.get("check_strength"),
+           # A2 幽灵引用标记（正文属性：每次写入按当次检测重算，不继承——
+           # 与 check_strength 的声明继承相反；缺省 None 不落键）。
+           uncertain_refs=ctx.get("ghost_phrases") or None,
            **_hyperedge_extra(a))
     out = {"ok": True, "id": ctx["nid"], "committed": True,
            "verdict": ctx["verdict"]}
     if ctx.get("cvd") is not None:
         out["consistency"] = ctx["cvd"]
+    # A2 幽灵引用出口（标记/告警级，不改写入语义）：短语层标记已随
+    # uncertain_refs 落 fm，此处把「值写进了哪里、怎么处置」如实带回。
+    if ctx.get("ghost_phrases"):
+        from . import nodefile
+        _gp = list(ctx["ghost_phrases"])
+        out["ghost_refs"] = _gp[:16]
+        out["ghost_hint"] = (
+            "幽灵引用标记（A2）：正文含无可解析出处的回指短语（%s）——"
+            "已落 fm.%s（**未拒收**）。若其指代某条既有记忆，请改为可解析引用"
+            "（正文写裸 id，写入链自动建 reference 边）；确为首次出现时，"
+            "该标记即「出处待补」的诚实记录。"
+            % ("、".join(_gp[:5]), nodefile.UNCERTAIN_REFS_FIELD))
+    if ctx.get("late_refs"):
+        out["late_refs"] = list(ctx["late_refs"])[:10]
+        out["late_hint"] = (
+            "目标晚于自身（A2 降级告警）：本文档声明的生效起点早于被引目标的"
+            "创建时刻——引用了「当时尚不存在」的目标。边照常建立（linkref 不看"
+            "时间轴）；请核对两条时间轴：若引用意图成立可忽略，若是回填/转写"
+            "产生的时序错觉，请修正 valid_from。")
     # ⑥：直写提示（不改落盘行为、不改 verdict；见本函数开头注释）
     if _prior is not None:
         out["overwrite_of"] = _prior
@@ -610,6 +676,10 @@ _AUTONOMY_META_KEYS = ("tags", "condition_space", "verification_basis",
                        "non_applicable_conditions", "derived_from", "relation",
                        "depends_on", "valid_from", "valid_until",
                        "verification_state", "importance", "importance_source",
+                       # A1 补接（2026-10-05）：检验强度同族入载荷——否则
+                       # confirm 档出单 → accept 重放会丢该声明（与
+                       # verification_state 同款的「两条路径元数据不等价」坑）。
+                       "check_strength",
                        "override")
 
 
@@ -727,6 +797,12 @@ def install_default_gates(pipe):
     """
     from . import linkref
     pipe.register_before("linkref", linkref.before_hook(), position=0)
+    # A2 幽灵引用闸（2026-10-05）：插在 linkref 之后——判据 ② 要消费
+    # ctx["linkref_targets"]（linkref 是 targets 的唯一写入点）；判据 ① 的
+    # 「句内无可解析出处」与 linkref 同源（同一次检测的两个面）。**永不短路**
+    # （标记/告警级，不做拒收——设计稿 v0.1 复核修订：幽灵引用检查器限定
+    # 短语层标记；回指是现实写作常态，拒收会把正常记忆挡在门外）。
+    pipe.register_before("ghostref", _gate_ghostref, position=1)
     pipe.register_before("deps", _gate_deps)
     pipe.register_before("audit", _gate_audit)
     pipe.register_before("consistency", _gate_consistency)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进 md_cg 认知图（md 文档）",
   "type": "module",
   "main": "lib/index.js",
@@ -86,7 +86,7 @@
     "build": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
     "prepare": "node -e \"const fs=require('fs');const tsc='node_modules/typescript/bin/tsc';fs.existsSync(tsc)?(fs.rmSync('lib',{recursive:true,force:true}),require('child_process').execFileSync(process.execPath,[tsc,'-p','tsconfig.json'],{stdio:'inherit'})):console.log('[prepare] 跳过构建：typescript 未安装（NODE_ENV=production 或 --omit=dev 会省略 devDependencies）——需要构建请用 npm install --include=dev')\"",
-    "gate": "python scripts/check_unreachable.py && python scripts/check_publish_artifact.py && python scripts/check_publish_smoke.py && python scripts/cogmap_sync.py check && python scripts/link_check.py && python scripts/workspace_index.py --check && python scripts/verify_discipline.py --allow-missing && python scripts/gate_rust_crate_test.py && python scripts/gate_rust_parity.py",
+    "gate": "python scripts/check_unreachable.py && python scripts/check_publish_artifact.py && python scripts/check_publish_smoke.py && python scripts/cogmap_sync.py check && python scripts/link_check.py && python scripts/workspace_index.py --check && python scripts/discipline_nodes.py --init --write --cg-root .tmp/discipline-cg && python scripts/verify_discipline.py --allow-missing --cg-root .tmp/discipline-cg && python scripts/gate_rust_crate_test.py && python scripts/gate_rust_parity.py && python scripts/check_local_paths.py",
     "prepublishOnly": "npm run build && npm test && npm run gate"
   },
   "repository": {

package/skills/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "lingshu-skills",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "灵枢（AEIS）自我认知技能包——白箱条件化知识（Agent Skills 兼容导出）。本质是灵枢了解自身的工具：每个技能描述灵枢在什么条件下能做什么、怎么执行、克制什么（KCCS 四要素），由条件路由图精确路由，由灵枢 MCP 工具执行验证（物理基底）。",
   "author": {
     "name": "灵枢（AEIS）· CommonTrustProtocol"