foxclaw 0.1.0 → 0.1.3

package/python/tests/test_event_spine.py

@@ -0,0 +1,174 @@
+"""
+统一事件脊柱(EventSpine, P0 第二项)测试 —— 全离线。
+
+覆盖:
+  1. EventSpine:发布/订阅(前缀匹配) + 投影(收到每条) + 有界历史
+  2. SystemBus 门面:退化为脊柱门面后,既有消费者零改;系统事件汇入脊柱
+  3. Harness → 脊柱转发:harness 事件汇入脊柱;高频内部信号(goal_registered)不上脊柱
+  4. Foxclaw 统一投影:harness 事件与系统事件都被**同一个投影**观测(核心统一验证)
+
+为避免加载 7s 重模型,harness embedding 用不存在的模型名 → 降级 hash(不影响事件验证)。
+"""
+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"
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from foxclaw.kernel import EventSpine
+
+
+def test_spine_pubsub_prefix_projection():
+    print("\n【1】EventSpine:前缀订阅 + 投影 + 历史")
+    spine = EventSpine()
+    got = []
+    spine.subscribe("harness", lambda e: got.append(e.topic))
+    allseen = []
+    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.*"
+    assert allseen == ["harness.drift.blocked", "memory.ingested"], "投影应收到每一条"
+    assert len(spine.history()) == 2 and len(spine.history("harness")) == 1
+    print("  ✓ 前缀匹配正确;投影全量;历史可按前缀过滤")
+
+
+def test_systembus_facade():
+    print("\n【2】SystemBus 门面:消费者零改 + 汇入脊柱")
+    from foxclaw.core.system_bus import SystemBus
+    spine = EventSpine()
+    seen = []
+    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))
+    bus.publish("execution.completed", {"task": "t"})
+    assert got == [{"task": "t"}], "旧消费者 handler(msg) 仍收到 .payload"
+    assert ("execution.completed", "system_bus") in seen, "系统事件应汇入同一脊柱"
+    assert bus.history("execution.completed"), "history 门面可用"
+    print("  ✓ handler(msg) 兼容;系统事件经脊柱;history 正常")
+
+
+def test_harness_forwards_to_spine():
+    print("\n【3】Harness → 脊柱转发(goal_registered 不上脊柱)")
+    from foxclaw.harness.harness import Harness
+    from foxclaw.core.thought_chain import ThoughtChain
+    d = tempfile.mkdtemp(prefix="spine_h_")
+    try:
+        spine = EventSpine()
+        seen = []
+        spine.project(lambda e: seen.append(e.topic))
+        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})
+        h.bus.emit("goal_registered", {"g": 1})
+        assert local == [{"a": 1}], "本地订阅(向后兼容)仍收到"
+        assert "harness_warn" in seen, "harness 事件应汇入脊柱"
+        assert "goal_registered" not in seen, "高频内部信号不应上脊柱(降噪)"
+    finally:
+        shutil.rmtree(d, ignore_errors=True)
+    print("  ✓ 本地订阅兼容 + harness 汇入脊柱 + goal_registered 被过滤")
+
+
+def test_hkc_events_bridge_to_spine():
+    print("\n【3b】HKC EventBus → 脊柱桥接(知识事件不再是孤岛;memory.* 刻意不桥)")
+    from foxclaw.knowledge import bridge_hkc_events
+
+    class _FakeHKCBus:
+        def __init__(self): self._h = {}
+        def subscribe(self, ev, h): self._h.setdefault(ev, []).append(h)
+        def publish(self, d):
+            for h in self._h.get(d.get("event"), []): h(d)
+
+    spine = EventSpine()
+    seen = []
+    spine.project(lambda e: seen.append((e.topic, e.source, e.payload)))
+    bus = _FakeHKCBus()
+    assert bridge_hkc_events(bus, spine) is True
+    bus.publish({"event": "knowledge.merged", "payload": {"ku_id": "K1"}, "event_id": "EVT_1"})
+    bus.publish({"event": "conflict.detected", "payload": {"card": "C1"}})
+    bus.publish({"event": "ability.created", "payload": {"key": "A1"}})
+    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)
+    bus.publish({"event": "memory.created", "payload": {}})
+    assert not any(t == "memory.created" for t, _, _ in seen), "memory.* 不应被桥接"
+    assert bridge_hkc_events(None, spine) is False
+    print("  ✓ knowledge.merged/conflict/ability 桥到脊柱(source=hkc);memory.* 不桥;None 优雅降级")
+
+
+def test_unified_projection_via_foxclawos():
+    print("\n【4】Foxclaw:harness 事件与系统事件被同一投影统一观测")
+    d = tempfile.mkdtemp(prefix="spine_os_")
+    try:
+        from foxclaw import Foxclaw
+        os_ = Foxclaw(data_dir=d, shadow_rounds=50)
+        seen = []
+        os_.event_spine.project(lambda e: seen.append(e.topic))
+        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:
+        shutil.rmtree(d, ignore_errors=True)
+    print("  ✓ harness + 系统事件汇入同一脊柱、被同一投影观测(4→1 统一成立)")
+
+
+def test_ws_projection_safe_and_bounded():
+    print("\n【5】WS 投影净化:脏/大 payload 不丢连接、不泛洪(深审修复)")
+    import json as _json
+    import foxclaw.api as api
+    class Weird:
+        def __repr__(self): return "<Weird>"
+    safe = api._ws_safe_payload({"obj": Weird(), "n": 1})
+    _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 化;超大被截断;正常透传")
+
+    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()})
+        items = []
+        while not api._event_queue.empty():
+            items.append(api._event_queue.get_nowait())
+        assert items, "投影应把事件放进队列"
+        for it in items:
+            _json.dumps(it)
+        topics = {it["event"] for it in items}
+        assert "execution.completed" in topics, f"应含 execution.completed,实得 {topics}"
+        asyncio.run(os_.aclose())
+    finally:
+        shutil.rmtree(d, ignore_errors=True)
+    print("  ✓ 脏 result 事件经投影后队列项 JSON 安全(WS 不会静默丢连接)")
+
+
+def main():
+    print("=" * 60)
+    print("统一事件脊柱 · EventSpine(P0 第二项)")
+    print("=" * 60)
+    test_spine_pubsub_prefix_projection()
+    test_systembus_facade()
+    test_harness_forwards_to_spine()
+    test_hkc_events_bridge_to_spine()
+    test_unified_projection_via_foxclawos()
+    test_ws_projection_safe_and_bounded()
+    print("\n" + "=" * 60)
+    print("✓ P0-2 验证完成:脊柱 + SystemBus门面 + Harness转发 + 统一投影")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

