foxclaw 0.1.2 → 0.1.3

package/python/tests/test_attachments.py

@@ -7,7 +7,6 @@ import os, sys, tempfile, shutil
 from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-# ── 环境隔离:必须在 import foxclaw 之前(import 会读这些键初始化) ─────────────
 for _k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY",
            "GOOGLE_API_KEY", "DASHSCOPE_API_KEY", "FOXCLAW_API_KEY"):
     os.environ.pop(_k, None)
@@ -15,10 +14,10 @@ os.environ["HKC_EMBEDDING"] = "stub"
 os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
 os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_att_")
 os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
-os.environ["FOXCLAW_PROVIDER"] = ""      # 不指定 provider → 无 key 时降级 stub(确定性)
+os.environ["FOXCLAW_PROVIDER"] = ""
 os.environ["FOXCLAW_MODEL"] = ""
 os.environ["FOXCLAW_MCP_SERVER"] = "0"
-os.environ["HF_HUB_OFFLINE"] = "1"      # 离线:HMR embedding 读本地缓存,不联网
+os.environ["HF_HUB_OFFLINE"] = "1"
 os.environ["TRANSFORMERS_OFFLINE"] = "1"
 
 import pytest
@@ -40,31 +39,25 @@ def store():
 
 
 def test_sanitize_attachments():
-    # 数量上限
     many = [{"name": f"f{i}.txt", "text": "t"} for i in range(_MAX_ATTACHMENTS + 4)]
     assert len(_sanitize_attachments(many)) == _MAX_ATTACHMENTS
 
-    # 单文件正文截断到上限
     one = _sanitize_attachments([{"name": "a.txt", "text": "x" * (_ATTACH_TEXT_MAX + 100)}])
     assert len(one[0]["text"]) == _ATTACH_TEXT_MAX
 
-    # name 截断到 200
     assert _sanitize_attachments([{"name": "a" * 300, "text": "x"}])[0]["name"] == "a" * 200
 
-    # 累计正文封顶:单文件先截到 20000,4×20000 累计 60000 封顶 → 第 4 个正文被清空(名字仍在)
     big = "x" * (_ATTACH_TEXT_MAX + 1000)
     four = _sanitize_attachments([{"name": f"f{i}.txt", "text": big} for i in range(4)])
     assert len(four) == 4
     assert sum(len(a["text"]) for a in four) == _ATTACH_TEXT_TOTAL
     assert four[3]["text"] == ""
 
-    # 非列表 / 非 dict / 空 name+空 text → 全部剔除
     assert _sanitize_attachments("notalist") == []
     assert _sanitize_attachments([1, "x"]) == []
     assert _sanitize_attachments([{"name": "", "text": ""}]) == []
     assert _sanitize_attachments(None) == []
 
-    # 字段类型清洗:size 非数字 → 0;mime/url 转 str
     out = _sanitize_attachments([{"name": "a", "size": "big", "mime": None, "url": None, "text": "t"}])
     assert out[0]["size"] == 0 and out[0]["mime"] == "" and out[0]["url"] == ""
     print("护栏(数量/单文件/累计/类型清洗/边界)OK")
@@ -78,10 +71,10 @@ def test_attachments_context():
     ctx = CognitiveAgent._attachments_context(atts)
     assert "【附件「a.txt」内容如下】" in ctx and "hello world" in ctx
     assert "【附件「b.txt」" not in ctx
-    assert "b.pdf" in ctx and "无法提取" in ctx   # 非文本降级为「文件名 + 元数据」提示
+    assert "b.pdf" in ctx and "无法提取" in ctx
     assert CognitiveAgent._attachments_context([]) == ""
     assert CognitiveAgent._attachments_context(None) == ""
-    assert CognitiveAgent._attachments_context([1, "x"]) == ""   # 非 dict 全跳过
+    assert CognitiveAgent._attachments_context([1, "x"]) == ""
     print("LLM 上下文注入(正文/降级/空)OK")
 
 
@@ -98,7 +91,6 @@ def test_sessions_append_attachments(store):
     assert len(m["attachments"]) == 2
     assert m["attachments"][0] == {"name": "a.txt", "size": 11, "mime": "text/plain", "url": "/api/attachments/abc"}
     assert "text" not in m["attachments"][0], "text 不得落盘(会话文件不膨胀)"
