@furongjun1999/dsh-memory 0.4.7 → 0.4.9

package/md_cg/test_reach_keys.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+"""test_reach_keys.py · 新鲜度键与落盘的**编码无歧义**验收（r11 复核反例固化）。
+
+背景：_node_key 曾用 ';'/'|' 拼接 tags/edges，导致 ["a;b"] 与 ["a","b"] 生成同键；
+倒排曾用 ',' 与 chr(31) 拼接路径。本测试把编码层的不变性固化：
+  ① tags 含分隔符不碰撞   ② edges 含分隔符不碰撞
+  ③ 倒排落地/重载对含控制字符的路径原样保留   ④ TTL<=0 回落默认（不得静默关闭兜底）
+  ⑤ hash_complete 按原始 content_hash 判定
+
+运行：python -m md_cg.test_reach_keys
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import time
+
+from . import reach
+
+PASS = FAIL = 0
+
+
+def ok(cond, label, detail=""):
+    global PASS, FAIL
+    PASS += int(bool(cond))
+    FAIL += int(not cond)
+    print(f'[{"✓" if cond else "✘"}] {label}' + (f"  · {detail}" if detail else ""))
+
+
+def _fake(root, **entry):
+    base = {"path": "knowledge/a.md", "content_hash": "H1", "tags": [], "edges": []}
+    base.update(entry)
+
+    class _CG:
+        def __init__(self):
+            self.root = root
+            self.index = {"nodes": {"n1": dict(base)}}
+        def _read(self, e):
+            return {}, ""
+        def _open_content(self, node_id, fm, content):
+            return content
+    return _CG()
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="reach_keys_")
+    # reach 为显式 opt-in（契约 §7：不在默认路径上启用新行为），本测试须自行开启
+    os.environ["MDCG_REACH"] = "1"
+    os.environ["MDCG_REACH_INDEX"] = os.path.join(root, "idx.json")
+    # r12 复核：无 path 的条目不计入覆盖判定（与 build 口径一致）
+    class _CG3:
+        def __init__(self):
+            self.root = root
+            self.index = {"nodes": {"n1": {"path": "knowledge/a.md", "content_hash": "H1"},
+                                          "n2": {"content_hash": None}}}
+        def _read(self, e):
+            return {}, ""
+        def _open_content(self, node_id, fm, content):
+            return content
+    ok(reach._hash_complete(_CG3()) is True,
+       "⑤ 无 path 条目不计入 hash 覆盖（与 build 口径一致）")
+
+    print("md_cg reach 键编码验收 · 无歧义 / TTL 兜底 / 落盘往返")
+    print("=" * 66)
+    # ① tags 分隔符不碰撞
+    k1 = reach._node_key(_fake(root, tags=["a;b"]).index["nodes"]["n1"])
+    k2 = reach._node_key(_fake(root, tags=["a", "b"]).index["nodes"]["n1"])
+    ok(k1 != k2, "① tags 含分号不碰撞", f"{k1[:26]} vs {k2[:26]}")
+    k3 = reach._node_key(_fake(root, tags=["a|b"]).index["nodes"]["n1"])
+    k4 = reach._node_key(_fake(root, tags=["a", "b"]).index["nodes"]["n1"])
+    ok(k3 != k4, "① tags 含竖线不碰撞")
+    # ② edges 分隔符不碰撞
+    e1 = reach._node_key(_fake(root, edges=[{"target": "a|b", "type": ""}]).index["nodes"]["n1"])
+    e2 = reach._node_key(_fake(root, edges=[{"target": "a", "type": "b"}]).index["nodes"]["n1"])
+    ok(e1 != e2, "② edges 含竖线不碰撞")
+    e3 = reach._node_key(_fake(root, edges=[{"target": "a;b", "type": "c"}]).index["nodes"]["n1"])
+    e4 = reach._node_key(_fake(root, edges=[{"target": "a", "type": "b;c"}]).index["nodes"]["n1"])
+    ok(e3 != e4, "② edges 含分号不碰撞")
+    # ③ 倒排落盘对控制字符路径原样往返
+    idx = reach.ReachIndex(root)
+    weird = "knowledge/a" + chr(31) + "b.md"
+    idx.post = {"召": [weird]}
+    idx.adj = {}
+    idx.hashes = {}
+    idx.save()
+    back = reach.ReachIndex(root)
+    back.load()
+    ok(back.post.get("召") == [weird], "③ 含控制字符路径经落盘/重载原样保留",
+       str(back.post.get("召")))
+    # ④ TTL<=0 → 回落默认（不得静默关闭）
+    class _CG2:
+        def __init__(self):
+            self.root = root
+            self.index = {"nodes": {"n1": {"path": "knowledge/a.md", "content_hash": "H1",
+                                           "tags": [], "edges": []}}}
+    cg = _CG2()
+    os.environ["MDCG_REACH_TTL"] = "0"
+    idx2 = reach.ReachIndex(root)
+    idx2.built_at = time.time() - 4000
+    saved = reach._CACHE
+    reach._CACHE = {}
+    ok(reach._ttl() == 600.0, "④ TTL=0 经 _ttl() 回落 600s", str(reach._ttl()))
+    os.environ["MDCG_REACH_TTL"] = "-5"
+    ok(reach._ttl() == 600.0, "④ TTL 负值同样回落默认")
+    os.environ["MDCG_REACH_TTL"] = "abc"
+    ok(reach._ttl() == 600.0, "④ TTL 非法文本回落默认")
+    os.environ["MDCG_REACH_TTL"] = "30"
+    ok(reach._ttl() == 30.0, "④ 正数 TTL 原样生效")
+    os.environ["MDCG_REACH_TTL"] = "inf"
+    ok(reach._ttl() == 600.0, "④ TTL=inf 回落默认（否则过期判断永假）", str(reach._ttl()))
+    os.environ["MDCG_REACH_TTL"] = "1e999"
+    ok(reach._ttl() == 600.0, "④ TTL=1e999（溢出为 inf）回落默认")
+    os.environ["MDCG_REACH_TTL"] = "nan"
+    ok(reach._ttl() == 600.0, "④ TTL=nan 回落默认")
+    os.environ["MDCG_REACH_TTL"] = "0"
+    reach._CACHE = saved
+    # ⑤ hash_complete 按原始 content_hash 判定
+    a = reach.ReachIndex(root); a.hash_complete = None
+    b = reach.ReachIndex(root); b.hash_complete = None
+    a.build(_fake(root, content_hash="H1"))
+    b.build(_fake(root, content_hash=None))
+    ok(a.hash_complete is True and b.hash_complete is False,
+       "⑤ hash_complete 按原始 content_hash", f"a={a.hash_complete} b={b.hash_complete}")
+    # r13 复核：真实磁盘新鲜度路径（不手写 _CACHE）
+    os.environ["MDCG_REACH_TTL"] = "0"
+    cg2 = _CG3()
+    idx_a = reach.ReachIndex(root)
+    idx_a.build(cg2)
+    idx_a.save()
+    idx_b = reach.ReachIndex(root)
+    idx_b.load()
+    ok(reach._disk_fresh(idx_b, cg2) is True, "⑤ 真实磁盘缓存：同库判新鲜")
+    cg3 = _CG3()
+    cg3.index["nodes"]["n1"]["content_hash"] = "H2"
+    ok(reach._disk_fresh(idx_b, cg3) is False, "⑤ 真实磁盘缓存：content_hash 变即判不新鲜")
+    # r13 复核：落盘失败（只读根）时不得入进程缓存（类级替换 save 注入 OSError）
+    saved_save = reach.ReachIndex.save
+    def _boom(self):
+        raise OSError('readonly')
+    reach.ReachIndex.save = _boom
+    try:
+        reach._CACHE.clear()
+        reach._index(cg2, force=True)
+        ok(len(reach._CACHE) == 0, '⑤ 落盘失败时不入进程缓存（下次调用重建）', str(list(reach._CACHE)))
+    finally:
+        reach.ReachIndex.save = saved_save
+    # r15 复核：库内缺 content_hash 时，即使本次刚重建也必须回退（不得收敛）
+    class _CG5:
+        def __init__(self):
+            self.root = root
+            self.index = {"nodes": {"n1": {"path": "knowledge/a.md", "tags": [], "edges": []}}}
+        def _read(self, e):
+            return {}, ""
+        def _open_content(self, node_id, fm, content):
+            return content
+    os.environ["MDCG_REACH_INDEX"] = os.path.join(root, "idx2.json")
+    reach._CACHE.clear()
+    got_h, meta_h = reach.narrow(_CG5(), [{"path": "knowledge/a.md"}], ["abcd"], {"abcd"}, None, q="abcd")
+    ok(got_h is None and meta_h.get("reach") == "hash_incomplete",
+       "⑤ 缺 content_hash 时一律回退不收敛", str(meta_h)[:80])
+    # r17 复核：库内含不可读节点时，磁盘缓存仍须判新鲜（口径与 build 的剔除对齐）
+    class _CG6:
+        def __init__(self):
+            self.root = root
+            self.index = {"nodes": {"n1": {"path": "knowledge/a.md", "content_hash": "H1"},
+                                          "n2": {"path": "knowledge/locked.md", "content_hash": "H2"}}}
+        def _read(self, e):
+            if e.get("path", "").endswith("locked.md"):
+                return None, None          # 不可读（模拟解密失败）
+            return {}, ""
+        def _open_content(self, node_id, fm, content):
+            return content
+    os.environ["MDCG_REACH_INDEX"] = os.path.join(root, "idx3.json")
+    cg6 = _CG6()
+    i6 = reach.ReachIndex(root)
+    i6.build(cg6)
+    i6.save()
+    i6b = reach.ReachIndex(root)
+    i6b.load()
+    ok(reach._disk_fresh(i6b, cg6) is True,
+       "⑤ 含不可读节点时磁盘缓存仍判新鲜（跨进程可复用）",
+       "hashes=%d" % len(i6.hashes))
+    cg6.index["nodes"]["n1"]["content_hash"] = "H9"
+    ok(reach._disk_fresh(i6b, cg6) is False, "⑤ 已缓存节点 hash 变即判不新鲜")
+    # r18 复核：hash 不完整时——首次调用必须暴露首建成本；第二次调用不得再全库重建
+    os.environ["MDCG_REACH_INDEX"] = os.path.join(root, "idx4.json")
+    reach._CACHE.clear()
+    _cg7 = _CG5()
+    _g1, m1 = reach.narrow(_cg7, [{"path": "knowledge/a.md"}], ["abcd"], {"abcd"}, None, q="abcd")
+    ok(_g1 is None and m1.get("reach") == "hash_incomplete" and m1.get("reach_build_docs") is not None,
+       "⑤ hash 不完整：首次调用暴露首建成本", str(m1)[:90])
+    _g2, m2 = reach.narrow(_cg7, [{"path": "knowledge/a.md"}], ["abcd"], {"abcd"}, None, q="abcd")
+    ok(_g2 is None and m2.get("reach") == "hash_incomplete" and "reach_build_docs" not in m2,
+       "⑤ hash 不完整：第二次调用复用缓存（不再全库重建）", str(m2)[:90])
+    print(f"\n===== 键编码验收：{PASS}/{PASS + FAIL} 通过 =====")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/md_cg/test_reach_meta_exits.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+"""narrow() 各退化出口必须如实暴露首建 / 部分重建成本。
+
+历史取证：r19 复核发现 no_tokens / empty_converge 吞掉 reach_build_docs；
+r32 发现 index_unavailable 连部分读盘成本也丢了、且旧测试用 sem=True 使 set(True)
+异常被吞掉；r34 发现只计「已入倒排」会漏计「读了很多但都不可读」的情形、且模块级状态不安全。
+"""
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from md_cg import reach  # noqa: E402
+
+
+class StubIdx:
+    hash_complete = True
+    sem = []          # 必须是真容器：曾写 sem=True，set(True) 报错被吞掉 → 语义分支未真实验证（r32 复核）
+    built_now = True
+    built_docs = 7
+    built_reads = 9
+    hashes = {}
+    built_at = 0.0
+
+    def postings(self, toks):
+        return {"x"}
+
+
+class ReadStubCG:
+    """按 plan 依次返回 cg._read 结果，plan 耗尽后抛错（模拟重建中途失败）。"""
+
+    def __init__(self, root, nodes, plan):
+        self.root = root
+        self.index = {"nodes": nodes}
+        self._plan = list(plan)
+        self.calls = 0
+
+    def _read(self, entry):
+        self.calls += 1
+        if not self._plan:
+            raise RuntimeError("simulated rebuild failure")
+        return self._plan.pop(0)
+
+    def _open_content(self, nid, fm, c):
+        return c
+
+
+def _tmp_root():
+    return tempfile.mkdtemp(prefix="reach_meta_exits_")
+
+
+def _use(path):
+    os.environ["MDCG_REACH_INDEX"] = os.path.join(path, "_reach_index.json")
+
+
+def main():
+    os.environ["MDCG_REACH"] = "1"
+    import md_cg.mdcg as mdcg_mod
+    orig_with, orig_sem = reach._index_with_meta, mdcg_mod.semantic_on
+    mdcg_mod.semantic_on = lambda: True
+    reach._index_with_meta = lambda cg, force=False: (StubIdx(), {})
+    try:
+        # ① 无 token → no_tokens，必须带首建成本
+        _, m1 = reach.narrow(object(), [], [], set(), q="")
+        assert m1.get("reach") == "no_tokens", m1
+        assert m1.get("reach_build_docs") == 7, "no_tokens 出口漏首建成本：%r" % (m1,)
+        # ② 语义空收敛 → empty_converge，同样必须带首建成本
+        _, m2 = reach.narrow(object(), [], ["甲乙"], {"甲", "乙"}, q="甲乙")
+        assert m2.get("reach") == "empty_converge", m2
+        assert m2.get("reach_build_docs") == 7, "empty_converge 出口漏首建成本：%r" % (m2,)
+
+        # ③ 未重建时不得虚构成本
+        class Cold(StubIdx):
+            built_now = False
+
+        reach._index_with_meta = lambda cg, force=False: (Cold(), {})
+        _, m3 = reach.narrow(object(), [], [], set(), q="")
+        assert "reach_build_docs" not in m3 and "reach_build_reads" not in m3, m3
+
+        # ④ 语义分支确实生效：sem 为真容器时，无词面命中的语义节点也必须入池
+        class SemIdx(StubIdx):
+            sem = ["p/sem"]
+
+        reach._index_with_meta = lambda cg, force=False: (SemIdx(), {})
+        got4, m4 = reach.narrow(object(), [{"path": "p/sem"}], ["甲乙"], {"甲", "乙"}, q="甲乙")
+        assert m4.get("reach") == "converged", m4
+        assert [e["path"] for e in got4] == ["p/sem"], "sem 分支未真实生效：%r" % (got4,)
+
+        # ⑤ fresh_overflow：未索引节点超上限 → 整段回退，且同时暴露 reach_fresh_nodes 与首建成本
+        reach._index_with_meta = lambda cg, force=False: (StubIdx(), {})
+        many = [{"path": "x"}] + [{"path": "p/f%04d" % i} for i in range(reach._FRESH_MAX + 1)]
+        got5, m5 = reach.narrow(object(), many, ["甲乙"], {"甲", "乙"}, q="甲乙")
+        assert got5 is None and m5.get("reach") == "fresh_overflow", m5
+        assert m5.get("reach_fresh_nodes") == reach._FRESH_MAX + 1, m5
+        assert m5.get("reach_build_docs") == 7, "fresh_overflow 出口漏首建成本：%r" % (m5,)
+
+        # ⑥ r34 反例：读了很多节点但都不可读（None）后失败 → 已读盘量必须如实计数
+        reach._index_with_meta = orig_with
+        r1 = _tmp_root()
+        _use(r1)
+        cg_a = ReadStubCG(r1, {"a": {"path": "pa"}, "b": {"path": "pb"}, "c": {"path": "pc"}},
+                          [(None, None), (None, None)])
+        idx_a, fail_a = reach._index_with_meta(cg_a)
+        assert idx_a is None, idx_a
+        assert fail_a.get("reach_build_reads") == 2, "不可读读盘未计数：%r" % (fail_a,)
+        assert fail_a.get("reach_build_docs") == 0 and fail_a.get("reach_build_partial") is True, fail_a
+        # 端到端：narrow 的 index_unavailable 出口也必须带这些字段
+        # （每次调用各自独立：本例用**新** stub 与新根，否则上一次调用已把 plan 耗尽）
+        r4 = _tmp_root()
+        _use(r4)
+        cg_a2 = ReadStubCG(r4, {"a": {"path": "pa"}, "b": {"path": "pb"}, "c": {"path": "pc"}},
+                           [(None, None), (None, None)])
+        got6, m6 = reach.narrow(cg_a2, [], ["甲乙"], {"甲", "乙"}, q="甲乙")
+        assert got6 is None and m6.get("reach") == "index_unavailable", m6
+        assert m6.get("reach_build_reads") == 2 and m6.get("reach_build_partial") is True, m6
+
+        # ⑦ 部分成功：第一个节点已入倒排后失败 → docs 与 reads 都要如实
+        r2 = _tmp_root()
+        _use(r2)
+        cg_b = ReadStubCG(r2, {"a": {"path": "pa"}, "b": {"path": "pb"}}, [({"id": "a"}, "hello")])
+        idx_b, fail_b = reach._index_with_meta(cg_b)
+        assert idx_b is None, idx_b
+        assert fail_b.get("reach_build_docs") == 1 and fail_b.get("reach_build_reads") == 1, fail_b
+        assert fail_b.get("reach_build_partial") is True, fail_b
+
+        # ⑧ 成功路径：无 fail 元数据；首建成本同时暴露读盘数与入索引数（各调用各自独立容器）
+        r3 = _tmp_root()
+        _use(r3)
+        cg_c = ReadStubCG(r3, {"a": {"path": "pa", "content_hash": "h"}}, [({"id": "a"}, "hello")])
+        idx_c, fail_c = reach._index_with_meta(cg_c)
+        assert idx_c is not None and fail_c == {}, (idx_c, fail_c)
+        bm = reach._build_meta(idx_c)
+        assert bm.get("reach_build_docs") == 1 and bm.get("reach_build_reads") == 1, bm
+        # 重复调用不得把上次成本带下来
+        idx_d, fail_d = reach._index_with_meta(cg_c)
+        assert fail_d == {}, fail_d
+    finally:
+        reach._index_with_meta, mdcg_mod.semantic_on = orig_with, orig_sem
+        os.environ.pop("MDCG_REACH_INDEX", None)
+    print("ALL PASS test_reach_meta_exits")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_read_clip.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""md_cg · Pi⑦② read 截断 + 续读提示（_clip_text / _node_view / schema 落点）
+
+验收三件事：
+① 单次 read 返回受「2000 行 / 50KB」双阈值约束，且**不静默丢内容**——
+   截断必带 total_lines / total_bytes / next_offset / note；
+② 续读按 offset 连续取回可拼回原文（不丢不重，可裁决的等价性判据）；
+③ 小内容行为兼容——旧四键（id/path/frontmatter/content）不丢、content 原样；
+   验证态 `verification_state` 为**有意的 additive 透出**（不参与排序），
+   故 B1 断言「旧键 ⊆ 新键 ∧ 验证态在场」而非「键集逐一相等」。
+   真源：protocol.py 的 read.node.required 已把 `verification_state` 列为必需键。
+
+运行：python -m md_cg.test_read_clip
+"""
+
+import os
+import sys
+
+from .mcp_server import KERNEL_TOOLS, READ_MAX_BYTES, READ_MAX_LINES, \
+    _cg_call, _clip_text, _node_view
+
+_ok = 0
+_bad = []
+
+
+def check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print(f"  [ok] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        _bad.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+class _FakeCG:
+    """只实现 read 面所需的最小取节点契约。"""
+
+    def __init__(self, nodes):
+        self._nodes = nodes
+
+    def get(self, nid, *a, **k):
+        return self._nodes.get(nid)
+
+
+def main():
+    print("[A] _clip_text 双阈值与续读语义")
+    small = "第一行\n第二行\n第三行"
+    c = _clip_text(small)
+    check("A1 小文本原样返回（note 空串、无截断位点）",
+          c["text"] == small and c["truncated"] is False
+          and c["next_offset"] is None and c["total_lines"] == 3
+          and c["note"] == "", str(c)[:160])
+
+    many = "\n".join(f"line-{i:05d}" for i in range(READ_MAX_LINES + 500))
+    c = _clip_text(many)
+    check("A2 行数上限：超 2000 行截断且给出续读位点",
+          c["truncated"] is True and c["returned_lines"] == READ_MAX_LINES
+          and c["next_offset"] == READ_MAX_LINES + 1
+          and str(READ_MAX_LINES) in c["note"], c["note"])
+
+    wide = "\n".join("x" * 60 for _ in range(3000))   # 约定 180KB > 50KB
+    c = _clip_text(wide)
+    check("A3 字节上限生效（行未满 2000 但字节先到顶）",
+          c["truncated"] is True and c["returned_lines"] < READ_MAX_LINES
+          and len(c["text"].encode("utf-8")) <= READ_MAX_BYTES
+          and str(READ_MAX_BYTES) in c["note"], f"{c['returned_lines']}行/{c['total_bytes']}B")
+
+    # 续读拼接等价性：按 next_offset 连续取回，拼回必须与原文逐字一致
+    got, off, hops = [], 0, 0
+    while True:
+        c = _clip_text(many, offset=off)
+        got.append(c["text"])
+        hops += 1
+        if not c["truncated"]:
+            break
+        off = c["next_offset"]
+        if hops > 10:
+            break
+    check("A4 续读拼接 == 原文（不丢不重）",
+          "\n".join(got) == many and hops == 2, f"hops={hops}")
+
+    c = _clip_text("a\nb", offset=99)
+    check("A5 offset 越界：返回空并如实说明（不假装有内容）",
+          c["text"] == "" and c["truncated"] is False and "超出总行数" in c["note"],
+          c["note"])
+
+    c = _clip_text("y" * (READ_MAX_BYTES + 100))
+    check("A6 单行超字节上限也保底返回一行（不返回空）",
+          c["returned_lines"] == 1 and c["truncated"] is False
+          and len(c["text"]) == READ_MAX_BYTES + 100, str(c["returned_lines"]))
+
+    print("[B] _node_view 兼容与截断字段")
+    node = {"id": "n1", "path": "/p/n1.md", "frontmatter": {"layer": "knowledge"},
+            "content": "短内容"}
+    v = _node_view(node)
+    check("B1 旧四键不丢（零回归）+ 验证态 additive 透出",
+          {"id", "path", "frontmatter", "content"} <= set(v)
+          and v["content"] == "短内容"
+          and v["verification_state"] == "unverified", str(sorted(v)))
+    check("B2 空节点维持 None（旧契约）", _node_view(None) is None)
+
+    big = dict(node, content=many)
+    v = _node_view(big)
+    check("B3 大节点截断 + 审计字段（truncated/next_offset/note）",
+          v["truncated"] is True and v["next_offset"] == READ_MAX_LINES + 1
+          and v["content_lines"] == READ_MAX_LINES + 500
+          and v["content"].split("\n")[-1] == f"line-{READ_MAX_LINES - 1:05d}",
+          str({k: v[k] for k in ("truncated", "next_offset", "content_lines")}))
+    v2 = _node_view(big, offset=v["next_offset"])
+    check("B4 按 next_offset 续读可取回尾部且拼回原文",
+          "\n".join([v["content"], v2["content"]]) == many
+          and v2["offset"] == READ_MAX_LINES + 1, str(v2["offset"]))
+
+    print("[C] 工具面落点（schema + 分发透传）")
+    cg = next(t for t in KERNEL_TOOLS if t["name"] == "cg")
+    props = cg["inputSchema"]["properties"]
+    check("C1 cg schema 暴露 offset 且描述含续读语义",
+          props["offset"]["type"] == "integer" and "next_offset" in props["offset"]["description"])
+    check("C2 read 面描述声明截断与续读（调用方可知情）",
+          "next_offset" in cg["description"] and "截断" in cg["description"])
+
+    fcg = _FakeCG({"n1": node})
+    out = _cg_call(fcg, {"op": "read", "node_id": "n1"})
+    check("C3 未传 offset：行为与旧版一致",
+          out["content"] == "短内容" and "truncated" not in out, str(out)[:160])
+    fcg = _FakeCG({"n1": big})
+    out = _cg_call(fcg, {"op": "read", "node_id": "n1", "offset": READ_MAX_LINES + 1})
+    check("C4 offset 经 _cg_call 透传到节点视图（真实续读通路）",
+          out["offset"] == READ_MAX_LINES + 1 and out["truncated"] is False
+          and out["content"].startswith(f"line-{READ_MAX_LINES:05d}")
+          and out["content"].endswith("line-02499"), str(out["offset"]))
+
+    print(f"\n结果：{_ok} 通过 / {len(_bad)} 失败")
+    if _bad:
+        print("失败项：" + "、".join(_bad))
+    return 1 if _bad else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())