package/python/tests/test_evidence_semantic.py

@@ -0,0 +1,88 @@
+"""证据融合语义化 —— 原始复盘点名的 `search/evidence.py "规则占位"`(此前一直漏修)。
+
+修掉两个真问题:
+  ① 否定词**子串**误命中:原 ("不是","并非","no longer","not") 按子串匹配 →
+     "another"/"notebook" 里的 "not" 被命中 → 无关证据被判**矛盾**;而 confidence()
+     按矛盾数扣分(0.1/条)→ 搜索置信被**幻影矛盾**无端拉低。
+     这与 hkc_kee/kee.py 早已修过的 not⊂nothing / no⊂know 是**同一 bug 家族**,证据层漏了同步。
+  ② 相似度是**字符级**(SequenceMatcher)而非语义 → 语义等价的证据识别不出互相支持。
+
+无 ST 模型时优雅降级回字符级(不崩),故本测试对语义部分做"可用才断言"。
+"""
+import os, sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+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"
+
+    from foxclaw.search.evidence import EvidenceFusion, _has_neg, _semantic_sim
+    from foxclaw.search.models import RawEvidence
+
+    print("=" * 60); print("证据融合语义化验证"); print("=" * 60)
+    f = EvidenceFusion()
+
+    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 不该命中"
+    assert _has_neg("cannot proceed") is True
+    assert _has_neg("this is not good") is True
+    assert _has_neg("这个方案并非最优") is True
+    print("[1] 否定词词边界(another/notebook/know 不误命中)OK")
+
+    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")
+
+    assert f._contradicts("cannot proceed", "can proceed") is True
+    assert f._contradicts("这个方案并非最优", "这个方案是最优") is True
+    print("[3] 真矛盾仍识别(cannot/并非)OK")
+
+    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),
+    ])
+    assert len(g.contradictions()) == 0, f"不该有矛盾边: {g.contradictions()}"
+    assert f.confidence(g) >= 0.85, f"置信不该被幻影矛盾扣分: {f.confidence(g)}"
+    print(f"[4] 端到端:无幻影矛盾边,置信未被误扣({f.confidence(g):.2f})OK")
+
+    if _semantic_sim("a", "a") is None:
+        print("[skip] ST 模型未缓存 → 语义部分跳过(已回退字符级,不崩)")
+        print("\n证据融合语义化验证通过(降级路径)")
+        if __name__ != "__main__":
+            import pytest
+            pytest.skip("ST 模型未缓存 → 语义部分跳过(降级路径已由 [1]-[4] 覆盖)",
+                        allow_module_level=True)
+        import sys as _sys
+        _sys.exit(0)
+
+    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")
+
+    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),
+    ])
+    sup = [e for e in g2.edges if e.relation == "supports"]
+    assert sup, "语义等价的证据应互相支持(字符级识别不出)"
+    print("[6] 语义等价证据建立 supports 边 OK")
+
+    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),
+    ])
+    assert len(g3.nodes) == 1, f"完全相同应去重: {list(g3.nodes)}"
+    print("[7] 阈值在余弦下仍成立 + 相同证据去重 OK")
+
+    print("\n证据融合语义化验证全部通过")
+
+
+if __name__ == "__main__":
+    test_evidence_semantic()