-    # 不带附件 → 无 attachments 字段(向后兼容)
     assert store.append(s["id"], "assistant", "好")
     assert "attachments" not in store.get(s["id"])["messages"][1]
     print("会话落盘(轻字段/不存 text/向后兼容)OK")
@@ -106,42 +98,35 @@ def test_sessions_append_attachments(store):
 
 def test_upload_and_download():
     with TestClient(app) as c:
-        # 上传文本文件 → 提取正文
         r = c.post("/api/upload", files={"file": ("笔记.txt", "今天学了三件事".encode(), "text/plain")})
         assert r.status_code == 200, r.text
         a = r.json()
         assert a["name"] == "笔记.txt" and a["text"] == "今天学了三件事"
         assert a["url"].startswith("/api/attachments/") and a["id"] and a["size"] > 0
 
-        # 下载 → 同一内容
         r2 = c.get(a["url"])
         assert r2.status_code == 200
         assert r2.content.decode("utf-8") == "今天学了三件事"
 
-        # 二进制(不可提取)→ text 为空,降级
         r3 = c.post("/api/upload", files={"file": ("img.bin", b"\x00\x01\x02", "application/octet-stream")})
         assert r3.status_code == 200 and r3.json()["text"] == ""
 
-        # 空文件 → 400;超大 → 413
         assert c.post("/api/upload", files={"file": ("e.txt", b"", "text/plain")}).status_code == 400
         big = b"x" * (21 * 1024 * 1024)
         assert c.post("/api/upload", files={"file": ("big.txt", big, "text/plain")}).status_code == 413
 
-        # 路径穿越:HTTP 层规范化后到不了附件路由(404);非法 id 字符 → 400;合法但不存在 → 404
-        assert c.get("/api/attachments/../../etc/passwd").status_code == 404  # .. 被 URL 规范化,不匹配路由
-        assert c.get("/api/attachments/a.b").status_code == 400               # . 不在 id 白名单 [_A-Za-z0-9_-]
-        assert c.get("/api/attachments/deadbeef0000").status_code == 404      # 合法 id 但文件不存在
+        assert c.get("/api/attachments/../../etc/passwd").status_code == 404
+        assert c.get("/api/attachments/a.b").status_code == 400
+        assert c.get("/api/attachments/deadbeef0000").status_code == 404
     print("上传/下载(正文提取/二进制降级/空/超大/穿越/404)OK")
 
 
 def test_chat_stream_with_attachments():
     import foxclaw.api as _api
     with TestClient(app) as c:
-        # 先上传一个带正文的附件,拿到引用
         up = c.post("/api/upload", files={"file": ("要点.txt", "预算 100 万".encode(), "text/plain")})
         att = up.json()
