foxclaw 0.1.2 → 0.1.4

package/python/tests/test_kernel.py

@@ -52,11 +52,9 @@ def test_process_manager():
     check(pm.get(p.process_id).state == "completed", "完整生命周期到 completed")
     check(pm.get(p.process_id).state_history == ["created", "queued", "scheduled", "running", "completed"],
           "状态历史完整")
-    # 幂等:已终态再标记不崩溃,且**不重复扣减**活跃计数
     r = pm.mark_failed(p.process_id, "二次")
     check(r is not None and r.state == "completed", "终态重复标记幂等不崩溃")
     check(pm.active_count() == 0, "终态重复标记不重复扣减活跃计数(仍为0,不为负)")
-    # 非法流转拦截
     p2 = pm.create("x", schedule={"priority": 0.1})
     p2.state = "created"
     try:
@@ -89,7 +87,6 @@ def test_truth_pipeline():
     bus = SystemBus()
     hmr = FakeHMR()
     tp = TruthPipeline(bus, hmr=hmr)
-    # 【P3-9】TruthPipeline.emit_execution 已删除:事件名即契约,直接经 bus 入队。
     bus.publish("execution.completed", {"agent_id": "finance", "task": "分析预算",
                                         "result": "预算正常", "blocked": False})
     check(tp.last_trace is not None, "执行→审计 trace 生成")
@@ -110,11 +107,9 @@ def test_cognitive_state():
     s = t.snapshot()
     check(s["active_goal"] == "分析财务", "活跃目标聚合")
     check(s["semantic_focus"] == "reasoning", "语义焦点聚合")
-    # 去重
     for _ in range(5):
         bus.publish("memory.updated", {"memory_update": {"content": "同样"}})
     check(len(t.snapshot()["activated_memories"]) == 1, "重复记忆去重")
-    # None 防护
     class M: payload = None
     t._on_exec(M())
     check(True, "None payload 不崩溃")
@@ -147,8 +142,7 @@ def test_trust_single_source():
     from foxclaw.skills import permission as perm
     from foxclaw.skills.permission import evaluate
     check(not hasattr(perm, "TRUST_LEVEL"), "permission.TRUST_LEVEL 死字典已删(不再双真源)")
