foxclaw 0.1.2 → 0.1.3

package/python/tests/test_readme_claims.py

@@ -0,0 +1,163 @@
+"""README 与仓库实际的一致性巡检。
+
+README 里的结构和数字曾经长期漂移:目录注释写「五智能体」而实际三个、
+写「76 个测试文件」而实际 110、写「77 个依赖」而实际 96 条。
+这类不一致第一眼就被识破,所以把可机器核对的部分钉在这里:
+改了代码不改文档,这个文件会红。
+
+刻意不钉的东西:测试文件个数、代码行数、依赖条目数——它们每次提交都在变,
+写进 README 就是下一个「76」。需要真实数字时用命令现取,不抄文档。
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+README_EN = ROOT / "README.md"
+README_CN = ROOT / "README_CN.md"
+
+HKC_ROUTES = ROOT / "vendor" / "hkc" / "hkc_api" / "routes" / "knowledge.py"
+KDE = ROOT / "vendor" / "hkc" / "hkc_kde" / "kde.py"
+CHUNKER = ROOT / "vendor" / "hkc" / "hkc_kde" / "chunker.py"
+EXTRACTOR = ROOT / "vendor" / "hkc" / "hkc_kde" / "extractor.py"
+
+
+@pytest.fixture(scope="module")
+def docs() -> dict[str, str]:
+    return {p.name: p.read_text(encoding="utf-8") for p in (README_EN, README_CN)}
+
+
+def _num(path: Path, pattern: str) -> int:
+    m = re.search(pattern, path.read_text(encoding="utf-8"), re.M)
+    assert m, f"{path.relative_to(ROOT)} 中找不到模式 {pattern!r}"
+    return int(m.group(1))
+
+
+def test_agents_are_three(docs: dict[str, str]) -> None:
+    impl = sorted(
+        p.stem
+        for p in (ROOT / "foxclaw" / "agents" / "impl").glob("*.py")
+        if not p.stem.startswith("_")
+    )
+    assert impl == ["finance", "office", "supervisor"], f"实际智能体实现: {impl}"
+
+    for name, text in docs.items():
+        assert "五智能体" not in text, f"{name} 仍写着五智能体"
+        assert "五个智能体" not in text, f"{name} 仍写着五个智能体"
+        assert "five agents" not in text.lower(), f"{name} 仍写着 five agents"
+
+    assert "Three agents" in docs["README.md"]
+    assert "三个智能体" in docs["README_CN.md"]
+
+
+def test_channels_are_four() -> None:
+    for adapter in ("weixin", "feishu", "telegram", "discord"):
+        assert (ROOT / "foxclaw" / "channels" / f"{adapter}.py").exists(), adapter
+    assert (ROOT / "foxclaw" / "channels" / "dispatcher.py").exists()
+
+    text = README_EN.read_text(encoding="utf-8")
+    for brand in ("WeChat", "Feishu", "Telegram", "Discord"):
+        assert brand in text, brand
+
+
+def test_runtime_governance_modules_exist() -> None:
+    for rel in (
+        "foxclaw/core/idempotency.py",
+        "foxclaw/core/recovery.py",
+        "foxclaw/harness/loop_detection.py",
+        "foxclaw/core/compaction.py",
+        "foxclaw/core/steering_queue.py",
+        "docs/GOVERNANCE.md",
+    ):
+        assert (ROOT / rel).exists(), rel
+
+
+def test_ingest_limits_match_docs(docs: dict[str, str]) -> None:
+    upload_mb = _num(HKC_ROUTES, r"MAX_UPLOAD_BYTES\s*=\s*(\d+)\s*\*\s*1024\s*\*\s*1024")
+    assert upload_mb == 20, f"单文件上传上限已变为 {upload_mb}MB,README 写的 20MB 要改"
+
+    assert _num(HKC_ROUTES, r"MAX_INGEST_CHARS\s*=\s*([\d_]+)") == 2_000_000
+    assert _num(KDE, r"DEFAULT_MAX_CHUNKS_PER_DOC\s*=\s*(\d+)") == 800
+    assert _num(EXTRACTOR, r'"HKC_EXTRACT_MAX_TOKENS",\s*"(\d+)"') == 8192
+
+    for name, text in docs.items():
+        assert "20 MB" in text or "20MB" in text, name
+        assert "2,000,000" in text, name
+        assert "800" in text, name
+        assert "8192" in text, name
+
+
+def test_chunk_geometry_matches_docs(docs: dict[str, str]) -> None:
+    max_tokens = _num(CHUNKER, r"^MAX_TOKENS\s*=\s*(\d+)")
+    overlap_tokens = _num(CHUNKER, r"^OVERLAP_TOKENS\s*=\s*(\d+)")
+    m = re.search(r"^CHARS_PER_TOKEN\s*=\s*([\d.]+)", CHUNKER.read_text(encoding="utf-8"), re.M)
+    assert m, "chunker.py 中找不到 CHARS_PER_TOKEN"
+    chars_per_token = float(m.group(1))
+
+    max_chars = int(max_tokens * chars_per_token)
+    overlap_chars = int(overlap_tokens * chars_per_token)
+    step = max_chars - overlap_chars
+
+    assert (max_chars, overlap_chars, step) == (1792, 224, 1568), (
+        f"分块几何已变为 {max_chars}/{overlap_chars}/{step},README 写的 1792/224/1568 要改"
+    )
+    for name, text in docs.items():
+        for value in ("1792", "224", "1568"):
+            assert value in text, f"{name} 未出现 {value}"
+
+
+def test_supported_formats_match_docs(docs: dict[str, str]) -> None:
+    src = HKC_ROUTES.read_text(encoding="utf-8")
+    m = re.search(r"ALLOWED_SUFFIXES\s*=\s*\((.*?)\)", src, re.S)
+    assert m, "knowledge.py 中找不到 ALLOWED_SUFFIXES"
+    suffixes = re.findall(r'"(\.\w+)"', m.group(1))
+    assert len(suffixes) == 10, f"支持格式已变为 {suffixes}"
+
+    for name, text in docs.items():
+        for suffix in suffixes:
+            assert suffix in text, f"{name} 未列出支持格式 {suffix}"
+
+
+def test_relative_links_exist(docs: dict[str, str]) -> None:
+    for name, text in docs.items():
+        for target in re.findall(r"\]\(([^)#:]+)\)", text):
+            if target.startswith(("http", "mailto")):
+                continue
+            assert (ROOT / target).exists(), f"{name} 的链接指向不存在的 {target}"
+
+
+def test_directory_tree_paths_exist() -> None:
+    for rel in (
+        "foxclaw/core",
+        "foxclaw/kernel",
+        "foxclaw/pipeline",
+        "foxclaw/planning",
+        "foxclaw/cognitive",
+        "foxclaw/knowledge",
+        "foxclaw/agents",
+        "foxclaw/harness",
+        "foxclaw/finance",
+        "foxclaw/learning",
+        "foxclaw/itinerary",
+        "foxclaw/channels",
+        "foxclaw/skills",
+        "foxclaw/search",
+        "foxclaw/browser",
+        "foxclaw/capability",
+        "foxclaw/governance",
+        "vendor/hmr",
+        "vendor/hkc",
+        "examples",
+        "tests",
+        "docs",
+    ):
+        assert (ROOT / rel).is_dir(), f"目录树列出的 {rel} 不存在"
+
+
+def test_referenced_skills_exist(docs: dict[str, str]) -> None:
+    for skill in ("general-assistant", "schedule-itinerary"):
+        assert (ROOT / "skills" / skill).is_dir(), skill
+        assert skill in docs["README_CN.md"], skill

package/python/tests/test_reasoner.py

@@ -35,11 +35,8 @@ def test_reasoner_base_order():
 
 def _policy():
     from foxclaw.finance import FinanceRuntime
-    # data_path 显式隔离:默认落在 policy 同目录(系统 Temp),会与其他测试共用一份数据文件
     p = FinanceRuntime(policy_path=tempfile.mktemp(suffix=".yaml"),
                        data_path=tempfile.mktemp(suffix=".json")).policy
-    # 显式锁定本测试的前提阈值(200,模糊带 [140,200)),**不依赖产品默认值** ——
-    # 默认阈值是给用户按自己实际调的可调项,不该让调它就牵动这些验证推理逻辑的测试。
     for r in p.rules:
         if r.id == "large_purchase_check":
             r.threshold = 200.0
@@ -52,12 +49,10 @@ def test_finance_gatekeeper_reasoner():
     from foxclaw.finance.reasoner import FinanceGatekeeperReasoner
     from foxclaw.finance.models import Transaction
     r = FinanceGatekeeperReasoner(_policy())
-    # 小额(规则内)→ approve
     rv = r.reason((Transaction(amount=-150, category="travel", entity="高铁", account="default"), 5000))
     assert rv.decision == "approve" and rv.rationale == "财务批准:travel 预算 150 在规则内"
     assert rv.source == "rules" and any(e.factor == "rules_clear" for e in rv.evidence)
     assert rv.hypotheses, "应有假设"
-    # 大额(>阈值)→ confirm,证据=large_purchase_check
     rv2 = r.reason((Transaction(amount=-680, category="travel", entity="酒店", account="default"), 5000))
     assert rv2.decision == "confirm" and any(e.factor == "large_purchase_check" for e in rv2.evidence)
     print(f"  ✓ 小额→approve(证据 rules_clear);大额→confirm(证据 large_purchase_check;假设={rv2.hypotheses})")
@@ -71,7 +66,7 @@ def test_context_evidence_no_decision_change():
     rt = FinanceRuntime(policy_path=tempfile.mktemp(suffix=".yaml"),
                         data_path=tempfile.mktemp(suffix=".json"))
     rt.set_budget("travel", 3000); rt.set_balance("default", 5000)
-    for _ in range(3):   # 3 笔历史同类交易(同对手方)
+    for _ in range(3):
         rt.add_transaction(Transaction(amount=-100, category="travel", entity="高铁",
                                        account="default"), run_gatekeeper=False)
     r = FinanceGatekeeperReasoner(rt.policy, runtime=rt)
@@ -80,7 +75,6 @@ def test_context_evidence_no_decision_change():
     assert rv.decision == "approve", "规则内 → 决策仍是 approve(情境证据不改裁决)"
     factors = {e.factor for e in rv.evidence}
     assert {"history_category", "budget_remaining", "entity_frequency"} <= factors, factors
-    # 无 runtime → 无情境证据(向后兼容;裁决相同)
     rv0 = FinanceGatekeeperReasoner(rt.policy).reason(
         (Transaction(amount=-150, category="travel", entity="高铁", account="default"), 5000))
     assert not ({"history_category", "budget_remaining", "entity_frequency"}
@@ -103,41 +97,33 @@ def test_llm_arbitration_safety():
     print("\n【2c】Step3:LLM 裁决的安全不变量(只增强模糊、只能 approve→confirm、永不 reject)")
     from foxclaw.finance.reasoner import FinanceGatekeeperReasoner
     from foxclaw.finance.models import Transaction
-    policy = _policy()   # large_purchase_check 阈值 200;模糊带 [140,200)
+    policy = _policy()
     def txn(amt): return Transaction(amount=-amt, category="travel", entity="高铁", account="default")
     def mk(llm, enabled=True): return FinanceGatekeeperReasoner(policy, llm=llm, llm_enabled=enabled)
 
-    # 1. 规则触发(680>200)→ 规则权威,LLM 绝不被调
     llm = _MockLLM("APPROVE"); rv = mk(llm).reason((txn(680), 5000))
     assert rv.decision == "confirm" and rv.source == "rules" and llm.calls == 0
 
-    # 2. 模糊(150∈[140,200))+ LLM 说 CONFIRM → confirm, source=llm
     llm = _MockLLM("CONFIRM"); rv = mk(llm).reason((txn(150), 5000))
     assert rv.decision == "confirm" and rv.source == "llm" and llm.calls == 1
 
-    # 3. 模糊 + LLM 说 APPROVE → approve, source=llm
     llm = _MockLLM("APPROVE"); rv = mk(llm).reason((txn(150), 5000))
     assert rv.decision == "approve" and rv.source == "llm"
 
-    # 4. LLM 出错/超时 → confirm(fail-safe),绝不自动放行
     llm = _MockLLM(raises=True); rv = mk(llm).reason((txn(150), 5000))
     assert rv.decision == "confirm" and rv.source == "llm_failsafe"
 
-    # 5. 【核心不变量】LLM 乱回(含"拒绝"/REJECT/含糊)→ **绝不 reject**,fail-safe confirm
     for bad in ["REJECT", "让我拒绝这笔", "不确定", "yes maybe"]:
         llm = _MockLLM(bad); rv = mk(llm).reason((txn(150), 5000))
         assert rv.decision == "confirm" and rv.source == "llm_failsafe", (bad, rv.decision)
         assert rv.decision != "reject", "LLM 永远不能产生 reject"
 
-    # 6. 明显安全(50<140)→ 规则批准,LLM 不调(省成本)
     llm = _MockLLM("CONFIRM"); rv = mk(llm).reason((txn(50), 5000))
     assert rv.decision == "approve" and rv.source == "rules" and llm.calls == 0
 
-    # 7. 默认关(llm_enabled=False)→ 全走规则,LLM 不调(behavior-preserving)
     llm = _MockLLM("CONFIRM"); rv = mk(llm, enabled=False).reason((txn(150), 5000))
     assert rv.decision == "approve" and rv.source == "rules" and llm.calls == 0
 
-    # 8. is_stub(无真实模型)→ 视为不可用,不调 LLM
     stub = _MockLLM("CONFIRM"); stub.is_stub = True
     rv = FinanceGatekeeperReasoner(policy, llm=stub, llm_enabled=True).reason((txn(150), 5000))
     assert rv.source == "rules" and stub.calls == 0
@@ -153,7 +139,6 @@ def test_real_path_evidence():
         from foxclaw.orchestration import CrossAgentRequest
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
         os_.finance_runtime.set_balance("default", 5000)
-        # 大额 → 需确认(裁决不变)+ 证据链附在 req 上
         req = os_.orchestrator.route_request(CrossAgentRequest(
             from_agent="admin", to_agent="finance", request_type="budget_request",
             payload={"amount": 680, "category": "travel", "entity": "酒店", "account": "default"},

package/python/tests/test_release_check.py

@@ -28,7 +28,7 @@ def _load():
     spec = importlib.util.spec_from_file_location(
         "release_check", REPO / "tools" / "release_check.py")
     mod = importlib.util.module_from_spec(spec)
-    sys.modules["release_check"] = mod      # dataclass 需要能按模块名回查,否则 exec 时炸
+    sys.modules["release_check"] = mod
     spec.loader.exec_module(mod)
     return mod
 
@@ -36,8 +36,6 @@ def _load():
 rc = _load()
 
 
-# ── 造最小产物 ────────────────────────────────────────────
-
 def _wheel(dist: Path, version="0.1.0", name="foxclaw", extra=(),
            description=True) -> Path:
     p = dist / f"{name}-{version}-py3-none-any.whl"
@@ -93,8 +91,6 @@ def _mini_repo(root: Path, version: str, npm_version: str) -> Path:
     return root
 
 
-# ── 版本与 tag ────────────────────────────────────────────
-
 def test_repo_versions_are_consistent():
     """真仓库当前状态:四处一致,无 error。"""
     assert [i for i in rc.check_versions(REPO) if i.level == "error"] == []
@@ -127,8 +123,6 @@ def test_empty_tag_is_skipped():
     assert rc.check_tag("", "0.1.0") == []
 
 
-# ── 项目页正文(long_description)────────────────────────────
-
 def test_repo_declares_readme():
     """真仓库必须声明正文:0.1.1 在 PyPI 上的项目页就是空白的,这就是回归点。"""
     assert [i for i in rc.check_metadata(REPO) if i.level == "error"] == []
@@ -157,8 +151,6 @@ def test_readme_pointing_to_missing_file_is_error(tmp_path):
     assert any(i.code == "readme_missing" for i in rc.check_metadata(root))
 
 
-# ── 归档内容 ──────────────────────────────────────────────
-
 @pytest.mark.parametrize("entry", [
     "foxclaw/.env",
     "foxclaw/.env.local",
@@ -173,7 +165,7 @@ def test_forbidden_entries_detected(entry):
 
 
 @pytest.mark.parametrize("entry", [
-    "foxclaw/.env.example",     # 模板必须能进包
+    "foxclaw/.env.example",
     "foxclaw/cli.py",
     "foxclaw/vendor/hmr/hmr/__init__.py",
 ])
@@ -181,8 +173,6 @@ def test_allowed_entries_pass(entry):
     assert rc.forbidden_entry(entry) is None
 
 
-# ── dist / npm ────────────────────────────────────────────
-
 def test_check_dist_passes_with_vendor_warning_only(tmp_path):
     dist = tmp_path / "dist"
     dist.mkdir()
@@ -254,7 +244,6 @@ def test_run_end_to_end(tmp_path):
     dist.mkdir()
     issues = rc.run(REPO, tag="", dist=dist, npm_tgz=None)
     assert any(i.level == "error" for i in issues), "空 dist 应报错"
-    # 版本号跟着仓库走:写死 0.1.0 会在每次改版本时假红
     version = rc.collect_versions(REPO)["pyproject.toml:project.version"]
     _wheel(dist, version=version)
     _sdist(dist, version=version)

package/python/tests/test_resume_checkpoint.py

@@ -41,8 +41,6 @@ class _Rec:
         self.finished.append((tid, status))
 
 
-# ── ① 日志层 ───────────────────────────────────────────────
-
 def test_record_and_replay_steps(tmp_path) -> None:
     rec = RestartRecovery(str(tmp_path / "recovery.jsonl"), fsync=False)
     rec.record_step("t1", {"kind": "stage", "name": "perceive"})
@@ -59,14 +57,12 @@ def test_compact_log_keeps_steps(tmp_path) -> None:
     rec.task_started("t1", "任务一")
     rec.record_step("t1", {"kind": "tool", "name": "web_search", "key": "k", "result": "r"})
     rec.task_finished("t1", status="done")
-    rec.compact_log(keep_recent_days=7)      # 保留 → 步骤必须还在
+    rec.compact_log(keep_recent_days=7)
     assert len(rec.steps_of("t1")) == 1
-    rec.compact_log(keep_recent_days=0)      # 过期 → 记录与步骤一起丢
+    rec.compact_log(keep_recent_days=0)
     assert rec.steps_of("t1") == []
 
 
-# ── ② 指纹与成败判定 ────────────────────────────────────────
-
 def test_step_key_is_argument_order_insensitive() -> None:
     a = tool_exec._step_key("web_search", {"q": "x", "n": 3})
     b = tool_exec._step_key("web_search", {"n": 3, "q": "x"})
@@ -87,8 +83,6 @@ def test_step_ok_rejects_failure_texts(text, ok) -> None:
     assert tool_exec._step_ok(text) is ok
 
 
-# ── ③ 续跑复用 ──────────────────────────────────────────────
-
 def test_run_tool_calls_reuses_completed_steps(monkeypatch) -> None:
     executed: list = []
 
@@ -124,16 +118,14 @@ def test_run_tool_calls_skips_recording_failures(monkeypatch) -> None:
     assert rec.steps == [], "失败/超时步不能进 checkpoint(否则续跑会把失败当完成)"
 
 
-# ── ④ 装载与生命周期钩子 ────────────────────────────────────
-
 def test_load_resume_cache_filters_bad_steps() -> None:
     rows = [
-        {"kind": "stage", "name": "act"},                                  # 非工具步 → 跳过
+        {"kind": "stage", "name": "act"},
         {"kind": "tool", "name": "web_search", "key": "k1", "result": "ok"},
         {"kind": "tool", "name": "web_search", "key": "k2", "result": "x",
-         "truncated": True},                                               # 截断 → 不复用
-        {"kind": "tool", "name": "web_search", "key": "k3", "result": "  "},  # 空 → 不复用
-        {"kind": "tool", "name": "web_search", "result": "no-key"},         # 无指纹 → 跳过
+         "truncated": True},
+        {"kind": "tool", "name": "web_search", "key": "k3", "result": "  "},
+        {"kind": "tool", "name": "web_search", "result": "no-key"},
     ]
     fake = types.SimpleNamespace(_recovery=_Rec(rows))
     assert CognitiveAgent._load_resume_cache(fake, "t1") == {"k1": {"name": "web_search",
@@ -151,6 +143,6 @@ def test_lifecycle_hooks_record_for_any_agent() -> None:
     assert rec.started[0]["channel"] == "cli"
     assert rec.finished == [("t1", "done")]
 
-    CognitiveAgent._on_session_started(types.SimpleNamespace(), "t1", "x", {})   # 无 recovery
+    CognitiveAgent._on_session_started(types.SimpleNamespace(), "t1", "x", {})
     CognitiveAgent._on_task_settled(types.SimpleNamespace(), "t1", "done")
     CognitiveAgent._record_stage(types.SimpleNamespace(), "t1", "recall")

package/python/tests/test_routing.py

@@ -19,7 +19,6 @@ def test_routing():
 
     print("=" * 60); print("任务感知模型路由 + fallback 链验证"); print("=" * 60)
 
-    # [1] 任务→档
     assert _route_tier("supervisor", [{"role": "user", "content": "x"}]) == "fast"
     assert _route_tier("finance", [{"role": "user", "content": "帮我做深度财务分析报告"}]) == "smart"
     assert _route_tier("assistant", [{"role": "user", "content": "你好"}]) == "fast"
@@ -27,7 +26,6 @@ def test_routing():
     assert _tier_model("deepseek", "smart") == "deepseek-reasoner"
     print("[1] 任务→档 + 档→模型 OK")
 
-    # [2] 按任务/Agent 选档
     os.environ["FOXCLAW_PROVIDER"] = "deepseek"; os.environ["DEEPSEEK_API_KEY"] = "x"
     r = ModelRouter()
     assert r.provider == "deepseek"
@@ -35,7 +33,6 @@ def test_routing():
     assert r._model_for("deepseek", "finance", [{"role": "user", "content": "深度分析报告方案评估"}]) == "deepseek-reasoner"
     print("[2] 按任务/Agent 选档(supervisor→chat,复杂→reasoner) OK")
 
-    # [3] fallback 链:主 provider 失败 → 试下一个已配 provider
     os.environ["OPENAI_API_KEY"] = "y"
     r2 = ModelRouter(); calls = []
     def _fake(p, c, m, s, msgs, mt):
@@ -49,33 +46,26 @@ def test_routing():
     assert "回退到 openai" in r2.fallback_reason
     print("[3] fallback 链(deepseek 失败→openai) OK")
 
-    # [4] 锁定模型(显式 model=)不分档
     r3 = ModelRouter(provider="deepseek", model="fixed-x")
     assert r3._model_for("deepseek", "supervisor", [{"role": "user", "content": "x"}]) == "fixed-x"
     print("[4] 锁定模型不分档(向后兼容) OK")
 
-    # [5] 全部 provider 失败 → 显式失败(不再降 stub 伪装成功)
     def _allfail(*a):
         raise RuntimeError("boom")
     r2._call_provider = _allfail
     out = r2.complete("sys", [{"role": "user", "content": "hi"}])
     assert "STUB" in out or "全部模型失败" in out, out
-    # 失败语义(A 类修复):全部 provider 挂掉属**故障**,不是"未配置模型"的离线态。
-    # 旧实现会拼接 stub 文案「已完成处理:…」—— 那是把故障伪装成成功,且该文本会
-    # 经 base._store_memory 沉入长期记忆造成持续复读。此处锁死该行为不得回归。
     assert "已完成处理" not in out, f"故障被伪装成成功: {out}"
     assert r2.is_degraded() is True, "全部失败必须置 degraded 标志(上游据此禁写长期记忆)"
     print("[5] 全部失败 → 显式失败(无假成功文案) + degraded OK")
 
-    # [6] switch 尊重显式模型(修回归:UI 切模型不能被 tiering 覆盖);只切 provider 清锁恢复分档
     r4 = ModelRouter()
     r4.switch("deepseek", "deepseek-reasoner")
     assert r4._model_for("deepseek", "supervisor", [{"role": "user", "content": "简单"}]) == "deepseek-reasoner"
-    r4.switch("deepseek")   # 无 model → 清锁
+    r4.switch("deepseek")
     assert r4._model_for("deepseek", "supervisor", [{"role": "user", "content": "简单"}]) == "deepseek-chat"
     print("[6] switch 尊重显式模型 + 清锁恢复分档 OK")
 
-    # [7] 断路器:主 provider 持续宕机,第二次调用直接跳过它(免每次等超时)
     r5 = ModelRouter(); seq = []
     def _fk(p, c, m, s, msgs, mt):
         seq.append(p)
@@ -84,7 +74,7 @@ def test_routing():
         return f"OK-{p}", None
     r5._call_provider = _fk
     r5.complete("s", [{"role": "user", "content": "hi"}]); seq.clear()
-    r5.complete("s", [{"role": "user", "content": "hi"}])   # 第二次:deepseek 冷却中
+    r5.complete("s", [{"role": "user", "content": "hi"}])
     assert seq == ["openai"], f"断路器失效: {seq}"
     print("[7] 断路器跳过宕机 provider OK")
 

package/python/tests/test_scheduler.py

@@ -29,11 +29,11 @@ def _run_n_concurrent(sched, n, work):
 
 def test_unlimited_reaches_peak():
     print("\n【1】无上限(默认):并发不受限,行为直通")
-    sched = Scheduler()                         # max_concurrency=None
+    sched = Scheduler()
     N = 6
-    barrier = threading.Barrier(N)              # 让 N 个任务确定性地同时在跑
+    barrier = threading.Barrier(N)
     def work():
-        barrier.wait(timeout=5)                 # 全部到齐才继续 → 峰值=N
+        barrier.wait(timeout=5)
         time.sleep(0.01)
         return "ok"
     _run_n_concurrent(sched, N, work)
@@ -62,12 +62,10 @@ def test_lifecycle_events_and_accounting():
     print("\n【3】生命周期事件 + 记账 + 失败传播")
     spine = _CapSpine()
     sched = Scheduler(spine=spine)
-    # 成功任务
     r = sched.run(lambda: 42, agent_id="finance", task="算账")
     assert r == 42
     assert spine.events == ["task.lifecycle.scheduled", "task.lifecycle.running",
                             "task.lifecycle.completed"], spine.events
-    # 失败任务:异常透传 + failed 事件 + 记账
     spine.events.clear()
     raised = False
     try:
@@ -90,14 +88,13 @@ def test_pm_delegation_unified_lifecycle():
     spine = EventSpine()
     seen = []
     spine.project(lambda e: seen.append(e.topic))
-    pm = ProcessManager(bus=SystemBus(spine=spine))       # pm 经总线发事件到脊柱
-    sched = Scheduler(spine=spine, process_manager=pm)    # 调度器委托 pm
+    pm = ProcessManager(bus=SystemBus(spine=spine))
+    sched = Scheduler(spine=spine, process_manager=pm)
     r = sched.run(lambda: 7, agent_id="finance", task="t")
     assert r == 7
     life = [t for t in seen if t.startswith("task.lifecycle")]
     assert life == ["task.lifecycle.scheduled", "task.lifecycle.running",
                     "task.lifecycle.completed"], f"应由 pm 发唯一词汇,实得 {life}"
-    # pm 里确有该进程(顶层任务也成了进程),调度器记账仍在
     assert pm.stats()["by_state"].get("completed") == 1
     assert sched.stats()["completed"] == 1
     print("  ✓ pm 发 task.lifecycle.{scheduled,running,completed};顶层任务纳入进程;记账双在")
@@ -116,8 +113,8 @@ def test_priority_admission():
         sched.run(lambda: order.append(name), priority=p, task=name)
     tlo = threading.Thread(target=worker, args=(0, "lo"))
     thi = threading.Thread(target=worker, args=(10, "hi"))
-    tlo.start(); time.sleep(0.05); thi.start(); time.sleep(0.15)   # 两者都已在准入队列里等
-    release.set()                                                  # 释放 blocker 的槽
+    tlo.start(); time.sleep(0.05); thi.start(); time.sleep(0.15)
+    release.set()
     for t in (tb, tlo, thi): t.join(5)
     assert order == ["hi", "lo"], f"高优先应先获空位,实得 {order}"
     print(f"  ✓ 释放后:高优先先获空位 → {order}(准入优先级,非抢占运行中)")

package/python/tests/test_search.py

@@ -39,7 +39,6 @@ def test_empty_sources_terminates():
 def test_memory_evidence():
     print("\n【2】内部记忆证据进证据图(MEMORY 来源)")
     rt = SearchRuntime(hmr=FakeHMR(), knowledge_port=None, external_ports=[])
-    # "分析" 是 HYBRID 触发词 → 会查内部记忆(见 planner._HYBRID_HINTS)
     r = rt.search("分析活字印刷的历史", agent_id="office")
     nodes = list(r.graph.nodes.values())
     mem = [n for n in nodes if n.source == SourceType.MEMORY]
@@ -62,11 +61,9 @@ def test_via_foxclawos_lazy():
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        # 【P1-3】search_runtime 由能力中枢惰性构造:未访问前未缓存
         assert "search_runtime" not in os_.capabilities._caps, "未访问前不该构造"
-        rt = os_.search_runtime   # 触发构造(顺带惰性装配 HKC 作知识端口)
+        rt = os_.search_runtime
         assert rt is not None and os_.search_runtime is rt, "应缓存同一实例"
-        # 不联网:替换外部端口为空,跑一次
         rt.external_ports = []
         r = rt.search("测试查询", agent_id="supervisor")
         assert r.confidence is not None
@@ -124,7 +121,6 @@ def test_agent_port_all_subsources():
     assert any("thoughtchain" in o for o in origins("预算风险")), "推理链应连通"
     assert any("capability:skill" in o for o in origins("发邮件")), "能力目录应连通"
     assert any(":hmr:" in o for o in origins("任意")), "各Agent记忆应连通"
-    # 全部证据都标记为 AGENT 源
     evs = port.query("星巴克", top_k=8)
     assert all(e.source == SourceType.AGENT for e in evs)
     print("  ✓ 财务/学习/行程/推理链/能力/各Agent记忆 六路均连通,来源标记 AGENT")
@@ -137,20 +133,16 @@ def test_bidirectional_and_internal_only():
         from foxclaw import Foxclaw
         from foxclaw.search import SourceType
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        # 往财务内核放一笔交易
         from foxclaw.finance.models import Transaction
         os_.finance_runtime.add_transaction(
             Transaction(entity="蔚来汽车", amount=-260000, category="购车",
                         account="alipay", timestamp="2026-05-01T10:00:00"),
             run_gatekeeper=False)
-        # 触发 search_runtime 装配(会把自身注入各 Agent)
         _ = os_.search_runtime
-        # 财务 Agent 反向调用内部搜索
         res = os_.finance.search_internal("蔚来汽车")
         assert res is not None, "search_internal 应返回 SearchResult"
         agent_ev = [n for n in res.graph.nodes.values() if n.source == SourceType.AGENT]
         assert any("蔚来" in n.fact for n in agent_ev), "应从财务内核检索到该交易"
-        # internal_only:轨迹里不应出现 web 证据来源
         assert all(n.source != SourceType.WEB for n in res.graph.nodes.values())
         print(f"  ✓ os_.finance.search_internal('蔚来汽车') → AGENT证据 {len(agent_ev)} 条,无联网")
         asyncio.run(os_.aclose())
@@ -168,7 +160,6 @@ def test_internal_source_isolation():
             from foxclaw.search.models import RawEvidence
             return [RawEvidence(id="k1", fact=f"知识:{text}", source=SourceType.KNOWLEDGE,
                                 origin="hkc:k1", confidence=0.7)]
-    # agent_port 抛异常 + memory(FakeHMR)正常 + knowledge 正常 → search 不崩,仍返回其它源证据
     rt = SearchRuntime(hmr=FakeHMR(), knowledge_port=_OKKnow(),
                        agent_port=_BoomPort(), external_ports=[])
     r = rt.search("测试查询", agent_id="finance", internal_only=True)
@@ -176,7 +167,6 @@ def test_internal_source_isolation():
     assert any("知识" in f for f in facts), "知识源应仍返回(不受 agent 源崩溃影响)"
     assert any("记忆" in f for f in facts), "记忆源应仍返回"
     print(f"  ✓ agent 源抛异常被隔离,其它源正常:{len(r.graph.nodes)} 节点")
-    # 全部内部源都抛异常 → search 仍不崩,返回空图(优雅降级)
     rt2 = SearchRuntime(hmr=None, knowledge_port=_BoomPort(),
                         agent_port=_BoomPort(), external_ports=[])
     r2 = rt2.search("测试", internal_only=True)

package/python/tests/test_secrets.py

@@ -37,8 +37,6 @@ def no_kr(monkeypatch):
     monkeypatch.setattr(secrets, "_keyring", lambda: None)
 
 
-# ── 基础行为 ──────────────────────────────────────────────────
-
 def test_store_takes_over_when_keyring_available(fake_kr):
     assert secrets.store("m1", "sk-abc") is True
     assert fake_kr.store[(secrets.SERVICE, "m1")] == "sk-abc"
@@ -76,7 +74,7 @@ def test_rename_without_source_is_noop(fake_kr):
 def test_delete_is_idempotent(fake_kr):
     secrets.store("m1", "sk-abc")
     secrets.delete("m1")
-    secrets.delete("m1")            # 再删一次不能抛
+    secrets.delete("m1")
     assert secrets.load("m1") == ""
 
 
@@ -84,8 +82,6 @@ def test_delete_without_keyring_does_not_raise(no_kr):
     secrets.delete("m1")
 
 
-# ── 写入侧:JSON 里放什么 ─────────────────────────────────────
-
 def test_save_key_keeps_only_marker_when_keyring_available(fake_kr):
     """有 OS 凭据库时,JSON 里不能再有任何可还原的密文。"""
     from foxclaw.api.routes.llm_admin import _save_key
@@ -110,7 +106,7 @@ def test_save_key_empty_input_clears_both(no_kr):
 
 
 @pytest.mark.parametrize("record,expected", [
-    ({"api_key_kr": True, "api_key_obf": ""}, True),     # 存 keyring
+    ({"api_key_kr": True, "api_key_obf": ""}, True),
     ({"api_key_kr": False, "api_key_obf": "c2stYWJj"}, True),
     ({"api_key": "sk-legacy"}, True),
     ({"api_key_kr": False, "api_key_obf": ""}, False),
@@ -122,8 +118,6 @@ def test_has_key(record, expected):
     assert _has_key(record) is expected
 
 
-# ── 回退而非拒绝保存 ─────────────────────────────────────────
-
 def test_obf_is_reversible(no_kr):
     """base64 只是混淆,不要在任何地方当加密用 —— 这条测试的作用是钉住这一点。"""
     import base64
@@ -152,8 +146,8 @@ def test_backend_probe_is_cached(monkeypatch):
 
     secrets.reset_probe()
     try:
-        assert secrets.available() is False        # Fail 后端等同「没有可用凭据库」
+        assert secrets.available() is False
         secrets.available()
-        assert len(calls) == 1                     # 探测结果被缓存,不反复 import
+        assert len(calls) == 1
     finally:
         secrets.reset_probe()