foxclaw 0.1.2 → 0.1.4

package/python/tests/test_mcp_server.py

@@ -13,14 +13,14 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 )
 def test_mcp_server():
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
-    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"      # 用进程环境变量自洽测试,不加载开发机 .env
+    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
     os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_mcpsrv_")
-    os.environ["FOXCLAW_API_KEY"] = "mcp-test-key"              # ★ 开鉴权,测真实暴露
+    os.environ["FOXCLAW_API_KEY"] = "mcp-test-key"
     os.environ["FOXCLAW_MCP_SERVER"] = "1"
     os.environ["FOXCLAW_MCP_AGENTS"] = "1"
-    os.environ["FOXCLAW_MCP_RATE_AGENT"] = "1"                  # ask_foxclaw 限 1/桶,测限流
+    os.environ["FOXCLAW_MCP_RATE_AGENT"] = "1"
     os.environ.setdefault("FOXCLAW_EMBEDDING_MODEL", "foxclaw-nonexistent-fast")
-    os.environ["HF_HUB_OFFLINE"] = "1"         # 无网环境:跳过 huggingface 联网重试(否则模型加载拖 2 分钟,服务器赶不上就绪窗口)
+    os.environ["HF_HUB_OFFLINE"] = "1"
     os.environ["TRANSFORMERS_OFFLINE"] = "1"
     import uvicorn
     import httpx
@@ -35,13 +35,12 @@ def test_mcp_server():
                      daemon=True).start()
     for _ in range(60):
         try:
-            urllib.request.urlopen(f"http://127.0.0.1:{PORT}/health", timeout=2); break   # /health 开放
+            urllib.request.urlopen(f"http://127.0.0.1:{PORT}/health", timeout=2); break
         except urllib.error.HTTPError:
             break
         except Exception:
             time.sleep(1)
 
-    # [0] 防后门:设了 key,不带/错 key 访问 /api/mcp/ 必须 401(未被鉴权绕过)
     with httpx.Client(timeout=8) as c:
         body = {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}
         hdr = {"Accept": "application/json, text/event-stream"}
@@ -55,7 +54,6 @@ def test_mcp_server():
     async def probe():
         from mcp.client.streamable_http import streamablehttp_client
         from mcp import ClientSession
-        # 带正确 key 连接
         async with streamablehttp_client(f"http://127.0.0.1:{PORT}/api/mcp/",
                                          headers={"X-API-Key": KEY}) as (r, w, _):
             async with ClientSession(r, w) as s:
@@ -64,7 +62,7 @@ def test_mcp_server():
                 assert tools == {"knowledge_search", "knowledge_get", "memory_recall", "ask_foxclaw"}, tools
                 print("[1] 带key initialize + list_tools(3 只读 + ask_foxclaw) OK")
 
-                res = await s.call_tool("knowledge_search", {"query": "anything", "top_k": 999999})  # 试超大 top_k(应被钳制不崩)
+                res = await s.call_tool("knowledge_search", {"query": "anything", "top_k": 999999})
                 assert res.content is not None
                 print("[2] knowledge_search 可调 + top_k 钳制不崩 OK")
 
@@ -82,7 +80,6 @@ def test_mcp_server():
                 assert "dispatched_to" in txt or "reply" in txt or "error" in txt, txt
                 print("[5] ask_foxclaw Agent 调度可调(返回 reply/dispatched_to) OK")
 
-                # [6] 限流:agent 桶设 1,上面已消耗 → 再调应被限流
                 res = await s.call_tool("ask_foxclaw", {"task": "再来一次"})
                 txt = res.content[0].text if res.content else ""
                 assert "rate limited" in txt, f"限流未生效: {txt}"

package/python/tests/test_memory_recall.py

@@ -18,7 +18,7 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 from foxclaw.core.memory_adapter import create_memory_backend
 
 QUERY = "quarterly revenue growth and budget forecast analysis"
-N_FINANCE = 55           # > 老路径 fetch_k(50),< 压缩阈值(同类型 80)
+N_FINANCE = 55
 
 
 def check(cond, msg):
@@ -36,16 +36,13 @@ def main():
         print("  · HMR 不可用(降级 Mock),跳过 M4 测试")
         print("结果:跳过"); return
 
