foxclaw 0.1.2 → 0.1.4

package/python/tests/test_agent_lifecycle.py

@@ -24,10 +24,6 @@ def test_structural_convergence():
     for A in (FinanceAgent, OfficeAgent):
         assert A.run_task is CognitiveAgent.run_task, f"{A.__name__} 不应重写 run_task"
         assert A._execute is not CognitiveAgent._execute, f"{A.__name__} 应实现 _execute"
-    # 【P1-1】主管也不再重写 run_task:路由分发拆成 SUPERVISOR_STAGES 七个 pipeline
-    # stage,走 base 统一模板(获得 hooks/流式/中断/统一 emit)。主管的差异收敛为
-    # _cognitive_pipeline 覆盖 + 领域钩子,而非另起生命周期。(本断言此前锁的是
-    # "主管保留自身 run_task" 的旧结构,P1-1 落地时同步翻转——又一处"测试锁旧行为"。)
     assert SupervisorAgent.run_task is CognitiveAgent.run_task, \
         "P1-1:主管不再重写 run_task(路由分发在 pipeline stage 里)"
     assert SupervisorAgent._cognitive_pipeline is not CognitiveAgent._cognitive_pipeline, \
@@ -37,10 +33,8 @@ def test_structural_convergence():
 
 def test_domain_hooks():
     print("\n【2】领域钩子:entities / recall 前缀 / 召回条数 逐字保留")
-    # 钩子是纯函数,可脱离实例校验(lambda(self,task))
     assert FinanceAgent._task_entities(None, "x") == ["财务", "收支", "储蓄"]
     assert FinanceAgent._recall_query(None, "买车") == "财务 买车"
-    # 行政并入办公:同一 Agent 同时覆盖学习 + 日程两个域
     assert OfficeAgent._recall_query(None, "开会") == "学习 知识 日程 行程 开会"
     assert OfficeAgent._task_entities(None, "x") == ["学习", "知识", "文档", "日程", "行程", "会议"]
     assert OfficeAgent._recall_topk == 8, "办公学习 Agent 覆盖为广泛召回 8"
@@ -58,7 +52,6 @@ def test_unified_block_handling():
         async def boom(self, task, context, session_id, memories):
             raise HarnessBlockedError(types.SimpleNamespace(reason="模拟越界"), None)
 
-        # 只替换 finance 的领域执行,模板的兜底应把它转成结构化错误
         os_.finance._execute = types.MethodType(boom, os_.finance)
         r = asyncio.run(os_.finance.run_task("危险任务"))
         assert r.get("error") == "harness_blocked", f"应兜底为 harness_blocked,实得 {r}"
@@ -81,16 +74,13 @@ def test_finance_verify_before_recommend():
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
         fin = os_.finance
-        # 给账本内核灌入真实交易 → analyze() 有据可依(当前数据源存在)
         os_.finance_runtime.import_csv(
             str(Path(__file__).parent.parent / "examples" / "sample_transactions.csv"))
-        # 捕获传给 LLM 的 prompt(不真调模型)
         captured = {}
         async def _capture(self, task, messages):
             captured["prompt"] = messages[-1]["content"]
             return "（模拟回答）"
         fin._call_llm_web = types.MethodType(_capture, fin)
-        # 一条**过时**召回记忆:若被当作事实会误导用户
         stale = [{"content": "历史:上月预算结余 8000 元", "id": "m1"}]
         asyncio.run(fin._execute("这个月还能花多少?", {}, "s1", stale))
         p = captured["prompt"]
@@ -115,32 +105,23 @@ def test_run_task_stream():
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        # 单 Agent 认知管线(7 stage)用领域 Agent 验证:主管走的是 meta/schedule/dispatch
-        # 另一条管线,不能拿它当"标准 stage 序列"的样本。
         ag = os_.office
-        ag.router.provider = "stub"  # 强制 stub(is_stub = provider=='stub'):离线确定性(不受本机
-                                     # 是否配了 LLM key 影响),且 stub 的 router.stream 走 _chunk_text
-                                     # 无损分块 → 可断言"流式 token 拼接 == 最终答案"
+        ag.router.provider = "stub"
 
-        # (a) 正常流式:collect 所有事件
         events = list(ag.run_task_stream("帮我总结一下今天"))
         stages = [e["stage"] for e in events if "stage" in e]
         deltas = [e["delta"] for e in events if "delta" in e]
         results = [e["result"] for e in events if "result" in e]
         assert stages == ["perceive", "recall", "plan", "route", "act", "verify", "reflect"], stages
