foxclaw 0.1.2 → 0.1.4

package/python/tests/test_tool_center.py

@@ -19,67 +19,56 @@ def test_tool_center():
     with TestClient(app) as c:
         print("=" * 60); print("工具中心 · 技能台 + 审核门 + 治理 验证"); print("=" * 60)
 
-        # 1. 安装 web_api 技能(https 只读 → allow)
         r = c.post("/api/ahs/skills", json=WEBAPI)
         assert r.status_code == 200, r.text
         assert r.json()["created"] is True
         print("[1] 安装 web_api 技能 OK")
 
-        # 2. 列表里出现且 source=user
         r = c.get("/api/ahs/skills"); assert r.status_code == 200
         ids = {s["id"]: s for s in r.json()["skills"]}
         assert "wx_weather" in ids and ids["wx_weather"]["source"] == "user"
         print("[2] 列表含新技能且 source=user OK")
 
-        # 3. 拒绝 local kind
         r = c.post("/api/ahs/skills", json={**WEBAPI, "id": "x_local", "kind": "local"})
         assert r.status_code == 400
         print("[3] 拒绝 local kind(400) OK")
 
-        # 4. 拒绝非法 endpoint
         r = c.post("/api/ahs/skills", json={**WEBAPI, "id": "x_bad", "endpoint": "ftp://x"})
         assert r.status_code == 400
         print("[4] 拒非法 endpoint(400) OK")
 
-        # 5. mcp 缺字段
         r = c.post("/api/ahs/skills", json={"id": "x_mcp", "name": "m", "kind": "mcp", "side_effect": "read"})
         assert r.status_code == 400
         print("[5] mcp 缺 server/tool(400) OK")
 
-        # 6. 启停
         r = c.patch("/api/ahs/skills/wx_weather", json={"enabled": False})
         assert r.status_code == 200 and r.json()["skill"]["enabled"] is False
         r = c.patch("/api/ahs/skills/wx_weather", json={"enabled": True})
         assert r.json()["skill"]["enabled"] is True
         print("[6] 启停切换 OK")
 
-        # 7. 删内置 → 409(取列表里第一个 builtin)
         r = c.get("/api/ahs/skills")
         builtin = next((s["id"] for s in r.json()["skills"] if s["source"] == "builtin"), None)
         if builtin:
             rd = c.delete(f"/api/ahs/skills/{builtin}")
             assert rd.status_code == 409, rd.text
             print("[7] 内置技能不可删(409) OK")
-            # 7b. 用内置 id 安装 → 拒(不能覆盖内置)
             rc = c.post("/api/ahs/skills", json={**WEBAPI, "id": builtin})
             assert rc.status_code == 409, rc.text
             print("[7b] 用内置 id 安装被拒(409) OK")
         else:
             print("[7] 跳过(无内置技能)")
 
-        # 8. 测试调用:read 技能直接跑(返回 SkillResult 结构)
         r = c.post("/api/ahs/skills/wx_weather/test", json={"args": {}})
         assert r.status_code == 200 and "success" in r.json()
         print("[8] 测试调用返回 SkillResult OK")
 
-        # 9. 安装审核门:打本地地址的 web_api 安装期被 deny(403)
         r = c.post("/api/ahs/skills", json={"id": "ssrf_t", "name": "s", "description": "", "kind": "web_api",
                    "triggers": ["x"], "side_effect": "read", "endpoint": "http://127.0.0.1:8000/api/status"})
         assert r.status_code == 403, r.text
         assert r.json()["detail"]["error"] == "install_denied"
         print("[9] 安装审核门 deny 本地地址(403) OK")
 
-        # 9b. 有副作用技能未确认 → 409 needs_ack;acknowledged 后 → 200(且持久,供步12 round-trip)
         _send = {"id": "send_x", "name": "发信", "description": "", "kind": "web_api",
                  "triggers": ["发"], "side_effect": "send", "endpoint": "https://example.com/send"}
         r = c.post("/api/ahs/skills", json=_send)
@@ -88,19 +77,16 @@ def test_tool_center():
         assert r.status_code == 200, r.text
         print("[9b] 副作用技能需确认(409→200) OK")
 
-        # 10. 治理端点可用
         assert c.get("/api/ahs/breaker").status_code == 200
         assert c.get("/api/ahs/hooks/audit").status_code == 200
         print("[10] 治理端点(breaker/audit) OK")
 