-        # 会话须先存在,append 才会落盘(前端 ensureSession 同款:POST /api/sessions → 拿 id)
-        sid = _api._os_instance.sessions.create()["id"]
+        sid = _api.os_instance().sessions.create()["id"]
         payload = {
             "task": "帮我总结要点",
             "agent_id": "supervisor",
@@ -153,8 +138,7 @@ def test_chat_stream_with_attachments():
         assert r.status_code == 200, r.text[:200]
         assert "data:" in r.text and '"error"' not in r.text, r.text[:300]
 
-        # 会话已落盘用户消息 + 附件元数据(不含 text)
-        d = _api._os_instance.sessions.get(sid)
+        d = _api.os_instance().sessions.get(sid)
         assert d is not None, "会话未落盘"
         um = d["messages"][0]
         assert um["role"] == "user" and um["content"] == "帮我总结要点"

package/python/tests/test_audit_chain.py

@@ -24,8 +24,6 @@ def _write_chain(path: Path, records) -> None:
     path.write_text("\n".join(lines) + "\n", encoding="utf-8")
 
 
-# ── 链 ─────────────────────────────────────────────────────────────
-
 def test_chain_passes(tmp_path):
     from foxclaw.core import audit_chain
 
@@ -42,7 +40,7 @@ def test_tampered_line_detected(tmp_path):
     _write_chain(p, [{"verdict": "deny"}, {"verdict": "allow"}])
     lines = p.read_text(encoding="utf-8").splitlines()
     rec = json.loads(lines[0])
-    rec["verdict"] = "allow"                     # 把一次拒绝抹成放行
+    rec["verdict"] = "allow"
     lines[0] = json.dumps(rec, ensure_ascii=False)
     p.write_text("\n".join(lines) + "\n", encoding="utf-8")
 
@@ -69,7 +67,7 @@ def test_resume_after_restart(tmp_path):
     p = tmp_path / "governance.jsonl"
     GovernanceAuditor(sink_path=p).record(
         layer="skill", actor="office", action="write_note", verdict="success")
-    aud = GovernanceAuditor(sink_path=p)          # 模拟重启
+    aud = GovernanceAuditor(sink_path=p)
     aud.record(layer="skill", actor="office", action="write_note", verdict="success")
 
     ok, n, msg = aud.verify()
@@ -96,8 +94,6 @@ def test_tail_hash_ignores_torn_line(tmp_path):
     assert audit_chain.tail_hash(p) == "h1"
 
 
-# ── recovery 脱敏 ──────────────────────────────────────────────────
-
 def test_recovery_step_args_and_result_redacted():
     from types import SimpleNamespace
 
@@ -117,5 +113,4 @@ def test_recovery_step_args_and_result_redacted():
 
     assert "sk-" not in json.dumps(got["args"]), got["args"]
     assert "[已脱敏]" in got["result"], got["result"]
-    # key 必须用未脱敏的 args 算,否则同一步骤前后 key 不一致(缓存/回放对不上)
     assert got["key"] == _step_key("http", {"api_key": key})

package/python/tests/test_audit_sink.py

@@ -42,7 +42,6 @@ def test_unit():
             "reason": "office 的职责域不含 ['type:decision','finance.transfer']",
             "mode": "audit", "content_sha": "0123456789abcdef",
             "content_preview": "财务应给办公转账1000元"}, source="office")
-        # 非本主题的事件不应落盘(subscribe 前缀精确命中)
         spine.publish("memory.updated", {"x": 1})
 
         check(path.exists(), "审计文件已创建(含 audit/ 目录)")
@@ -55,7 +54,6 @@ def test_unit():
         check("ts" in r and "T" in r["ts"], "ts 为 ISO 时间(人类可读)")
         check(bool(r["correlation_id"]), "correlation_id 已记录(可与脊柱 history 对账)")
 