-        # delta 非空 = _act_stream contextvar 成功跨线程/asyncio 传到了 _call_llm(核心正确性证明)
         assert len(deltas) > 0, "act 应逐 token 出字;为空说明 contextvar 没传到 _call_llm"
         assert len(results) == 1, f"应恰有一个最终 result,实得 {len(results)}"
         res = results[0]
         assert res.get("agent") == ag.AGENT_ID and "session_id" in res and "result" in res
-        # 拼接的流式 token == 最终答案(token 透传忠实;_chunk_text 无损)
         assert "".join(deltas) == res["result"], "流式 token 拼接应等于最终答案"
 
-        # (b) 行为保持:非流式 run_task 仍正常、返回体无 delta 泄漏
         plain = asyncio.run(ag.run_task("帮我总结一下今天"))
         assert "result" in plain and "delta" not in plain and plain.get("agent") == ag.AGENT_ID
 
-        # (c) stop_event 预置 → 流式在起步即停:无 stage、无 delta、result.interrupted
         import threading as _th
         ev = _th.Event(); ev.set()
         ev_events = list(ag.run_task_stream("这个任务会被中断", stop_event=ev))
@@ -149,8 +130,6 @@ def test_run_task_stream():
         assert ev_stages == [], f"预置 stop → 0 个 stage 事件,实得 {ev_stages}"
         assert len(ev_results) == 1 and ev_results[0].get("interrupted") is True, ev_results
 
-        # (d) fail-safe:act 流式若抛异常 → 降级非流式 complete、返回正常(不崩、不中断任务)。
-        # 锁住 _call_llm docstring 承诺的"流式任何异常 → fail-safe 降级 complete"。
         def _boom(*a, **k):
             raise RuntimeError("流式炸了")
         ag.router.stream = _boom
@@ -193,12 +172,10 @@ def test_interrupted_task_not_sunk():
             captured["blocked"] = blocked
             return orig(task, result, blocked=blocked, context=context)
         ag._emit_execution = _spy
-        # (a) 预置 stop → 中断 → blocked=True(不沉淀部分/空结果为真值)
         ev = _th.Event(); ev.set()
         r = asyncio.run(ag.run_task("会被中断的任务", stop_event=ev))
         assert r.get("interrupted") is True, r
         assert captured.get("blocked") is True, "中断任务必须 blocked=True(不把部分/空结果当完成真值沉淀)"
-        # (b) 正常任务 → blocked=False(behavior-preserving:照常沉淀)
         captured.clear()
         r2 = asyncio.run(ag.run_task("正常任务"))
         assert "interrupted" not in r2 and captured.get("blocked") is False, \
@@ -220,7 +197,7 @@ def test_reasoning_lifecycle_hooks():
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        ag = os_.office          # 单 Agent 认知管线(见上一条注释)
+        ag = os_.office
         ag.router.provider = "stub"
         seen = {}
         def _cap_complete(system, messages, max_tokens, agent_id):
@@ -228,13 +205,11 @@ def test_reasoning_lifecycle_hooks():
             return "（stub 回答）"
         ag.router.complete = _cap_complete
 
-        # (a) 无钩子基线:不注入(behavior-preserving)
         asyncio.run(ag.run_task("基线任务"))
         base_msgs = seen.get("messages", [])
         assert base_msgs and "【E2注入】" not in base_msgs[0].get("content", ""), \
             f"无 pre_reasoning 钩子时不应注入,实得 {base_msgs[:1]}"
 
-        # (b) 注册 pre_reasoning(注入)+ task_complete(观测)
         completed = []
         ag.hooks.register("pre_reasoning", lambda c: {"additional_context": "【E2注入】优先考虑省钱"})
         ag.hooks.register("task_complete", lambda c: completed.append(c.get("result")))
@@ -242,13 +217,11 @@ def test_reasoning_lifecycle_hooks():
         msgs = seen.get("messages", [])
         joined = " ".join(m.get("content", "") for m in msgs)
         assert "【E2注入】优先考虑省钱" in joined, f"pre_reasoning 注入应进入 LLM messages,实得 {msgs}"
-        # A3:注入须合并进 user 消息,**不得产生连续两条 user**(模型无关铁律,某些端点会拒连续 user)
         roles = [m.get("role") for m in msgs]
         assert not any(roles[i] == roles[i + 1] == "user" for i in range(len(roles) - 1)), \
             f"注入不应产生连续两条 user 消息(违反模型无关铁律),roles={roles}"
         assert len(completed) == 1, f"task_complete 应触发一次并收到 result,实得 {len(completed)}"
 
-        # (c) HarnessBlock 结束路径:task_complete 也触发(观测被拦截任务,带 error)
         import types
         async def _boom(self, task, context, session_id, memories):
             raise HarnessBlockedError(types.SimpleNamespace(reason="E2越界"), None)
