foxclaw 0.1.0 → 0.1.2

package/python/tests/test_multimodal.py

@@ -0,0 +1,135 @@
+"""多模态对话:图片随问题发给视觉模型(model_router 多模态通道 + /chat/stream images)。
+全离线:用假 client 捕获实际发出的 messages,验证按 provider 正确组装多模态 content。
+模型无关:图片附到任意配置的模型,非视觉模型由 router 报错降级(不在此断言真实视觉)。"""
+import os, sys, types, tempfile
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+import pytest
+
+def test_multimodal():
+    # ISOLATION_GUARD:本用例依赖 import 时固化的模块级单例(网关/限流器/路由配置按 env 在 import 时定型),单进程全量跑会被前序用例污染 →
+    # 假红。全量请用 tests/run_all.py(每文件独立子进程)。
+    if "foxclaw.core.model_router" in sys.modules:
+        pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
+    for k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY"):
+        os.environ.pop(k, None)
+    os.environ["HKC_EMBEDDING"] = "stub"
+    os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
+    os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_mm_")
+
+    from foxclaw.core.model_router import ModelRouter
+
+    print("=" * 60); print("多模态对话通道验证"); print("=" * 60)
+
+    IMG = [{"media_type": "image/png", "data": "AAAABBBB"}]
+    BASE = [{"role": "user", "content": "这是什么?"}]
+
+    # [1] anthropic 组装:image/base64 block
+    a = ModelRouter._attach_images("anthropic", BASE, IMG)
+    blocks = a[-1]["content"]
+    assert isinstance(blocks, list) and blocks[0] == {"type": "text", "text": "这是什么?"}, blocks
+    assert blocks[1]["type"] == "image" and blocks[1]["source"]["type"] == "base64" \
+        and blocks[1]["source"]["media_type"] == "image/png" and blocks[1]["source"]["data"] == "AAAABBBB", blocks
+    assert BASE[-1]["content"] == "这是什么?", "不得改动原 messages(tier/stub/meter 仍需文本)"
+    print("[1] anthropic 多模态 block 组装 OK")
+
+    # [2] openai 系组装:image_url data URI
+    for prov in ("openai", "deepseek", "qwen"):
+        o = ModelRouter._attach_images(prov, BASE, IMG)
+        blk = o[-1]["content"]
+        assert blk[1]["type"] == "image_url" and blk[1]["image_url"]["url"] == "data:image/png;base64,AAAABBBB", (prov, blk)
+    print("[2] openai/deepseek/qwen 多模态 image_url 组装 OK")
+
+    # [3] google/未知 provider:无视觉通道 → 原样(纯文本降级)
+    assert ModelRouter._attach_images("google", BASE, IMG) == BASE
+    assert ModelRouter._attach_images("whatever", BASE, IMG) == BASE
+    print("[3] google/未知 provider 纯文本降级 OK")
+
+    # [4] 无 user 消息 / 已是多模态 → 不重复组装
+    assert ModelRouter._attach_images("anthropic", [{"role": "assistant", "content": "x"}], IMG)[0]["content"] == "x"
+    already = [{"role": "user", "content": [{"type": "text", "text": "hi"}]}]
+    assert ModelRouter._attach_images("anthropic", already, IMG) == already
+    assert ModelRouter._attach_images("anthropic", BASE, None) == BASE
+    print("[4] 无 user / 已多模态 / 无图 边界 OK")
+
+    # [5] _sanitize_images 护栏(数量/大小/类型/非列表)
+    from foxclaw.api import _sanitize_images, _MAX_IMAGES, _MAX_IMG_B64
+    big = "x" * (_MAX_IMG_B64 + 1)
+    many = [{"media_type": "image/png", "data": "a"}] * (_MAX_IMAGES + 3)
+    assert len(_sanitize_images(many)) == _MAX_IMAGES, "未限数量"
+    assert _sanitize_images([{"media_type": "image/png", "data": big}]) == [], "未限大小"
+    assert _sanitize_images([{"media_type": "image/tiff", "data": "a"}]) == [], "未按类型白名单"
+    assert _sanitize_images([{"media_type": "image/jpeg", "data": ""}]) == [], "空数据未拒"
+    assert _sanitize_images("notalist") == [] and _sanitize_images([1, "x"]) == []
+    ok = _sanitize_images([{"media_type": "image/JPEG", "data": "abc"}])
+    assert ok == [{"media_type": "image/jpeg", "data": "abc"}], ok    # 类型小写归一
+    # 累计总量上限:每张 8MB,第 3 张会使总量 24MB>20MB → 只留前 2 张
+    half = "x" * (8 * 1024 * 1024)
+    three = [{"media_type": "image/png", "data": half}] * 3
+    assert len(_sanitize_images(three)) == 2, "未按累计总量封顶"
+    print("[5] _sanitize_images 护栏(数量/单图/累计总量/类型/归一)OK")
+
+    # [6] _call_provider 把图片真正带进发给 provider 的 messages(openai 假 client 捕获)
+    cap = {}
+    def _make_openai():
+        def create(model, max_tokens, messages, **kw):
+            cap["messages"] = messages
+            return types.SimpleNamespace(
+                choices=[types.SimpleNamespace(message=types.SimpleNamespace(content="ok"))],
+                usage=None)
+        return types.SimpleNamespace(chat=types.SimpleNamespace(
+            completions=types.SimpleNamespace(create=create)))
+    r = ModelRouter()
+    out, _ = r._call_provider("openai", _make_openai(), "gpt-4o", "sys", BASE, 100, images=IMG)
+    assert out == "ok"
+    sent = cap["messages"][-1]["content"]      # 最后一条(user)应为多模态列表
+    assert isinstance(sent, list) and any(b.get("type") == "image_url" for b in sent), sent
+    print("[6] _call_provider 把图片带进 provider 请求 OK")
+
+    # [7] router.stream(openai) 流式路径也带图(假流式 client 捕获)
+    capS = {}
+    def _make_openai_stream():
+        def create(model, max_tokens, messages, stream=False, **kw):
+            capS["messages"] = messages
+            chunk = types.SimpleNamespace(choices=[types.SimpleNamespace(
+                delta=types.SimpleNamespace(content="hi"))])
+            return iter([chunk])
+        return types.SimpleNamespace(chat=types.SimpleNamespace(
+            completions=types.SimpleNamespace(create=create)))
+    r2 = ModelRouter()
+    r2.provider = "openai"; r2._client = _make_openai_stream()   # 非 None → is_stub 自动为 False
+    r2._locked_model = "gpt-4o"
+    got = "".join(r2.stream("sys", BASE, images=IMG))
+    assert got == "hi", got
+    sSent = capS["messages"][-1]["content"]
+    assert isinstance(sSent, list) and any(b.get("type") == "image_url" for b in sSent), sSent
+    print("[7] router.stream 流式多模态带图 OK")
+
+    # [8] stub 模式:带图不崩,忽略图片(无视觉时优雅降级)
+    r3 = ModelRouter(provider="stub")
+    assert r3.is_stub
+    sc = r3.complete("sys", BASE, images=IMG)
+    assert isinstance(sc, str) and sc, "stub complete 带图应正常返回文本"
+    ss = "".join(r3.stream("sys", BASE, images=IMG))
+    assert isinstance(ss, str) and ss, "stub stream 带图应正常返回文本"
+    print("[8] stub 带图优雅降级(忽略图片,不崩)OK")
+
+    # [9] /api/chat/stream 端到端:带图 SSE 正常产出(stub),超大图被 sanitize 掉不崩
+    from fastapi.testclient import TestClient
+    from foxclaw.api import app
+    with TestClient(app) as c:
+        body = {"task": "看图说话", "agent_id": "supervisor",
+                "images": [{"media_type": "image/png", "data": "iVBORw0KGgo="},
+                           {"media_type": "image/tiff", "data": "bad"},          # 类型不合法→被剔
+                           {"media_type": "image/png", "data": "y" * (_MAX_IMG_B64 + 1)}]}  # 超大→被剔
+        r = c.post("/api/chat/stream", json=body)
+        assert r.status_code == 200, r.status_code
+        assert "data:" in r.text, r.text[:200]
+        # 无 error 事件(sanitize 把坏图剔掉,剩 1 张合法图走 stub)
+        assert '"error"' not in r.text, r.text[:300]
+    print("[9] /api/chat/stream 带图端到端(含超大/非法图被剔)OK")
+
+    print("\n多模态对话通道验证全部通过")
+
+if __name__ == "__main__":
+    test_multimodal()