-    # office:一条与 query 相关的关键记忆 + 一条无关
     hmr.ingest("office quarterly revenue growth and budget forecast for planning",
                type="concept", agent_id="office", title="office-key")
     hmr.ingest("office meeting room booking schedule for next week",
                type="concept", agent_id="office", title="office-other")
-    # finance:大量与 query 强相关记忆(会在全局排序里淹没 office 的记忆)
     for i in range(N_FINANCE):
         hmr.ingest(f"finance quarterly revenue growth and budget forecast record {i}",
                    type="concept", agent_id="finance", title=f"fin-{i}")
-    # 一条共享记忆
     hmr.ingest("shared team quarterly planning memo", type="concept",
                agent_id="finance", shared=True, title="shared-memo")
 

package/python/tests/test_metrics.py

@@ -6,8 +6,6 @@ import pytest
 
 
 def test_metrics():
-    # ISOLATION_GUARD:本用例依赖 import 时固化的模块级单例(网关/限流器/路由配置按 env 在 import 时定型),单进程全量跑会被前序用例污染 →
-    # 假红。全量请用 tests/run_all.py(每文件独立子进程)。
     if "foxclaw.api" in sys.modules:
         pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
@@ -21,11 +19,9 @@ def test_metrics():
     print("=" * 60); print("ops 监控验证"); print("=" * 60)
 
     with TestClient(app) as c:
-        # 产生一些请求 + 一次任务(触发 LLM 埋点,stub)
         c.get("/api/status"); c.get("/api/ahs/skills"); c.get("/health")
         c.post("/api/task", json={"task": "测试", "agent_id": "supervisor"})
 
-        # [1] 深度健康:逐子系统(开放路径,探针无需鉴权;不泄露 provider 名)
         hd = c.get("/health/ready")
         assert hd.status_code == 200, hd.status_code
         j = hd.json()
@@ -33,7 +29,6 @@ def test_metrics():
         assert j["components"]["router"] in ("ok", "stub", "down"), "router 不应泄露 provider 名"
         print(f"[1] /health/ready 深度健康({j['status']},{len(j['components'])} 组件,router 不泄露) OK")
 
-        # [2] JSON metrics:端点延迟分位 + 错误率
         m = c.get("/api/metrics").json()
         assert "uptime_s" in m and m["endpoints"], m
         ep = next(k for k in m["endpoints"] if "status" in k)
@@ -41,16 +36,13 @@ def test_metrics():
         assert st["count"] >= 1 and "p95_ms" in st and "error_rate" in st and "avg_ms" in st, st
         print(f"[2] /api/metrics 端点(p50={st['p50_ms']} p95={st['p95_ms']} err={st['error_rate']}) OK")
 
-        # [3] LLM 埋点(stub 也计入调用量)
         assert m["llm"], f"LLM 指标应非空: {m['llm']}"
         print(f"[3] LLM 埋点({list(m['llm'])}) OK")
 
-        # [4] Prometheus 文本格式
         p = c.get("/metrics")
         assert p.status_code == 200 and "foxclaw_requests_total" in p.text and "foxclaw_llm_calls_total" in p.text
         print("[4] /metrics Prometheus 文本 OK")
 
-        # [5] 未匹配路由(404)不撑爆 key:20 个不同 404 路径 → 只 1 个 "unmatched" key
         for i in range(20):
             c.get(f"/api/does-not-exist/random-{i}")
         m2 = c.get("/api/metrics").json()

package/python/tests/test_multi_chain.py

@@ -16,32 +16,25 @@ def test_multi_chain():
 
     print("=" * 60); print("多步跨 Agent 链式协作验证"); print("=" * 60)
 
-    # [1] 无前序 → 原样返回(第 1 步不该有前言)
     assert _with_prior("查餐饮支出", []) == "查餐饮支出"
     print("[1] 首步无前序上下文(原样)OK")
 
-    # [2] 有前序 → 并进任务文本
     t = _with_prior("据此定预算", [{"step": 1, "agent": "finance", "output": "餐饮 1200 元"}])
     assert "据此定预算" in t and "餐饮 1200 元" in t and "第1步(finance)" in t, t
     print("[2] 前序结果并进下一步任务文本 OK")
 