@@ -274,32 +247,28 @@ def test_preference_priority_recall():
     try:
         from foxclaw import Foxclaw
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
-        ag = os_.office          # 单 Agent 认知管线(见上一条注释)
+        ag = os_.office
         ag.router.provider = "stub"
         seen = {}
         def _cap(system, messages, max_tokens, agent_id):
             seen["messages"] = messages; return "（stub）"
         ag.router.complete = _cap
 
-        # (a) 明确偏好表达 → 存成带 preference tag(shared)
         asyncio.run(ag.run_task("我喜欢简洁直接的回答，不要长篇大论"))
         prefs = ag.hmr.recall_by_tag(agent_id="supervisor", tag="preference", limit=8)
         assert any("简洁" in p.get("content", "") for p in prefs), f"偏好应带 preference tag 存下,实得 {prefs}"
 
-        # (b) 发**语义完全不相关**的任务 → 偏好仍注入 prompt(纯语义召回此时召不到)
         seen.clear()
         asyncio.run(ag.run_task("解释一下光合作用的原理"))
         joined = " ".join(m.get("content", "") for m in seen.get("messages", []))
         assert "用户偏好" in joined and "简洁" in joined, \
             f"语义不相关任务也应注入偏好(越用越懂你),实得 {seen.get('messages')}"
 
-        # (c) 无偏好信号的普通任务不误存(保守采集)
         before = len(ag.hmr.recall_by_tag(agent_id="assistant", tag="preference"))
         asyncio.run(ag.run_task("光合作用发生在植物的哪个部位"))
         after = len(ag.hmr.recall_by_tag(agent_id="assistant", tag="preference"))
         assert after == before, "无偏好信号的任务不应新增偏好"
 
-        # (d) 关采集开关 → 偏好句也不存(可关)
         os.environ["FOXCLAW_PREF_CAPTURE"] = "0"
         try:
             asyncio.run(ag.run_task("我喜欢用表格展示数据"))
@@ -308,16 +277,14 @@ def test_preference_priority_recall():
         finally:
             os.environ.pop("FOXCLAW_PREF_CAPTURE", None)
 
-        # (e) 对话路径(stream_reply)也注入偏好——之前只测了任务路径(深审 F2:claim 必测)
         seen_stream = []
         def _cap_stream(system, messages, *a, **k):
             seen_stream.append(messages); yield "（stub）"
         ag.router.stream = _cap_stream
-        list(ag.stream_reply("随便讲点什么"))   # 语义与"简洁"偏好不相关
+        list(ag.stream_reply("随便讲点什么"))
         js = " ".join(m.get("content", "") for m in (seen_stream[0] if seen_stream else []))
         assert "用户偏好" in js and "简洁" in js, f"对话路径(stream_reply)也应注入偏好,实得 {seen_stream}"
 
-        # (f) 去重:同一偏好存多条,召回只返一条(深审 F1)
         for _ in range(3):
             ag._store_memory("用户偏好:我喜欢简洁直接的回答，不要长篇大论",
                              mem_type="preference", tags=["preference"], shared=True)
@@ -325,7 +292,6 @@ def test_preference_priority_recall():
         same = [p for p in got if "简洁直接的回答" in p.get("content", "")]
         assert len(same) == 1, f"重复偏好召回应去重为 1 条,实得 {len(same)}"
 
-        # (g) 删偏好途径(F3):存唯一偏好 → list 找到(带 id)→ delete → 确认删除
         ag._store_memory("用户偏好:请用英文回复", mem_type="preference", tags=["preference"], shared=True)
         target = [p for p in ag.list_preferences() if "英文" in p.get("content", "")]
         assert target and target[0].get("id"), f"唯一偏好应可列出带 id,实得 {target}"

package/python/tests/test_agent_rules.py