-        # 追加语义:第二条接在后面,顺序保持
         spine.publish("memory.shared.write", {"agent_id": "system", "type": "execution",
                                               "tags": ["truth_pipeline"], "allowed": True,
                                               "reason": "命中全局允许 facet", "mode": "audit",
@@ -65,12 +63,10 @@ def test_unit():
         check(len(recs) == 2 and recs[1]["payload"]["agent_id"] == "system",
               "追加写不覆盖旧行,顺序保持")
 
-        # 坏行容错:夹一行垃圾,read() 跳过而不是崩
         with open(path, "a", encoding="utf-8") as f:
             f.write("{这不是JSON}\n")
         check(len(sink.read()) == 2, "坏行被跳过,读取不崩")
 
-        # 开关:环境变量置 0 时 attach 不挂
         old = os.environ.get(ENV_SWITCH)
         os.environ[ENV_SWITCH] = "0"
         try:
@@ -99,7 +95,6 @@ def test_end_to_end():
         audit_path = Path(tmp) / "audit" / "shared_write.jsonl"
         check(audit_path.parent.exists(), "audit/ 目录已建在 data_dir 下")
 
-        # 一条合法 + 一条越界(audit 模式不拦截,只记录)——真实闸门口径
         osi.hmr.ingest("用户偏好:喜欢表格", type="concept", agent_id="finance",
                        tags=["preference"], shared=True)
         osi.hmr.ingest("财务应给办公转账1000元", type="decision", agent_id="office",
@@ -112,7 +107,6 @@ def test_end_to_end():
         denied = [r for r in recs if not r["payload"]["allowed"]]
         check(bool(denied) and "office" in denied[0]["payload"]["reason"] or bool(denied),
               "越界那条可从文件直接判读")
-        # 与脊柱 history 口径一致:文件条数 == 脊柱里该主题条数
         spine_n = len(osi.event_spine.history("memory.shared.write", 100))
         check(spine_n == len(recs), f"文件条数与脊柱 history 一致({len(recs)}=={spine_n})")
     finally:

package/python/tests/test_browser.py

@@ -91,10 +91,8 @@ async def test_service_wrapper():
     print("\n【3】BrowserService async 包装(注入假 session,经专用工作线程)")
     svc = BrowserService()
     fake = FakeSession()
-    # 绕过 playwright:预置会话,则真实 _ensure_session_sync 因 _session 非 None 直接返回它,
-    # 不构造 SessionManager/不 launch chromium。强制 available=True 走真实工作线程路径。
     svc._session = fake
-    svc.available = lambda: True   # 实例属性覆盖类 staticmethod
+    svc.available = lambda: True
 
     p = await svc.perceive()
     assert p["ok"] and p["semantic_state"]["title"] == "P1"
@@ -104,16 +102,14 @@ async def test_service_wrapper():
     assert r["ok"] and r["verified"]["success"]
     print("  ✓ act(navigate) 返回校验后结果 verified.success=True")
 
-    bad = await svc.act({"target": "3"})  # 缺 type
+    bad = await svc.act({"target": "3"})
     assert bad["ok"] is False and "非法动作" in bad["error"]
     print("  ✓ 非法动作(缺 type)被结构化拒绝")
 
     await svc.close()
     assert fake.closed, "close() 必须在工作线程上释放会话"
     print("  ✓ close() 释放了会话")
-    # 幂等:再次 close 不报错
     await svc.close()
-    # 关停后调用被拒(executor 已关)
     after_close = await svc.perceive()
     assert after_close["ok"] is False
     print("  ✓ close() 幂等 + 关停后调用被安全拒绝")

package/python/tests/test_browser_request_guard.py

@@ -10,8 +10,6 @@ from foxclaw.browser.action import url_policy
 from foxclaw.browser.driver.playwright_driver import PlaywrightDriver
 
 
-# ── 判定层 ────────────────────────────────────────────────────
-
 @pytest.mark.parametrize("url", [
     "data:image/png;base64,iVBORw0KGgo=",
     "blob:https://example.com/2f8c-4a",
@@ -112,8 +110,6 @@ def test_short_ipv6_with_scope_is_not_mistaken(monkeypatch):
     url_policy._resolve_cache.clear()
 
 
-# ── 路由回调 ──────────────────────────────────────────────────
-
 class _FakeRoute:
     def __init__(self, url):
         self.request = type("Req", (), {"url": url})()

package/python/tests/test_capabilities.py

@@ -43,10 +43,8 @@ def test_cycles_broken_structural():
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        # 环1:Agent 不再直接持 search_runtime
         assert not hasattr(os_.finance, "_search_runtime"), "Agent 不应有 _search_runtime 直接引用"
         assert os_.finance._caps is os_.capabilities, "Agent 改持能力中枢"
-        # 环2:Orchestrator 不再把 agents 存为实例字段(改为经中枢解析的 property)
         assert "agents" not in os_.orchestrator.__dict__, "orchestrator 不应把 agents 存为实例字段"
         assert os_.orchestrator._caps is os_.capabilities
         assert os_.orchestrator.agents is os_._agents, "orchestrator.agents 经中枢解析"
@@ -63,17 +61,14 @@ def test_behavior_preserved():
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        # 跨 Agent 编排(orchestrator 经中枢解析 finance)
         r = os_.supervisor.cross_request(
             from_agent="admin", to_agent="finance", request_type="budget_request",
             payload={"amount": 150, "category": "travel", "entity": "高铁", "account": "default"},
             reason="出差")
         assert r["status"] in ("approved", "confirm_required", "rejected"), f"裁决异常 {r}"
         print(f"  ✓ cross_request 经中枢解析 agents → 状态 {r['status']}")
-        # Agent 反向调用内部搜索(经中枢解析 search_runtime)
         res = os_.finance.search_internal("测试查询")
         assert res is not None, "search_internal 应经中枢解析到 search_runtime"
-        # 中枢缓存:两次解析同一实例
         assert os_.capabilities.get("search_runtime") is os_.search_runtime
         print("  ✓ search_internal 经中枢解析 search_runtime(缓存一致)")
         asyncio.run(os_.aclose())
@@ -101,7 +96,6 @@ def test_lazy_build_once_concurrent():
     for t in ts: t.join()
     assert calls["n"] == 1, f"并发下惰性应只构造 1 次,实得 {calls['n']}"
     assert len({id(r) for r in results}) == 1, "12 线程应拿到同一实例"
-    # 不同能力不互相阻塞(构造锁 per-name;此处只验证正确性:各自构造一次)
     reg.register_lazy("y", lambda: object())
     assert reg.get("y") is reg.get("y")
     print("  ✓ 12 线程并发 get 同一惰性 → 只构造 1 次、同一实例;不同能力独立")

package/python/tests/test_channel_signing.py

@@ -23,8 +23,6 @@ def _headers(secret: str = SECRET, body: bytes = b'{"a":1}', ts: float = 1_700_0
     return signer.headers(body, nonce="n0nce", now=ts)
 
 
-# ── canonical / 签名 ────────────────────────────────────────
-
 def test_canonical_format_is_locked() -> None:
     """canonical 是两端的协议:字段顺序/分隔符一改,对方全部验签失败。"""
     line = S.canonical("1700000000", "abc", b"body").decode()
@@ -63,7 +61,6 @@ def test_replay_guard_rejects_second_use() -> None:
     guard = S.ReplayGuard(ttl=300)
     assert S.verify(h, body, SECRET, replay=guard, now=1_700_000_000) == (True, "ok")
     assert S.verify(h, body, SECRET, replay=guard, now=1_700_000_000) == (False, "replay")
-    # 换一个 nonce(正常新请求)→ 通过
     h2 = S.OutboundSigner(SECRET).headers(body, nonce="other", now=1_700_000_000)
     assert S.verify(h2, body, SECRET, replay=guard, now=1_700_000_000) == (True, "ok")
 
@@ -82,12 +79,10 @@ def test_verify_reason_codes() -> None:
 
 def test_header_lookup_is_case_insensitive() -> None:
     body = b"{}"
-    h = {k.lower(): v for k, v in _headers(body=body).items()}   # ASGI 常给小写
+    h = {k.lower(): v for k, v in _headers(body=body).items()}
     assert S.verify(h, body, SECRET, now=1_700_000_000) == (True, "ok")
 
 
-# ── signer ─────────────────────────────────────────────────
-
 def test_signer_optional_key_id_and_disabled_state() -> None:
     h = S.OutboundSigner(SECRET, key_id="k9").headers(b"{}")
     assert h[S.KEY_ID_HEADER] == "k9"
@@ -105,8 +100,6 @@ def test_from_env_opt_in() -> None:
     assert S.from_env({S.ENV_SECRET: "   "}) is None
 
 
-# ── 桥接层 ─────────────────────────────────────────────────
-
 class _Resp:
     status_code = 200
     text = ""
@@ -155,7 +148,7 @@ def test_bridge_signs_the_bytes_it_sends(fake_http) -> None:
     assert isinstance(body, bytes) and json.loads(body)["text"] == "hi"
     assert cap["headers"]["Content-Type"] == "application/json"
     assert cap["headers"]["Authorization"] == "Bearer t"
-    ok, why = S.verify(cap["headers"], body, SECRET)      # 网关侧照此验签
+    ok, why = S.verify(cap["headers"], body, SECRET)
     assert (ok, why) == (True, "ok")
 
 

package/python/tests/test_channels.py

@@ -23,7 +23,6 @@ def check(cond, msg):
 def test_abstraction():
     print("\n【1】渠道抽象层")
     from foxclaw.channels import ChannelAdapter, InboundMessage, SendResult, ChannelRegistry, OutboundMessage
-    # handle_raw 异常隔离:on_message 抛异常不冒泡
     class A(ChannelAdapter):
         CHANNEL = "t"
         def normalize(self, raw):
@@ -38,7 +37,6 @@ def test_abstraction():
     for txt in ["a", "bad", "c"]:
         ad.handle_raw({"text": txt})
     check(processed == ["a", "c"], "handle_raw 异常隔离(单条失败不影响其他)")
-    # 注册表
     reg = ChannelRegistry(); reg.register(ad)
     check(reg.get("t") is ad, "渠道注册表")
     check(not reg.send("nope", OutboundMessage("c", "x")).ok, "未注册渠道发送失败")
@@ -69,14 +67,12 @@ def test_weixin():
     check(h["Authorization"].startswith("Bearer "), "Bearer token")
     check(int(base64.b64decode(h["X-WECHAT-UIN"]).decode()) >= 0, "X-WECHAT-UIN 格式")
     check(wx._build_client_version("2.4.3") == 132099, "ClientVersion 计算")
-    # 标准化 + context_token 记忆
     msg = {"message_id": 1, "from_user_id": "u1", "session_id": "s",
            "message_type": MSG_FROM_USER, "context_token": "ctx1",
            "item_list": [{"type": ITEM_TEXT, "text_item": {"text": "你好"}}]}
     inb = wx._normalize_msg(msg)
     check(inb.text == "你好", "消息标准化")
     check(wx._context_tokens.get("u1") == "ctx1", "记住 context_token")
-    # bot 回显忽略
     check(wx._normalize_msg({"message_type": 2, "item_list": []}) is None, "bot 回显忽略")
 
 
@@ -84,10 +80,8 @@ def test_feishu():
     print("\n【4】飞书")
     from foxclaw.channels.feishu import FeishuAdapter
     fs = FeishuAdapter(app_id="x", app_secret="y", encrypt_key="my_secret_key_123")
-    # URL 验证
     r = fs.handle_event({"type": "url_verification", "challenge": "c1"})
     check(r.get("challenge") == "c1", "URL 验证 challenge")
-    # 加密解密端到端
     def encrypt(plaintext, key_str):
         from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
         key = hashlib.sha256(key_str.encode()).digest()
@@ -100,10 +94,8 @@ def test_feishu():
     original = {"type": "event", "x": "测试"}
     dec = fs.decrypt_event(encrypt(json.dumps(original), "my_secret_key_123"))
     check(dec == original, "AES 加密解密端到端")
-    # 错误密钥明确报错
     fs2 = FeishuAdapter(app_id="x", app_secret="y", encrypt_key="wrong")
     check(fs2.decrypt_event(encrypt(json.dumps(original), "my_secret_key_123")) is None, "错误密钥解密失败")
-    # 消息标准化
     event = {"header": {"event_type": "im.message.receive_v1"},
              "event": {"message": {"message_id": "om1", "chat_id": "oc1", "chat_type": "p2p",
                                    "content": json.dumps({"text": "查日程"}), "create_time": "1718900000000"},
@@ -141,7 +133,7 @@ def test_closed_loop():
 
     import tempfile, shutil
     data_dir = tempfile.mkdtemp(prefix="foxclaw_ch_test_")
-    shutil.rmtree(data_dir, ignore_errors=True)   # 确保干净起步(防残留幂等记录污染)
+    shutil.rmtree(data_dir, ignore_errors=True)
     os_ = Foxclaw(data_dir=data_dir, shadow_rounds=50)
     disp = ChannelDispatcher(os_.supervisor)
     mock = Mock(); disp.register_channel(mock)
@@ -151,12 +143,10 @@ def test_closed_loop():
                              sender_id="u1", conversation_id="c1")
         r1 = await disp.handle(msg)
         check(r1["replied"], "闭环:收→主管→回")
-        # 幂等:同消息重发只处理一次
         r2 = await disp.handle(msg)
         check(r2.get("idempotent_skip"), "重发消息被幂等跳过")
         check(len(mock.sent) == 1, "重发只回复一次")
     asyncio.run(go())
-    # 清理
     import shutil
     shutil.rmtree(data_dir, ignore_errors=True)
 

package/python/tests/test_config_layering.py

@@ -9,7 +9,6 @@ def test_config_layering():
 
     from foxclaw.core.config import LayeredConfig, load_policy_layer
 
-    # 1) LayeredConfig:标量高层覆盖;集合三层并集(只增不减);policy_locked
     cfg = LayeredConfig(policy={"model": "P", "deny": ["a"]},
                         user={"model": "U", "deny": ["b"]},
                         runtime={"model": "R", "deny": ["c"], "x": 1})
@@ -19,7 +18,6 @@ def test_config_layering():
     assert cfg.policy_locked("deny") == {"a"}, "policy 层锁定项"
     print("[1] LayeredConfig 标量覆盖 + 集合并集 + policy_locked OK")
 
-    # 2) load_policy_layer:env + policy.json 合并;默认空
     d = tempfile.mkdtemp(prefix="e1_")
     try:
         os.environ["FOXCLAW_POLICY_DENY"] = "gmail_send, danger_tool"
@@ -28,7 +26,6 @@ def test_config_layering():
         assert set(pl["deny"]) == {"gmail_send", "danger_tool", "file_delete"}, pl
         print(f"[2] load_policy_layer(env + policy.json) = {pl['deny']} OK")
 
-        # 3) SkillPolicy:policy 层 deny 生效 + undeny 撤不掉 + 从盘 user deny 生效(引用未断) + user 可撤
         (Path(d) / "skill_policy.json").write_text(
             json.dumps({"deny": ["user_denied"], "allow": []}), encoding="utf-8")
         from foxclaw.skills.policy import SkillPolicy
@@ -45,7 +42,6 @@ def test_config_layering():
         os.environ.pop("FOXCLAW_POLICY_DENY", None)
         shutil.rmtree(d, ignore_errors=True)
 
-    # 4) behavior-preserving:无 policy 层(无 env、无 policy.json)→ SkillPolicy 行为 = 现状
     d2 = tempfile.mkdtemp(prefix="e1b_")
     try:
         from foxclaw.skills.policy import SkillPolicy

package/python/tests/test_confirm_nonce.py

@@ -25,15 +25,12 @@ from foxclaw.skills import pipeline as sk_pipeline
 SESSION = "sess-1"
 
 
-# ── broker 单元 ────────────────────────────────────────────
-
 def test_issue_consume_single_use() -> None:
     b = ConfirmationBroker(ttl=300, clock=lambda: 1000.0)
     ch = b.issue(SESSION, "skill:mail_send", {"to": "a@x"})
     assert ch["nonce"] and ch["expires_at"] == 1300.0
     assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "a@x"},
                      now=1000.0) == (True, "ok")
-    # 第二次:已消费 → 拒绝(单次使用)
     assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "a@x"},
                      now=1000.0) == (False, "unknown_nonce")
 
@@ -48,12 +45,10 @@ def test_expired_nonce_rejected() -> None:
 def test_args_and_action_drift_rejected() -> None:
     b = ConfirmationBroker(clock=lambda: 1000.0)
     ch = b.issue(SESSION, "skill:mail_send", {"to": "a@x"})
-    # 确认"发给 A"却执行"发给 B" → 指纹不匹配
     assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "b@x"},
                      now=1000.0) == (False, "args_mismatch")
     assert b.consume(SESSION, ch["nonce"], "skill:pay", {"to": "a@x"},
                      now=1000.0) == (False, "action_mismatch")
-    # 原动作原参数仍可用(前两次失败没有消费掉它)
     assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "a@x"},
                      now=1000.0) == (True, "ok")
 