-    # [3] 步数封顶:只带最近 N 步(防长链把提示词滚爆)
     many = [{"step": i, "agent": "a", "output": f"out{i}"} for i in range(1, 9)]
     t3 = _with_prior("x", many)
     assert "out8" in t3 and "out6" in t3 and "out5" not in t3, t3
     assert t3.count("第") - 1 == PRIOR_MAX_STEPS or t3.count("步(") == PRIOR_MAX_STEPS, t3
     print(f"[3] 只带最近 {PRIOR_MAX_STEPS} 步(更早的不注入)OK")
 
-    # [4] 单步字符封顶
     t4 = _with_prior("x", [{"step": 1, "agent": "a", "output": "y" * 900}])
     assert "y" * PRIOR_MAX_CHARS in t4 and "y" * (PRIOR_MAX_CHARS + 1) not in t4
     print(f"[4] 单步输出截断到 {PRIOR_MAX_CHARS} 字符 OK")
 
-    # ── 集成:直接驱动 _dispatch_multi,看子 Agent 真实收到了什么 ──
     from foxclaw import Foxclaw
 
-    # 注意:Foxclaw 的 data_dir 是**构造参数**(默认 ./foxclaw_data),不读 FOXCLAW_DATA_DIR
-    # ——env 是 api.py 读了再传进来的。测试必须显式传临时目录,否则会写进真实用户记忆库。
     os_ = Foxclaw(data_dir=os.environ["FOXCLAW_DATA_DIR"])
     sup = os_.supervisor
 
@@ -58,35 +51,30 @@ def test_multi_chain():
     adm = StubAgent("admin", "已按 1200 元安排下周预算")
     subs = {"finance": fin, "admin": adm}
     sched = sup._schedule_for("t", subs) if hasattr(sup, "_schedule_for") else None
-    if sched is None:                       # 兼容:直接拿一个 schedule 对象
+    if sched is None:
         from foxclaw.core.scheduler import SystemContext
         sched = sup._scheduler.schedule("t", SystemContext(active_agents=0, queue_depth=0, system_load=0.1))
 
     routes = [("查本月餐饮支出", "finance"), ("据此安排下周预算", "admin")]
     out = asyncio.run(sup._dispatch_multi("查餐饮并定预算", routes, sched, "sess1", subs, {}, []))
 
-    # [5] 第 1 步不带前序;第 2 步**收到了**第 1 步的输出 → 链真的接上了
     s1, s2 = fin.seen[0]["task"], adm.seen[0]["task"]
     assert "前序步骤结果" not in s1, f"首步不该有前序前言: {s1}"
     assert "本月餐饮 1200 元" in s2, f"第2步应看到第1步结果,实际: {s2}"
     assert "据此安排下周预算" in s2
     print("[5] 第2步真实收到第1步输出(链式成立)OK")
 
-    # [6] context 里也有结构化 prior_steps(两手准备)
     ps = adm.seen[0]["context"].get("prior_steps")
     assert ps and ps[0]["agent"] == "finance" and "1200" in ps[0]["output"], ps
     assert fin.seen[0]["context"].get("prior_steps") == [], "首步 prior 应为空"
     print("[6] context.prior_steps 结构化传递 OK")
 
-    # [7] 展示用 subtask 保留原始文本(不被前序前言污染 UI)
     steps = out["result"]["multi_steps"]
     assert steps[1]["subtask"] == "据此安排下周预算", steps[1]["subtask"]
     assert "前序步骤结果" not in steps[1]["subtask"]
     assert out["result"]["dispatched_to"] == "multi" and len(steps) == 2
     print("[7] UI 展示的 subtask 仍是原始文本(未被污染)OK")
 
-    # [8] 【长期运行】入链的输出必须截断:prior 会被复制进**每个**后续步骤的 context,
-    #     不截断则长链 + 大输出会滚成可观的内存/拷贝开销(渲染本就只用 300 字符)。
     big = StubAgent("finance", "X" * 5000)
     subs2 = {"finance": big, "admin": StubAgent("admin", "ok")}
     asyncio.run(sup._dispatch_multi("t", [("查", "finance"), ("用", "admin")],

package/python/tests/test_multimodal.py

@@ -7,8 +7,6 @@ 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"):
@@ -24,7 +22,6 @@ def test_multimodal():
     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
@@ -33,26 +30,22 @@ def test_multimodal():
     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)
@@ -62,14 +55,12 @@ def test_multimodal():
     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 张
+    assert ok == [{"media_type": "image/jpeg", "data": "abc"}], ok
     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):