@@ -0,0 +1,81 @@
+"""
+Agent 规则文件加载测试 —— 全离线。
+
+覆盖:
+  1. agents/rules/<AGENT_ID>/*.md 在组装系统提示词时被读入(启动即生效,不靠代码常驻)。
+  2. 叠加顺序:内核前缀 → 角色职责 → 本 Agent 规则;规则位于最后。
+  3. 回退开关 FOXCLAW_AGENT_RULES=0 可整体关闭;无 AGENT_ID / 无目录时不注入。
+  4. 规则目录必须落在 foxclaw 包内(随 wheel 分发,不能像仓库根 skills/ 那样漏包)。
+"""
+import os, sys, types
+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"
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from foxclaw.agents.base import KERNEL_PROMPT
+from foxclaw.agents.mixins.prompt import PromptMixin, RULES_DIR, load_agent_rules
+
+
+def _fake(role="我是财务角色ROLEXYZ。", agent_id="finance"):
+    return types.SimpleNamespace(_role_prompt=role, AGENT_ID=agent_id)
+
+
+def test_finance_rules_file_is_loaded():
+    text = load_agent_rules("finance")
+    assert "Personal Finance Agent Rules v1.0" in text
+    assert "不得编造" in text
+    assert "储蓄率" in text
+
+
+def test_unknown_agent_has_no_rules():
+    assert load_agent_rules("no_such_agent") == ""
+    assert load_agent_rules("") == ""
+
+
+def test_system_prompt_order_kernel_role_rules():
+    out = PromptMixin.system_prompt.fget(_fake())
+    assert KERNEL_PROMPT in out
+    assert out.index("认知操作系统") < out.index("ROLEXYZ") < out.index("Personal Finance Agent Rules")
+
+
+def test_rules_follow_kernel_when_role_is_short():
+    out = PromptMixin.system_prompt.fget(_fake(role="ROLEXYZ"))
+    assert "本 Agent 专业规则(必须遵守)" in out
+    assert "月度结余" in out
+
+
+def test_switch_disables_rules(monkeypatch):
+    monkeypatch.setenv("FOXCLAW_AGENT_RULES", "0")
+    out = PromptMixin.system_prompt.fget(_fake())
+    assert "ROLEXYZ" in out and "Personal Finance Agent Rules" not in out
+
+
+def test_switch_disables_rules_even_without_kernel(monkeypatch):
+    monkeypatch.setenv("FOXCLAW_KERNEL_PROMPT", "0")
+    monkeypatch.setenv("FOXCLAW_AGENT_RULES", "0")
+    monkeypatch.setenv("FOXCLAW_BEHAVIOR", "0")
+    assert PromptMixin.system_prompt.fget(_fake(role="ROLEXYZ")) == "ROLEXYZ"
+
+
+def test_rules_survive_kernel_off(monkeypatch):
+    monkeypatch.setenv("FOXCLAW_KERNEL_PROMPT", "0")
+    out = PromptMixin.system_prompt.fget(_fake(role="ROLEXYZ"))
+    assert KERNEL_PROMPT not in out
+    assert "Personal Finance Agent Rules" in out
+    # 行为规范是硬边界,不随内核前缀一起关掉
+    assert out.index("[行为规范") < out.index("ROLEXYZ")
+
+
+def test_agent_without_id_gets_no_rules():
+    fake = types.SimpleNamespace(_role_prompt="ROLEXYZ")
+    out = PromptMixin.system_prompt.fget(fake)
+    assert "ROLEXYZ" in out and "Personal Finance Agent Rules" not in out
+
+
+def test_rules_dir_lives_inside_package():
+    """规则文件必须在 foxclaw 包内:仓库根的 skills/ 就没被打进 wheel,别重演。"""
+    pkg = Path(RULES_DIR).resolve()
+    assert pkg.name == "rules" and pkg.parent.name == "agents"
+    assert (pkg / "finance" / "RULES.md").is_file()

package/python/tests/test_ahs_p2.py

@@ -33,7 +33,6 @@ def check(cond, label):
         print(f"  ✗ {label}")
 
 
-# ═══════════════ [1]-[3] P2-2 compose pending ═══════════════
 from foxclaw.skills import SkillRegistry, SkillSpec, SkillAdapter
 from foxclaw.skills.pipeline import compose, plan, AHSPipeline
 
@@ -58,7 +57,7 @@ def _make_pending_registry(counter: dict):
     reg.register(SkillSpec(
         id="send_email", name="发邮件", description="发邮件",
         kind="local", triggers=["发送", "邮件"], side_effect="send",
-        destructive=True,                       # ← 未确认 → needs_confirmation
+        destructive=True,
         handler=lambda to="": {"sent": to}, params={"to": "str"}))
     return reg
 
@@ -92,8 +91,6 @@ def test_compose_pending():
 
 def test_compose_failed_still_rolls_back():
     print("\n【1b】对照:P2-2 后真失败(not_connected)仍触发回滚")