-    # 3 个合法 kind × 两种 source:permission 的 downgrade 恒等于 (trust_level()=='low'),且行为不变
-    expect = {"local": False, "web_api": False, "mcp": True}   # behavior-preserving 基线
+    expect = {"local": False, "web_api": False, "mcp": True}
     for kind, want_dg in expect.items():
         for source in ("builtin", "user"):
             s = SkillSpec(id=f"s_{kind}_{source}", name="t", description="d",
@@ -174,7 +168,6 @@ def test_breaker_hooks():
     check(ad.breaker.status("flaky")["state"] == "open", "连续失败3次断路器开闸")
     r = ad.invoke(reg.get("flaky"), {})
     check(r.status == "circuit_open", "开闸后停止调用")
-    # 钩子
     log = []
     hm = HookManager()
     hm.register("pre_skill", lambda ctx: log.append("pre"))
@@ -193,13 +186,10 @@ def test_ahs_pipeline():
     reg = build_default_registry()
     ad = SkillAdapter(reg)
     pipe = AHSPipeline(reg, ad)
-    # router 否定词
     r = route("不要计算", reg)
     check(r.primary != "calculator", "否定词检测:不要计算→不选calculator")
-    # planner 拆解
     p = plan("先算 5+5 然后再算 9*9", reg)
     check(len(p.tasks) == 2, "planner 多步拆解")
-    # 端到端
     res = pipe.run("帮我算一下 12*12")
     check(res.success, "AHS 执行链端到端成功")
 

package/python/tests/test_learning.py

@@ -27,23 +27,19 @@ def main():
     print(f"\n采集 {n} 个知识点")
     check(n == 8, f"采集 8 个知识点(实为 {n})")
 
-    # 1. 间隔重复:模拟几次复习
     print("\n【固化:间隔重复】")
     ids = list(rt.items.keys())
     check(len(ids) >= 4, f"至少 4 个知识点可供复习(实为 {len(ids)})")
-    # 模拟:前两个记得好,第三个记不住
-    rt.review(ids[0], grade=5)  # 完美
+    rt.review(ids[0], grade=5)
     rt.review(ids[0], grade=4)
     rt.review(ids[1], grade=4)
-    rt.review(ids[2], grade=1)  # 没记住
-    rt.review(ids[2], grade=2)  # 又没记住
+    rt.review(ids[2], grade=1)
+    rt.review(ids[2], grade=2)
     for iid in ids[:4]:
         st = rt.review_states[iid]
         item = rt.items[iid]
         print(f"  掌握度 {st.mastery:.2f} | 间隔 {st.interval}天 | "
               f"复习{st.total_reviews}次 遗忘{st.lapses}次 | {item.content[:24]}...")
-    # SM-2 的语义后果:连续答不好应累积 lapses,且掌握度被压低。
-    # 这是"间隔重复真的在起作用"的核心断言 —— 只打印 0.60/0.11 两个数字不算验证。
     st_good, st_bad = rt.review_states[ids[0]], rt.review_states[ids[2]]
     check(st_bad.lapses == 2, f"连错两次的知识点累积 lapses=2(实为 {st_bad.lapses})")
     check(st_bad.mastery < st_good.mastery,
@@ -51,7 +47,6 @@ def main():
     check(st_good.total_reviews == 2 and st_bad.total_reviews == 2,
           "复习次数被正确累计(各 2 次)")
 
-    # 2. 知识图谱:构建连接
     print("\n【连接:知识图谱】")
     conn = rt.build_connections(semantic_threshold=0.5)
     print(f"  同主题边: {conn['topic_edges']} · 语义边: {conn['semantic_edges']}")
@@ -61,12 +56,10 @@ def main():
     print(f"  边类型: {g['edge_types']}")
     check(conn["topic_edges"] > 0, f"同主题连接已建立({conn['topic_edges']} 条)")
     check(g["items"] == n, f"图谱节点数 = 知识点数({g['items']} == {n})")
-    # 结构不变式:总边数必须等于各类边之和,否则说明有一类边被漏计/重复计
     check(g["edges"] == conn["topic_edges"] + conn["semantic_edges"],
           f"总边数 = 同主题边 + 语义边({g['edges']} == {conn['topic_edges']}+{conn['semantic_edges']})")
     check(g["clusters"] > 0, f"聚类非空({g['clusters']} 个知识簇)")
 
-    # 3. 连接发现:某知识点的关联
     print("\n【连接发现】")
     related = rt.related(ids[0])
     base = rt.items[ids[0]].content[:20]
@@ -77,7 +70,6 @@ def main():
     check(all(("edge_type" in x and "weight" in x and "item" in x) for x in related),
           "每条关联都带 edge_type / weight / item 结构")
 
-    # 4. 综合分析
     print("\n【综合分析】")
     rep = rt.analyze()
     print(f"  知识点 {rep['total_items']} · 平均掌握度 {rep['avg_mastery']}")
@@ -89,7 +81,6 @@ def main():
     check(rep["weakest_topic"] in rep["topic_mastery"],
           f"最薄弱主题来自主题掌握度表(weakest_topic={rep['weakest_topic']})")
 
-    # 5. 学习策略裁决
     print("\n【学习策略裁决】")
     for v in rep["strategy"]:
         print(f"  [{v['action']}] {v['message']}")

package/python/tests/test_llm_admin.py

@@ -11,7 +11,6 @@ import os, sys, json, tempfile
 from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-# ── 环境隔离:必须在 import foxclaw 之前 ──────────────────────────────
 for _k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY", "GOOGLE_API_KEY",
            "DASHSCOPE_API_KEY", "MINIMAX_API_KEY", "LLM_API_KEY", "FOXCLAW_API_KEY"):
     os.environ.pop(_k, None)
@@ -32,17 +31,14 @@ import foxclaw.api as _api
 from foxclaw.api.routes import llm_admin
 
 
-# ── 1. BASE URL 规范化 ───────────────────────────────────────────────
-
 @pytest.mark.parametrize("raw,expected", [
     ("https://api.deepseek.com",            "https://api.deepseek.com/v1"),
     ("https://api.deepseek.com/",           "https://api.deepseek.com/v1"),
     ("https://api.deepseek.com/v1",         "https://api.deepseek.com/v1"),
     ("https://api.deepseek.com/v1/",        "https://api.deepseek.com/v1"),
     ("  https://api.openai.com/v1  ",       "https://api.openai.com/v1"),
-    ("api.deepseek.com",                    "https://api.deepseek.com/v1"),   # 漏 scheme
+    ("api.deepseek.com",                    "https://api.deepseek.com/v1"),
     ("api.deepseek.com/v1",                 "https://api.deepseek.com/v1"),
-    # 已有非 /v1 的 path 必须原样保留(通义兼容模式 / 自建网关 /openai/v1)
     ("https://dashscope.aliyuncs.com/compatible-mode/v1",
      "https://dashscope.aliyuncs.com/compatible-mode/v1"),
     ("http://localhost:11434/v1",           "http://localhost:11434/v1"),
@@ -50,7 +46,6 @@ from foxclaw.api.routes import llm_admin
 ])
 def test_normalize_base_url(raw, expected):
     assert normalize_base_url(raw) == expected
-    # 幂等:规范化两次结果不变(前端 blur + 后端保存 + router 构造都会过一遍)
     assert normalize_base_url(expected) == expected
 
 
@@ -60,8 +55,6 @@ def test_normalize_base_url_rejects(bad):
         normalize_base_url(bad)
 
 
-# ── 2. custom 必须被当作 openai-compatible 家族成员 ──────────────────
-
 def test_custom_is_openai_family():
     assert "custom" in ModelRouter._OPENAI_FAMILY, \
         "custom 漏了会让流式退化为一次性输出、工具能力静默关闭"
@@ -71,28 +64,22 @@ def test_custom_is_openai_family():
 def test_custom_provider_supports_tools():
     r = ModelRouter(provider="stub")
     r.provider = "custom"
-    r._client = object()          # 假装已构造好(不联网)
+    r._client = object()
     assert r.supports_tools() is True
 
 
-# ── 3. stream() 必须 reload 选择(聊天主路径)─────────────────────────
-
 def test_stream_reloads_selection():
     r = ModelRouter(provider="stub")
     hits = []
-    r._maybe_reload_selection = lambda: hits.append(True)   # 不打真实文件
+    r._maybe_reload_selection = lambda: hits.append(True)
     list(r.stream("sys", [{"role": "user", "content": "hi"}]))
     assert hits, "stream() 未调用 _maybe_reload_selection → 切模型后流式对话不生效"
 
 
-# ── 4. 保存 / 切换端点 ───────────────────────────────────────────────
-
 @pytest.fixture()
 def fresh_store(monkeypatch):
     """每个用例一份干净的 custom_models.json + .current_model。"""
     d = Path(tempfile.mkdtemp(prefix="llm_admin_store_"))
-    # router 侧按 env 现算路径(_custom_models_path / _selection_path),必须一起指过来,
-    # 否则端点写 A 目录、router 读 B 目录 → 预检假失败。
     monkeypatch.setenv("FOXCLAW_DATA_DIR", str(d))
     monkeypatch.setattr(llm_admin, "CUSTOM_MODELS_PATH", d / "custom_models.json")
     monkeypatch.setattr(llm_admin, "CURRENT_MODEL_PATH", d / ".current_model")
@@ -110,7 +97,6 @@ def test_add_normalizes_base_url(fresh_store):
     saved = json.loads((fresh_store / "custom_models.json").read_text(encoding="utf-8"))
     assert saved[0]["base_url"] == "https://api.deepseek.com/v1"
 
-    # 更新时同样规范化
     import asyncio
     asyncio.run(llm_admin.update_custom_model("deepseek", llm_admin._CustomUpdateReq(
         base_url="https://api.deepseek.com")))
@@ -133,7 +119,7 @@ def test_select_custom_takes_effect_immediately(fresh_store, monkeypatch):
         pass
     fake = _FakeOS()
     fake.router = router
-    monkeypatch.setattr(_api, "_os_instance", fake, raising=False)
+    monkeypatch.setattr(_api._state, "_os_instance", fake, raising=False)
 
     import asyncio
     out = asyncio.run(llm_admin.select_model(
@@ -143,7 +129,6 @@ def test_select_custom_takes_effect_immediately(fresh_store, monkeypatch):
     assert out["runtime"]["provider"] == "custom"
     assert out["runtime"]["model"] == "deepseek-chat"
     assert router.provider == "custom" and router.model == "deepseek-chat"
-    # .current_model 落盘,重启后 lazy reload 仍能读到
     cur = json.loads((fresh_store / ".current_model").read_text(encoding="utf-8"))
     assert cur["source"] == "custom" and cur["name"] == "deepseek"
 

package/python/tests/test_llm_planner.py

@@ -83,20 +83,15 @@ def test_build_plan_tool_schema():
 
 def test_llm_plan_failsafe():
     print("\n【3】fail-safe:不支持/不产出/解析失败/空输入/抛异常 → None")
-    # 不支持 tools
     r = _FakeRouter(result={"supported": False})
     assert llm_plan(r, "任务", _catalog()) is None
-    # 模型没调用工具(空 tool_calls)
     r2 = _FakeRouter(result={"supported": True, "tool_calls": []})
     assert llm_plan(r2, "任务", _catalog()) is None
-    # args 解析失败
     r3 = _FakeRouter(result={"supported": True, "tool_calls": [
         {"id": "c1", "name": "submit_plan", "args": {}, "args_parse_failed": True}]})
     assert llm_plan(r3, "任务", _catalog()) is None
-    # 空 catalog / 空 task
     assert llm_plan(r2, "任务", {}) is None
     assert llm_plan(r2, "", _catalog()) is None
-    # call_tools 抛异常 → None(不冒泡)
 
     class _Boom:
         def call_tools(self, *a, **k):
@@ -120,13 +115,11 @@ def test_llm_plan_parse():
     assert [s["agent"] for s in out["steps"]] == ["finance", "finance", "office"]
     assert out["steps"][1]["depends_on"] == [0]
 
-    # 单步 → flow 强制 single
     r2 = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("parallel", [{"name": "查天气", "agent": "office"}])]})
     out2 = llm_plan(r2, "查天气", _catalog())
     assert out2["flow"] == "single" and len(out2["steps"]) == 1
 