-        # 10b. 信任分级:内置 calculator(local)=high、内置 mcp=low、用户 web_api=mid
         sk = {s["id"]: s for s in c.get("/api/ahs/skills").json()["skills"]}
         assert sk["calculator"]["trust"] == "high", sk["calculator"]["trust"]
-        assert sk["gmail_send"]["trust"] == "low", sk["gmail_send"]["trust"]   # 内置但 mcp→低
+        assert sk["gmail_send"]["trust"] == "low", sk["gmail_send"]["trust"]
         assert sk["wx_weather"]["trust"] == "mid"
         print("[10b] 信任分级 high/mid/low OK")
 
-        # 10c. deny 封杀:封杀后测试调用被拦 + blocked 标;解封恢复
         c.post("/api/ahs/policy/deny", json={"id": "wx_weather"})
         r = c.post("/api/ahs/skills/wx_weather/test", json={"args": {}, "confirmed": True}).json()
         assert r["status"] == "blocked" and "封杀" in r["message"], r
@@ -111,12 +97,10 @@ def test_tool_center():
         assert next(s for s in c.get("/api/ahs/skills").json()["skills"] if s["id"] == "wx_weather")["blocked"] is False
         print("[10c] deny 封杀/解封 kill-switch OK")
 
-        # 11. 删除用户技能
         assert c.delete("/api/ahs/skills/wx_weather").status_code == 200
         r = c.get("/api/ahs/skills"); assert "wx_weather" not in {s["id"] for s in r.json()["skills"]}
         print("[11] 删除用户技能 OK")
 
-    # 12. 持久化 round-trip:直建新 OS(同数据目录),已安装的 send_x 应仍在
     from foxclaw import Foxclaw
     os2 = Foxclaw(data_dir=_DATA)
     assert os2.skill_registry.get("send_x") is not None, "重启后用户技能丢失"

package/python/tests/test_tool_parallel.py

@@ -43,7 +43,7 @@ def test_readonly_tools_run_concurrently(monkeypatch) -> None:
     barrier = threading.Barrier(2, timeout=3)
 
     def behave(name, args, sink):
-        barrier.wait()          # 串行时第二个永远到不了 → BrokenBarrierError
+        barrier.wait()
         return f"{name}:ok"
 
     fake = _make(monkeypatch, behave)
@@ -72,7 +72,7 @@ def test_slow_tool_is_cut_off(monkeypatch) -> None:
 
 def test_taint_collected_in_worker_and_merged_in_main(monkeypatch) -> None:
     def behave(name, args, sink):
-        sink.append(3 if name == "web_search" else 2)   # worker 只能收集,不能直接写会话污点
+        sink.append(3 if name == "web_search" else 2)
         return "ok"
 
     fake = _make(monkeypatch, behave)

package/python/tests/test_tool_params.py

@@ -46,13 +46,11 @@ def main():
     print("\n【3】类型不符被检出(C 类:静默失败改为可见)")
     errs = r.validate_args("web_search", {"query": {"a": 1}})
     check(any("类型" in e for e in errs), f"dict 传 string 位被检出({errs})")
-    # top_k 声明在 recall_memory 上(不在 web_search),故用它验 integer 校验
     errs = r.validate_args("recall_memory", {"query": "x", "top_k": "ten"})
     check(any("类型" in e for e in errs), f"字符串传 integer 被检出({errs})")
     errs = r.validate_args("recall_memory", {"query": "x", "top_k": True})
     check(not any("top_k" in e for e in errs),
-          f"bool 不被误判为 integer({errs})")  # bool 是 int 子类,须排除
-    # 未在 schema 中声明的额外字段应放过(不引入 jsonschema 依赖的宽松设计)
+          f"bool 不被误判为 integer({errs})")
     check(r.validate_args("web_search", {"query": "ok", "未声明字段": 1}) == [],
           "未声明的额外字段不报错(避免过度约束模型)")
 
@@ -82,8 +80,6 @@ def main():
     print("\n【6】参数解析失败不再静默(args_parse_failed 标记存在)")
     import inspect
     from foxclaw.core.model_router import ModelRouter
-    # 检查整个类:标记可能随重构从 call_tools 移到 _call_openai_tools 等子方法,
-    # 锁「类内存在该标记」而非锁某个方法名(避免重构后误报)。
     src = inspect.getsource(ModelRouter)
     check("args_parse_failed" in src,
           "call_tools 标记解析失败(可观测)")