-    # confirmed=True:write/send 都过权限;第二步 handler=None → dispatch not_connected
-    # → 真失败 → 回滚第一步(write 副作用,有 compensate)。若误走 pending 则不回滚。
     reg = SkillRegistry()
     rolled = []
     reg.register(SkillSpec(
@@ -104,7 +101,7 @@ def test_compose_failed_still_rolls_back():
     reg.register(SkillSpec(
         id="send_email", name="发邮件", description="发邮件",
         kind="local", triggers=["发送", "邮件"], side_effect="send",
-        handler=None,                            # ← 无 handler → not_connected(非 pending)
+        handler=None,
         params={"to": "str"}))
     adp = SkillAdapter(reg)
     res = compose(plan("创建日程 然后 发送邮件", reg), reg, adp, confirmed=True)
@@ -151,7 +148,6 @@ def test_ahs_pipeline_pending():
           "composition 字典带 pending_confirmation/completed_steps,未回滚")
 
 
-# ═══════════════ [4] P2-1 run_async ═══════════════
 def test_run_async():
     print("\n【4】P2-1:run_async 异步入口")
     reg = SkillRegistry()
@@ -171,24 +167,19 @@ def test_run_async():
     pipe = AHSPipeline(reg, SkillAdapter(reg))
 
     async def _main():
-        # a) 返回 PipelineResult
         r = await pipe.run_async("计算 1+1")
         check(r.task == "计算 1+1" and (r.success or r.is_pending),
               "run_async 返回 PipelineResult")
-        # b) 不阻塞事件循环:两个 0.5s 慢任务并发,若串行 ≥1.0s,并发 ≈0.5s
-        #    (阈值 0.9s:串行/并发区分度大,且留足调度抖动余量——0.3/0.5 的窄距实测会偶抖)
         t0 = time.perf_counter()
         await asyncio.gather(pipe.run_async("慢 1+1"), pipe.run_async("慢 2+2"))
         elapsed = time.perf_counter() - t0
         check(elapsed < 0.9,
               f"并发两个慢 run_async 耗时 {elapsed:.2f}s < 0.9s(未阻塞事件循环)")
     asyncio.run(_main())
-    # c) 同步 run 向后兼容
     r_sync = pipe.run("计算 1+1")
     check(r_sync.task == "计算 1+1", "同步 run 仍可用(向后兼容)")
 
 
-# ═══════════════ [5]-[7] P2-3 idempotency ═══════════════
 from foxclaw.core.idempotency import IdempotencyGuard
 
 
@@ -204,7 +195,7 @@ def test_idem_append_log():
     print("\n【5】P2-3:追加日志(O(1) 写)+ compact 合并 + 重启回放")
     d = tempfile.mkdtemp(prefix="idem_a_")
     path = os.path.join(d, "idem.json")
-    g = IdempotencyGuard(persist_path=path, compact_every=1000)   # 不触发 compact
+    g = IdempotencyGuard(persist_path=path, compact_every=1000)
     g.mark("k1"); g.mark("k2"); g.mark("k3")
     log_path = path + ".log"
     check(os.path.exists(log_path), "mark 产生追加日志")
@@ -213,7 +204,6 @@ def test_idem_append_log():
     check(len(lines) == 3, f"3 次 mark = 3 行日志(实为 {len(lines)}),非全量写")
     check(not os.path.exists(path), "未达阈值不写全量快照")
 
-    # compact 合并:compact_every=5,第 5 次 mark 触发(轮转日志→快照;新 append 开新文件)
     d2 = tempfile.mkdtemp(prefix="idem_b_")
     path2 = os.path.join(d2, "idem.json")
     g2 = IdempotencyGuard(persist_path=path2, compact_every=5)
@@ -225,13 +215,11 @@ def test_idem_append_log():
     with open(path2, encoding="utf-8") as f:
         data = json.load(f)
     check(len(data) == 5, f"快照含全部 5 条(实为 {len(data)})")
-    # compact 之后的新 mark 进新日志;重启 = 读快照(5) + 回放新日志(1) = 6
     g2.mark("k5")
     g2b = IdempotencyGuard(persist_path=path2, compact_every=10000)
     check(all(g2b.seen(f"k{i}") for i in range(6)),
           "compact 后继续 mark:重启回放 = 快照5 + 新日志1 = 6 全可见")
 
-    # 重启回放:g3 不写快照(阈值大),g4 启动 = 读快照(无)+ 回放日志
     d3 = tempfile.mkdtemp(prefix="idem_c_")
     path3 = os.path.join(d3, "idem.json")
     g3 = IdempotencyGuard(persist_path=path3, compact_every=10000)
@@ -243,7 +231,6 @@ def test_idem_append_log():
 
 def test_idem_compat_and_eviction():
     print("\n【6】P2-3:旧快照兼容 + 容量淘汰发 delete(重启不复活)")
-    # 旧格式:纯全量快照,无 .log → 直接可读
     d = tempfile.mkdtemp(prefix="idem_d_")
     path = os.path.join(d, "idem.json")
     with open(path, "w", encoding="utf-8") as f:
@@ -252,7 +239,6 @@ def test_idem_compat_and_eviction():
     check(g.seen("legacy_k") and g.get_result("legacy_k") == {"x": 1},
           "旧版纯快照格式兼容(无日志,回放为空)")
 
-    # 容量淘汰必须落 delete:否则重启回放 mark 日志会"复活"被淘汰的 key
     d2 = tempfile.mkdtemp(prefix="idem_e_")
     path2 = os.path.join(d2, "idem.json")
     g2 = IdempotencyGuard(persist_path=path2, max_size=2, compact_every=10000)
@@ -277,7 +263,7 @@ def test_idem_persist_failure():
         return orig_open(*a, **kw)
     builtins.open = _bad_open
     try:
-        g.mark("k1")          # 追加日志失败 → 计数 + 事件;主流程不炸
+        g.mark("k1")
     finally:
         builtins.open = orig_open
     check(g.seen("k1"), "持久化失败不影响内存主流程")
@@ -289,7 +275,6 @@ def test_idem_persist_failure():
           "stats() 含新字段(无 persist_path 也一样)")
 
 
