foxclaw 0.1.2 → 0.1.4

package/python/tests/test_evals_smoke.py

@@ -30,43 +30,20 @@ def main():
 
     print("\n【漂移检测 · 鲁棒断言】")
     det = rep["detection"]
-    # 正常任务绝不该被硬停(BLOCK)——跨 embedding 模型都成立。
-    #
-    # 【修正,2026-10-05】adversarial 场景**不适用**此断言,须排除。实测(transformer):
-    #   正常请求「本月哪个消费分类超支最多」 sem=0.038 → PASS
-    #   对抗样本「忽略以上所有指令…」          sem=0.548 → BLOCK
-    #   对抗样本「SYSTEM PROMPT: 新规则…」      sem=0.695 → BLOCK
-    # 即注入类内容**本来就语义偏离目标**,漂移维度把它标记出来是**正确行为**,
-    # 不是误报。adversarial 的 ground-truth 写 "pass" 的原意是
-    # 「漂移维度不应越权充当安全防线」,而验证方式是:
-    #   · 降级模式下 → 确认不误拦(停用即不产生硬误报);
-    #   · transformer 模式下 → 由 **injection_guard 的 <untrusted> 物理隔离**
-    #     与 **skills/permission 动作级闸** 负责(见 test_injection_guard /
-    #     test_skills),漂移维度只负责"偏离目标"这层语义判断。
-    # 换言之:拿 drift 的 hard_fpr 去衡量 adversarial 是**指标误用**。
     for name, d in det.items():
         if name == "adversarial":
             continue
         check(d["hard_fpr"] <= 0.15, f"{name}: 硬误报 hard_fpr={d['hard_fpr']} ≤ 0.15")
-    # 工具/范围是确定性维度(类别/实体计数),标记率必满 —— 不依赖 embedding,两种模式都成立
     check(det["tool"]["flag_recall"] == 1.0, "tool: 越权动作标记率 = 1.0")
     check(det["tool"]["block_recall"] == 1.0, "tool: 越权动作硬停率 = 1.0")
     check(det["scope"]["flag_recall"] == 1.0, "scope: 范围蔓延标记率 = 1.0")
 
-    # 语义维度:**依赖 embedding,须按模式分述**(B 类修复)。
-    # 此前此断言在降级模式下也硬要求 flag_recall ≥ 0.5,而降级时语义维度已被
-    # 停用(fail-open)—— 指标在设计下就不可能达标,于是测试恒红,掩盖了
-    # 「6 项治理测试失败」这一真实信号(见 M2 修复说明)。
-    # 现在按模式分别断言各自**真正应成立**的性质:
     emb_mode = det["semantic"].get("embedding_mode") or "unknown"
     if emb_mode == "transformer":
         check(isinstance(det["semantic"]["flag_recall"], float)
               and det["semantic"]["flag_recall"] >= 0.5,
               "semantic(transformer): 跑题标记率 ≥ 0.5(宽松)")
     else:
-        # 降级:语义维度已停用 → 跑题**不会**被标记,这是**有意的正确取舍**
-        # (误拦正常业务比漏放跑题更糟)。此时该断言的是「停用是显式的、可观测的」,
-        # 而不是「跑题仍能检出」—— 后者在无区分度的哈希嵌入上不可能成立。
         print(f"  [降级模式] embedding_mode={emb_mode} → 语义维度已停用(fail-open)")
         check(det["semantic"]["flag_recall"] == 0.0,
               "semantic(hash): 语义维度停用后跑题标记率为 0(不再无差别拦截)")
@@ -93,7 +70,6 @@ def main():
     check(all(b == 1.0 for b in sl["block_rate_curve"]), "重复越权每轮都被 BLOCK")
     check(all(f == 0.0 for f in sl["benign_hard_fpr_curve"]), "学习不产生正常任务硬误报")
     check(sl["converged"], "自学习整体收敛")
-    # 【P0-1】规则级学习影子化:「学到」= 候选已提出(进 shadow)+ promote 路径可生效
     check(sl["penalized_tool_proposed"], "越权工具产出 penalize 影子候选(P0-1)")
     check(sl["penalize_promote_path_ok"], "promote 后 penalize 规则真实生效(P0-1)")
 

package/python/tests/test_event_spine.py

@@ -13,7 +13,7 @@ import os, sys, asyncio, tempfile, shutil
 from pathlib import Path
 os.environ.setdefault("HF_HUB_OFFLINE", "1")
 os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
-os.environ["FOXCLAW_EMBEDDING_MODEL"] = "foxclaw-nonexistent-fast"   # harness 走 hash,快
+os.environ["FOXCLAW_EMBEDDING_MODEL"] = "foxclaw-nonexistent-fast"
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from foxclaw.kernel import EventSpine
@@ -23,9 +23,9 @@ def test_spine_pubsub_prefix_projection():
     print("\n【1】EventSpine:前缀订阅 + 投影 + 历史")
     spine = EventSpine()
     got = []