-    # 非法 agent(含已下放的 assistant/admin)兜底 office
     r3 = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("single", [{"name": "x", "agent": "不存在的Agent"}])]})
     out3 = llm_plan(r3, "x", _catalog())
@@ -140,14 +133,12 @@ def test_supervisor_llm_plan():
     D = type("D", (), {"AGENT_NAME": "dummy"})
     sub = {"finance": D(), "office": D()}
 
-    # 未开启 → None
     os.environ.pop("FOXCLAW_LLM_PLAN", None)
     a1 = SupervisorAgent.__new__(SupervisorAgent)
     a1.router = _FakeRouter(result={"supported": True})
     a1._subagents = sub
     assert a1._llm_plan("任务") is None
 
-    # 开启 + 多步 → (Plan, step_routes)
     os.environ["FOXCLAW_LLM_PLAN"] = "1"
     a2 = SupervisorAgent.__new__(SupervisorAgent)
     a2.router = _FakeRouter(result={"supported": True, "tool_calls": [
@@ -161,14 +152,12 @@ def test_supervisor_llm_plan():
     assert len(plan.tasks) == 2
     assert routes == [("查支出", "finance"), ("发邮件", "office")]
 
-    # 单步 → None(交回关键词路由,不改变单步行为)
     a3 = SupervisorAgent.__new__(SupervisorAgent)
     a3.router = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("single", [{"name": "查天气", "agent": "office"}])]})
     a3._subagents = sub
     assert a3._llm_plan("查天气") is None
 