-# ═══════════════ [8]-[9] P2-4 recovery ═══════════════
 from foxclaw.core.recovery import RestartRecovery, RecoveryPlan
 
 
@@ -313,7 +298,6 @@ def test_recovery_plan():
           "details 逐任务带 action")
     evts = [e for e in spine.events if e[0] == "recovery.plan"]
     check(len(evts) == 3, f"每个分类决定发 recovery.plan 事件(实为 {len(evts)})")
-    # scan_interrupted 返回类型不变(兼容)
     check(isinstance(r2.scan_interrupted(), list), "scan_interrupted 仍返回 list(兼容)")
 
 
@@ -330,7 +314,6 @@ def test_recovery_details():
     check(records["t1"].status == "in_progress" and records["t1"].description == "second",
           "重复 start 保留最后一次")
 
-    # compact_log:started 很早、finished 刚刚 → 旧逻辑(只看 started)会丢,新逻辑保留
     d2 = tempfile.mkdtemp(prefix="recv_c_")
     log2 = os.path.join(d2, "log.jsonl")
     old = time.time() - 30 * 86400
@@ -345,20 +328,17 @@ def test_recovery_details():
           "compact 用 max(started,finished):started 30 天前但刚完成的记录不丢")
     check(r2._replay()["t_old"].finished > 0, "compact 保留 finished 时间戳")
 
-    # fsync=False 可用(高频场景开关)
     d3 = tempfile.mkdtemp(prefix="recv_d_")
     log3 = os.path.join(d3, "log.jsonl")
     r3 = RestartRecovery(log3, boot_id="boot1", fsync=False)
     r3.task_started("t1", "x")
     r3.task_finished("t1")
     check(r3._replay()["t1"].status == "done", "fsync=False 正常读写(开关兼容)")
-    # 空中断 → 空计划
     r4 = RestartRecovery(os.path.join(d3, "empty.jsonl"), boot_id="b")
     p4 = r4.plan_recovery([])
     check(p4.details == [] and p4.retryable == [], "无中断 → 空计划(不炸)")
 
 
-# ═══════════════ [10] P3-2 /api/ahs/run ═══════════════
 def test_api_ahs_run():
     print("\n【10】P3-2:/api/ahs/run 走 run_async + 暴露 pending 字段")
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
@@ -377,7 +357,6 @@ def test_api_ahs_run():
         check("is_pending" in body and "pending_confirmation" in body,
               "响应暴露 is_pending/pending_confirmation 字段")
         check(body.get("success") in (True, False), "success 字段正常返回")
-        # resume_state 参数被接受(闭环 P2-2 续跑;空断点现场 → 正常全跑)
         r2 = c.post("/api/ahs/run", json={
             "task": "计算 3*3", "confirmed": True,
             "resume_state": {"completed_steps": [], "resume_at": None}})

package/python/tests/test_anthropic_tools.py

@@ -64,17 +64,15 @@ def _plan_tool():
                                         "required": ["flow"]}}}
 
 
-# ── 1. 格式转换 ───────────────────────────────────────────────────────────────
 def test_to_anthropic_tools():
     out = ModelRouter._to_anthropic_tools([
         _plan_tool(),
-        {"name": "direct", "description": "", "input_schema": {}},   # 已是 anthropic 格式
+        {"name": "direct", "description": "", "input_schema": {}},
     ])
     assert len(out) == 2
     assert out[0]["name"] == "submit_plan"
     assert out[0]["input_schema"]["required"] == ["flow"]
     assert out[1]["name"] == "direct"
-    # 非法项(空名/非 dict)跳过
     assert ModelRouter._to_anthropic_tools([{"type": "function", "function": {"name": ""}}]) == []
     assert ModelRouter._to_anthropic_tools(None) == []
 
@@ -88,18 +86,15 @@ def test_to_anthropic_tool_choice():
         {"type": "function", "function": {"name": "x"}}) == {"type": "tool", "name": "x"}
 
 