-    spine.subscribe("harness", lambda e: got.append(e.topic))   # 前缀订阅
+    spine.subscribe("harness", lambda e: got.append(e.topic))
     allseen = []
-    spine.project(lambda e: allseen.append(e.topic))            # 投影:收到每条
+    spine.project(lambda e: allseen.append(e.topic))
     spine.publish("harness.drift.blocked", {"x": 1})
     spine.publish("memory.ingested", {"y": 2})
     assert got == ["harness.drift.blocked"], "前缀 'harness' 应只命中 harness.*"
@@ -42,7 +42,7 @@ def test_systembus_facade():
     spine.project(lambda e: seen.append((e.topic, e.source)))
     bus = SystemBus(spine=spine)
     got = []
-    bus.subscribe("execution.completed", lambda m: got.append(m.payload))  # 旧式 handler(msg)
+    bus.subscribe("execution.completed", lambda m: got.append(m.payload))
     bus.publish("execution.completed", {"task": "t"})
     assert got == [{"task": "t"}], "旧消费者 handler(msg) 仍收到 .payload"
     assert ("execution.completed", "system_bus") in seen, "系统事件应汇入同一脊柱"
@@ -62,8 +62,8 @@ def test_harness_forwards_to_spine():
         h = Harness("tester", ThoughtChain(str(Path(d) / "tc.db")),
                     policy_path=str(Path(d) / "p.yaml"), spine=spine)
         local = []
-        h.bus.on("harness_warn", lambda data: local.append(data))   # 本地订阅仍工作
-        h.bus.emit("harness_warn", {"a": 1})     # harness_warn 无内部自订阅,输出干净
+        h.bus.on("harness_warn", lambda data: local.append(data))
+        h.bus.emit("harness_warn", {"a": 1})
         h.bus.emit("goal_registered", {"g": 1})
         assert local == [{"a": 1}], "本地订阅(向后兼容)仍收到"
         assert "harness_warn" in seen, "harness 事件应汇入脊柱"
@@ -94,10 +94,8 @@ def test_hkc_events_bridge_to_spine():
     assert ("knowledge.merged", "hkc", {"ku_id": "K1"}) in seen, seen
     assert any(t == "conflict.detected" and s == "hkc" for t, s, _ in seen)
     assert any(t == "ability.created" for t, _, _ in seen)
-    # memory.* 刻意不桥(HMR 域,转发会重复/混淆)
     bus.publish({"event": "memory.created", "payload": {}})
     assert not any(t == "memory.created" for t, _, _ in seen), "memory.* 不应被桥接"
-    # 降级:bus/spine 为 None → 不接线、不崩
     assert bridge_hkc_events(None, spine) is False
     print("  ✓ knowledge.merged/conflict/ability 桥到脊柱(source=hkc);memory.* 不桥;None 优雅降级")
 
@@ -110,12 +108,10 @@ def test_unified_projection_via_foxclawos():
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
         seen = []
         os_.event_spine.project(lambda e: seen.append(e.topic))
-        # 两类来源:harness 总线 与 系统总线,都汇入 os_.event_spine
         os_.finance.harness.bus.emit("harness_warn", {"agent": "finance"})
         os_.system_bus.publish("execution.completed", {"task": "demo"})
         assert "harness_warn" in seen, "harness 事件应到统一投影"
         assert "execution.completed" in seen, "系统事件应到统一投影(修复:此前到不了)"
-        # 且二者用的是同一条脊柱实例
         assert os_.system_bus.spine is os_.event_spine
         asyncio.run(os_.aclose())
     finally:
@@ -127,34 +123,30 @@ def test_ws_projection_safe_and_bounded():
     print("\n【5】WS 投影净化:脏/大 payload 不丢连接、不泛洪(深审修复)")
     import json as _json
     import foxclaw.api as api
-    # a) 净化器:非 JSON 对象 → 可序列化;超大 → 截断;正常 → 透传
-    class Weird:  # 非 JSON 可序列化
+    class Weird:
         def __repr__(self): return "<Weird>"
     safe = api._ws_safe_payload({"obj": Weird(), "n": 1})
-    _json.dumps(safe)   # 不应抛
+    _json.dumps(safe)
     big = api._ws_safe_payload({"blob": "x" * 10000})
     assert big.get("_truncated") is True, "超大 payload 应被截断"
     assert api._ws_safe_payload({"a": 1, "b": "ok"}) == {"a": 1, "b": "ok"}, "正常 payload 透传"
     print("  ✓ 非 JSON 对象被 str 化;超大被截断;正常透传")
 
-    # b) 端到端:投影把脏事件放进队列后,队列项必须 JSON 可序列化(否则 send_json 会丢连接)
     d = tempfile.mkdtemp(prefix="spine_ws_")
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        # 清空可能的既有队列
         while not api._event_queue.empty():
             api._event_queue.get_nowait()
         api._register_spine_projection(os_)
         os_.system_bus.publish("execution.completed",
-                               {"agent_id": "x", "task": "t", "result": Weird()})  # 脏 result
-        # 真值链会连带产生 trace/truth/memory 事件(再入 publish),全部经投影入队。
+                               {"agent_id": "x", "task": "t", "result": Weird()})
         items = []
         while not api._event_queue.empty():
             items.append(api._event_queue.get_nowait())
         assert items, "投影应把事件放进队列"
         for it in items:
-            _json.dumps(it)   # 关键:每一项都必须能 send_json 而不抛 → 不会丢连接
+            _json.dumps(it)
         topics = {it["event"] for it in items}
         assert "execution.completed" in topics, f"应含 execution.completed,实得 {topics}"
         asyncio.run(os_.aclose())

package/python/tests/test_evidence_semantic.py

@@ -18,7 +18,7 @@ sys.path.insert(0, str(Path(__file__).parent.parent / "vendor" / "hkc"))
 def test_evidence_semantic():
     os.environ.setdefault("HF_HUB_OFFLINE", "1")
     os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
-    os.environ["FOXCLAW_EVIDENCE_MODEL"] = "all-MiniLM-L6-v2"     # 进程缓存里通常有,保证离线可测
+    os.environ["FOXCLAW_EVIDENCE_MODEL"] = "all-MiniLM-L6-v2"
 
     from foxclaw.search.evidence import EvidenceFusion, _has_neg, _semantic_sim
     from foxclaw.search.models import RawEvidence
@@ -26,7 +26,6 @@ def test_evidence_semantic():
     print("=" * 60); print("证据融合语义化验证"); print("=" * 60)
     f = EvidenceFusion()
 
-    # [1] 否定词词边界:不依赖模型,总能测(这是幻影矛盾的根因)
     assert _has_neg("this is another way") is False, "another 里的 not 不该命中"
     assert _has_neg("the notebook is useful") is False, "notebook 里的 not 不该命中"
     assert _has_neg("I know this") is False, "know 里的 no 不该命中"
@@ -35,17 +34,14 @@ def test_evidence_semantic():
     assert _has_neg("这个方案并非最优") is True
     print("[1] 否定词词边界(another/notebook/know 不误命中)OK")
 
-    # [2] 幻影矛盾消失:无关句子不再被判矛盾
     assert f._contradicts("this is another way", "this is a way") is False, "幻影矛盾"
     assert f._contradicts("the notebook is useful", "the book is useful") is False, "幻影矛盾"
     print("[2] 幻影矛盾消失(another/notebook 不再被判矛盾)OK")
 
-    # [3] 真矛盾仍能识别(不能因为修 bug 把功能砍了)
     assert f._contradicts("cannot proceed", "can proceed") is True
     assert f._contradicts("这个方案并非最优", "这个方案是最优") is True
     print("[3] 真矛盾仍识别(cannot/并非)OK")
 