@@ -83,8 +78,6 @@ def test_pending_is_bounded() -> None:
     assert b.pending("nobody") == []
 
 
-# ── adapter 集成 ───────────────────────────────────────────
-
 class _Calls:
     def __init__(self):
         self.n = 0
@@ -118,7 +111,6 @@ def test_send_requires_nonce_even_when_confirmed():
         assert first.confirm_nonce and first.confirm_expires_at > 0
         assert calls.n == 0
 
-        # 只有 confirmed=True 没有确认码 → 不放行(退回待确认,换发新码)
         no_nonce = adapter.invoke(skill, args, confirmed=True)
         assert no_nonce.status == "needs_confirmation" and calls.n == 0
         assert "missing_nonce" in no_nonce.message
@@ -128,7 +120,6 @@ def test_send_requires_nonce_even_when_confirmed():
                             confirm_nonce=no_nonce.confirm_nonce)
         assert ok.success and calls.n == 1
 
-        # 重放同一个码 → 拒绝,不执行
         replay = adapter.invoke(skill, args, confirmed=True,
                                 confirm_nonce=no_nonce.confirm_nonce)
         assert replay.status == "needs_confirmation" and calls.n == 1
@@ -156,13 +147,11 @@ def test_read_skill_and_no_broker_unaffected():
     adapter, reg, calls = _build(ConfirmationBroker())
     assert adapter.invoke(reg.get("calc"), {}, confirmed=True).success
 
