dsh-deepmoyu 2.3.0 → 2.4.2

package/tests/test_pv_stage1.py

@@ -1,250 +0,0 @@
-"""Isolated video regressions. No Bili writes, network TTS or model loads."""
-from __future__ import annotations
-
-import array
-import importlib.util
-import json
-import math
-import shutil
-import tempfile
-import unittest
-import wave
-from datetime import datetime, timezone
-from pathlib import Path
-from unittest.mock import patch
-
-from PIL import ImageChops
-
-ROOT = Path(__file__).resolve().parents[1]
-
-
-def module(name):
-    spec = importlib.util.spec_from_file_location(name, ROOT / "lib" / f"{name}.py")
-    result = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(result)
-    return result
-
-
-pv = module("pv")
-planner = module("pv_plan")
-gsv = module("pv_gsv")
-
-
-def write_wave(path, amplitude=2400, duration=.7, rate=24000):
-    path = Path(path)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    samples = array.array("h", (int(amplitude * math.sin(2 * math.pi * 220 * i / rate))
-                                for i in range(round(rate * duration))))
-    with wave.open(str(path), "wb") as handle:
-        handle.setparams((1, 2, rate, len(samples), "NONE", "not compressed"))
-        handle.writeframes(samples.tobytes())
-    return samples
-
-
-class Sources(unittest.TestCase):
-    def test_only_public_report_note_is_adapted(self):
-        with tempfile.TemporaryDirectory() as directory:
-            home = Path(directory)
-            (home / "out").mkdir()
-            (home / "out" / "2026-10-21.md").write_text(
-                "# 材料\n### BV1epp96iE6i 《公共测试标题》\n"
-                "**这段先举例再解释，容易看出问题究竟出在哪里。**\n"
-                "- 私信：绝对不要出现在片子里的秘密\n## 私信\n隐藏正文\n", encoding="utf-8")
-            facts = planner.gather(home, "2026-10-21")
-            plan = planner.auto_plan(facts, first=True)
-            raw = json.dumps(plan, ensure_ascii=False)
-            self.assertEqual(len(plan["sources"]), 1)
-            self.assertEqual(plan["sources"][0]["line"], 2)
-            self.assertEqual(plan["sources"][0]["url"], "https://www.bilibili.com/video/BV1epp96iE6i")
-            self.assertNotIn("绝对不要", raw)
-            self.assertNotIn("隐藏正文", raw)
-            claims = [shot for shot in plan["shots"] if shot["provenance"] == "record-adaptation"]
-            self.assertEqual(len(claims), 2)
-            self.assertTrue(all(shot["source_ids"] == ["note-1"] for shot in claims))
-            self.assertIn("虚构", plan["disclosure"])
-
-    def test_sensitive_lines_are_excluded_before_highlights(self):
-        self.assertEqual(planner.public_excerpt("私信：**这段是虚构隐私，不可拿来当公开视频笔记。**"), "")
-        self.assertEqual(planner.public_excerpt(r"来源 C:\\private\\voice.wav **这是一段不能进视频的私人路径注释。**"), "")
-        self.assertEqual(planner.public_excerpt("- **这行是回复记录，不应被选为笔记正文。**"), "")
-
-    def test_empty_day_never_inherits_old_first_day_facts(self):
-        with tempfile.TemporaryDirectory() as directory:
-            plan = planner.auto_plan(planner.gather(Path(directory), "2026-10-22"), first=True)
-        raw = json.dumps(plan, ensure_ascii=False)
-        for false_fact in ("k卷", "746", "麻姑", "岐路九秋风", "午夜", "生鱼片"):
-            self.assertNotIn(false_fact, raw)
-        self.assertEqual(plan["sources"], [])
-        self.assertTrue(all(shot["provenance"] == "original-dialogue" for shot in plan["shots"]))
-        self.assertIn("没留下能用的公开选片笔记", raw)
-
-    def test_utc8_midnight(self):
-        before = datetime(2026, 10, 20, 15, 59, 59, tzinfo=timezone.utc).timestamp() * 1000
-        self.assertEqual(planner.day_of(before), "2026-10-20")
-        self.assertEqual(planner.day_of(before + 1000), "2026-10-21")
-        self.assertEqual(planner.day_of(float("nan")), "")
-
-    def test_durable_index_rotation_and_clear_archive_deduplicate(self):
-        with tempfile.TemporaryDirectory() as directory:
-            home = Path(directory)
-            stamp = datetime(2026, 10, 21, 2, tzinfo=timezone.utc).timestamp() * 1000
-            event_id = "a" * 64
-            row = {"t": stamp, "seq": 7, "kind": "done", "tool": "bili_search", "text": "公开搜索", "eventId": event_id}
-            index = home / "records" / "days" / "2026-10-21.jsonl"
-            event = home / "records" / "events" / "aa" / f"{event_id}.json"
-            archived = home / "records" / "activity" / "2026-10-21" / "unique.jsonl"
-            for path in (index, event, archived):
-                path.parent.mkdir(parents=True, exist_ok=True)
-            index.write_text(json.dumps({"eventId": event_id, "at": "2026-10-21T02:00:00Z"}) + "\n", encoding="utf-8")
-            event.write_text(json.dumps({"type": "activity", "data": row}), encoding="utf-8")
-            archived.write_text(json.dumps(row) + "\n", encoding="utf-8")
-            (home / "activity.jsonl.2").write_text(json.dumps(row) + "\n", encoding="utf-8")
-            (home / "activity.jsonl").write_text("{truncated\n" + json.dumps(row) + "\n", encoding="utf-8")
-            rows = planner.load_activity(home, "2026-10-21")
-            self.assertEqual(len(rows), 1)
-            self.assertEqual(rows[0]["_source"]["eventId"], event_id)
-            self.assertEqual(planner.gather(home, "2026-10-21")["stats"]["searches"], 1)
-            self.assertEqual(planner.load_activity(home, "2026-10-22"), [])
-
-
-class Audio(unittest.TestCase):
-    def test_cache_identity_changes_with_text_voice_and_reference_bytes(self):
-        voice = {"name": "a", "rate": "+8%"}
-        key = pv.audio_cache_key("一", voice, "edge")
-        self.assertNotEqual(key, pv.audio_cache_key("二", voice, "edge"))
-        self.assertNotEqual(key, pv.audio_cache_key("一", dict(voice, pitch="+2Hz"), "edge"))
-        self.assertEqual(key, pv.audio_cache_key("一", dict(reversed(list(voice.items()))), "edge"))
-        with tempfile.TemporaryDirectory() as directory:
-            reference = Path(directory) / "ref.wav"
-            reference.write_bytes(b"first")
-            voice = {"gsvRef": str(reference), "gsvPrompt": "测试"}
-            key = pv.audio_cache_key("一", voice, "gsv")
-            reference.write_bytes(b"later")
-            self.assertNotEqual(key, pv.audio_cache_key("一", voice, "gsv"))
-
-    def test_modified_take_and_reordering_do_not_reuse_numbered_audio(self):
-        with tempfile.TemporaryDirectory() as directory:
-            work = Path(directory)
-            (work / "tts").mkdir()
-            (work / "wav").mkdir()
-            calls = []
-            def synth(text, path, *args):
-                calls.append(text)
-                write_wave(path, duration=.7 if text == "甲" else 1.1)
-                return "test-tts"
-            def convert(source, destination):
-                shutil.copyfile(source, destination)
-                with wave.open(str(destination), "rb") as stream:
-                    pcm = array.array("h")
-                    pcm.frombytes(stream.readframes(stream.getnframes()))
-                    return pcm, stream.getframerate()
-            with patch.object(pv, "tts", synth), patch.object(pv, "to_wav", convert):
-                first = pv.prepare_audio([{"text": "甲"}, {"text": "乙"}], {}, work, 12)
-                second = pv.prepare_audio([{"text": "乙"}, {"text": "甲"}], {}, work, 12)
-                third = pv.prepare_audio([{"text": "丙"}, {"text": "甲"}], {}, work, 12)
-            self.assertEqual(calls, ["甲", "乙", "丙"])
-            self.assertEqual(first[0]["cache_key"], second[1]["cache_key"])
-            self.assertAlmostEqual(second[0]["dur"], 1.1)
-            self.assertNotEqual(second[0]["cache_key"], third[0]["cache_key"])
-
-    def test_partial_gsv_batch_keeps_full_original_order(self):
-        with tempfile.TemporaryDirectory() as directory:
-            work = Path(directory)
-            (work / "wav").mkdir()
-            calls = []
-            def synth(texts, target, voice):
-                calls.append(list(texts))
-                for index, text in enumerate(texts):
-                    path = target / f"{index:02d}.wav"
-                    if not path.exists():
-                        write_wave(path, amplitude=1000 + index * 1000, duration=.5 + index * .1)
-            def convert(source, destination):
-                shutil.copyfile(source, destination)
-                with wave.open(str(destination), "rb") as stream:
-                    pcm = array.array("h")
-                    pcm.frombytes(stream.readframes(stream.getnframes()))
-                    return pcm, stream.getframerate()
-            voice = {"gsvRepo": "repo", "gsvRef": "reference", "gsvPrompt": "原话"}
-            shots = [{"text": "甲"}, {"text": "乙"}, {"text": "丙"}]
-            with patch.object(pv, "gsv_batch", synth), patch.object(pv, "to_wav", convert):
-                first = pv.prepare_audio(shots, voice, work, 12)
-                middle = next((work / "gsv").glob("*/01.wav"))
-                middle.unlink()
-                second = pv.prepare_audio(shots, voice, work, 12)
-            self.assertEqual(calls, [["甲", "乙", "丙"], ["甲", "乙", "丙"]])
-            self.assertEqual([take["dur"] for take in first], [take["dur"] for take in second])
-
-    def test_inner_speaker_explicitly_selects_edge_voice(self):
-        voice = pv.shot_voice({"gsvRepo": "repo", "gsvRef": "ref", "gsvPrompt": "原话"},
-                             {"voice": {"mode": "edge", "name": "inner"}})
-        self.assertEqual(voice["name"], "inner")
-        self.assertFalse(any(key.startswith("gsv") for key in voice))
-
-    def test_pcm_timeline_preserves_tail_and_pause_and_does_not_overlap(self):
-        shots = [{"text": "甲", "pause_after": .35}, {"text": "乙"}]
-        audios = [{"dur": 1.137, "env": [0, .7, 0]}, {"dur": 2.217, "env": [.2]}]
-        starts, total, cues = pv.make_timeline(shots, audios, .18, .12, .5, 12)
-        self.assertAlmostEqual(starts[1], .18 + 1.137 + .35)
-        self.assertGreaterEqual(total, cues[-1]["end"] + .5)
-        self.assertLess(total - (cues[-1]["end"] + .5), 1 / 12)
-        self.assertGreater(cues[1]["start"], cues[0]["end"])
-        self.assertEqual(cues[0]["mouth_frames"], 1)
-        with tempfile.TemporaryDirectory() as directory:
-            path = Path(directory) / "captions.srt"
-            pv.write_captions(cues, path)
-            self.assertIn("00:00:00,180 --> 00:00:01,317", path.read_text(encoding="utf-8"))
-
-    def test_lip_envelope_responds_to_pcm_silence(self):
-        samples = array.array("h", [0] * 6000 + [3000, -3000] * 3000 + [0] * 6000)
-        env = pv.envelope(samples, 24000, 12)
-        self.assertEqual(env[0], 0)
-        self.assertEqual(env[-1], 0)
-        self.assertGreater(max(env), .9)
-
-
-class GsvHelper(unittest.TestCase):
-    def test_output_paths_are_fixed_before_model_changes_cwd(self):
-        with tempfile.TemporaryDirectory() as directory:
-            batch = Path(directory) / "incoming" / "batch.json"
-            target = Path(directory) / "audio"
-            items = gsv.resolve_items([{"text": "甲", "out": "00.wav"}], batch, str(target))
-            self.assertEqual(Path(items[0]["out"]), target / "00.wav")
-            items = gsv.resolve_items([{"text": "甲", "out": "00.wav"}], batch)
-            self.assertEqual(Path(items[0]["out"]), batch.parent / "00.wav")
-
-    def test_same_output_filename_requires_matching_metadata(self):
-        with tempfile.TemporaryDirectory() as directory:
-            path = Path(directory) / "00.wav"
-            write_wave(path)
-            key = gsv.take_key("甲", {"speed": 1.06})
-            self.assertFalse(gsv.cached_take(path, key))
-            path.with_suffix(".json").write_text(json.dumps({"key": key}), encoding="utf-8")
-            self.assertTrue(gsv.cached_take(path, key))
-            self.assertFalse(gsv.cached_take(path, gsv.take_key("乙", {"speed": 1.06})))
-
-
-class Stage(unittest.TestCase):
-    def test_mouth_patch_stays_on_reviewed_source_mouth(self):
-        rig = pv.DialoguePortrait()
-        self.assertTrue(rig.rigged)
-        closed = rig.render(0).convert("RGB")
-        opened = rig.render(1).convert("RGB")
-        box = ImageChops.difference(closed, opened).getbbox()
-        self.assertIsNotNone(box)
-        # Original mouth is x505..520/y513..517 in the 1037x1100 source.
-        self.assertTrue(330 <= box[0] < box[2] <= 370, box)
-        self.assertTrue(335 <= box[1] < box[3] <= 368, box)
-
-    def test_invalid_render_settings_fail_before_starting_audio(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            with self.assertRaises(ValueError):
-                pv.build({"shots": []}, root / "out.mp4", root)
-            with self.assertRaises(ValueError):
-                pv.build({"shots": [{}]}, root / "out.mp4", root, fps=0)
-            with self.assertRaises(ValueError):
-                pv.build({"shots": [{}], "width": 900}, root / "out.mp4", root)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/tests/test_reply_pictures.py

@@ -1,255 +0,0 @@
-"""Offline MCP regression for bili_reply pictures (2026-10-22, sticker request).
-
-Loads the real vendor mcp_server.py with bilibili_api + guard replaced by fakes,
-then pins the pictures rules: floor replies refuse pictures, >2 pictures
-refused, missing local file refused, URL entries deferred to load_remote_pictures,
-and pic= actually reaches comment.send_comment only for new comments.
-No network, no credentials, no real comment API.
-"""
-from __future__ import annotations
-
-import ast
-import asyncio
-import importlib.util
-import json
-import sys
-import tempfile
-import types
-import unittest
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-MCP = ROOT / "vendor" / "bilibili-mcp" / "mcp_server.py"
-
-
-def load_mcp_with_fakes():
-    """Import mcp_server.py but stub every third-party touchpoint before exec."""
-    source = MCP.read_text(encoding="utf-8")
-    tree = ast.parse(source)
-    # Syntax sanity first: file must parse clean.
-    compile(tree, str(MCP), "exec")
-
-    fake = types.ModuleType("fake_bilibili_api")
-
-    class Picture:
-        calls: list = []
-
-        def __init__(self, spec):
-            self.spec = spec
-
-        @classmethod
-        def from_file(cls, path):
-            cls.calls.append(("from_file", path))
-            return cls(("file", path))
-
-        @classmethod
-        async def load_url(cls, url):
-            cls.calls.append(("load_url", url))
-            return cls(("url", url))
-
-    class CommentResourceType:
-        VIDEO = "VIDEO"
-        ARTICLE = "ARTICLE"
-        AUDIO = "AUDIO"
-        DYNAMIC = "DYNAMIC"
-        DYNAMIC_DRAW = "DYNAMIC_DRAW"
-
-    fake.Picture = Picture
-    fake.CommentResourceType = CommentResourceType
-
-    comment_mod = types.ModuleType("fake_bilibili_api.comment")
-    comment_mod.send_comment_calls = []
-
-    async def fake_send_comment(text, oid, type_, root=None, parent=None, credential=None, pic=None):
-        comment_mod.send_comment_calls.append(
-            {"text": text, "oid": oid, "type": type_, "root": root, "parent": parent, "pic": pic})
-        return {"rpid": 4242, "root": root or 0, "parent": parent or 0, "rpid_str": "4242"}
-
-    comment_mod.send_comment = fake_send_comment
-    fake.comment = comment_mod
-
-    utils_mod = types.ModuleType("fake_bilibili_api.utils")
-    picture_mod = types.ModuleType("fake_bilibili_api.utils.picture")
-    picture_mod.Picture = Picture
-    utils_mod.picture = picture_mod
-    fake.utils = utils_mod
-
-    sentinels: dict = {}
-
-    def install(name: str, **attrs):
-        mod = types.ModuleType(name)
-        for key, value in attrs.items():
-            setattr(mod, key, value)
-        sys.modules[name] = mod
-        return mod
-
-    def stub_module(name: str, extra_names: tuple = ()) -> types.ModuleType:
-        """ModuleType fails `from X import Y` for names not set as attributes; pre-stub them."""
-        mod = install(name)
-        for attr in extra_names:
-            if not hasattr(mod, attr):
-                setattr(mod, attr, types.ModuleType(f"{name}.{attr}"))
-        return mod
-
-    stub_module("bilibili_api", ("video", "search", "comment", "Credential", "dynamic", "opus",
-                                 "hot", "rank", "user", "session", "favorite_list"))
-    sys.modules["bilibili_api"].Picture = Picture
-    sys.modules["bilibili_api"].CommentResourceType = CommentResourceType
-    sys.modules["bilibili_api"].Credential = object  # never constructed in these tests
-    comment_pkg = install("bilibili_api.comment", send_comment=fake_send_comment, CommentResourceType=CommentResourceType)
-    sys.modules["bilibili_api"].comment = comment_pkg  # `from bilibili_api import comment` reads the parent attr
-    install("bilibili_api.utils", picture=picture_mod)
-    install("bilibili_api.utils.picture", Picture=Picture)
-    sys.modules["bilibili_api.utils"].picture = picture_mod
-    stub_module("bilibili_api.video_uploader", ("VideoUploader", "VideoUploaderPage", "VideoMeta", "Lines"))
-    login_stub = stub_module("bilibili_api.login_v2")
-    # `QrCodeLogin | None` annotations evaluate eagerly at module level → need real classes, not modules.
-    class QrCodeLoginStub:  # noqa: D401 - placeholder type
-        pass
-    class QrCodeLoginEventsStub:  # noqa: D401
-        pass
-    login_stub.QrCodeLogin = QrCodeLoginStub
-    login_stub.QrCodeLoginEvents = QrCodeLoginEventsStub
-
-    # video.get_info must not hit network: module imports `video` and calls video.get_info.
-    async def fake_get_info(bvid):
-        return {"aid": 12345, "bvid": bvid}
-
-    video_mod = install("bilibili_api.video", get_info=fake_get_info)
-    video_mod.video = types.SimpleNamespace(get_info=fake_get_info)
-
-    # Guard: record reservations instead of touching real state files.
-    guard_mod = install("bili_guard",
-                        reserve_send=lambda key: {"key": key},
-                        mark_sent=lambda key: None,
-                        mark_unknown=lambda key: None,
-                        note_risk=lambda *a, **k: None)
-    sentinels["guard"] = guard_mod
-
-    spec = importlib.util.spec_from_file_location("mcp_server_under_test", MCP)
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    return mod, Picture, comment_mod
-
-
-class BiliReplyPictures(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.mcp, cls.Picture, cls.comment = load_mcp_with_fakes()
-        # mcp.bili_reply may be the raw fn (no BILI_MCP_TOOLS whitelist) or the lossless wrapper.
-        # Store as staticmethod: a plain function on the class binds `self` on instance access,
-        # which showed up as "got multiple values for argument 'bvid'".
-        target = cls.mcp.bili_reply
-        target = getattr(target, "fn", target)
-        target = getattr(target, "__wrapped__", target)
-        cls.reply = staticmethod(target)
-        # Neutralize every real-world side channel BEFORE any call:
-        # get_cred reads the user's credential file, video.Video reaches the network,
-        # _get_runtime_guard writes the home SQLite ledger. None of that may happen here.
-        cls.mcp.get_cred = lambda: object()
-
-        class FakeVideo:
-            def __init__(self, bvid=None, credential=None):
-                self.bvid = bvid
-
-            async def get_info(self):
-                return {"aid": 12345, "bvid": self.bvid}
-
-        cls.mcp.video.Video = FakeVideo
-
-        class FakeGuard:
-            def __init__(self):
-                self.reserved = []
-
-            def reserve_send(self, key, legacy_keys=()):
-                # 2026-10-25：mcp_server.py 改成传跨通道 legacy keys 了，
-                # 测试桩跟着收第二个参数（收不收都行，这里只关心 key）。
-                self.reserved.append(key)
-                return {"allowed": True}
-
-            def commit_send(self, *args, **kwargs):
-                pass
-
-            def reject_send(self, *args, **kwargs):
-                return {}
-
-            def mark_sent(self, *args, **kwargs):
-                pass
-
-            def mark_unknown(self, *args, **kwargs):
-                pass
-
-            def note_risk(self, *args, **kwargs):
-                pass
-
-        cls.guard = FakeGuard()
-        cls.mcp._get_runtime_guard = lambda: cls.guard
-
-    def test_01_signature_declares_pictures(self):
-        import inspect
-        params = inspect.signature(self.reply).parameters
-        self.assertIn("pictures", params)
-        self.assertEqual(params["pictures"].default, None)
-
-    def test_02_floor_reply_with_pictures_refuses_before_send(self):
-        before = len(self.comment.send_comment_calls)
-        out = json.loads(asyncio.run(self.reply(bvid="BV1aaaaaaaaa", text="hi", rpid="8001", pictures=["whatever"])))
-        self.assertFalse(out.get("success", True))
-        self.assertIn("回复楼层", out.get("error", ""))
-        self.assertFalse(out.get("retry_blocked", False))
-        self.assertEqual(len(self.comment.send_comment_calls), before, "floor refusal must not call send_comment")
-
-    def test_03_too_many_pictures_refused(self):
-        out = json.loads(asyncio.run(self.reply(
-            bvid="BV1aaaaaaaaa", text="hi", rpid="0",
-            pictures=["a.jpg", "b.jpg", "c.jpg"])))
-        self.assertFalse(out.get("success", True))
-        self.assertIn("最多 2 张", out.get("error", ""))
-
-    def test_04_missing_local_file_refused(self):
-        out = json.loads(asyncio.run(self.reply(
-            bvid="BV1aaaaaaaaa", text="hi", rpid="0",
-            pictures=[r"C:\definitely\not\here.jpg"])))
-        self.assertFalse(out.get("success", True))
-        self.assertIn("图片不存在", out.get("error", ""))
-        self.assertTrue(out.get("invalid_pictures"))
-
-    def test_05_new_comment_local_picture_reaches_send_comment(self):
-        self.Picture.calls.clear()
-        self.comment.send_comment_calls.clear()
-        with tempfile.TemporaryDirectory() as directory:
-            picture = Path(directory) / "s.jpg"
-            picture.write_bytes(b"\xff\xd8\xff\xe0" + b"\x00" * 12)
-            out = json.loads(asyncio.run(self.reply(
-                bvid="BV1aaaaaaaaa", text="带上表情", rpid="0", pictures=[str(picture)])))
-        self.assertTrue(out.get("success"), out)
-        kinds = [kind for kind, _ in self.Picture.calls]
-        self.assertIn("from_file", kinds)
-        self.assertEqual(len(self.comment.send_comment_calls), 1)
-        call = self.comment.send_comment_calls[0]
-        self.assertIsNotNone(call["pic"], "pic= must be passed for new comments with pictures")
-        self.assertEqual(call["root"], None)
-        self.assertEqual(call["parent"], None)
-
-    def test_06_reply_without_pictures_stays_text_only(self):
-        self.comment.send_comment_calls.clear()
-        asyncio.run(self.reply(bvid="BV1aaaaaaaaa", text="纯文字回复", rpid="8001", root="9001"))
-        call = self.comment.send_comment_calls[-1]
-        self.assertIsNone(call["pic"], "text floor replies must not pass pic=")
-        self.assertEqual(call["parent"], 8001)
-
-    def test_07_url_picture_defers_to_load_url(self):
-        self.Picture.calls.clear()
-        self.comment.send_comment_calls.clear()
-        with tempfile.TemporaryDirectory() as directory:
-            out = json.loads(asyncio.run(self.reply(
-                bvid="BV1aaaaaaaaa", text="网络表情", rpid="0",
-                pictures=["https://i0.hdslb.com/bfs/x.jpg"])))
-        self.assertTrue(out.get("success"), out)
-        kinds = [kind for kind, _ in self.Picture.calls]
-        self.assertIn("load_url", kinds)
-        self.assertIn("https://i0.hdslb.com/bfs/x.jpg", [arg for _, arg in self.Picture.calls])
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/tests/token-ledger.test.mjs

@@ -1,78 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import {
-  tokenTaskStart, tokenTaskUpdate, tokenTaskEnd, tokenLedgerSnapshot, clearTokenLedger, TOKEN_LEDGER_MAX,
-} from '../lib/tokens.mjs'
-
-test('session task ledger records measured tokens and ends idempotently', () => {
-  const home = mkdtempSync(join(tmpdir(), 'dafeiyu-token-'))
-  try {
-    const a = tokenTaskStart(home, { kind: 'session', label: '鲸鱼摸鱼会话', model: 'p/m', budget: 100000, maxRounds: 8, why: 'session' })
-    assert.ok(a.id, 'start returns an id for the caller to keep')
-    assert.equal(a.tokensUnknown, false)
-    tokenTaskUpdate(home, a.id, { rounds: 2, tokens: { input: 8000, output: 1500 } })
-    tokenTaskUpdate(home, a.id, { rounds: 5, tokens: { input: 21000, output: 3000 } })
-    tokenTaskEnd(home, a.id, { stopReason: 'user', tokens: { input: 26000, output: 4000, total: 30000 } })
-    // 收账是幂等的：clear 再收一次不重写时间、不重置 token
-    tokenTaskEnd(home, a.id, { stopReason: 'clear', rounds: 9 })
-    const snap = tokenLedgerSnapshot(home, { limit: 10 })
-    assert.equal(snap.entries.length, 1)
-    const e = snap.entries[0]
-    assert.equal(e.rounds, 5, 'end with explicit rounds overrides, idempotent end does not reset to 9')
-    assert.equal(e.stopReason, 'clear', 'later stopReason wins')
-    assert.equal(e.tokens.total, 30000)
-    assert.ok(e.endedAt, 'endedAt set once')
-    assert.ok(e.durationSec >= 0)
-    assert.equal(snap.sums.tasks, 1)
-    assert.equal(snap.sums.total, 30000)
-  } finally { rmSync(home, { recursive: true, force: true }) }
-})
-
-test('background tasks stay unmeasured until real beacon data arrives, then count', () => {
-  const home = mkdtempSync(join(tmpdir(), 'dafeiyu-token-'))
-  try {
-    // ① 没有信标对账：宿主读不到子进程的计量 ⇒ 如实标未计量，不计入总和（宁缺毋假）
-    const b = tokenTaskStart(home, { kind: 'background', label: '桌宠后台轮', model: 'p/b', budget: 60000, why: 'pet' })
-    assert.equal(b.tokensUnknown, true)
-    tokenTaskEnd(home, b.id, { stopReason: 'exit', code: 0 })
-    let snap = tokenLedgerSnapshot(home, {})
-    assert.equal(snap.entries[0].tokens, null)
-    assert.equal(snap.entries[0].tokensUnknown, true)
-    assert.equal(snap.sums.tasks, 0)
-    assert.equal(snap.sums.unknown, 1)
-    assert.equal(snap.sums.total, 0)
-    // ② 信标对账（reconcileBgUsage 按 pid 从 bg-usage.jsonl 读到的真实计量）：
-    //    这不是猜数，是子进程自报 ⇒ 收下、翻成已计量、计入总和
-    const c = tokenTaskStart(home, { kind: 'background', label: '桌宠后台轮·信标', model: 'p/b', budget: 60000, why: 'pet' })
-    assert.equal(c.tokensUnknown, true)
-    tokenTaskEnd(home, c.id, { stopReason: 'exit', code: 0, tokens: { input: 1, output: 2, total: 3 } })
-    snap = tokenLedgerSnapshot(home, {})
-    assert.equal(snap.entries[0].tokensUnknown, false, '真实计量到达后未计量翻转为已计量')
-    assert.deepEqual(snap.entries[0].tokens, { input: 1, output: 2, total: 3 })
-    assert.equal(snap.sums.tasks, 1)
-    assert.equal(snap.sums.unknown, 1, '没计量到的那条仍然如实留在 unknown 里')
-    assert.equal(snap.sums.total, 3)
-  } finally { rmSync(home, { recursive: true, force: true }) }
-})
-
-test('ledger is capped, newest-first in snapshots, and clear empties it', () => {
-  const home = mkdtempSync(join(tmpdir(), 'dafeiyu-token-'))
-  try {
-    for (let i = 0; i < TOKEN_LEDGER_MAX + 10; i++) {
-      const t = tokenTaskStart(home, { kind: 'background', label: 't' + i, why: 'manual', startedAt: new Date(Date.UTC(2026, 0, 1, 0, 0, i)).toISOString() })
-      tokenTaskEnd(home, t.id, { stopReason: 'exit', code: 0 })
-    }
-    let snap = tokenLedgerSnapshot(home, { limit: 5 })
-    assert.ok(snap.entries.length <= 5, 'snapshot respects limit')
-    const all = tokenLedgerSnapshot(home, { limit: 200 })
-    assert.ok(all.entries.length <= TOKEN_LEDGER_MAX, 'storage is capped')
-    // 新任务在前：第一条应是最后一个启动的
-    assert.equal(all.entries[0].label, 't' + (TOKEN_LEDGER_MAX + 9))
-    clearTokenLedger(home)
-    snap = tokenLedgerSnapshot(home, {})
-    assert.equal(snap.entries.length, 0)
-  } finally { rmSync(home, { recursive: true, force: true }) }
-})