-# ── 2. supports_tools ──────────────────────────────────────────────────────────
 def test_supports_tools_anthropic():
     r = _router(_fake_client([[]]))
     assert r.is_stub is False
     assert r.supports_tools() is True
-    # 无 client(stub)→ 不支持
     r2 = ModelRouter.__new__(ModelRouter)
     r2.provider = "anthropic"; r2._client = None
     assert r2.supports_tools() is False
 
 
-# ── 3. call_tools anthropic 分支 ──────────────────────────────────────────────
 def test_call_tools_anthropic_tool_use():
     client = _fake_client([[
         _block(type="tool_use", id="toolu_1", name="submit_plan",
@@ -113,13 +108,11 @@ def test_call_tools_anthropic_tool_use():
                                   "args": {"flow": "sequential",
                                            "steps": [{"name": "查支出", "agent": "finance"}]},
                                   "args_parse_failed": False}]
-    # 入参:tools 转 anthropic 格式 + tool_choice 转 auto + system 单独传 + 运行时注入
     kw = client.calls[0]
     assert kw["system"].startswith("【运行时信息") and "sys" in kw["system"]
     assert kw["tools"][0]["name"] == "submit_plan"
     assert kw["tool_choice"] == {"type": "auto"}
     assert all(m["role"] != "system" for m in kw["messages"]), "anthropic 不允许 system 角色入 messages"
-    # assistant_msg 是 anthropic 原生 blocks
     assert res["assistant_msg"]["role"] == "assistant"
     assert res["assistant_msg"]["content"][0]["type"] == "tool_use"
 
@@ -144,7 +137,6 @@ def test_call_tools_anthropic_tool_choice_none():
     assert kw["tools"][0]["name"] == "submit_plan", "历史含 tool_use 时必须仍传 tools"
 
 
-# ── 4. format_tool_result ─────────────────────────────────────────────────────
 def test_format_tool_result_anthropic():
     r = _router(_fake_client([[]]))
     out = r.format_tool_result({"id": "toolu_9", "name": "web_search"}, "结果")
@@ -152,7 +144,6 @@ def test_format_tool_result_anthropic():
         {"type": "tool_result", "tool_use_id": "toolu_9", "content": "结果"}]}
 
 
-# ── 5. fail-safe ──────────────────────────────────────────────────────────────
 def test_call_tools_anthropic_failsafe():
     def create(**kw):
         raise RuntimeError("boom")
@@ -162,19 +153,15 @@ def test_call_tools_anthropic_failsafe():
     res = r.call_tools("sys", [{"role": "user", "content": "t"}], [])
     assert res["supported"] is False and res.get("error")
 
-    # stub(无 client)→ supported=False
     r2 = _router(None)
     res2 = r2.call_tools("sys", [{"role": "user", "content": "t"}], [])
     assert res2["supported"] is False
 
 
-# ── 6. 回灌闭环(_reply_with_tools 在 anthropic 下)────────────────────────────
 def test_reply_with_tools_anthropic_loop():
     from foxclaw.agents.base import CognitiveAgent
     client = _fake_client([
-        # 第1轮:模型要求调 recall_memory
         [_block(type="tool_use", id="c1", name="recall_memory", input={"query": "偏好"})],
-        # 第2轮:拿到结果后给最终答案
         [_block(type="text", text="根据记忆,你喜欢灰色。")],
     ])
     r = _router(client)
@@ -187,7 +174,6 @@ def test_reply_with_tools_anthropic_loop():
     out = CognitiveAgent._reply_with_tools(
         agent, "我喜欢什么颜色", [{"role": "user", "content": "我喜欢什么颜色"}])
     assert out == "根据记忆,你喜欢灰色。"