-    plain = SkillAdapter(reg)                      # 未注入 broker → 旧语义
+    plain = SkillAdapter(reg)
     assert plain.invoke(reg.get("mail_send"), {"to": "a@x"}, confirmed=True).success
     assert calls.n >= 1
 
 
-# ── pipeline 兼容 ──────────────────────────────────────────
-
 def test_pipeline_invoke_tolerates_old_adapter():
     """测试/第三方 adapter 只实现 4 参 invoke 时自动降级(签名探测,不吞内部 TypeError)。"""
     seen = {}

package/python/tests/test_context_compaction_wiring.py

@@ -26,8 +26,6 @@ def _long_history(n: int = 12, chars: int = 400) -> list:
             for i in range(n)]
 
 
-# ── 1. Compactor.maybe_compact 契约 ─────────────────────────────
-
 def test_maybe_compact_noop_when_under_budget() -> None:
     msgs = [{"role": "user", "content": "短问题"}]
     out, res = Compactor(router=None, max_tokens=6000).maybe_compact(msgs)
@@ -57,8 +55,6 @@ def test_maybe_compact_never_raises_on_garbage() -> None:
     assert isinstance(out, list)
 
 
-# ── 2. CognitiveAgent._compact_context 接入层 ────────────────────────
-
 def _stub_agent(thoughts: list) -> SimpleNamespace:
     return SimpleNamespace(router=None,
                            _think=lambda **kw: thoughts.append(kw.get("content", "")))