package/python/tests/test_negotiation.py

@@ -0,0 +1,146 @@
+"""智能体层深化·跨域协商闭环:被守门人拒 → 发起方降标准重报 → 再裁决。
+
+原缺口:cross_request 是**一次性**的(路由→拿裁决→return)。「下周去上海出差」→ 行程排程
+→ 财务守门人预算不足 → rejected → **到此为止**,用户只拿到一句"被拒绝"。
+
+安全不变量(比功能更重要):
+  · 裁决权仍在目标 Agent 的守门人,协商**不得成为绕过手段**
+  · 协商失败**维持 rejected**,绝不降级成 needs_confirmation(否则等于开了个点穿守门人的口子)
+  · 有界 + 必须真让步(否则无限贴红线试探)
+"""
+import os, sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+def test_negotiation():
+    os.environ["HKC_EMBEDDING"] = "stub"
+    os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
+
+    from foxclaw.orchestration import CrossAgentRequest, Orchestrator
+
+    print("=" * 60); print("跨域协商闭环验证"); print("=" * 60)
+
+
+    class _Gate:
+        """假目标 Agent:预算 <= limit 才批(模拟财务守门人)。"""
+        def __init__(self, limit): self.limit = limit; self.seen = []
+        def handle_cross_request(self, req):
+            amt = float(req.payload.get("amount", 0))
+            self.seen.append(amt)
+            if amt <= self.limit:
+                req.status = "approved"; req.verdict = f"预算 {amt:.0f} 在额度内"
+            else:
+                req.status = "rejected"; req.verdict = f"预算不足:申请 {amt:.0f} > 可用 {self.limit:.0f}"
+
+
+    class _Requester:
+        """假发起方:每轮降 25%,夹到原始的 floor 倍;到底则认输(与 AdminAgent.concede 同款)。"""
+        def __init__(self, floor=0.6): self.floor = floor; self.calls = 0
+        def concede(self, req, verdict):
+            self.calls += 1
+            amt = float(req.payload.get("amount", 0))
+            orig = float(req.payload.get("_original_amount") or amt)
+            new = max(round(amt * 0.75), round(orig * self.floor))
+            if new <= 0 or new >= amt:
+                return None
+            p = dict(req.payload); p["amount"] = new; p["_original_amount"] = orig
+            return p
+
+
+    class _Caps:
+        """假能力注册中枢:Orchestrator 经它惰性解析 agents(P1-3 打断对象环)。"""
+        def __init__(self, agents): self._a = agents
+        def get(self, name): return self._a if name == "agents" else None
+
+
+    def _orch(agents):
+        return Orchestrator(_Caps(agents))              # 只测协议,不拉起整个 OS
+
+
+    def _req(amount=8000):
+        return CrossAgentRequest(from_agent="admin", to_agent="finance",
+                                 request_type="budget_request", payload={"amount": amount})
+
+
+    # [1] 核心场景:被拒 → 让步 → 通过(原先到 rejected 就结束了)
+    gate = _Gate(limit=5000); r = _orch({"finance": gate, "admin": _Requester()})
+    req = r.negotiate(_req(8000))
+    assert req.status == "approved", (req.status, req.verdict)
+    assert req.payload["amount"] <= 5000, req.payload
+    assert len(req.negotiation) >= 2, "应发生过至少一轮让步"
+    assert gate.seen[0] == 8000 and gate.seen[-1] <= 5000, gate.seen
+    print(f"[1] 被拒→让步→通过({' → '.join(str(int(a)) for a in gate.seen)})OK")
+
+    # [2] 让步记录可追溯(每轮裁决 + 让到多少)
+    n = req.negotiation
+    assert n[0]["status"] == "rejected" and "conceded_to" in n[0], n[0]
+    assert n[-1]["status"] == "approved", n[-1]
+    print(f"[2] 协商日志可追溯({len(n)} 轮,含每轮裁决与让步)OK")
+
+    # [3] 安全:让无可让 → **维持 rejected**,绝不降级成 needs_confirmation
+    gate2 = _Gate(limit=100); r2 = _orch({"finance": gate2, "admin": _Requester()})
+    req2 = r2.negotiate(_req(8000))
+    assert req2.status == "rejected", f"协商失败必须维持 rejected,不得降级: {req2.status}"
+    print("[3] 让无可让 → 维持 rejected(不给点穿守门人的口子)OK")
+
+    # [4] 有界:轮数不超过 max_rounds(防死循环)
+    gate3 = _Gate(limit=1); r3 = _orch({"finance": gate3, "admin": _Requester(floor=0.0)})
+    req3 = r3.negotiate(_req(8000), max_rounds=3)
+    assert len(gate3.seen) <= 3, f"轮数应有界: {gate3.seen}"
+    assert req3.status == "rejected"
+    print(f"[4] 有界协商(裁决 {len(gate3.seen)} 次 ≤ max_rounds=3)OK")
+
+    # [5] 必须真让步:concede 返回原样 payload → 立即停(否则无限重复同一请求)
+    class _NoOp:
+        def concede(self, req, verdict): return dict(req.payload)     # 假让步
+    gate4 = _Gate(limit=1); r4 = _orch({"finance": gate4, "admin": _NoOp()})
+    r4.negotiate(_req(8000), max_rounds=5)
+    assert len(gate4.seen) == 1, f"无实质让步应只裁决一次: {gate4.seen}"
+    print("[5] 假让步(payload 无变化)→ 立即停,不重复轰炸守门人 OK")
+
+    # [6] 不让步的 Agent(默认 concede→None)→ 与协商前逐字等价:只跑一轮
+    class _Silent:
+        def concede(self, req, verdict): return None
+    gate5 = _Gate(limit=1); r5 = _orch({"finance": gate5, "admin": _Silent()})
+    req5 = r5.negotiate(_req(8000))
+    assert len(gate5.seen) == 1 and req5.status == "rejected"
+    print("[6] 未实现让步的 Agent → 只跑一轮(零行为变更)OK")
+
+    # [7] 让步逻辑抛异常 → 停 + 维持原裁决(不因发起方 bug 放行)
+    class _Boom:
+        def concede(self, req, verdict): raise RuntimeError("concede 崩了")
+    gate6 = _Gate(limit=1); r6 = _orch({"finance": gate6, "admin": _Boom()})
+    req6 = r6.negotiate(_req(8000))
+    assert req6.status == "rejected", "发起方 concede 崩溃不得影响裁决"
+    assert any("concede_error" in x for x in req6.negotiation)
+    print("[7] 让步逻辑崩溃 → 维持 rejected + 记录错误 OK")
+
+    # ── 真 OfficeAgent 的让步策略(行政并入办公,领域逻辑仍归领域 Agent)──
+    from foxclaw.agents.agents import OfficeAgent
+    adm = OfficeAgent.__new__(OfficeAgent)
+
+    # [8] OfficeAgent(原 AdminAgent):逐轮降档 → 夹到下限(600)→ 到底认输。全程单调下降、必然终止
+    p = adm.concede(_req(1000), "预算不足")
+    assert p and p["amount"] == 750 and "降标准" in p["_concession"], p
+    seq, cur = [1000], _req(1000).payload
+    while True:                                    # 走完整条让步链,证明单调且会终止
+        nxt = adm.concede(_req(0).__class__(from_agent="admin", to_agent="finance",
+                                            request_type="budget_request", payload=dict(cur)), "拒")
+        if nxt is None:
+            break
+        assert nxt["amount"] < cur["amount"], "让步必须单调下降"
+        cur = nxt; seq.append(cur["amount"])
+        assert len(seq) < 20, "让步链必须终止"
+    assert seq[-1] == 600, f"应走到下限 600(原始 1000 的 60%),实际 {seq}"
+    print(f"[8] OfficeAgent 让步链 {seq} → 到下限认输(单调下降·必然终止)OK")
+
+    # [9] OfficeAgent:非预算请求不插手(回退默认不让步)
+    other = CrossAgentRequest(from_agent="admin", to_agent="office",
+                              request_type="knowledge_request", payload={"q": "x"})
+    assert adm.concede(other, "拒") is None
+    print("[9] 非 budget_request → 不插手(回退默认)OK")
+
+    print("\n跨域协商闭环验证全部通过")
+
+if __name__ == "__main__":
+    test_negotiation()