-    # 不支持 tools → None
     a4 = SupervisorAgent.__new__(SupervisorAgent)
     a4.router = _FakeRouter(is_stub=True)
     a4._subagents = sub
@@ -192,7 +181,6 @@ def test_llm_replan_parse():
     print("\n【7】llm_replan:修正计划 + 空 steps 放弃 + fail-safe")
     prior = [{"subtask": "查支出", "agent": "finance", "output": "超时", "blocked": True},
              {"subtask": "发邮件", "agent": "office", "output": "未执行", "blocked": False}]
-    # 正常:换 agent 重排失败步骤
     r = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("sequential", [
             {"name": "查支出(重试)", "agent": "finance"},
@@ -200,12 +188,10 @@ def test_llm_replan_parse():
         ])]})
     out = llm_replan(r, "查支出再发邮件", prior, _catalog())
     assert out is not None and [s["agent"] for s in out["steps"]] == ["finance", "office"]
-    # 空 steps = 模型判定放弃 → 返回 {"steps": []} 而非 None
     r2 = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("sequential", [])]})
     out2 = llm_replan(r2, "任务", prior, _catalog())
     assert out2 is not None and out2["steps"] == []
-    # fail-safe:不支持 tools → None
     r3 = _FakeRouter(result={"supported": False})
     assert llm_replan(r3, "任务", prior, _catalog()) is None
     print("  ✓ 修正计划 / 空steps放弃 / 不支持回退 正确")
@@ -214,12 +200,9 @@ def test_llm_replan_parse():
 def test_dispatch_failed():
     print("\n【8】_dispatch_failed:失败判定")
     from foxclaw.agents.agents import _dispatch_failed
-    # 多步 blocked → True
     assert _dispatch_failed({"result": {"dispatched_to": "multi", "blocked": True}}) is True
-    # parallel steps 含 failed → True
     assert _dispatch_failed({"result": {"dispatched_to": "parallel",
         "parallel_steps": [{"failed": True}]}}) is True
-    # 单 Agent / 成功 / 非 dict → False
     assert _dispatch_failed({"result": {"dispatched_to": "finance"}}) is False
     assert _dispatch_failed({"result": {"dispatched_to": "multi", "blocked": False,
         "multi_steps": [{"blocked": False}]}}) is False
@@ -235,7 +218,6 @@ def test_replan_and_redo():
     D = type("D", (), {"AGENT_NAME": "dummy"})
     sub = {"finance": D(), "office": D()}
 