package/python/tests/test_evidence_sse.py

@@ -0,0 +1,94 @@
+"""/api/chat/stream 的命名 SSE 事件:`event: evidence`(执行凭据)与正文 delta 分离。
+
+锁住的契约:
+  · 工具轮每步的核验结论 + 凭据以**命名事件**整块送出,不拼进正文(否则复制/落库被污染);
+  · 没有工具步的纯对话不产生 evidence 事件(不能凭空生成"凭据",前端也不闪空面板);
+  · 前端拿到的是一个数组:`[{tool,status,reason,evidence:[{kind,ref,label,...}]}]`。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+EVIDENCE = [
+    {"tool": "web_search", "kind": "ok", "status": "verified", "reason": "",
+     "evidence": [{"kind": "url", "ref": "https://example.com/a", "label": "example.com",
+                   "source": "web_search", "at": 0}]},
+    {"tool": "send_mail", "kind": "ok", "status": "unverified",
+     "reason": "该工具未声明可观察的后置条件", "evidence": []},
+]
+
+
+def _parse(body: str) -> tuple[list, str]:
+    """拆 SSE:返回 (evidence 事件载荷列表, 正文 delta 拼接)。"""
+    ev_payloads, delta_text = [], ""
+    for b in [x for x in body.split("\n\n") if x.strip()]:
+        name, data = "message", None
+        for line in b.splitlines():
+            if line.startswith("event: "):
+                name = line[7:].strip()
+            elif line.startswith("data: "):
+                data = line[6:].strip()
+        if data is None:
+            continue
+        ev = json.loads(data)
+        if name == "evidence":
+            ev_payloads.append(ev)
+        elif "delta" in ev:
+            delta_text += ev["delta"]
+    return ev_payloads, delta_text
+
+
+def test_chat_stream_evidence_event_contract():
+    if "foxclaw.api" in sys.modules:
+        import pytest
+        pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
+    os.environ.setdefault("FOXCLAW_DATA_DIR", tempfile.mkdtemp(prefix="foxclaw_ev_"))
+
+    from fastapi.testclient import TestClient
+    from foxclaw.agents.base import CognitiveAgent
+    from foxclaw.api import app
+
+    seen: dict = {}
+
+    def _fake_stream(self, task, stop_event=None, images=None, history=None,
+                     attachments=None, on_thinking=None, on_evidence=None):
+        seen["has_cb"] = on_evidence is not None
+        if task == "plain":
+            yield "纯对话,没有动用工具。"
+            return
+        yield "已完成。"
+        if on_evidence is not None:
+            on_evidence(EVIDENCE)
+
+    original = CognitiveAgent.stream_reply
+    CognitiveAgent.stream_reply = _fake_stream
+    try:
+        with TestClient(app) as c:
+            with_tools = c.post("/api/chat/stream", json={"task": "use-tools", "agent_id": "supervisor"})
+            plain = c.post("/api/chat/stream", json={"task": "plain", "agent_id": "supervisor"})
+            assert with_tools.status_code == 200 and plain.status_code == 200
+            body, plain_body = with_tools.text, plain.text
+    finally:
+        CognitiveAgent.stream_reply = original
+
+    assert seen.get("has_cb") is True, "端点必须把 on_evidence 传给 Agent"
+
+    ev_payloads, delta_text = _parse(body)
+    assert "event: evidence" in body, "证据必须以命名事件送出"
+    assert len(ev_payloads) == 1, "一轮只上报一次"
+    items = ev_payloads[0]["evidence"]
+    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() == "已完成。"
+
+    assert "event: evidence" not in plain_body
+    assert "纯对话" in plain_body

package/python/tests/test_file_ingest.py

@@ -0,0 +1,135 @@
+"""
+文件摄入打通交互层：docx/xlsx 加载器 + KDE 后缀分派 + 上传路由格式门。
+
+离线可跑：加载器是确定性纯解析（无 LLM）；KDE 分派用假抽取器验证
+「新后缀 → loader → chunker → packager → KU」链路，不调真实模型。
+真实 LLM 抽取质量不在离线回归内（与 test_hkc 一致哲学）。
+"""
+import os, sys, tempfile
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+sys.path.insert(0, str(Path(__file__).parent.parent / "vendor" / "hkc"))
+
+
+def test_file_ingest():
+    for k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY"):
+        os.environ.pop(k, None)
+    os.environ["HKC_EMBEDDING"] = "stub"
+    os.environ["HF_HUB_OFFLINE"] = "1"
+    os.environ["TRANSFORMERS_OFFLINE"] = "1"
+
+    from docx import Document
+    from openpyxl import Workbook
+    from hkc_kde.loaders.office_loader import DocxLoader, XlsxLoader
+    from hkc_kde.chunker import Chunker
+    from hkc_kde.models import ExtractionResult, RawExtraction
+
+    print("=" * 60); print("文件摄入（docx/xlsx）打通验证"); print("=" * 60)
+
+    TMP = Path(tempfile.mkdtemp(prefix="foxclaw_fileingest_"))
+
+    def _make_docx() -> Path:
+        p = TMP / "sample.docx"
+        doc = Document()
+        doc.add_heading("第一章 引言", level=1)
+        doc.add_paragraph("Foxclaw 是一个认知代理操作系统，由五个 Agent 组成。")
+        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"
+        doc.add_heading("第二章 架构", level=1)
+        doc.add_paragraph("知识核心负责长期记忆的沉淀与演化。")
+        doc.save(str(p))
+        return p
+
+    def _make_xlsx() -> Path:
+        p = TMP / "sample.xlsx"
+        wb = Workbook()
+        ws = wb.active; ws.title = "财务"
+        ws.append(["科目", "金额"]); ws.append(["收入", 100]); ws.append(["支出", 40])
+        ws2 = wb.create_sheet("备注")
+        ws2.append(["说明", "季度汇总"])
+        wb.save(str(p)); wb.close()
+        return p
+
+    pd = DocxLoader().load(str(_make_docx()))
+    assert pd.doc_type == "DOCX", pd.doc_type
+    titles = [c.title for c in pd.chapters]
+    assert "第一章 引言" in titles and "第二章 架构" in titles, titles
+    alltext = "\n".join(s.content for c in pd.chapters for s in c.sections)
+    assert "五个 Agent" in alltext, "正文段落丢失"
+    assert "版本 | v1.6" in alltext, "表格行未转文本"
+    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")
+
+    px = XlsxLoader().load(str(_make_xlsx()))
+    assert px.doc_type == "XLSX", px.doc_type
+    sheet_titles = [c.title for c in px.chapters]
+    assert "财务" in sheet_titles and "备注" in sheet_titles, sheet_titles
+    xtext = "\n".join(s.content for c in px.chapters for s in c.sections)
+    assert "收入 | 100" in xtext and "季度汇总" in xtext, xtext
+    print(f"[2] XlsxLoader（{len(px.chapters)} 表→章，行合并）OK")
+
+    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")
+
+    def _build_kde():
+        from hkc_core.utils.id_gen import IDGenerator
+        from hkc_core.graph.sqlite_store import SQLiteGraphStore
+        from hkc_kep.event_bus import EventBus
+        from hkc_kde.kde import KnowledgeDigestEngine
+        d = Path(tempfile.mkdtemp(prefix="foxclaw_kde_"))
+        store = SQLiteGraphStore(str(d / "hkc.db"))
+        bus = EventBus(str(d / "events.db"))
+        idg = IDGenerator(str(d / "id.db"))
+        return KnowledgeDigestEngine(store, bus, idg, provider="anthropic")
+
+    class _FakeExtractor:
+        """每个 chunk 抽出一个实体，捕获收到的 chunk 供断言。"""
+        def __init__(self): self.seen = []
+        def extract(self, chunks, progress_cb=None):
+            self.seen = list(chunks)
+            doc_id = chunks[0].doc_id if chunks else ""
+            raw = RawExtraction(entities=[{"name": "Foxclaw", "type": "Person"}])
+            return ExtractionResult(doc_id=doc_id, source=doc_id, items=[raw])
+
+    for suffix, maker in ((".docx", _make_docx), (".xlsx", _make_xlsx)):
+        kde = _build_kde()
+        fake = _FakeExtractor(); kde.extractor = fake
+        kus = kde.ingest_file(str(maker()), source=f"user{suffix}")
+        assert fake.seen, f"{suffix}: 抽取器未收到 chunk（分派断裂）"
+        assert kus, f"{suffix}: 未写入任何 KU"
+    print("[4] KDE 分派 .docx/.xlsx → loader → chunker → KU 全链路 OK")
+
+    kde = _build_kde()
+    bad = TMP / "x.pptx"; bad.write_bytes(b"PK\x03\x04not really")
+    try:
+        kde.ingest_file(str(bad))
+        raise AssertionError("应对 .pptx 抛不支持错误")
+    except ValueError as e:
+        assert ".pptx" in str(e) or "不支持" in str(e), str(e)
+    print("[5] 不支持格式（.pptx）明确 ValueError OK")
+
+    from fastapi.testclient import TestClient
+    from foxclaw.api import app
+    with TestClient(app) as c:
+        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 提示未含新格式"
+        with open(_make_docx(), "rb") as fh:
+            r2 = c.post("/knowledge/ingest/file",
+                        files={"file": ("sample.docx", fh.read(),
+                               "application/vnd.openxmlformats-officedocument.wordprocessingml.document")},
+                        data={"domain": "test"})
+        assert r2.status_code == 200, (r2.status_code, r2.text)
+    print("[6] 上传路由格式门（.pptx→415；.docx→200）OK")
+
+    print("\n文件摄入（docx/xlsx）验证全部通过")
+
+
+if __name__ == "__main__":
+    test_file_ingest()

package/python/tests/test_finance.py

@@ -0,0 +1,144 @@
+"""
+B 阶段测试 — 财务 Agent 内核(资金行为操作系统)
+验证:CSV 导入 → 推理(预算/异常/订阅/烧钱) → Policy 守门人裁决
+不真实动钱:执行层只产出审批请求。
+"""
+import sys, tempfile
+from datetime import datetime, timedelta
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from foxclaw.finance import FinanceRuntime, Transaction
+from foxclaw.finance.reasoning import FinanceReasoning
+
+CSV = str(Path(__file__).parent.parent / "examples" / "sample_transactions.csv")
+
+
+def check(cond, msg):
+    if not cond:
+        raise AssertionError(f"✗ {msg}")
+    print(f"  ✓ {msg}")
+
+
+def main():
+    print("=" * 60)
+    print("B 阶段 · 财务 Agent 内核(资金行为操作系统)")
+    print("=" * 60)
+
+    fr = FinanceRuntime(policy_path=str(Path(tempfile.mkdtemp()) / "b_finance_policy.yaml"))
+    n = fr.import_csv(CSV)
+    fr.set_budget("food", 400)
+    fr.set_budget("subscription", 100)
+    fr.set_balance("debit", 11800)
+    fr.set_balance("credit_card_1", -700)
+    print(f"\n导入 {n} 笔交易")
+    check(n == 13, f"CSV 导入 13 笔交易(实为 {n})")
+
+    r = fr.analyze(period="2026-06", current_balance=11100)
+
+    print("\n【预算推理】")
+    for b in r["budget_status"]:
+        flag = "⚠ 超支" if b["is_over"] else "OK"
+        print(f"  {b['category']:<14} {b['spent']:.0f}/{b['monthly_limit']:.0f} "
+              f"({b['usage_ratio']*100:.0f}%) {flag}")
+    over = {b["category"]: b["is_over"] for b in r["budget_status"]}
+    check(over.get("food") is True and over.get("subscription") is True,
+          f"两大超支分类被正确标记(food={over.get('food')}, subscription={over.get('subscription')})")
+
+    print("\n【超支预测】")
+    for f in r["overspend_forecast"]:
+        print(f"  {f['category']:<14} 月底预计 {f['projected_month_end']:.0f} / "
+              f"限额 {f['monthly_limit']:.0f} · 将超支={f['will_overspend']}")
+    check(len(r["overspend_forecast"]) >= 2
+          and all(f["will_overspend"] for f in r["overspend_forecast"]),
+          f"超支预测命中({len(r['overspend_forecast'])} 项,全部 will_overspend=True)")
+
+    print("\n【异常消费(MAD 检测)】")
+    for a in r["anomalies"]:
+        print(f"  {a['entity']} {a['amount']} (修正Z={a['z_score']}) — {a['reason']}")
+    check(any(a["entity"] == "高级餐厅" for a in r["anomalies"]),
+          f"MAD 检测出「高级餐厅」离群消费({len(r['anomalies'])} 条异常)")
+
+    print("\n【重复扣款】")
+    for d in r["duplicate_charges"]:
+        print(f"  {d['reason']}")
+    if not r["duplicate_charges"]:
+        print("  无")
+    check(isinstance(r["duplicate_charges"], list), "重复扣款检测返回列表结构")
+
+    print("\n【订阅膨胀】")
+    sc = r["subscription_creep"]
+    print(f"  {sc['subscription_count']} 个订阅,月总 {sc['monthly_total']:.0f},"
+          f"预警={sc['creep_warning']}")
+    check(sc["subscription_count"] == 6 and sc["creep_warning"] is True,
+          f"订阅膨胀预警触发(6 个订阅 / 月总 {sc['monthly_total']:.0f})")
+
+    print("\n【烧钱速度 / 现金流】")
+    br = r["burn_rate"]
+    print(f"  日均支出 {br['daily_burn']} · 日均净流 {br['daily_net']}")
+    cf = r["cashflow_projection"]
+    if cf:
+        print(f"  现金流趋势: {cf['trend']} · 月净流 {cf['monthly_net']}")
+        for t in cf["trajectory"]:
+            print(f"    第 {t['month']} 月预计余额 {t['projected_balance']}")
+        check(len(cf["trajectory"]) == 3, "现金流预测给出 3 个月轨迹")
+
+    _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)
+    check(br["total_expense"] == expect_expense,
+          f"burn_rate 严格按 now-30天 窗口统计(窗口内 {len(in_window)} 笔;样例日期已过期,故为 {expect_expense})")
+    check(isinstance(br["daily_burn"], (int, float)) and br["daily_burn"] == round(expect_expense / 30, 2),
+          f"日均支出 = 窗口内支出 / 30(daily_burn={br['daily_burn']})")
+
+    fresh = [
+        Transaction(amount=-300, category="food", entity="测试超市", account="debit"),
+        Transaction(amount=-150, category="transport", entity="测试打车", account="debit"),
+        Transaction(amount=2000, category="salary", entity="某公司", account="debit"),
+    ]
+    br2 = FinanceReasoning.burn_rate(fresh, days=30)
+    check(br2["total_expense"] == 450.0 and br2["total_income"] == 2000.0,
+          f"当日交易用例:支出 450 / 收入 2000(实为 {br2['total_expense']}/{br2['total_income']})")
+    check(br2["daily_burn"] == 15.0, f"日均支出 = 450/30 = 15.0(实为 {br2['daily_burn']})")
+    check(br2["daily_net"] == round(1550 / 30, 2),
+          f"日均净流 = (2000-450)/30(实为 {br2['daily_net']})")
+    cf2 = FinanceReasoning.cashflow_projection(fresh, current_balance=1000.0, months=3)
+    check(cf2["trend"] == "上升" and cf2["monthly_net"] > 0, "净流入 → 趋势判定为上升")
+    check(cf2["trajectory"][-1]["projected_balance"] > 1000.0, "预测余额随净流入增长")
+
+    print("\n【守门人裁决(整体状态)】")
+    for v in r["gatekeeper_verdicts"]:
+        print(f"  [{v['action'].upper()}] {v['message']}")
+    acts = {v["action"].lower() for v in r["gatekeeper_verdicts"]}
+    check("veto" in acts and "alert" in acts,
+          f"整体裁决含 VETO(异常消费否决)与 ALERT(订阅超标)(实为 {sorted(acts)})")
+
+    print("\n【守门人裁决(单笔大额交易)】")
+    big = Transaction(amount=-680, category="electronics", entity="Apple Store",
+                      account="credit_card_1")
+    big_acts = {v.action.lower() for v in fr.policy.evaluate_transaction(big, account_balance=300)}
+    for v in fr.policy.evaluate_transaction(big, account_balance=300):
+        print(f"  [{v.action.upper()}] {v.message}")
+    check("require_confirmation" in big_acts,
+          "大额支出(680>500)触发 REQUIRE_CONFIRMATION")
+    check("freeze" in big_acts,
+          "余额不足(300<500)触发 FREEZE 可选支出")
+
+    print("\n【执行层:审批流(不自动动钱)】")
+    req = fr.request_action("cancel_subscription", {"entity": "YouTube", "save": 12.0})
+    print(f"  请求: {req['action']} · 状态: {req['status']}")
+    print(f"  说明: {req['note']}")
+    check("PENDING" in str(req["status"]).upper(),
+          f"执行层只产出待批状态,不自动动钱(status={req['status']})")
+
+    print("\n" + "=" * 60)
+    print("✓ B 阶段验证完成:财务内核(记忆+推理+Policy 守门人)成立")
+    print("=" * 60)
+
+
+def test_finance():
+    main()
+
+
+if __name__ == "__main__":
+    main()