package/python/tests/test_tool_use.py

@@ -20,7 +20,6 @@ from foxclaw.core.model_router import ModelRouter
 from foxclaw.agents.base import CognitiveAgent
 
 
-# ── 1. P1 运行时注入 ───────────────────────────────────────────────────────────
 def test_runtime_context_and_idempotent():
     r = ModelRouter(provider="stub")
     ctx = r._runtime_context()
@@ -30,7 +29,6 @@ def test_runtime_context_and_idempotent():
     assert r._inject_runtime(a) == a, "二次注入必须幂等(防 stream→complete 重复)"
 
 
-# ── 2. ToolRegistry ────────────────────────────────────────────────────────────
 def test_registry_default_and_deny():
     reg = T.default_registry()
     assert set(reg.names()) == {"web_search", "recall_memory"}
@@ -55,7 +53,6 @@ def test_tool_use_flag_default_off():
         os.environ.pop("FOXCLAW_TOOL_USE", None)
 
 
-# ── 3. call_tools 降级 ─────────────────────────────────────────────────────────
 def test_call_tools_unsupported_degrades():
     r = ModelRouter(provider="stub")
     assert r.supports_tools() is False
@@ -63,7 +60,6 @@ def test_call_tools_unsupported_degrades():
     assert res["supported"] is False and res["tool_calls"] == []
 
 
-# ── 4. 工具循环 ────────────────────────────────────────────────────────────────
 class _FakeRouter:
     """脚本化 call_tools:按序返回预设结果,记录每轮 messages 长度。"""
     def __init__(self, script):
@@ -93,10 +89,8 @@ def _fake_agent(router):
 
 def test_reply_with_tools_multi_round():
     router = _FakeRouter([
-        # 第1轮:模型要求调 web_search
         {"supported": True, "text": "", "assistant_msg": {"role": "assistant", "content": ""},
          "tool_calls": [{"id": "c1", "name": "web_search", "args": {"query": "最新模型"}}]},
-        # 第2轮:拿到结果后给最终答案
         {"supported": True, "text": "根据搜索,最新是 X。", "tool_calls": [],
          "assistant_msg": {"role": "assistant", "content": "根据搜索,最新是 X。"}},
     ])
@@ -104,7 +98,6 @@ def test_reply_with_tools_multi_round():
     out = CognitiveAgent._reply_with_tools(agent, "有哪些新模型",
                                            [{"role": "user", "content": "有哪些新模型"}])
     assert out == "根据搜索,最新是 X。"
-    # 第2轮的 messages 必须已追加 assistant(带 tool_calls)+ tool 结果
     _, round2_msgs = router.seen[1]
     roles = [m["role"] for m in round2_msgs]
     assert "assistant" in roles and "tool" in roles
@@ -129,7 +122,6 @@ def test_reply_with_tools_unsupported_returns_none():
 
 
 def test_reply_with_tools_empty_answer_returns_none():