@@ -84,10 +80,8 @@ def test_compact_context_swallows_errors(monkeypatch) -> None:
     monkeypatch.setenv("FOXCLAW_CONTEXT_MAX_TOKENS", "100")
     msgs = _long_history()
     out = CognitiveAgent._compact_context(SimpleNamespace(router=None), msgs, "chat")
-    assert isinstance(out, list)          # _think 缺失 → 内部异常被吞,不影响主流程
-
+    assert isinstance(out, list)
 
-# ── 3. 工具调用循环里确实过闸 ───────────────────────────────────
 
 class _NoToolRouter:
     """supports_tools=True 但模型直接给答案:只跑一轮,便于断言压缩闸被调用。"""

package/python/tests/test_dispatch.py

@@ -27,12 +27,10 @@ async def main():
     print("=" * 60)
     os_ = Foxclaw(data_dir=tempfile.mkdtemp(prefix="foxclaw_dispatch_"), shadow_rounds=20)
 
-    # 1. 主管调度不同类型任务,验证路由
     print("\n【1】主管真实调度(关键词路由)")
     routing_cases = [
         ("分析本月家庭支出预算", "finance"),
         ("学习一篇关于 RAG 的论文", "office"),
-        # 行政并入办公(日程/会议走 office);"整理邮件"不再有助手 Agent,归办公
         ("安排周三下午的项目会议", "office"),
         ("帮我整理今天的邮件要点", "office"),
     ]
