foxclaw 0.1.2 → 0.1.4

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_behavior_spec.py

@@ -0,0 +1,198 @@
+"""
+行为规范(Behavior Spec)测试 —— 全离线。
+
+覆盖:
+  1. 内置 behavior.yaml 可加载,id 唯一,每个 code_check 都解析到真实可调用对象。
+  2. 检查点不是装饰:policy_gate.check_action / confirms.consume / verify.verify 在业务代码里真有调用。
+  3. prompt 注入:行为规范在最前段(Markdown 内核之前、persona 之前),带 spec_version,可整体关闭。
+  4. 本地覆盖:可新增 / 可收紧;放宽或省略删除严格层规则 → BehaviorLoadError。
+  5. 本地覆盖的语法错、版本过期 → 降级为 warning 并忽略,不把应用锁死(内置文件的问题仍然硬失败)。
+"""
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+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.agents.mixins.prompt import PromptMixin
+from foxclaw.behavior import BehaviorLoadError, load, local_path, prompt_block
+
+ROOT = Path(__file__).parent.parent
+
+BASE_YAML = """
+version: 1
+spec_id: test-behavior
+prohibitions:
+  - id: no_x
+    rule: 不做 X
+    enforce: both
+    code_check: "foxclaw.core.verify:verify"
+confirmations:
+  - id: confirm_y
+    rule: 做 Y 前先确认
+    enforce: prompt
+uncertainty:
+  - id: zzz
+    rule: 不确定就问
+    enforce: prompt
+"""
+
+
+def _write(tmp_path, name, text):
+    p = tmp_path / name
+    p.write_text(text, encoding="utf-8")
+    return p
+
+
+def _loaded(tmp_path, local_text):
+    return load(_write(tmp_path, "behavior.yaml", BASE_YAML),
+                _write(tmp_path, "behavior.local.yaml", local_text))
+
+
+def test_builtin_spec_loads_with_unique_ids():
+    spec = load()
+    ids = [r.id for r in spec.rules]
+    assert len(ids) == len(set(ids))
+    assert spec.version == 1 and spec.spec_version
+    assert {"confirm_side_effect", "no_silent_failure"} <= set(ids)
+
+
+def test_every_code_check_resolves_to_callable():
+    spec = load()
+    checks = spec.checkpoints()
+    assert checks, "内置规范至少要登记一个真实检查点"
+    assert all(callable(fn) for fn in checks.values())
+
+
+def test_checkpoints_are_really_wired_in_business_code():
+    """反漂移:登记了检查点,业务代码里就必须真有调用,否则清单会退化成装饰。"""
+    blob = "\n".join(p.read_text(encoding="utf-8")
+                     for p in (ROOT / "foxclaw").rglob("*.py")
+                     if p.parts[len(ROOT.parts)] != "behavior")
+    assert "policy_gate.check_action(" in blob
+    assert "confirms.consume(" in blob
+    assert "verify.verify(" in blob
+
+
+def test_prompt_block_leads_with_spec_and_version():
+    spec = load()
+    block = prompt_block(spec)
+    assert block.startswith("[行为规范")
+    assert spec.spec_version in block
+    for rule in spec.injectable():
+        assert f"[{rule.id}]" in block
+    assert "不可协商" in block
+
+
+def test_behavior_precedes_kernel_and_role():
+    import types
+    fake = types.SimpleNamespace(_role_prompt="我是角色ROLEXYZ。", AGENT_ID="finance")
+    out = PromptMixin.system_prompt.fget(fake)
+    assert out.index("[行为规范") < out.index("认知操作系统") < out.index("ROLEXYZ")
+
+
+def test_switch_disables_behavior_block(monkeypatch):
+    monkeypatch.setenv("FOXCLAW_BEHAVIOR", "0")
+    assert prompt_block() == ""
+
+
+def test_local_can_add_and_tighten(tmp_path):
+    spec = _loaded(tmp_path, """
+version: 1
+confirmations:
+  - id: confirm_y
+    rule: 做 Y 前先确认(收紧)
+    enforce: both
+    code_check: "foxclaw.core.verify:verify"
+uncertainty:
+  - id: new_rule
+    rule: 新加的更严规则
+    enforce: prompt
+""")
+    assert spec.by_id("confirm_y").enforce == "both"
+    assert spec.by_id("new_rule") is not None
+    assert spec.by_id("no_x").enforce == "both"  # 未提及的保持不变
+
+
+def test_local_cannot_weaken_enforce(tmp_path):
+    with pytest.raises(BehaviorLoadError, match="不能放宽"):
+        _loaded(tmp_path, """
+prohibitions:
+  - id: no_x
+    rule: 不做 X
+    enforce: prompt
+""")
+
+
+def test_local_cannot_drop_strict_layer_rule(tmp_path):
+    with pytest.raises(BehaviorLoadError, match="不能通过省略删除"):
+        _loaded(tmp_path, "confirmations: []\n")
+
+
+def test_local_syntax_error_is_warning_not_fatal(tmp_path):
+    spec = _loaded(tmp_path, "prohibitions: [oops\n")
+    assert spec.warnings and "已忽略" in spec.warnings[0]
+    assert spec.by_id("no_x") is not None
+
+
+def test_local_stale_version_is_ignored(tmp_path):
+    spec = _loaded(tmp_path, "version: 99\nuncertainty: []\n")
+    assert any("已过期" in w for w in spec.warnings)
+    assert spec.by_id("zzz") is not None
+
+
+def test_builtin_version_mismatch_is_fatal(tmp_path):
+    p = _write(tmp_path, "behavior.yaml", "version: 99\nprohibitions: []\n")
+    with pytest.raises(BehaviorLoadError, match="version"):
+        load(p, tmp_path / "none.yaml")
+
+
+def test_enforce_without_code_check_fails(tmp_path):
+    p = _write(tmp_path, "behavior.yaml", """
+version: 1
+prohibitions:
+  - id: no_x
+    rule: 不做 X
+    enforce: both
+""")
+    with pytest.raises(BehaviorLoadError, match="没有 code_check"):
+        load(p, tmp_path / "none.yaml")
+
+
+def test_unknown_checkpoint_fails(tmp_path):
+    p = _write(tmp_path, "behavior.yaml", """
+version: 1
+prohibitions:
+  - id: no_x
+    rule: 不做 X
+    enforce: code
+    code_check: "foxclaw.core.verify:no_such_function"
+""")
+    with pytest.raises(BehaviorLoadError, match="不存在"):
+        load(p, tmp_path / "none.yaml")
+
+
+def test_duplicate_id_fails(tmp_path):
+    p = _write(tmp_path, "behavior.yaml", """
+version: 1
+prohibitions:
+  - id: no_x
+    rule: A
+    enforce: prompt
+uncertainty:
+  - id: no_x
+    rule: B
+    enforce: prompt
+""")
+    with pytest.raises(BehaviorLoadError, match="重复"):
+        load(p, tmp_path / "none.yaml")
+
+
+def test_local_path_follows_data_dir(monkeypatch, tmp_path):
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path))
+    assert local_path() == tmp_path / "behavior.local.yaml"

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