-    # 阶段五·步骤15:模型无工具调用且文本为空 → 返回 None 让上层 fallback(不再"空回复且不回退")
     router = _FakeRouter([
         {"supported": True, "text": "", "tool_calls": [],
          "assistant_msg": {"role": "assistant", "content": ""}},
@@ -139,7 +131,6 @@ def test_reply_with_tools_empty_answer_returns_none():
     assert out is None, "空答必须返回 None 让上层 fallback"
 
 
-# ── 5. 工具分派 ────────────────────────────────────────────────────────────────
 def test_dispatch_web_search_ok(monkeypatch):
     from foxclaw.core import web_search as ws
     monkeypatch.setattr(ws, "search_answer", lambda q: {"answer": "实时答案XYZ", "references": []})
@@ -168,11 +159,9 @@ def test_dispatch_denied(monkeypatch):
     assert "禁用" in out
 
 
-# ── 6. 动作级权限闸(permission 管线 + HITL)──────────────────────────────────────
 def test_tool_capability_readonly_and_failclosed():
     assert T.tool_capability("web_search")["read_only"] is True
     assert T.tool_capability("recall_memory")["side_effect"] == "read"
-    # 未声明的新工具 → fail-closed:当有副作用 + 外部
     cap = T.tool_capability("some_future_write_tool")
     assert cap["read_only"] is False and cap["side_effect"] == "write" and cap["external"] is True
 
@@ -194,7 +183,6 @@ def test_dispatch_hitl_blocks_side_effect_tool(monkeypatch):
     called = {"n": 0}
     monkeypatch.setattr(ws, "search_answer",
                         lambda q: called.__setitem__("n", called["n"] + 1) or {"answer": "x"})
-    # 把 web_search 强制降级为有副作用 → 应被闸门拦成 HITL
     monkeypatch.setattr(T, "tool_capability",
                         lambda name: {"side_effect": "send", "read_only": False,
                                       "external": True, "destructive": False})
@@ -219,7 +207,6 @@ def test_tool_path_injects_preferences(monkeypatch):
     fake.AGENT_ID = "assistant"
     fake._ability_augment = lambda t, m: m
     fake._skill_augment = lambda t, m: m
-    # 偏好注入:把标记并进最后一条 user
     fake._pref_augment = lambda m: (list(m[:-1]) +
         [{"role": "user", "content": "【用户偏好】喜欢简洁\n\n" + m[-1]["content"]}])
 

package/python/tests/test_toplevel_concurrency.py

@@ -70,7 +70,6 @@ def test_same_instance_concurrent(os_):
         per[sid] = per.get(sid, 0) + 1
     cross = sum(1 for _id, sid, p in rows for par in json.loads(p)
                 if par in sid_of and sid_of[par] != sid)
-    # goal 归属:每个返回会话的 goal 节点含本任务标记
     ok_goal = 0
     for i, r in enumerate(res):
         g = con.execute("SELECT content FROM thought_nodes WHERE session_id=? "
@@ -90,9 +89,9 @@ def test_supervisor_concurrent(os_):
 
     async def run():
         return await asyncio.gather(
-            sup.run_task("分析本月理财预算"),      # → finance
-            sup.run_task("总结这篇论文的要点"),    # → office(学习)
-            sup.run_task("你能做什么"),            # 元问题 → supervisor 自答
+            sup.run_task("分析本月理财预算"),
+            sup.run_task("总结这篇论文的要点"),
+            sup.run_task("你能做什么"),
         )
     res = asyncio.run(run())
     routed = [r["result"].get("dispatched_to") for r in res]

package/python/tests/test_tracing.py

@@ -5,9 +5,6 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 def test_tracing():
-    # 关掉 .env:否则开发者 .env 的 FOXCLAW_MCP_SERVER=1 会在 import api 时构建 MCP 服务器,
-    # 而本测试有**两处** `with TestClient(app)`(82/189 行),第二次进 lifespan 会撞
-    # StreamableHTTPSessionManager「.run() can only be called once per instance」而失败。
     os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
     os.environ["HKC_EMBEDDING"] = "stub"
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
@@ -20,27 +17,24 @@ def test_tracing():
 
     print("=" * 60); print("请求链路追踪验证"); print("=" * 60)
 
-    # [1] 无 trace 时 span 是零成本 no-op(后台任务不该报错)
     clear_trace()
     assert current_trace() is None
     with span("orphan", x=1) as s:
         assert s is None
     print("[1] 无 trace 时 span no-op(不报错/不产生垃圾)OK")
 
-    # [2] span 记录名称/耗时/meta;嵌套按结束顺序落盘
     tr = start_trace("unit")
     with span("outer", k="v"):
         with span("inner"):
             time.sleep(0.01)
     d = tr.to_dict()
     names = [s["name"] for s in d["spans"]]
-    assert names == ["inner", "outer"], names          # inner 先结束先记
+    assert names == ["inner", "outer"], names
     inner = d["spans"][0]
     assert inner["ok"] is True and inner["ms"] >= 9, inner
     assert d["spans"][1]["meta"] == {"k": "v"}
     print(f"[2] span 记录(嵌套/耗时 {inner['ms']}ms/meta)OK")
 
-    # [3] 异常:记 ok=False + error,并原样抛出(不吞异常)
     try:
         with span("boom"):
             raise ValueError("kaboom")
@@ -51,14 +45,12 @@ def test_tracing():
     assert bad["ok"] is False and "kaboom" in bad["error"], bad
     print("[3] span 异常记录 ok=False + 原样抛出 OK")
 
-    # [4] 单 trace span 上限(防病态循环撑爆内存)
     t2 = Trace("cap")
     for i in range(MAX_SPANS_PER_TRACE + 50):
         t2.add_span({"name": f"s{i}"})
     assert len(t2.to_dict()["spans"]) == MAX_SPANS_PER_TRACE and t2.to_dict()["dropped_spans"] == 50
     print(f"[4] 单 trace span 封顶 {MAX_SPANS_PER_TRACE}(超出计 dropped)OK")
 
-    # [5] TraceStore 有界环存 + 按 id 取
     st = TraceStore(limit=3)
     ids = []
     for i in range(5):
@@ -67,7 +59,6 @@ def test_tracing():
     assert st.get(ids[-1]) is not None and st.get(ids[0]) is None, "应只留最近 3 条"
     print("[5] TraceStore 有界环存(只留最近 N)+ 按 id 取 OK")
 
-    # [6] 线程隔离:contextvars 各线程独立,span 不串 trace
     clear_trace()
     res = {}
     def worker(name):
@@ -81,13 +72,10 @@ def test_tracing():
     assert all(v[1] == ["work"] for v in res.values()), "各线程 span 应各归各的 trace"
     print("[6] 线程隔离(3 线程 3 条独立 trace,span 不串)OK")
 
-    # ── 端到端:经 API 请求产生 trace ─────────────────────────
     from fastapi.testclient import TestClient
     from foxclaw.api import app
 
     with TestClient(app) as c:
-        # [7] 数据面请求 → 带 X-Trace-Id + 可查详情;链路里能看到 LLM span
-        #     (用 office:主管走路由管线,不经过 act/verify,埋点覆盖要用领域 Agent 验)
         r = c.post("/api/task", json={"task": "追踪自测", "agent_id": "office"})
         assert r.status_code == 200, r.status_code
         tid = r.headers.get("X-Trace-Id")
@@ -97,12 +85,9 @@ def test_tracing():
         names = [s["name"] for s in detail["spans"]]
         llm = [n for n in names if n.startswith("llm.")]
         assert llm, f"链路里应有 LLM span: {names}"
-        # 跨层传播:Agent 跑在 asyncio.to_thread 的线程里,它的 span 仍落进本请求的 trace
-        # → 证明 contextvars 确实穿过了线程边界(本设计的核心假设)
         mem = [n for n in names if n.startswith("memory.")]
         assert mem, f"跨线程的 Agent 记忆 span 应归属本 trace(contextvars 传播): {names}"
         assert all(s["ms"] >= 0 for s in detail["spans"]), "每个 span 都应有耗时"
-        # 覆盖度:认知管线各 stage 都要在链路里(否则"慢在哪"会落在没埋点的暗区)
         stages = [n for n in names if n.startswith("stage.")]
         for must in ("stage.recall", "stage.act", "stage.verify"):
             assert must in names, f"缺 {must},埋点覆盖退化了: {names}"
@@ -110,21 +95,18 @@ def test_tracing():
         print(f"[7] 请求→trace + X-Trace-Id;{detail['span_count']} span "
               f"(管线 {len(stages)} stage + 跨线程 {mem[0]})OK")
 
-        # [8] 列表可查;未知 id → 404
         lst = c.get("/api/traces?limit=5").json()["traces"]
         assert any(t["trace_id"] == tid for t in lst), "最近列表应含刚才那条"
         assert "spans" not in lst[0], "列表是摘要,不带 spans(省负载)"
         assert c.get("/api/traces/deadbeef0000").status_code == 404
         print(f"[8] /api/traces 列表({len(lst)} 条摘要)+ 未知 id 404 OK")
 
-        # [9] 探针/静态不追踪(不污染)
         before = len(c.get("/api/traces?limit=200").json()["traces"])
         c.get("/health"); c.get("/metrics")
         after = c.get("/api/traces?limit=200").json()["traces"]
         assert not any(t["name"].endswith("/health") for t in after), "探针不该被追踪"
         print("[9] 探针 /health、/metrics 不进 trace OK")
 
-    # ── 持久化 + 采样(内存环重启即失;慢的/出错的必须留得住)──────────
     import time as _t
     store = TraceStore(limit=2)
     store.attach_db(Path(os.environ["FOXCLAW_DATA_DIR"]) / "t.db")
@@ -134,7 +116,6 @@ def test_tracing():
         tr.duration_ms = ms; tr.start_ts = _t.time()
         return tr
 
-    # [10] 采样:慢的必存、出错的必存、正常的(采样率 0)不存
     os.environ["FOXCLAW_TRACE_SLOW_MS"] = "500"; os.environ["FOXCLAW_TRACE_SAMPLE"] = "0"
     slow = _mk("GET /slow", 900); fast = _mk("GET /fast", 5); bad = _mk("GET /err", 5, err=True)
     for t in (slow, fast, bad):
@@ -145,21 +126,18 @@ def test_tracing():
     assert fast.trace_id not in ids, "正常请求(采样率0)不该落库"
     print("[10] 采样策略(慢/出错必存、正常按采样率不存)OK")
 
-    # [11] 内存环滚出后,仍能从库里捞回慢请求 —— 这才是"查昨天那次慢请求"
-    for i in range(5):                       # 环 limit=2,把 slow 挤出内存
+    for i in range(5):
         store.put(_mk(f"GET /x{i}", 1))
     assert store.get(slow.trace_id) is None, "应已滚出内存环"
     d = store.get_dict(slow.trace_id)
     assert d and d.get("persisted") and d["duration_ms"] == 900 and d["spans"], d
     print("[11] 内存环滚出后仍可从库捞回(重启/滚动后可查历史)OK")
 
-    # [12] 过滤:按慢阈值 / 只看出错
     assert all(r["duration_ms"] >= 500 for r in store.query(limit=99, slow_ms=500))
     errs = store.query(limit=99, errors_only=True)
     assert errs and all(r["ok"] is False for r in errs), errs
     print("[12] 历史查询过滤(slow_ms / errors_only)OK")
 
-    # [13] 保留上限:超出删最旧(磁盘有界)
     os.environ["FOXCLAW_TRACE_RETAIN"] = "100"; os.environ["FOXCLAW_TRACE_SAMPLE"] = "1"
     for i in range(140):
         store.put(_mk(f"GET /bulk{i}", 1))
@@ -167,17 +145,14 @@ def test_tracing():
     os.environ["FOXCLAW_TRACE_SAMPLE"] = "0"
     print("[13] 落库保留上限(超出删最旧,磁盘有界)OK")
 
-    # [14] 库不可用 → 优雅降级为仅内存(不能因为落库失败就把请求搞挂)
     s2 = TraceStore(limit=2)
     s2.attach_db("/nonexistent-dir-xyz/なし/t.db")
-    s2.put(_mk("GET /ok", 900))              # 不应抛异常
+    s2.put(_mk("GET /ok", 900))
     assert s2.query(limit=9) == [] and len(s2.list(limit=9)) == 1
     print("[14] 库不可用 → 降级仅内存,不影响请求 OK")
 
-    # ── W3C Trace Context:零依赖跨进程传播(Foxclaw 唯一的跨进程边界=MCP 双向)──
     from foxclaw.core.tracing import parse_traceparent, to_traceparent, current_traceparent
 
-    # [15] traceparent 解析:合法接受,非法/全零一律拒(不信外部输入)
     good = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
     assert parse_traceparent(good) == "4bf92f3577b34da6a3ce929d0e0e4736"
     assert parse_traceparent("00-" + "0" * 32 + "-00f067aa0ba902b7-01") is None, "全零 trace-id 非法"
@@ -185,25 +160,21 @@ def test_tracing():
         assert parse_traceparent(bad_tp) is None, bad_tp
     print("[15] traceparent 解析(合法接受/非法+全零拒绝)OK")
 
-    # [16] trace_id 符合 W3C 规格(32 hex)→ 出站 traceparent 可被对端接受
     t16 = Trace("w3c")
     assert len(t16.trace_id) == 32 and all(c in "0123456789abcdef" for c in t16.trace_id), t16.trace_id
     tp = to_traceparent(t16.trace_id)
     assert parse_traceparent(tp) == t16.trace_id, "自己生成的应能被自己解析(自洽)"
     print("[16] trace_id 32hex 合规 + 出站 traceparent 自洽 OK")
 
-    # [17] 入站接链:带 traceparent 的请求应**复用**其 trace_id(两边链路对齐)
     with TestClient(app) as c:
         r = c.post("/api/task", json={"task": "接链自测", "agent_id": "supervisor"},
                    headers={"traceparent": good})
         assert r.headers.get("X-Trace-Id") == "4bf92f3577b34da6a3ce929d0e0e4736", r.headers.get("X-Trace-Id")
-        # 非法 traceparent → 不采信,自开一条
         r2 = c.post("/api/task", json={"task": "非法头", "agent_id": "supervisor"},
                     headers={"traceparent": "garbage"})
         assert r2.headers.get("X-Trace-Id") and r2.headers["X-Trace-Id"] != "garbage"
     print("[17] 入站接链(合法 traceparent 复用其 trace_id;非法则自开)OK")
 
-    # [18] 出站:current_traceparent 在 trace 内可用、trace 外为 None(MCP 调用据此带头)
     clear_trace()
     assert current_traceparent() is None
     t18 = start_trace("out")
@@ -211,17 +182,14 @@ def test_tracing():
     clear_trace()
     print("[18] 出站 current_traceparent(trace 内可用/trace 外 None)OK")
 
-    # ── OTLP/HTTP-JSON 导出(可选、零依赖、绝不阻塞请求)───────────────
     from foxclaw.core.tracing import OTLP, _trace_to_otlp
 
-    # [19] 默认关:未配 endpoint → 完全不启用(零成本)
     os.environ.pop("FOXCLAW_OTLP_ENDPOINT", None)
     assert OTLP.stats()["enabled"] is False
-    OTLP.submit(_mk("GET /x", 5))                # 未配 endpoint → no-op,不该起线程/不该报错
+    OTLP.submit(_mk("GET /x", 5))
     print("[19] 未配 endpoint → OTLP 完全不启用(零成本)OK")
 
-    # [20] OTLP/JSON 结构:根 span + 子 span(parentSpanId 挂根)、traceId 32hex、状态码
-    t20 = start_trace("GET /demo")               # 建 trace 并绑到当前上下文
+    t20 = start_trace("GET /demo")
     with span("child.ok"): pass
     try:
         with span("child.bad"):
@@ -244,7 +212,6 @@ def test_tracing():
     assert svc["key"] == "service.name" and svc["value"]["stringValue"] == "foxclaw"
     print(f"[20] OTLP/JSON 结构(根+{len(kids)} 子 span·parentSpanId·32hex traceId·状态码)OK")
 
-    # [21] 端到端:起一个本地 collector,确认真的 POST /v1/traces 且 body 可解析
     import http.server, socketserver, threading as _th2
     received = []
     class _H(http.server.BaseHTTPRequestHandler):
@@ -259,7 +226,7 @@ def test_tracing():
     os.environ["FOXCLAW_OTLP_ENDPOINT"] = f"http://127.0.0.1:{port}"
     t21 = _mk("GET /exported", 12)
     OTLP.submit(t21)
-    for _ in range(50):                          # 后台线程异步发,等它落地
+    for _ in range(50):
         if received: break
         _t.sleep(0.1)
     srv.shutdown()
@@ -270,8 +237,7 @@ def test_tracing():
     assert got["traceId"] == t21.trace_id and got["name"] == "GET /exported", got
     print("[21] 端到端导出(本地 collector 收到 POST /v1/traces,traceId 对得上)OK")
 
-    # [22] 队列满 → 丢弃计数增长,submit 不阻塞(遥测绝不能拖慢请求)
-    os.environ["FOXCLAW_OTLP_ENDPOINT"] = "http://127.0.0.1:1"    # 打不通 → worker 卡住,队列会满
+    os.environ["FOXCLAW_OTLP_ENDPOINT"] = "http://127.0.0.1:1"
     from foxclaw.core.tracing import _OtlpExporter
     ex = _OtlpExporter(maxsize=2)
     before = ex.dropped

package/python/tests/test_truth_crystallizer.py

@@ -72,13 +72,12 @@ def test_pending_bounded_no_leak():
     print("\n【3b】深审回归:持续结晶下 _pending 不无界增长(prune 已完成 Future)")
     hkc = _HKC()
     tc = TruthCrystallizer(hkc_provider=lambda: hkc, enabled=True)
-    for i in range(200):                      # 模拟长期运行:大量 truth.appended
+    for i in range(200):
         tc.on_truth(_msg({"truth": {"fact": f"事实{i}"}, "agent_id": "office"}))
-    tc.drain()                                # 等全部结晶完成
-    # 再来一发触发 prune,此时之前 200 个都已 done → 被清掉
+    tc.drain()
     tc.on_truth(_msg({"truth": {"fact": "末尾"}, "agent_id": "office"}))
     import time as _t
-    for _ in range(50):                       # 等末尾这发也完成
+    for _ in range(50):
         if all(f.done() for f in tc._pending):
             break
         _t.sleep(0.02)
@@ -95,9 +94,8 @@ def test_integration_wiring():
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
         fake = _HKC()
-        os_.truth_crystallizer._hkc_provider = lambda: fake   # 换成假 HKC(不调 LLM)
+        os_.truth_crystallizer._hkc_provider = lambda: fake
         os_.truth_crystallizer.enabled = True
-        # 真值链末端事件 → 结晶器应被 Foxclaw 订阅到并触发
         os_.system_bus.publish("truth.appended",
                                {"truth": {"fact": "测试真值事实"}, "agent_id": "finance"})
         os_.truth_crystallizer.drain()

package/python/tests/test_truth_flow.py

@@ -15,7 +15,7 @@ import os, sys, asyncio, tempfile, shutil
 from pathlib import Path
 os.environ.setdefault("HF_HUB_OFFLINE", "1")
 os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
-os.environ["FOXCLAW_EMBEDDING_MODEL"] = "foxclaw-nonexistent-fast"   # harness 走 hash,快
+os.environ["FOXCLAW_EMBEDDING_MODEL"] = "foxclaw-nonexistent-fast"
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 
@@ -30,13 +30,11 @@ def main():
         seen = []
         os_.event_spine.project(lambda e: seen.append(e.topic))
 
-        # 1. _no_emit 守卫:子 Agent 不自发
         print("\n【1】_no_emit 守卫:分发时子 Agent 不自发 execution.completed")
         asyncio.run(os_.finance.run_task("守卫测试", {"_no_emit": True}))
         assert "execution.completed" not in seen, "带 _no_emit 时不应发 execution.completed"
         print("  ✓ context['_no_emit']=True → 子 Agent 未自发(留给主管统一发)")
 
-        # 2. 全路径触发:直连任务发恰好一条
         print("\n【2】全路径触发:直连领域 Agent 任务发恰好一条 execution.completed")
         before = seen.count("execution.completed")
         asyncio.run(os_.finance.run_task("分析我的月度开支"))
@@ -44,7 +42,6 @@ def main():
         assert emitted == 1, f"直连任务应发恰好 1 条,实得 {emitted}"
         print(f"  ✓ 直连 finance.run_task → execution.completed ×{emitted}")
 
-        # 3. 共享真值记录:别的 Agent 能召回
         print("\n【3】共享真值记录:直连任务经 TruthPipeline 产生 shared 记录,跨 Agent 可见")
         shared = os_.hmr.recall(query="分析我的月度开支 处理", agent_id="office", top_k=10)
         shared_hits = [m for m in shared if m.get("shared")]
@@ -52,7 +49,6 @@ def main():
         print(f"  ✓ office 召回到 {len(shared_hits)} 条共享真值记录(来自 finance 的直连任务)")
         print(f"    样例: {shared_hits[0].get('content','')[:50]!r}")
 
-        # 4. 被拦截的直连任务:发 blocked=True、不落共享真值记录、CognitiveState 不崩
         print("\n【4】被拦截的直连任务:blocked=True + 不落共享记录 + 观测不崩")
         import types
         from foxclaw.agents.base import HarnessBlockedError
@@ -68,11 +64,10 @@ def main():
         b_emitted = [x for x in blocked_flags if x is True]
         assert r.get("error") == "harness_blocked"
         assert len(b_emitted) - b_before == 1, "被拦截直连应发恰好一条 blocked=True"
-        # 精确判定:blocked 任务本身没产生真值记录(按内容过滤;语义召回可能带回 check2 的旧记录)
         own = [m for m in os_.hmr.recall(query="危险越界任务 处理", agent_id="office", top_k=10)
                if m.get("shared") and "危险越界" in m.get("content", "")]
         assert len(own) == 0, "被拦截任务不应产生自己的共享真值记录(TruthPipeline 跳过 blocked)"
-        snap = os_.cognitive_state.snapshot()   # 缺 schedule 的直连事件不应让观测崩溃
+        snap = os_.cognitive_state.snapshot()
         assert "active_agent" in snap
         print(f"  ✓ blocked=True ×1、无共享记录、CognitiveState 快照正常(focus={snap.get('semantic_focus')})")