@@ -46,19 +44,16 @@ async def main():
         print(f"  {'✓' if ok else '✗'} 「{task[:18]}」→ {dispatched} (预期 {expected})")
     check(not bad_routes, f"关键词路由 4/4 命中(失配: {bad_routes or '无'})")
 
-    # 2. 结果汇聚
     print("\n【2】结果汇聚")
     r = await os_.supervisor.run_task("评估我的投资组合风险")
     res = r.get("result", {})
     print(f"  派给: {res.get('dispatched_to')}")
     print(f"  汇聚: {str(res.get('sub_result'))[:50]}...")
     print(f"  主管摘要: {res.get('summary', '')}")
-    # 主管必须真的派出去并拿回子结果,而不是空转返回一句套话
     check(res.get("dispatched_to") == "finance",
           f"投资组合风险任务派给 finance(实为 {res.get('dispatched_to')})")
     check(bool(str(res.get("sub_result") or "").strip()), "子 Agent 结果已汇聚回主管(非空)")
 
-    # 3. 共享记忆:其他 Agent 能召回主管的调度记录
     print("\n【3】共享记忆层(所有 Agent 可见)")
     empty_shared = []
     for viewer in ["office", "finance", "supervisor"]:
@@ -69,7 +64,6 @@ async def main():
         print(f"  {viewer:<10} 召回共享调度记录: {len(shared_hits)} 条")
     check(not empty_shared, f"三个 Agent 都能召回共享调度记录(召回为空: {empty_shared or '无'})")
 
-    # 4. 隔离仍成立:私有记忆不跨 Agent
     print("\n【4】私有记忆隔离(共享层不打破隔离)")
     await os_.finance.run_task("记录我的私人理财偏好")
     office_view = os_.hmr.recall(query="理财 偏好", agent_id="office", top_k=10)