@@ -82,11 +73,10 @@ def test_multimodal():
     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)应为多模态列表
+    sent = cap["messages"][-1]["content"]
     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):
@@ -97,7 +87,7 @@ def test_multimodal():
         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.provider = "openai"; r2._client = _make_openai_stream()
     r2._locked_model = "gpt-4o"
     got = "".join(r2.stream("sys", BASE, images=IMG))
     assert got == "hi", got
@@ -105,7 +95,6 @@ def test_multimodal():
     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)
@@ -114,18 +103,16 @@ def test_multimodal():
     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)}]}  # 超大→被剔
+                           {"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")
 

package/python/tests/test_negotiation.py

@@ -54,7 +54,7 @@ def test_negotiation():
 
 
     def _orch(agents):
-        return Orchestrator(_Caps(agents))              # 只测协议,不拉起整个 OS
+        return Orchestrator(_Caps(agents))
 
 
     def _req(amount=8000):
@@ -62,7 +62,6 @@ def test_negotiation():
                                  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)
@@ -71,34 +70,29 @@ def test_negotiation():
     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)     # 假让步
+        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()})
@@ -106,7 +100,6 @@ def test_negotiation():
     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()})
@@ -115,15 +108,13 @@ def test_negotiation():
     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:                                    # 走完整条让步链,证明单调且会终止
+    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:
@@ -134,7 +125,6 @@ def test_negotiation():
     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

package/python/tests/test_orchestration.py

@@ -23,10 +23,9 @@ async def main():
     print("=" * 60)
     print("主管编排 · 全局态势 + 跨 Agent 协调")
     print("=" * 60)
-    _data = tempfile.mkdtemp(prefix="foxclaw_orch_")   # 系统临时目录,不污染仓库根
+    _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)
@@ -38,7 +37,6 @@ async def main():
     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']}")
@@ -47,7 +45,6 @@ async def main():
     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']})")
@@ -55,7 +52,6 @@ async def main():
     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",
@@ -66,7 +62,6 @@ async def main():
     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",
@@ -76,10 +71,8 @@ async def main():
     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",
@@ -90,9 +83,6 @@ async def main():
     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",

package/python/tests/test_orchestration_decoupled.py

@@ -55,14 +55,12 @@ def test_behavior_and_generic_routing():
         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",
@@ -74,15 +72,11 @@ def test_behavior_and_generic_routing():
         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}"

package/python/tests/test_p3_p5_hardening.py

@@ -30,7 +30,6 @@ def check(cond, label):
         print(f"  ✗ {label}")
 
 
-# 测试环境自洽:不读 .env,不打外部 API,不写真实数据目录(在任何 foxclaw import 之前)
 os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
 os.environ.setdefault("FOXCLAW_EMBEDDING_MODEL", "foxclaw-nonexistent-fast")
 os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_b7_")