-    # 反思时返回修正计划(重试失败步骤)
     router = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("sequential", [
             {"name": "查支出(重试)", "agent": "finance"},
@@ -244,7 +226,7 @@ def test_replan_and_redo():
     a = SupervisorAgent.__new__(SupervisorAgent)
     a.router = router
     a._subagents = sub
-    a._think = lambda **kw: None   # 屏蔽 thought_chain
+    a._think = lambda **kw: None
 
     calls = {"n": 0}
 
@@ -283,7 +265,6 @@ def test_replan_gives_up():
     D = type("D", (), {"AGENT_NAME": "dummy"})
     sub = {"finance": D(), "assistant": D()}
 
-    # 反思返回空 steps(放弃)
     router = _FakeRouter(result={"supported": True, "tool_calls": [
         _plan_args("sequential", [])]})
     a = SupervisorAgent.__new__(SupervisorAgent)
@@ -314,21 +295,18 @@ def test_sv_replan_stage():
     from types import SimpleNamespace
     from foxclaw.pipeline.supervisor_stages import sv_replan
 
-    # 无失败 → 短路
     a1 = SimpleNamespace(_replan_enabled=lambda: True)
     ctx1 = SimpleNamespace(extra={}, agent=a1,
                            dispatch_result={"result": {"dispatched_to": "multi", "blocked": False}})
     asyncio.run(sv_replan(ctx1))
     assert ctx1.dispatch_result["result"]["blocked"] is False
 
-    # 有失败但未开启 → 短路保留原结果
     a2 = SimpleNamespace(_replan_enabled=lambda: False)
     ctx2 = SimpleNamespace(extra={}, agent=a2,
                            dispatch_result={"result": {"dispatched_to": "multi", "blocked": True}})
     asyncio.run(sv_replan(ctx2))
     assert ctx2.dispatch_result["result"]["blocked"] is True
 
-    # 触发路径:有失败 + 开启 → 调用 _replan_and_redo 更新结果
     async def fake_replan(task, sched, session_id, subagents, context, memories, dr, max_rounds=2):
         return {"result": {"dispatched_to": "multi", "blocked": False}}
 

package/python/tests/test_markdown_skills.py

@@ -16,58 +16,47 @@ def test_markdown_skills():
     with TestClient(app) as c:
         print("=" * 60); print("工具中心 · SKILL.md 指令技能 验证"); print("=" * 60)
 
-        # 1. 缺 ack → 409
         r = c.post("/api/ahs/md-skills", json={"content": SKILL})
         assert r.status_code == 409 and r.json()["detail"]["needs_ack"] is True
         print("[1] 未确认 → 409 needs_ack OK")
 
-        # 2. ack → 200,列表出现
         r = c.post("/api/ahs/md-skills", json={"content": SKILL, "acknowledged": True})
         assert r.status_code == 200, r.text
         sid = r.json()["skill"]["id"]
         metas = c.get("/api/ahs/md-skills").json()["skills"]
         assert any(s["id"] == sid for s in metas)
-        assert all("body" not in s for s in metas)   # 列表不含 body
+        assert all("body" not in s for s in metas)
         print("[2] 上传(ack)+列表(不含body) OK")
 
-        # 3. GET/{id} 含 body
         r = c.get(f"/api/ahs/md-skills/{sid}")
         assert r.status_code == 200 and "成果" in r.json()["body"]
         print("[3] 查看含 body OK")
 
-        # 4. 缺 name → 400
         r = c.post("/api/ahs/md-skills", json={"content": "---\ndescription: x\n---\nbody", "acknowledged": True})
         assert r.status_code == 400
         print("[4] 缺 name → 400 OK")
 
-        # 5. 启停
         assert c.patch(f"/api/ahs/md-skills/{sid}", json={"enabled": False}).json()["skill"]["enabled"] is False
         assert c.patch(f"/api/ahs/md-skills/{sid}", json={"enabled": True}).status_code == 200
         print("[5] 启停 OK")
 
-    # 6. 注入:直建 OS,agent 挂了 md_skills,_skill_augment 命中注入 + 持久化
     from foxclaw import Foxclaw
     os2 = Foxclaw(data_dir=_DATA)
     assert os2.md_skills.get(sid) is not None, "重启后指令技能丢失(持久化)"
     ag = os2.supervisor
     out = ag._skill_augment("帮我写周报", [{"role": "user", "content": "帮我写周报"}])
     assert "先列本周成果" in out[-1]["content"] and "帮我写周报" in out[-1]["content"]
-    assert sum(1 for i in range(len(out) - 1) if out[i]["role"] == out[i + 1]["role"] == "user") == 0  # 无连续 user
+    assert sum(1 for i in range(len(out) - 1) if out[i]["role"] == out[i + 1]["role"] == "user") == 0
     out2 = ag._skill_augment("订机票", [{"role": "user", "content": "订机票"}])
-    assert out2[0]["content"] == "订机票"   # 不含触发词 → 原样
+    assert out2[0]["content"] == "订机票"
     print("[6] 注入命中/未命中 + 持久化 round-trip OK")
 
-    # 7. 删除
     with TestClient(app) as c:
         assert c.delete(f"/api/ahs/md-skills/{sid}").status_code == 200
         assert not any(s["id"] == sid for s in c.get("/api/ahs/md-skills").json()["skills"])
     print("[7] 删除 OK")
 
     print("\nSKILL.md 指令技能验证全部通过")
-    # 注:OpenClaw 兼容段(原 [8]-[12])已拆到 test_markdown_skills_openclaw.py。
-    # 原因:单进程内 3×TestClient lifespan + 4×Foxclaw 实例 + 两个不同 ST 模型共存时,
-    # 第三次 lifespan 预热阶段 torch/FAISS 必现 0xC0000005 进程崩溃(基线对照实锤,
-    # 与业务改动无关)。进程隔离后两段各自全绿。
 
 if __name__ == "__main__":
     test_markdown_skills()

package/python/tests/test_markdown_skills_openclaw.py

@@ -17,7 +17,6 @@ def test_markdown_skills_openclaw():
     from fastapi.testclient import TestClient
     from foxclaw.api import app
 
-    # 8. OpenClaw 兼容:无 triggers 的原味技能(单 .md)→ 装成功 + 描述相关触发
     NO_TRIG = "---\nname: skill-vetter\nversion: 1.0.0\ndescription: Security-first skill vetting. Use before installing any skill from ClawdHub or GitHub.\n---\nCheck red flags before install."
     with TestClient(app) as c:
         r = c.post("/api/ahs/md-skills", json={"content": NO_TRIG, "id": "skill_vetter", "acknowledged": True})
@@ -32,37 +31,33 @@ def test_markdown_skills_openclaw():
         z.writestr("_meta.json", _json.dumps({"slug": "skill-vetter-zip", "version": "1.0.0"}))
     _pkg = _b64.b64encode(_buf.getvalue()).decode()
     with TestClient(app) as c:
-        # 9. zip 包上传(base64)→ id 用 slug、version 带出
         r = c.post("/api/ahs/md-skills", json={"package_b64": _pkg, "acknowledged": True})
         assert r.status_code == 200, r.text
         assert r.json()["skill"]["id"] == "skill-vetter-zip" and r.json()["skill"]["version"] == "1.0.0"
         print("[9] OpenClaw zip 包上传(slug→id,version) OK")
-        # 10. zip 无 SKILL.md → 400
         _b2 = _io.BytesIO()
         with _zip.ZipFile(_b2, "w") as z: z.writestr("readme.txt", "hi")
         r = c.post("/api/ahs/md-skills", json={"package_b64": _b64.b64encode(_b2.getvalue()).decode(), "acknowledged": True})
         assert r.status_code == 400
         print("[10] zip 无 SKILL.md → 400 OK")
 
-    # 11. 描述相关注入(无 triggers)+ 持久化 round-trip
     from foxclaw import Foxclaw
     os3 = Foxclaw(data_dir=_DATA)
-    assert os3.md_skills.get("skill-vetter-zip") is not None   # 持久化含 zip 装的
+    assert os3.md_skills.get("skill-vetter-zip") is not None
     ag3 = os3.supervisor
     hit = ag3._skill_augment("please vet this skill before install", [{"role": "user", "content": "please vet this skill before install"}])
-    assert "Check red flags" in hit[-1]["content"]             # 描述相关命中注入
+    assert "Check red flags" in hit[-1]["content"]
     miss = ag3._skill_augment("订一张机票", [{"role": "user", "content": "订一张机票"}])
-    assert miss[0]["content"] == "订一张机票"                    # 无关不注入
+    assert miss[0]["content"] == "订一张机票"
     print("[11] 无 triggers 描述相关注入 + 持久化 OK")
 
-    # 12. 编辑触发词(免解压重打包):PATCH triggers → 中文任务也能触发
     with TestClient(app) as c:
         r = c.patch("/api/ahs/md-skills/skill-vetter-zip", json={"triggers": ["审核", "搜索"]})
         assert r.status_code == 200 and r.json()["skill"]["triggers"] == ["审核", "搜索"], r.text
     os4 = Foxclaw(data_dir=_DATA)
     ag4 = os4.supervisor
     hit = ag4._skill_augment("帮我审核这个技能", [{"role": "user", "content": "帮我审核这个技能"}])
-    assert "Check red flags" in hit[-1]["content"]   # 加了中文 triggers → 中文任务命中
+    assert "Check red flags" in hit[-1]["content"]
     print("[12] 编辑触发词 → 中文任务触发 OK")
 
     print("\nOpenClaw 兼容验证全部通过")

package/python/tests/test_mcp_connectors.py

@@ -5,8 +5,8 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 
 def test_mcp_connectors():
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
-    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"      # 不加载开发机 .env(否则 FOXCLAW_API_KEY 会开启鉴权导致 401)
-    os.environ["HF_HUB_OFFLINE"] = "1"         # 无网环境:跳过 huggingface 联网重试,直接用本地缓存
+    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
+    os.environ["HF_HUB_OFFLINE"] = "1"
     os.environ["TRANSFORMERS_OFFLINE"] = "1"
     _DATA = tempfile.mkdtemp(prefix="foxclaw_mcp_")
     os.environ["FOXCLAW_DATA_DIR"] = _DATA
@@ -16,8 +16,6 @@ def test_mcp_connectors():
     import foxclaw.skills.mcp_client as mc
     from types import SimpleNamespace as NS
 
-    # 客户端 SSRF 防线(用真实 _amcp_list_tools,monkeypatch 之前测):连内网/元数据 host
-    # 应被请求钩子在发包前拦截(防恶意 MCP server 用 307 把你重定向进内网/云元数据)。
     import asyncio as _aio
     _blocked = False
     try:
@@ -42,46 +40,38 @@ def test_mcp_connectors():
     with TestClient(app) as c:
         print("=" * 60); print("工具中心 · MCP 连接器 验证"); print("=" * 60)
 
-        # 1. 加服务器(https, ack) → 注册 2 工具
         r = c.post("/api/ahs/mcp/servers", json=SRV)
         assert r.status_code == 200, r.text
         assert r.json()["tools_registered"] == 2
         print("[1] 加服务器 + 注册 2 工具 OK")
 
-        # 2. 技能出现 + fail-closed side_effect
         skills = {s["id"]: s for s in c.get("/api/ahs/skills").json()["skills"]}
         assert skills["mcp__demo_srv__get_time"]["side_effect"] == "read"
-        assert skills["mcp__demo_srv__do_thing"]["side_effect"] == "write"   # fail-closed
+        assert skills["mcp__demo_srv__do_thing"]["side_effect"] == "write"
         print("[2] 工具成技能 + fail-closed(read/write) OK")
 
-        # 3. 服务器列表 tool_count=2
         srvs = c.get("/api/ahs/mcp/servers").json()["servers"]
         assert srvs and srvs[0]["tool_count"] == 2
         print("[3] 服务器列表 tool_count=2 OK")
 
-        # 4. 审核门 deny 内网
         r = c.post("/api/ahs/mcp/servers", json={"id": "bad", "url": "http://127.0.0.1/mcp"})
         assert r.status_code == 403, r.text
         print("[4] 审核门 deny 内网(403) OK")
 
-        # 5. 外部低信任未 ack → 409
         r = c.post("/api/ahs/mcp/servers", json={"id": "p2", "url": "https://mcp2.example.com/mcp"})
         assert r.status_code == 409 and r.json()["detail"]["needs_ack"] is True
         print("[5] 外部低信任需确认(409) OK")
 
-        # 6. 测试调用 mcp 技能:external 外部调用 → 先 needs_confirmation,确认后成功
         r = c.post("/api/ahs/skills/mcp__demo_srv__get_time/test", json={"args": {}})
         assert r.json()["status"] == "needs_confirmation", r.text
         r = c.post("/api/ahs/skills/mcp__demo_srv__get_time/test", json={"args": {}, "confirmed": True})
         j = r.json()
         assert r.status_code == 200 and j["success"] is True, r.text
-        # 双层防提示注入:结构标记 _untrusted + 内容内联安全警告(LLM 注入时看得到)
         out = j["output"]
         assert out.get("_untrusted") is True, out
         assert "不可信" in out.get("data", {}).get("content", ""), out
         print("[6] 测试调用 mcp 技能 + 双层 untrusted 标记(防提示注入) OK")
 
-        # 7. 连接失败 → 502
         async def boom(url, headers, transport): raise RuntimeError("connrefused")
         mc._amcp_list_tools = boom
         r = c.post("/api/ahs/mcp/servers", json={"id": "err_srv", "url": "https://mcp3.example.com/mcp", "acknowledged": True})
@@ -89,12 +79,10 @@ def test_mcp_connectors():
         mc._amcp_list_tools = fake_list
         print("[7] 连接失败 502 OK")
 
-        # 8. 移除服务器 → 技能消失
         assert c.delete("/api/ahs/mcp/servers/demo_srv").status_code == 200
         assert "mcp__demo_srv__get_time" not in {s["id"] for s in c.get("/api/ahs/skills").json()["skills"]}
         print("[8] 移除服务器 + 技能消失 OK")
 
-    # 9. 持久化 round-trip
     with TestClient(app) as c:
         c.post("/api/ahs/mcp/servers", json=SRV)
     from foxclaw import Foxclaw

package/python/tests/test_mcp_guardian_discovery.py

@@ -8,17 +8,15 @@ def test_mcp_guardian_discovery():
     os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
     os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_mcp_guardian_")
 
-    # 1. tool_to_spec 兼容 dict(守门人序列化产物),fail-closed 不变
     from foxclaw.skills.mcp_client import tool_to_spec
     spec = tool_to_spec("srv", {"name": "get_time", "description": "读时间", "inputSchema": {},
                                 "annotations": {"readOnlyHint": True, "destructiveHint": None}})
     assert spec.id == "mcp__srv__get_time" and spec.side_effect == "read" and not spec.destructive
     spec2 = tool_to_spec("srv", {"name": "do_thing", "description": "", "inputSchema": {},
                                  "annotations": None})
-    assert spec2.side_effect == "write"  # fail-closed:无注解按有副作用
+    assert spec2.side_effect == "write"
     print("[1] tool_to_spec 兼容 dict + fail-closed OK")
 
-    # 2. 守门人 mcp_register:主进程空 headers 不覆盖守门人已有凭证
     import foxclaw.kernel.sentinel as sm
     servers = {}
     sm._handle_mcp_register({"servers": [
@@ -30,7 +28,6 @@ def test_mcp_guardian_discovery():
     assert servers["a"]["headers"]["Authorization"] == "Bearer SECRET", "空 headers 不应覆盖守门人已有凭证"
     print("[2] mcp_register 空 headers 保留旧凭证 OK")
 
-    # 3. 守门人 mcp_list_tools 代发现:用自己的 headers 连 + 序列化为 dict
     import foxclaw.skills.mcp_client as mc
     _seen = {}
     async def fake_list(url, headers, transport):
@@ -41,10 +38,9 @@ def test_mcp_guardian_discovery():
     out = sm._handle_mcp_list_tools({"server_id": "a"}, servers)
     assert out["tools"][0]["name"] == "t1"
     assert out["tools"][0]["annotations"]["readOnlyHint"] is True
-    assert _seen["headers"].get("Authorization") == "Bearer SECRET"  # 守门人用自己的凭证连
+    assert _seen["headers"].get("Authorization") == "Bearer SECRET"
     print("[3] mcp_list_tools 守门人代发现 + 序列化 + 凭证不出守门人 OK")
 
-    # 4. mcp_add_server_guardian:主进程不存 headers,守门人收到 headers
     class FakeSentinel:
         def __init__(self):
             self.registered = None

package/python/tests/test_mcp_no_memory.py

@@ -6,9 +6,9 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 
 def test_mcp_no_memory():
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
-    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"      # 隔离开发机 .env,保证测试环境自洽
+    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
     os.environ.setdefault("FOXCLAW_EMBEDDING_MODEL", "foxclaw-nonexistent-fast")
-    os.environ["HF_HUB_OFFLINE"] = "1"         # 无网环境:跳过 huggingface 联网重试,直接用本地缓存
+    os.environ["HF_HUB_OFFLINE"] = "1"
     os.environ["TRANSFORMERS_OFFLINE"] = "1"
     os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_nomem_")
 
@@ -16,7 +16,7 @@ def test_mcp_no_memory():
 
     o = Foxclaw(data_dir=os.environ["FOXCLAW_DATA_DIR"])
     calls = []
-    o.hmr.ingest = lambda *a, **k: calls.append(1)   # spy:数 HMR 写入次数
+    o.hmr.ingest = lambda *a, **k: calls.append(1)
 
 
     async def dispatch_suppressed():

package/python/tests/test_mcp_policy_gate.py

@@ -24,7 +24,6 @@ class _StubGate:
                      taint_level=0, taint_threshold=0):
         assert skill.side_effect == "write" and skill.external is True
         assert confirmed is False, "外部驱动不能用 confirmed 自证"
-        # Verdict 的字段是 level(allow|warn|deny|confirm),不是 decision
         return SimpleNamespace(level=self.decision, reason="stub",
                                raw=SimpleNamespace(reason_code=self.code),
                                decision_id="d")