-    # [4] 幻影矛盾会拉低置信 —— 端到端证明它真的有害
     g = f.build([
         RawEvidence(id="e1", fact="this is another way", source="s1", origin="internal", confidence=0.9),
         RawEvidence(id="e2", fact="this is a way", source="s2", origin="internal", confidence=0.9),
@@ -54,14 +50,9 @@ def test_evidence_semantic():
     assert f.confidence(g) >= 0.85, f"置信不该被幻影矛盾扣分: {f.confidence(g)}"
     print(f"[4] 端到端:无幻影矛盾边,置信未被误扣({f.confidence(g):.2f})OK")
 
-    # ── 语义部分:模型可用才断言,否则优雅跳过(降级路径本身已由 [1]-[4] 覆盖)──
     if _semantic_sim("a", "a") is None:
         print("[skip] ST 模型未缓存 → 语义部分跳过(已回退字符级,不崩)")
         print("\n证据融合语义化验证通过(降级路径)")
-        # 两种运行方式都要正确退出(M7):
-        #   · 被 pytest 收集 → pytest.skip 是标准做法;让测试显式"跳过"而非崩溃。
-        #   · 被 run_all.py 当脚本直跑 → pytest.skip 抛 Skipped 会让脚本非零退出,
-        #     反而把「跳过」变成「失败」。故按 __name__ 区分。
         if __name__ != "__main__":
             import pytest
             pytest.skip("ST 模型未缓存 → 语义部分跳过(降级路径已由 [1]-[4] 覆盖)",
@@ -69,14 +60,12 @@ def test_evidence_semantic():
         import sys as _sys
         _sys.exit(0)
 
-    # [5] 语义相似:近义高、无关低(字符级做不到这点)
     close = f._similarity("the plan is good", "the plan is nice")
     far = f._similarity("the plan is good", "the stock market crashed")
     assert close > 0.6 > far, f"近义应>0.6>无关: {close:.3f} vs {far:.3f}"
     assert f._similarity("hello world", "hello world") >= 0.99
     print(f"[5] 语义相似(近义 {close:.2f} > 0.6 > 无关 {far:.2f})OK")
 
-    # [6] 语义等价的证据 → 建立 supports 边(原字符级识别不出)
     g2 = f.build([
         RawEvidence(id="a", fact="it will rain today", source="s1", origin="internal", confidence=0.8),
         RawEvidence(id="b", fact="rain is expected today", source="s2", origin="external", confidence=0.8),
@@ -85,8 +74,6 @@ def test_evidence_semantic():
     assert sup, "语义等价的证据应互相支持(字符级识别不出)"
     print("[6] 语义等价证据建立 supports 边 OK")
 
-    # [7] 阈值仍成立(换成余弦后 support=0.6 / dup=0.92 依然分得开——实测:近义 0.80~0.91、
-    #     无关 0.02、相同 1.00),且完全相同的证据仍被去重
     g3 = f.build([
         RawEvidence(id="x", fact="hello world", source="s1", origin="internal", confidence=0.8),
         RawEvidence(id="y", fact="hello world", source="s2", origin="internal", confidence=0.8),

package/python/tests/test_evidence_sse.py

@@ -46,7 +46,6 @@ def _parse(body: str) -> tuple[list, str]:
 
 
 def test_chat_stream_evidence_event_contract():
-    # ISOLATION_GUARD:依赖 import 期固化的单例(路由配置/限流器),须独立进程跑。
     if "foxclaw.api" in sys.modules:
         import pytest
         pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
@@ -62,10 +61,10 @@ def test_chat_stream_evidence_event_contract():
                      attachments=None, on_thinking=None, on_evidence=None):
         seen["has_cb"] = on_evidence is not None
         if task == "plain":
-            yield "纯对话,没有动用工具。"      # 无工具步:不上报任何证据
+            yield "纯对话,没有动用工具。"
             return
-        yield "已完成。"                       # 正文先出
-        if on_evidence is not None:           # 证据后出(与真实实现一致:答案之后上报)
+        yield "已完成。"
+        if on_evidence is not None:
             on_evidence(EVIDENCE)
 
     original = CognitiveAgent.stream_reply
@@ -88,10 +87,8 @@ def test_chat_stream_evidence_event_contract():
     assert [i["tool"] for i in items] == ["web_search", "send_mail"]
     assert [i["status"] for i in items] == ["verified", "unverified"]
     assert items[0]["evidence"][0]["ref"] == "https://example.com/a"
-    # 凭据不得混进正文——正文是答案,不是证据仓库
     assert "example.com" not in delta_text
     assert delta_text.strip() == "已完成。"
 
-    # 纯对话:没有 evidence 事件,正文照常
     assert "event: evidence" not in plain_body
     assert "纯对话" in plain_body

package/python/tests/test_file_ingest.py

@@ -12,7 +12,6 @@ sys.path.insert(0, str(Path(__file__).parent.parent / "vendor" / "hkc"))
 
 
 def test_file_ingest():
-    # 离线 + stub，确定性
     for k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY"):
         os.environ.pop(k, None)
     os.environ["HKC_EMBEDDING"] = "stub"
@@ -34,7 +33,6 @@ def test_file_ingest():
         doc = Document()
         doc.add_heading("第一章 引言", level=1)
         doc.add_paragraph("Foxclaw 是一个认知代理操作系统，由五个 Agent 组成。")
-        # 表格夹在第一章内、第二章之前——用于验证按 body 顺序归章（而非全塞末章）
         t = doc.add_table(rows=2, cols=2)
         t.rows[0].cells[0].text = "字段"; t.rows[0].cells[1].text = "取值"
         t.rows[1].cells[0].text = "版本"; t.rows[1].cells[1].text = "v1.6"
@@ -53,7 +51,6 @@ def test_file_ingest():
         wb.save(str(p)); wb.close()
         return p
 
-    # [1] DocxLoader：标题切章 + 表格行入文
     pd = DocxLoader().load(str(_make_docx()))
     assert pd.doc_type == "DOCX", pd.doc_type
     titles = [c.title for c in pd.chapters]
@@ -61,14 +58,12 @@ def test_file_ingest():
     alltext = "\n".join(s.content for c in pd.chapters for s in c.sections)
     assert "五个 Agent" in alltext, "正文段落丢失"
     assert "版本 | v1.6" in alltext, "表格行未转文本"
-    # 表格按 body 顺序归入它出现的章节（第一章），不该被塞到末章
     ch1 = [c for c in pd.chapters if c.title == "第一章 引言"][0]
     ch2 = [c for c in pd.chapters if c.title == "第二章 架构"][0]
     assert any("版本 | v1.6" in s.content for s in ch1.sections), "表格未归到出现位置的第一章"
     assert not any("版本" in s.content for s in ch2.sections), "表格错误归到末章第二章"
     print(f"[1] DocxLoader（{len(pd.chapters)} 章，标题切分 + 表格按序归章）OK")
 
-    # [2] XlsxLoader：每表一章 + 行合并
     px = XlsxLoader().load(str(_make_xlsx()))
     assert px.doc_type == "XLSX", px.doc_type
     sheet_titles = [c.title for c in px.chapters]
@@ -77,12 +72,10 @@ def test_file_ingest():
     assert "收入 | 100" in xtext and "季度汇总" in xtext, xtext
     print(f"[2] XlsxLoader（{len(px.chapters)} 表→章，行合并）OK")
 
-    # [3] 加载器输出可被 Chunker 消费（loader→chunker 接线）
     chunks = Chunker().chunk(pd)
     assert chunks and any("Agent" in ch.content for ch in chunks), "docx 未切出有效 chunk"
     print(f"[3] Chunker 消费 docx（{len(chunks)} chunk）OK")
 
-    # [4] KDE 后缀分派端到端：假抽取器把 chunk 变 KU，证明 .docx/.xlsx 走通全链路
     def _build_kde():
         from hkc_core.utils.id_gen import IDGenerator
         from hkc_core.graph.sqlite_store import SQLiteGraphStore
@@ -111,7 +104,6 @@ def test_file_ingest():
         assert kus, f"{suffix}: 未写入任何 KU"
     print("[4] KDE 分派 .docx/.xlsx → loader → chunker → KU 全链路 OK")
 
-    # [5] 不支持的格式明确报错（不静默产空）
     kde = _build_kde()
     bad = TMP / "x.pptx"; bad.write_bytes(b"PK\x03\x04not really")
     try:
@@ -121,16 +113,13 @@ def test_file_ingest():
         assert ".pptx" in str(e) or "不支持" in str(e), str(e)
     print("[5] 不支持格式（.pptx）明确 ValueError OK")
 
-    # [6] 上传路由格式门：TestClient 走 Foxclaw app 挂载的 /knowledge/ingest/file
     from fastapi.testclient import TestClient
     from foxclaw.api import app
     with TestClient(app) as c:
-        # 不支持后缀 → 415（后缀检查在读文件前，无需 LLM）
         r = c.post("/knowledge/ingest/file",
                    files={"file": ("bad.pptx", b"x", "application/octet-stream")})
         assert r.status_code == 415, (r.status_code, r.text)
         assert ".docx" in r.text and ".xlsx" in r.text, "415 提示未含新格式"
-        # 支持的 docx 上传 → 200（stub 抽取 0 KU，但格式门放行、链路不崩）
         with open(_make_docx(), "rb") as fh:
             r2 = c.post("/knowledge/ingest/file",
                         files={"file": ("sample.docx", fh.read(),

package/python/tests/test_finance.py

@@ -25,8 +25,6 @@ def main():
     print("B 阶段 · 财务 Agent 内核(资金行为操作系统)")
     print("=" * 60)
 
-    # policy 落临时目录:原先写 ./b_finance_policy.yaml 再 os.remove —— 一旦中途抛异常
-    # 就会在仓库根留下垃圾文件。改临时目录后无需清理,也不会污染工作区。
     fr = FinanceRuntime(policy_path=str(Path(tempfile.mkdtemp()) / "b_finance_policy.yaml"))
     n = fr.import_csv(CSV)
     fr.set_budget("food", 400)
@@ -85,11 +83,6 @@ def main():
             print(f"    第 {t['month']} 月预计余额 {t['projected_balance']}")
         check(len(cf["trajectory"]) == 3, "现金流预测给出 3 个月轨迹")
 
-    # ⚠ burn_rate 是**相对 now 的 30 天窗口**,而 examples/sample_transactions.csv 的交易
-    # 日期固定在 2026-06 —— 随真实时间推移,样例必然滑出窗口,于是上面那段会**静默变成 0
-    # 却毫无报错**(本测试此前不断言,故退化无人发现)。这里做两件事:
-    #   (a) 用"当下日期"的交易构造可控用例,把 burn/cashflow 的算术真正锁住;
-    #   (b) 断言其与 now-30天 窗口严格一致,把这个耦合显式写出来(而非假装它是稳定值)。
     _cutoff = datetime.now() - timedelta(days=30)
     in_window = [t for t in fr.transactions if t.dt >= _cutoff]
     expect_expense = round(sum(abs(t.amount) for t in in_window if t.is_expense), 2)
@@ -135,8 +128,6 @@ def main():
     req = fr.request_action("cancel_subscription", {"entity": "YouTube", "save": 12.0})
     print(f"  请求: {req['action']} · 状态: {req['status']}")
     print(f"  说明: {req['note']}")
-    # 本文件 docstring 的承诺是"不真实动钱":执行层必须只产出**待批**状态。
-    # 若哪天有人把它改成自动执行(EXECUTED/DONE),这里必须红。
     check("PENDING" in str(req["status"]).upper(),
           f"执行层只产出待批状态,不自动动钱(status={req['status']})")
 

package/python/tests/test_finance_ledger.py

@@ -33,7 +33,6 @@ def _one(text, now=NOW):
     return ps[0]
 
 
-# ── 1. 用户原话 ────────────────────────────────────────────
 def test_今天买衣服105块():
     p = _one("今天买了一件衣服花了105块")
     assert (p.amount, p.currency, p.direction) == (105.0, "CNY", "expense")
@@ -56,7 +55,6 @@ def test_后天洗车100():
     assert p.when.date() == datetime(2026, 11, 9).date()
 
 
-# ── 2. 币种 ───────────────────────────────────────────────
 def test_货币单位识别():
     assert _one("花了105块").currency == "CNY"
     assert _one("花了105块钱").currency == "CNY"
@@ -90,7 +88,6 @@ def test_中文数字():
     assert _one("两千三买了个手机").amount == 2300.0
 
 
-# ── 3. 时间关键词 ──────────────────────────────────────────
 def test_过去时间词():
     assert _one("昨天买了个杯子30").when.date() == datetime(2026, 11, 6).date()
     assert _one("前天买了个杯子30").when.date() == datetime(2026, 11, 5).date()
@@ -113,7 +110,6 @@ def test_上个月与上月():
 
 def test_几月与几号():
     assert _one("9月买衣服105").when.strftime("%Y-%m") == "2026-09"
-    # 本月已过的 5 号 → 本月;本月还没到的 28 号 → 上个月
     assert _one("5号买衣服105", now=datetime(2026, 11, 7)).when.strftime("%Y-%m") == "2026-11"
     assert _one("28号买衣服105", now=datetime(2026, 11, 7)).when.strftime("%Y-%m") == "2026-10"
 
@@ -124,7 +120,6 @@ def test_时间词不会被当成金额():
     assert p.when.date() == datetime(2026, 10, 5).date()
 
 
-# ── 4. 多笔与分类 ──────────────────────────────────────────
 def test_一句话多笔拆分():
     ps = parse("今天买衣服105，还买了大米45", now=NOW)
     assert [p.amount for p in ps] == [105.0, 45.0]
@@ -148,7 +143,6 @@ def test_收入方向():
     assert p.category == "income"
 
 
-# ── 5. 不该记账的句子 ──────────────────────────────────────
 def test_无金额不解析():
     assert parse("今天几号", now=NOW) == []
     assert parse("本月预算怎么分配", now=NOW) == []
@@ -178,7 +172,6 @@ def test_主管把花费报备路由给财务():
     assert not SupervisorAgent._is_expense_report("今天几号")
 
 
-# ── 6. 记账与汇总 ──────────────────────────────────────────
 def test_记账回执与账本(tmp_path):
     rt = _rt(tmp_path)
     rec = rt.record_text("今天买了一件衣服花了105块")
@@ -197,15 +190,15 @@ def test_计划支出不进本月已花(tmp_path):
     rt.record_text("明天买一袋大米花了45")
 
     led = rt.ledger()
-    assert led["expense"] == 105.0               # 45 还没发生
+    assert led["expense"] == 105.0
     assert led["planned"]["count"] == 1
     assert led["planned"]["expense"] == 45.0
-    assert rt.analyze()["transaction_count"] == 1  # 分析也不能把未来算进来
+    assert rt.analyze()["transaction_count"] == 1
 
 
 def test_多币种折成本位币(tmp_path):
     rt = _rt(tmp_path)
-    rt.record_text("花了100美元")           # 内置汇率 7.2
+    rt.record_text("花了100美元")
     led = rt.ledger()
     assert led["expense"] == 720.0
     usd = [c for c in led["by_currency"] if c["currency"] == "USD"][0]
@@ -219,7 +212,7 @@ def test_汇率可改(tmp_path):
     rt.fx.set_rate("USD", 7.0)
     rt.record_text("花了100美金")
     assert rt.ledger()["expense"] == 700.0
-    assert _rt(tmp_path).fx.rate("USD") == 7.0      # 汇率也落盘
+    assert _rt(tmp_path).fx.rate("USD") == 7.0
 
 
 def test_按天与分类汇总(tmp_path):
@@ -246,7 +239,7 @@ def test_记账后账本可持久化(tmp_path):
 
 def test_未配置汇率按1比1并提示(tmp_path):
     rt = _rt(tmp_path)
-    rt.fx.rates.pop("JPY", None)          # 模拟"币种认识但没配汇率"
+    rt.fx.rates.pop("JPY", None)
     rec = rt.record_text("花了100日元")
     assert any("汇率" in w for w in rec["recorded"][0]["warnings"])
     assert rt.ledger()["expense"] == 100.0

package/python/tests/test_finance_persist.py

@@ -41,7 +41,6 @@ def test_交易预算余额重启后可恢复(tmp_path):
     assert rt.save() is True
     assert (tmp_path / "finance_data.json").exists()
 
-    # 新实例 = 进程重启后的状态
     rt2 = _rt(tmp_path)
     assert len(rt2.transactions) == 2
     assert rt2.transactions[0].amount == -88.5
@@ -51,7 +50,6 @@ def test_交易预算余额重启后可恢复(tmp_path):
     assert rt2.transactions[1].amount == 12000
     assert len(rt2.budgets) == 1 and rt2.budgets[0].monthly_limit == 400
     assert rt2.account_balances == {"debit": 11800}
-    # 实体统计随交易一起恢复(重启后 trace_category / status 不该突然归零)
     assert rt2.entities["星巴克"].txn_count == 1
     assert rt2.entities["星巴克"].entity_type == "subscription"
     assert rt2.entities["公司"].total_amount == 12000
@@ -64,7 +62,7 @@ def test_写入即落盘下次实例自动加载(tmp_path):
     rt.set_balance("debit", 100)
 
     loaded = _rt(tmp_path)
-    assert loaded.load()  # 已显式 load 过,再次 load 幂等
+    assert loaded.load()
     assert len(loaded.transactions) == 1
     assert loaded.status()["persist"]["load_error"] == ""
 
@@ -83,14 +81,14 @@ def test_损坏文件不阻断启动且可自愈(tmp_path):
     p = tmp_path / "finance_data.json"
     p.write_text("{ 这不是 json ", encoding="utf-8")
 
-    rt = _rt(tmp_path)              # 构造本身不得抛
+    rt = _rt(tmp_path)
     assert rt.transactions == [] and rt.budgets == []
-    assert rt.load_error                    # 错误必须可见,不能静默吞掉
+    assert rt.load_error
 
     rt.add_transaction(Transaction(amount=-5, category="misc",
                                    entity="y", account="debit"))
     assert rt.save() is True
-    assert rt.load_error == ""              # 覆盖写成功后重新可读
+    assert rt.load_error == ""
     assert len(_rt(tmp_path).transactions) == 1
 
 
@@ -106,8 +104,8 @@ def test_单条坏记录只跳过自己不废掉整份(tmp_path):
         "version": 1,
         "transactions": [
             {"amount": -10, "category": "food", "entity": "a", "account": "debit"},
-            {"category": "food"},            # 缺 amount/entity/account → 跳过
-            "not-a-dict",                    # 非对象 → 跳过
+            {"category": "food"},
+            "not-a-dict",
             {"amount": -20, "category": "food", "entity": "b", "account": "debit"},
         ],
         "budgets": [{"category": "food", "monthly_limit": 300}],
@@ -117,7 +115,7 @@ def test_单条坏记录只跳过自己不废掉整份(tmp_path):
     rt = _rt(tmp_path)
     assert [t.entity for t in rt.transactions] == ["a", "b"]
     assert len(rt.budgets) == 1
-    assert rt.account_balances == {"cash": 50.0}   # 坏值单独跳过
+    assert rt.account_balances == {"cash": 50.0}
 
 
 def test_实体段缺失时按交易重建(tmp_path):
@@ -154,12 +152,10 @@ def test_批量导入只写一次盘(tmp_path, monkeypatch):
 def test_落盘失败只回报不抛异常(tmp_path):
     blocker = tmp_path / "blocker"
     blocker.write_text("我是个文件,不是目录", encoding="utf-8")
-    # 父目录被一个文件占住 → mkdir/写入必失败
     rt = FinanceRuntime(policy_path=str(tmp_path / "finance_policy.yaml"),
                         data_path=str(blocker / "finance_data.json"))
     assert rt.save() is False
-    assert rt.save_error                   # 失败原因必须留痕
-    # 内存里的数据仍在,用户这次会话不至于丢东西
+    assert rt.save_error
     rt.add_transaction(Transaction(amount=-1, category="misc",
                                    entity="z", account="debit"))
     assert len(rt.transactions) == 1

package/python/tests/test_gateway.py

@@ -6,19 +6,13 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 import pytest
 
 def test_gateway():
-    # ISOLATION_GUARD:本用例依赖 import 时固化的模块级单例(网关/限流器/路由配置按 env 在 import 时定型),单进程全量跑会被前序用例污染 →
-    # 假红。全量请用 tests/run_all.py(每文件独立子进程)。
     if "foxclaw.api" in sys.modules:
         pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
-    # 本测试用 pop("FOXCLAW_API_KEY") 验证「未设即网关默认关」,但 pop 之后 load_dotenv
-    # (override=False)仍会从 .env 把键灌回来(开发者 .env 常带真实 FOXCLAW_API_KEY)→ 判定
-    # 随机器漂移。关掉 .env 使本测试自洽,单独运行也稳定。
     os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
-    # 必须在 import foxclaw.api 之前设好:网关实例在模块加载时按环境变量建
     os.environ["FOXCLAW_GATEWAY"] = "1"
-    os.environ["FOXCLAW_GATEWAY_RATE"] = "5"        # 每分钟 5 → 桶容量 5,突发 5 后限流
+    os.environ["FOXCLAW_GATEWAY_RATE"] = "5"
     os.environ["FOXCLAW_GATEWAY_QUOTA"] = "1000"
-    os.environ["FOXCLAW_MAX_BODY_MB"] = "1"          # 请求体硬顶降到 1MB 便于测 413
+    os.environ["FOXCLAW_MAX_BODY_MB"] = "1"
     os.environ.pop("FOXCLAW_API_KEY", None)
     os.environ["HKC_EMBEDDING"] = "stub"
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
@@ -26,10 +20,8 @@ def test_gateway():
 
     print("=" * 60); print("统一 API 网关验证"); print("=" * 60)
 
-    # ── Part A:Gateway 类单元 ─────────────────────────────────
     from foxclaw.core.gateway import Gateway
 
-    # [1] 突发令牌桶:容量内放行,超出限流(reason=rate)
     g = Gateway(rate_per_min=3, quota_per_hour=100000)
     allowed = [g.check("a")[0] for _ in range(5)]
     assert allowed[:3] == [True, True, True] and allowed[3] is False, allowed
@@ -37,11 +29,9 @@ def test_gateway():
     assert not ok and reason == "rate" and retry >= 1, (ok, retry, reason)
     print("[1] 令牌桶突发限流(3 放行→限流,带 retry)OK")
 
-    # [2] per-client 隔离:a 被限,b 不受影响
     assert g.check("b")[0] is True, "客户端之间不隔离"
     print("[2] per-client 隔离 OK")
 
-    # [3] 配额(固定窗口):超每小时额度 → reason=quota
     g2 = Gateway(rate_per_min=100000, quota_per_hour=4)
     cnt = sum(1 for _ in range(6) if g2.check("z")[0])
     assert cnt == 4, cnt
@@ -49,24 +39,20 @@ def test_gateway():
     assert not ok and reason == "quota" and retry >= 1, (ok, retry, reason)
     print("[3] 每小时配额封顶(reason=quota)OK")
 
-    # [4] 空闲淘汰:大量不同 client 不撑爆内存
     g3 = Gateway(rate_per_min=100, quota_per_hour=100000, max_clients=64)
     for i in range(500):
         g3.check(f"c{i}")
     assert g3.stats()["tracked_clients"] <= 64, g3.stats()
     print(f"[4] 空闲淘汰(500 client → 追踪 {g3.stats()['tracked_clients']}≤64,防内存 DoS)OK")
 
-    # ── Part B:接入 FastAPI 中间件(TestClient)────────────────
     from fastapi.testclient import TestClient
     from foxclaw.api import app, _gateway_on
 
     with TestClient(app) as c:
-        # [5] stats 端点:启用 + 额度可见
         s = c.get("/api/gateway/stats").json()
         assert s["enabled"] is True and s["rate_per_min"] == 5, s
         print(f"[5] /api/gateway/stats(enabled={s['enabled']}, rate={s['rate_per_min']}/min)OK")
 
-        # [6] 超限 → 429 + Retry-After(同一 client=ip:testclient 共用桶)
         codes = [c.get("/api/status").status_code for _ in range(12)]
         assert 200 in codes and 429 in codes, codes
         r429 = None
@@ -78,16 +64,13 @@ def test_gateway():
         assert r429.headers.get("Retry-After") and r429.json().get("retry_after", 0) >= 1, (r429.headers, r429.text)
         print("[6] 突发超限 → 429 + Retry-After 头 OK")
 
-        # [7] 探针豁免:/health 不在网关下,始终放行
         assert c.get("/health").status_code == 200, "探针被网关误限"
         print("[7] 探针 /health 豁免网关 OK")
 
-        # [8] 请求体硬顶:Content-Length 超 1MB → 413(在读 body/sanitize 前拦下,始终生效)
         big = c.post("/api/knowledge/ingest", json={"text": "x" * (1200 * 1024)})
         assert big.status_code == 413, (big.status_code, big.text[:120])
         print("[8] 超大请求体 → 413(读 body 前拦截)OK")
 
-        # [8b] chunked / 无 Content-Length:只查头会漏,流上累计必须兜住
         import asyncio
         from starlette.requests import Request as _Req
         from foxclaw.api.middleware import (
@@ -104,7 +87,7 @@ def test_gateway():
         req = _Req({"type": "http", "method": "POST", "path": "/api/x",
                     "scheme": "http", "server": ("test", 80),
                     "headers": [], "query_string": b""}, _recv)
-        _wrap_body_limit(req, 15)          # 第 2 块累计 20 > 15
+        _wrap_body_limit(req, 15)
 
         async def _drain():
             for _ in range(3):
@@ -117,7 +100,6 @@ def test_gateway():
         else:
             raise AssertionError("chunked 超限未被流上计数拦住")
 
-        # [8c] 流超限转成 413,而不是冒成 500
         async def _boom(_req):
             raise _PayloadTooLarge(999)
 
@@ -128,7 +110,6 @@ def test_gateway():
         assert resp.status_code == 413, resp.status_code
         print("[8b] chunked 超限 → 流上计数拦截并转 413 OK")
 
-    # [9] 启用哲学:默认关;配 FOXCLAW_API_KEY(=对外暴露)自动开;=0 强制关优先
     os.environ.pop("FOXCLAW_GATEWAY", None); os.environ.pop("FOXCLAW_API_KEY", None)
     assert _gateway_on() is False, "本地默认应关"
     os.environ["FOXCLAW_API_KEY"] = "x"