@@ -39,7 +38,6 @@ for _k in ("DEEPSEEK_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY",
     os.environ[_k] = ""
 
 
-# ═══════════════ [1][2] P3-1 / P3-8 辅助函数行为 ═══════════════
 def test_helpers():
     print("\n【1】P3-1:_constant_time_eq 常量时间比较")
     from foxclaw.api import _constant_time_eq, _is_guarded_path
@@ -60,7 +58,6 @@ def test_helpers():
     check(_is_guarded_path("/docs") is False, "/docs 不受保护")
 
 
-# ═══════════════ [3] P3-1+P3-8 接线防退化(源码级) ═══════════════
 def test_wiring_source():
     print("\n【3】P3-1+P3-8 接线防退化:中间件/WS 统一走辅助函数(源码级断言)")
     import foxclaw.api as api_mod
@@ -83,7 +80,6 @@ def test_wiring_source():
     check("provided != api_key" not in src_ws, "WS 端点无残留 !=")
 
 
-# ═══════════════ [4] P3-7 isinstance 异常分类 ═══════════════
 def _run_ability_with(exc):
     """用抛指定异常的假 HKC 驱动 knowledge_ability 端点,返回 (status, body)。"""
     import foxclaw.api as api_mod
@@ -94,8 +90,8 @@ def _run_ability_with(exc):
             raise exc
 
     fake_hkc = SimpleNamespace(available=True, client=_Client())
-    old_os = api_mod._os_instance
-    api_mod._os_instance = SimpleNamespace(hkc=fake_hkc)
+    old_os = api_mod._state.current_os()
+    api_mod._state.set_os_instance(SimpleNamespace(hkc=fake_hkc))
     try:
         try:
             body = asyncio.run(api_mod.knowledge_ability("any_key"))
@@ -106,7 +102,7 @@ def _run_ability_with(exc):
                 return e.status_code, {"detail": e.detail}
             raise
     finally:
-        api_mod._os_instance = old_os
+        api_mod._state.set_os_instance(old_os)
 
 
 def test_ability_isinstance():
@@ -115,12 +111,10 @@ def test_ability_isinstance():
 
     check(api_mod._HKCInsuffCov is not None, "vendor 下 hkc_sdk.exceptions 可 import")
 
-    # a) 真 HKCInsufficientCoverage → 证据 gate(sufficient=False,非 404)
     from hkc_sdk.exceptions import HKCInsufficientCoverage
     try:
         raise HKCInsufficientCoverage("覆盖不足测试")
     except HKCInsufficientCoverage as e:
-        # 尽量补上端点要读的属性(不同版本构造签名可能不同)
         if not hasattr(e, "missing_skills"):
             e.missing_skills = ["s1"]
         if not hasattr(e, "coverage"):
@@ -129,7 +123,6 @@ def test_ability_isinstance():
     check(status == 200 and body.get("sufficient") is False,
           f"真 HKC 覆盖不足 → 证据 gate(实为 {status}: {str(body)[:80]})")
 
-    # b) 【精确化核心价值】带 missing_skills 属性的**非 HKC** 异常 → 404,不被误吞
     class _FakeInsuff(Exception):
         def __init__(self):
             super().__init__("鸭子异常")
@@ -140,7 +133,6 @@ def test_ability_isinstance():
     check(status == 404,
           f"isinstance 模式:鸭子异常不再误判为覆盖不足(实为 {status})")
 
-    # c) 回退:_HKCInsuffCov=None(模拟缺 vendor)时 hasattr 鸭子判断仍工作
     old = api_mod._HKCInsuffCov
     api_mod._HKCInsuffCov = None
     try:
@@ -153,7 +145,6 @@ def test_ability_isinstance():
         api_mod._HKCInsuffCov = old
 
 
-# ═══════════════ [5][6] P3-5 blocked 短路 + P3-0 system 归因 ═══════════════
 class _MockHMR:
     def __init__(self):
         self.calls = []
@@ -210,7 +201,6 @@ def test_truth_system_attribution():
     check(kw.get("shared") is True, "仍写共享层")
 
 
-# ═══════════════ [7] P3-6/P4-1 SystemBus exact ═══════════════
 def test_system_bus_exact():
     print("\n【7】P3-6/P4-1:SystemBus exact 参数")
     from foxclaw.core.system_bus import SystemBus
@@ -252,7 +242,6 @@ def test_system_bus_exact():
           f"前缀事件 execution.completed.extra 不触发真值链(沉淀 {len(hmr4.calls)} 次)")
 
 
-# ═══════════════ [8] P5-3 _transition 终态守卫 ═══════════════
 def test_transition_terminal_guard():
     print("\n【8】P5-3:ProcessManager._transition 终态守卫")
     from foxclaw.kernel.process_manager import ProcessManager
@@ -261,12 +250,10 @@ def test_transition_terminal_guard():
     pm.mark_running(rec.process_id)
     pm.mark_completed(rec.process_id)
     n = pm.active_count()
-    # 终态再 _transition(模拟未来新增的直接调用点)→ 幂等忽略
     pm._transition(rec, "failed")
     check(rec.state == "completed", "终态再流转 → 状态不变")
     check(pm.active_count() == n, "终态再流转 → 活跃计数不重复 -1")
     check(rec.state_history.count("completed") == 1, "终态再流转 → 历史不追加")
-    # 非终态的非法跳转仍 fail-fast(行为不变)
     rec2 = pm.create("t2")
     rec2.state = "created"
     try:
@@ -276,7 +263,6 @@ def test_transition_terminal_guard():
         check(True, "非终态非法跳转(created→completed)仍抛 ValueError")
 
 
-# ═══════════════ [9] P5-1 reason_code ═══════════════
 def test_reason_code():
     print("\n【9】P5-1:PermissionDecision.reason_code 分类")
     from foxclaw.skills import SkillSpec