package/python/tests/test_orchestration.py

@@ -0,0 +1,119 @@
+"""
+主管编排测试 — 全局态势 + 跨 Agent 编排
+核心场景:行程 Agent 规划出差 → 主管发起差旅预算申请 →
+         财务守门人裁决(够不够/要不要确认/否决)。
+这把三个独立内核真正串成一个有机系统。
+"""
+import sys, os, tempfile
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+os.environ["FOXCLAW_SHADOW_ROUNDS"] = "50"
+
+import asyncio
+from foxclaw import Foxclaw
+
+
+def check(cond, msg):
+    if not cond:
+        raise AssertionError(f"✗ {msg}")
+    print(f"  ✓ {msg}")
+
+
+async def main():
+    print("=" * 60)
+    print("主管编排 · 全局态势 + 跨 Agent 协调")
+    print("=" * 60)
+    _data = tempfile.mkdtemp(prefix="foxclaw_orch_")   # 系统临时目录,不污染仓库根
+    os_ = Foxclaw(data_dir=_data, shadow_rounds=50)
+
+    # 准备各内核的数据
+    fin = os_.finance_runtime
+    fin.set_budget("travel", 3000)
+    fin.set_balance("default", 5000)
+    fin.import_csv(str(Path(__file__).parent.parent / "examples" / "sample_transactions.csv"))
+
+    learn = os_.learning_runtime
+    learn.import_csv(str(Path(__file__).parent.parent / "examples" / "sample_knowledge.csv"))
+
+    itin = os_.itinerary_runtime
+    itin.import_csv(str(Path(__file__).parent.parent / "examples" / "sample_itinerary.csv"))
+
+    # 1. 全局态势(驾驶舱视图)
+    print("\n【1】主管全局态势(驾驶舱视图)")
+    sit = os_.supervisor.global_situation()
+    print(f"  财务: {sit['finance']}")
+    print(f"  学习: {sit['learning']}")
+    print(f"  行程: {sit['itinerary']}")
+    print(f"  跨域告警 {len(sit['alerts'])} 条:")
+    for a in sit["alerts"][:5]:
+        print(f"    [{a['severity']}] ({a['domain']}) {a['msg']}")
+    # "驾驶舱"的意义在于态势**来自各内核的真实数据**,不是空壳。故断言三域计数与导入一致。
+    check(sit["finance"]["transactions"] == 13, f"财务态势反映 13 笔导入交易(实为 {sit['finance']['transactions']})")
+    check(sit["learning"]["total_items"] == 8, f"学习态势反映 8 个知识点(实为 {sit['learning']['total_items']})")
+    check(sit["itinerary"]["waypoints"] == 5, f"行程态势反映 5 个行程点(实为 {sit['itinerary']['waypoints']})")
+    sev = {a["severity"] for a in sit["alerts"]}
+    check(len(sit["alerts"]) >= 2 and "critical" in sev,
+          f"跨域告警被汇总且含 critical(实为 {sorted(sev)})")
+
+    # 2. 跨 Agent 编排:差旅预算申请(小额,应批准)
+    print("\n【2】跨 Agent 编排:行程→财务 差旅预算申请(小额)")
+    r1 = os_.supervisor.cross_request(
+        from_agent="admin", to_agent="finance", request_type="budget_request",
+        payload={"amount": 150, "category": "travel", "entity": "高铁票", "account": "default"},
+        reason="出差北京高铁票")
+    print(f"  申请: 差旅 150 元 → 状态【{r1['status']}】")
+    print(f"  财务裁决: {r1['verdict']}")
+    check(r1["status"] == "approved",
+          f"小额(150)且在预算内 → 直接批准(实为 {r1['status']})")
+
+    # 3. 跨 Agent 编排:大额差旅(触发守门人确认)
+    print("\n【3】跨 Agent 编排:大额差旅(触发守门人)")
+    r2 = os_.supervisor.cross_request(
+        from_agent="admin", to_agent="finance", request_type="budget_request",
+        payload={"amount": 680, "category": "travel", "entity": "商务酒店", "account": "default"},
+        reason="出差住宿3晚")
+    print(f"  申请: 差旅 680 元 → 状态【{r2['status']}】")
+    print(f"  财务裁决: {r2['verdict']}")
+    check(r2["status"] == "needs_confirmation",
+          f"大额(680>500) → 转人工确认(实为 {r2['status']})")
+    # 金额确实改变结论(不是两条路都走同一个分支)
+    check(r1["status"] != r2["status"], "金额不同 → 裁决结论确实不同(150 批准 / 680 待确认)")
+
+    # 4. 跨 Agent 编排:日程占用申请
+    print("\n【4】跨 Agent 编排:日程占用申请→行政检查冲突")
+    r3 = os_.supervisor.cross_request(
+        from_agent="assistant", to_agent="admin", request_type="schedule_request",
+        payload={"start_time": "2026-06-10T10:30:00", "title": "临时电话会"},
+        reason="客户临时约电话会")
+    print(f"  申请: 10:30 电话会 → 状态【{r3['status']}】")
+    print(f"  行政裁决: {r3['verdict']}")
+    check(r3["status"] == "needs_confirmation",
+          f"与既有行程时段冲突 → 转人工确认(实为 {r3['status']})")
+
+    # 5. 【P1-0 守护】目标 Agent 不存在时必须 fail-closed
+    # 这是回归守卫:此前该分支返回 "approved"(默认放行)= fail-open —— 发起方会拿到
+    # "已批准",但**没有任何 Agent 真的处理过这个请求**。若哪天有人把它改回去,这里必须红。
+    print("\n【5】目标 Agent 不存在 → 必须转人工(不得默认放行)")
+    r4 = os_.supervisor.cross_request(
+        from_agent="admin", to_agent="不存在的Agent", request_type="budget_request",
+        payload={"amount": 1, "category": "travel", "entity": "x", "account": "default"},
+        reason="路由到不存在的目标")
+    print(f"  申请 → 状态【{r4['status']}】")
+    print(f"  裁决: {r4['verdict']}")
+    check(r4["status"] == "needs_confirmation",
+          f"目标不存在 → needs_confirmation 而非默认放行(实为 {r4['status']})")
+
+    import shutil
+    shutil.rmtree(_data, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print("✓ 主管编排验证完成:全局态势 + 跨 Agent 守门人协调成立")
+    print("=" * 60)
+
+
+def test_orchestration():
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/python/tests/test_orchestration_decoupled.py

@@ -0,0 +1,109 @@
+"""
+编排层去领域硬编码(P3)测试 —— 全离线。
+
+审计:Orchestrator 的 _handle_budget_request/_handle_schedule_request + gather_situation
+硬编码了 finance/learning/itinerary 内核内部 API(SRP 违反,编排层懂领域)。
+修复:领域知识下沉到各领域 Agent(situation()/handle_cross_request()),编排层只做
+通用聚合(逐个 agent.situation())+ 通用路由(dispatch 到 target.handle_cross_request())。
+
+覆盖:
+  1. 结构去耦:Orchestrator 删除 _handle_* 领域方法;编排层源码零领域内核 API 引用
+  2. 领域逻辑归属 Agent:finance/admin 有 handle_cross_request,base 默认放行
+  3. 行为保持:态势聚合 + 小额批准/大额确认/日程冲突确认(裁决与原一致)
+  4. 通用性:路由到不存在的 Agent → 转人工确认(P1-0 修 fail-open,仍不崩)
+"""
+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))
+
+
+def test_structural_decoupling():
+    print("\n【1】结构去耦:编排层无领域方法/无领域内核 API 引用")
+    from foxclaw.orchestration import Orchestrator
+    assert not hasattr(Orchestrator, "_handle_budget_request"), "编排层不应再有 _handle_budget_request"
+    assert not hasattr(Orchestrator, "_handle_schedule_request"), "编排层不应再有 _handle_schedule_request"
+    src = Path("foxclaw/orchestration/__init__.py").read_text(encoding="utf-8")
+    for banned in ("budget_status", "detect_conflicts", "due_items", "Transaction",
+                   ".waypoints", ".policy", "review_states"):
+        assert banned not in src, f"编排层仍引用领域内核 API: {banned}"
+    print("  ✓ 删除 _handle_*;源码零领域内核 API 引用")
+
+
+def test_domain_logic_in_agents():
+    print("\n【2】领域逻辑归属 Agent(situation / handle_cross_request)")
+    from foxclaw.agents.agents import FinanceAgent, OfficeAgent
+    from foxclaw.agents.base import CognitiveAgent
+    assert FinanceAgent.handle_cross_request is not CognitiveAgent.handle_cross_request
+    assert OfficeAgent.handle_cross_request is not CognitiveAgent.handle_cross_request
+    assert FinanceAgent.situation is not CognitiveAgent.situation
+    assert OfficeAgent.situation is not CognitiveAgent.situation
+    print("  ✓ finance/admin 覆盖 handle_cross_request;finance/admin/office 覆盖 situation")
+
+
+def test_behavior_and_generic_routing():
+    print("\n【3】行为保持 + 通用路由")
+    d = tempfile.mkdtemp(prefix="p3_")
+    try:
+        from foxclaw import Foxclaw
+        os_ = Foxclaw(data_dir=d, shadow_rounds=50)
+        fin = os_.finance_runtime
+        fin.set_budget("travel", 3000); fin.set_balance("default", 5000)
+        fin.import_csv(str(Path("examples/sample_transactions.csv")))
+        os_.learning_runtime.import_csv(str(Path("examples/sample_knowledge.csv")))
+        os_.itinerary_runtime.import_csv(str(Path("examples/sample_itinerary.csv")))
+
+        # 态势通用聚合
+        sit = os_.supervisor.global_situation()
+        assert set(sit["finance"]) >= {"transactions"} and "total_items" in sit["learning"]
+        assert "waypoints" in sit["itinerary"]
+        print(f"  ✓ 态势聚合: fin={sit['finance']}, learn.items={sit['learning']['total_items']}, "
+              f"itin.wp={sit['itinerary']['waypoints']}, alerts={len(sit['alerts'])}")
+
+        # 裁决行为保持(由目标 Agent 守门人裁决)
+        r_small = os_.supervisor.cross_request("admin", "finance", "budget_request",
+            {"amount": 150, "category": "travel", "entity": "高铁", "account": "default"}, "小额")
+        r_big = os_.supervisor.cross_request("admin", "finance", "budget_request",
+            {"amount": 680, "category": "travel", "entity": "酒店", "account": "default"}, "大额")
+        r_sched = os_.supervisor.cross_request("assistant", "admin", "schedule_request",
+            {"start_time": "2026-06-10T10:30:00", "title": "电话会"}, "占日程")
+        assert r_small["status"] == "approved", r_small
+        assert r_big["status"] in ("needs_confirmation", "rejected"), r_big
+        assert r_sched["status"] in ("needs_confirmation", "approved"), r_sched
+        print(f"  ✓ 小额={r_small['status']} 大额={r_big['status']} 日程={r_sched['status']}(委托目标守门人)")
+
+        # 通用性:路由到不存在的 Agent → 转人工确认,不崩(P1-0)
+        # 原断言锁的是 status == "approved" —— 那等于"没有任何 Agent 处理过,却回报批准",
+        # 是 fail-open:发起方会据此继续推进(如拿到"预算已批"去下单)。
+        r_unknown = os_.supervisor.cross_request("x", "nonexistent", "budget_request", {}, "未知目标")
+        assert r_unknown["status"] == "needs_confirmation", r_unknown
+        assert "不存在" in r_unknown["verdict"]
+        print(f"  ✓ 路由到不存在 Agent → {r_unknown['status']}(不再 fail-open 放行,仍不崩)")
+
+        # 深审修复:守门人裁决崩溃(畸形 payload)必须 fail-safe → 转人工确认,绝不自动放行
+        r_bad = os_.supervisor.cross_request("x", "admin", "schedule_request",
+            {"start_time": "不是合法时间"}, "畸形时间")
+        assert r_bad["status"] == "needs_confirmation", f"裁决崩溃应 fail-safe,实得 {r_bad}"
+        assert "转人工" in r_bad["verdict"]
+        print(f"  ✓ 畸形 payload 让守门人裁决崩溃 → {r_bad['status']}(fail-safe,不 fail-open 放行)")
+        asyncio.run(os_.aclose())
+    finally:
+        shutil.rmtree(d, ignore_errors=True)
+
+
+def main():
+    print("=" * 60)
+    print("编排层去领域硬编码 · 改委托(P3)")
+    print("=" * 60)
+    test_structural_decoupling()
+    test_domain_logic_in_agents()
+    test_behavior_and_generic_routing()
+    print("\n" + "=" * 60)
+    print("✓ P3 验证完成:编排层通用聚合/路由,领域知识归属领域 Agent")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()