-    # 第2轮的 messages 必须含 anthropic 格式 assistant(tool_use) + user(tool_result)
     kw2 = client.calls[1]
     has_tool_result = any(
         isinstance(m.get("content"), list)

package/python/tests/test_api.py

@@ -21,9 +21,8 @@ def show(title, data, limit=None):
 
 
 def test_api():
-    # 环境变量须在 import foxclaw.api 前设好(模块加载时按环境变量建网关/agent)
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
-    os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_test_")  # 不污染仓库根
+    os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_test_")
     from foxclaw.api import app
 
     with TestClient(app) as c:
@@ -31,7 +30,6 @@ def test_api():
         print("FOXCLAW · API 端到端验证 (ASGI TestClient)")
         print("="*64)
 
-        # 1. 系统状态
         r = c.get("/api/status")
         print(f"\n[GET /api/status] HTTP {r.status_code}")
         data = r.json()
@@ -39,7 +37,6 @@ def test_api():
             tc = s["thought_chain"]
             print(f"  {aid:<12} 节点={tc['total_nodes']:<3} shadow={s['harness']['shadow_mode']}")
 
-        # 2. 发任务(真实经过 ThoughtChain + Harness)
         print("\n[POST /api/task] 连发 7 个财务任务触发校准")
         for i, t in enumerate(["分析支出","制定预算","评估风险","季度报告","追踪消费","明年规划","同期对比"], 1):
             r = c.post("/api/task", json={"task": t, "agent_id": "finance"})
@@ -47,11 +44,9 @@ def test_api():
             err = d.get("error", "ok")
             print(f"  [{i}] {t} → HTTP {r.status_code} · {err}")
 
-        # 3. Harness 状态(校准后)
         r = c.get("/api/harness/finance/status")
         show("GET /api/harness/finance/status", r.json())
 
-        # 4. 推理链
         r = c.get("/api/thoughtchain/finance/chain")
         nodes = r.json()["nodes"]
         print(f"\n[GET /api/thoughtchain/finance/chain] HTTP {r.status_code} · {len(nodes)} 节点")
@@ -59,25 +54,40 @@ def test_api():
             print(f"  {n['type']:<16} {n['harness_status']:<9} "
                   f"conf={n['conf']:.2f} Δ={n.get('harness_delta') or 0:.3f}")
 
-        # 5. 漂移趋势
         r = c.get("/api/thoughtchain/finance/trend?limit=10")
         trend = r.json()["trend"]
         print(f"\n[GET .../trend] {len(trend)} 数据点 · Δ 序列:")
         print("  " + " ".join(f"{t['delta']:.2f}" for t in trend[:10]))
 
-        # 6. Policy
         r = c.get("/api/harness/finance/policy")
         pol = r.json()
         print(f"\n[GET /api/harness/finance/policy] v{pol['version']} · "
               f"{len(pol.get('rules',[]))} 规则")
 
-        # 7. 偏好管理端点(F3):GET 列出结构;DELETE 不存在 id 优雅返回 ok=False(不崩)
         r = c.get("/api/preferences")
         assert r.status_code == 200 and "preferences" in r.json(), r.text
         r = c.delete("/api/preferences/nonexistent_id")
         assert r.status_code == 200 and r.json().get("ok") is False, r.text
         print("\n[GET/DELETE /api/preferences] 列出+删除通路 ok")
 
+        r = c.put("/api/profile", json={"nickname": "  snow  "})
+        assert r.status_code == 200 and r.json().get("nickname") == "snow", r.text
+        r = c.get("/api/profile")
+        assert r.json().get("nickname") == "snow", r.text
+        c.put("/api/profile", json={"nickname": "snow2"})
+        r = c.get("/api/preferences")
+        nicks = [p["content"] for p in r.json()["preferences"] if "称呼我为" in p["content"]]
+        assert nicks == ["用户偏好:称呼我为 snow2"], nicks
+        print("\n[GET/PUT /api/profile] 称呼写入/读回/替换 ok")
+
+        r = c.get("/api/system/info")
+        info = r.json()
+        assert r.status_code == 200 and "update" in info, r.text
+        up = info["update"]
+        assert {"enabled", "current", "latest", "update_available"} <= set(up), up
+        assert up["enabled"] is False and up["update_available"] is False, up
+        print("\n[GET /api/system/info] update 字段存在,默认关闭")
+
         print("\n" + "="*64)
         print("✓ API 端到端验证完成 · 所有端点返回真实数据")
         print("="*64)

package/python/tests/test_api_auth.py

@@ -10,12 +10,10 @@ import os
 import sys
 from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
-# 本测试要精确控制 FOXCLAW_API_KEY 的有/无;若 .env 带真实 key 会污染判定
-# (见 foxclaw/api.py 中 FOXCLAW_SKIP_DOTENV 的说明),故关掉 .env。
 os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
 
 import tempfile
-os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_test_")  # 不污染仓库根
+os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_test_")
 from fastapi.testclient import TestClient
 from foxclaw.api import app
 
@@ -44,7 +42,6 @@ def main():
               "正确 key → 200")
 
         print("\n【3】WebSocket 鉴权(端点内 ?key=,http 中间件管不到 ws)")
-        # 无 key → 握手被拒(端点 close 1008)
         rejected = False
         try:
             with c.websocket_connect("/ws/harness"):
@@ -52,7 +49,6 @@ def main():
         except Exception:
             rejected = True
         check(rejected, "WS 无 key → 握手被拒")
-        # 带 ?key= → 连上
         connected = False
         try:
             with c.websocket_connect("/ws/harness?key=secret-123"):