foxclaw 0.1.2 → 0.1.4

package/python/tests/test_governance.py

@@ -23,36 +23,30 @@ def check(cond, msg):
 def test_loop_detection():
     print("\n【1】工具循环检测")
     from foxclaw.harness.loop_detection import ToolLoopDetector
-    # repeat
     d = ToolLoopDetector(warning=3, critical=5, circuit_break=8)
     for _ in range(8):
         v = d.record("web_search", {"q": "天气"})
     check(v.stuck and v.detector == "repeat", "重复调用检测为 repeat")
-    # ping_pong
     d2 = ToolLoopDetector(warning=4, critical=6, circuit_break=10)
     for i in range(6):
         v2 = d2.record("search" if i % 2 == 0 else "fetch", {"x": i % 2})
     check(v2.stuck and v2.detector == "ping_pong", "交替调用检测为 ping_pong")
-    # no_progress
     d3 = ToolLoopDetector(warning=3, critical=5, circuit_break=8)
     for _ in range(5):
         v3 = d3.record("poll", {"id": "j"}, result={"status": "pending"})
     check(v3.stuck and v3.detector == "no_progress", "轮询无变化检测为 no_progress")
-    # 正常不误报
     d4 = ToolLoopDetector(warning=3)
     for q in ["a", "b", "c", "d", "e"]:
         v4 = d4.record("search", {"q": q})
     check(not v4.stuck, "多样调用不误报")
-    # 熔断
     check(d.should_abort(), "达阈值 should_abort")
 
 
 def test_loop_per_session():
     print("\n【1b】循环检测 per-session 隔离(阶段四·步骤13,消除跨会话污染)")
     from foxclaw.skills import SkillAdapter, set_loop_session, reset_loop_session, _loop_session
-    adp = SkillAdapter(None)   # _detector_for 不依赖 registry,构造最小实例即可
+    adp = SkillAdapter(None)
 
-    # 会话 A 连续同工具 8 次(达熔断)
     tok = set_loop_session("sess_A")
     try:
         for _ in range(8):
@@ -61,7 +55,6 @@ def test_loop_per_session():
         reset_loop_session(tok)
     check(va.stuck, "会话 A 连续同工具达熔断")
 
-    # 切到会话 B:历史应从零,同工具仅 1 次不应被 A 污染成 stuck
     tok = set_loop_session("sess_B")
     try:
         vb = adp._detector_for(_loop_session.get()).record("web_search", {"q": "天气"})
@@ -70,7 +63,6 @@ def test_loop_per_session():
     check(not vb.stuck, "会话 B 不受会话 A 污染(独立历史)")
     check(not adp._detector_for("sess_B").should_abort(), "会话 B 未达熔断")
 
-    # 不同会话持有独立检测器实例;无会话时用共享默认槽(向后兼容)
     check(adp._detector_for("sess_A") is not adp._detector_for("sess_B"), "不同会话独立检测器实例")
     check(adp._detector_for(None) is adp._detector_for(None), "无会话共用默认槽(稳定)")
     check(_loop_session.get() is None, "退出后 contextvar 已复位(无残留)")
@@ -79,12 +71,9 @@ def test_loop_per_session():
 def test_compaction():
     print("\n【2】上下文压缩")
     from foxclaw.core.compaction import Compactor, extract_identifiers, estimate_messages_tokens
-    # token 估算(压缩触发的判据)
     check(estimate_messages_tokens([{"role": "user", "content": "你好世界"}]) > 0, "token 估算非零")
-    # 标识符提取(含 ¥金额)
     ids = extract_identifiers([{"role": "user", "content": "订单 txn_abc12345 金额 ¥1,200 流水 202606210001"}])
     check("txn_abc12345" in ids and any("¥" in i for i in ids), "关键标识符提取(含金额)")
-    # 截断兜底(无 router)
     msgs = [{"role": "system", "content": "你是助手"}]
     for i in range(10):
         msgs.append({"role": "user", "content": f"长消息{i}" * 20})
@@ -93,7 +82,6 @@ def test_compaction():
     r = c.compact(msgs)
     check(r.method == "truncate" and r.compacted_tokens < r.original_tokens, "无 router 截断兜底有效")
     check(r.messages[-1] == msgs[-1], "最近消息保留")
-    # 巨大系统消息 → 放弃无效压缩
     huge = [{"role": "system", "content": "x" * 8000}]
     for i in range(6):
         huge.append({"role": "user", "content": f"m{i}"})
@@ -108,20 +96,17 @@ def test_hooks():
     from foxclaw.skills.hooks_spec import Hooks, normalize_hook, is_valid_hook
     check(normalize_hook("pre_skill") == Hooks.BEFORE_TOOL_CALL, "旧名规整为标准名")
     check(is_valid_hook("on_loop"), "on_loop 是合法钩子")
-    # 向后兼容互通
     hm = HookManager()
     fired = []
     hm.register("pre_skill", lambda ctx: fired.append("x") or {})
     hm.fire("before_tool_call", "calc", {})
     check("x" in fired, "旧名注册 + 标准名触发 互通")
-    # 阻断权
     hm2 = HookManager()
     hm2.register("before_tool_call", lambda ctx: {"block": True, "reason": "test"})
     check(hm2.fire("before_tool_call", "calc", {}).blocked, "before_tool_call 可阻断")
     hm3 = HookManager()
     hm3.register("after_tool_call", lambda ctx: {"block": True})
     check(not hm3.fire("after_tool_call", "calc", {}).blocked, "after_tool_call 无阻断权")
-    # 非法名警告
     hm4 = HookManager()
     hm4.register("typo_hook", lambda ctx: {})
     check(any("未知钩子" in a.get("error", "") for a in hm4.audit_log), "拼错钩子名有警告")
@@ -135,7 +120,6 @@ def test_idempotency():
     check(k1 == k2, "相同输入得相同 key")
     g = IdempotencyGuard(ttl_seconds=3600)
     check(g.check_and_mark(k1) and not g.check_and_mark(k1), "原子查重:首次True重复False")
-    # 并发只1个成功
     g2 = IdempotencyGuard(ttl_seconds=3600)
     results, lock = [], threading.Lock()
     def worker():
@@ -145,11 +129,9 @@ def test_idempotency():
     for t in ts: t.start()
     for t in ts: t.join()
     check(sum(results) == 1, "50 线程抢同 key 恰好 1 个成功")
-    # TTL
     g3 = IdempotencyGuard(ttl_seconds=0.3)
     g3.check_and_mark("tmp"); time.sleep(0.4)
     check(g3.check_and_mark("tmp"), "TTL 过期后可重新执行")
-    # 跨重启
     p = tempfile.mktemp(suffix=".json")
     ga = IdempotencyGuard(persist_path=p); ga.check_and_mark("pk")
     gb = IdempotencyGuard(persist_path=p)
@@ -161,22 +143,16 @@ def test_recovery():
     print("\n【5】重启恢复")
     from foxclaw.core.recovery import RestartRecovery, _pid_alive
     log = tempfile.mktemp(suffix=".jsonl")
-    # boot_id 防 pid 复用
     rA = RestartRecovery(log_path=log, boot_id="bootA")
     rA.task_started("t1", "中断任务")
-    # 即使 pid 是存活的(复用),boot_id 不同也应识别中断
     rB = RestartRecovery(log_path=log, boot_id="bootB", current_pid=os.getpid())
     interrupted = rB.scan_interrupted()
     check(len(interrupted) == 1 and interrupted[0].task_id == "t1", "boot_id 识别中断(防 pid 复用)")
-    # 本次启动自己的任务不误判
     rB.task_started("t2", "本次任务")
     check(not any(t.task_id == "t2" for t in rB.scan_interrupted()), "不误判本次启动的任务")
-    # 完成的不算中断
     rB.task_finished("t2")
     check(not any(t.task_id == "t2" for t in rB.scan_interrupted()), "已完成任务不算中断")
     check(_pid_alive(os.getpid()) and not _pid_alive(999999), "pid 存活检测准确")
-    # 危险路径回归:探测【外部活进程】必须 True 且【绝不杀死】它
-    # (旧实现在 Windows 上 os.kill(pid,0) 会 TerminateProcess 误杀,本用例专抓此坑)
     import subprocess
     proc = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(10)"])
     try:
@@ -192,13 +168,11 @@ def test_recovery():
 def test_steering_queue():
     print("\n【6】干预队列")
     from foxclaw.core.steering_queue import SteeringQueue
-    # 基本流
     q = SteeringQueue(lease_seconds=30)
     q.publish("m1", "finance", {"r": "A"})
     leased = q.lease("m1")
     check(len(leased) == 1, "publish→lease")
     check(q.ack(leased[0].item_id, leased[0].lease_id), "ack 成功移除")
-    # 并发不重复租用
     q2 = SteeringQueue(lease_seconds=30)
     for i in range(20):
         q2.publish("m2", "a", {"i": i})
@@ -210,11 +184,9 @@ def test_steering_queue():
     for t in ts: t.start()
     for t in ts: t.join()
     check(len(got) == len(set(got)) == 20, "并发租取不重复")
-    # 租约过期重入队
     q3 = SteeringQueue(lease_seconds=0.3)
     q3.publish("m3", "a", {}); q3.lease("m3"); time.sleep(0.4)
     check(q3.pending_count() == 1, "租约过期自动重入队(不丢)")
-    # drain 尊重租约
     q4 = SteeringQueue(lease_seconds=30)
     q4.publish("m4", "a", {"r": 1}); q4.publish("m4", "a", {"r": 2})
     q4.lease("m4", max_items=1)
@@ -224,27 +196,21 @@ def test_steering_queue():
 def test_token_meter():
     print("\n【7】Token 计量器")
     from foxclaw.core.token_meter import TokenMeter, estimate_tokens
-    # 估算非零
     check(estimate_tokens("你好世界hello") > 0, "token 估算非零")
     check(estimate_tokens("") == 0, "空文本 0 token")
     m = TokenMeter()
-    # 真实 usage 优先(estimated=False)
     r1 = m.measure_call(system="s", messages=[{"role": "user", "content": "q"}],
                         output="a", provider="deepseek", model="deepseek-chat",
                         agent_id="finance", usage={"input_tokens": 100, "output_tokens": 200})
     check(not r1.estimated and r1.total_tokens == 300, "真实 usage 优先,total 正确")
-    # 无 usage 走估算(estimated=True)
     r2 = m.measure_call(system="你是主管", messages=[{"role": "user", "content": "分析理财预算"}],
                         output="已完成分析", provider="deepseek", model="deepseek-chat",
                         agent_id="supervisor", usage=None)
     check(r2.estimated and r2.total_tokens > 0, "无 usage 走估算")
-    # 按 agent 聚合(agent_id 正确)
     agg = m.by_agent()
     check("finance" in agg and "supervisor" in agg, "按 Agent 聚合(非 unknown)")
     check(agg["finance"]["total_tokens"] == 300, "Agent 聚合数值正确")
-    # 报告不崩
     check(len(m.report()) > 0, "文本报告生成")
-    # 成本估算
     cost = m.estimate_cost(price_per_1k_input=0.001, price_per_1k_output=0.002)
     check(cost["estimated_cost"] >= 0, "成本估算")
 
@@ -253,11 +219,9 @@ def test_thoughtchain_concurrency():
     print("\n【8】ThoughtChain 并发写(共享审计存储)")
     from foxclaw.core.thought_chain import ThoughtChain, ThoughtNode
     tc = ThoughtChain(db_path=tempfile.mktemp(suffix=".db"))
-    # WAL 已启用?(并发加固的核心)
     with tc._conn() as c:
         mode = c.execute("PRAGMA journal_mode").fetchone()[0]
     check(mode.lower() == "wal", f"WAL 日志模式已启用(实为 {mode})")
-    # N 线程 × M 节点并发写:默认 busy_timeout=0 时这会 database is locked
     N, M, errors = 8, 25, []
     def writer(aid):
         try:
@@ -288,7 +252,7 @@ def test_harness_action_wiring():
                     policy_path=tempfile.mktemp(suffix=".yaml"), shadow_rounds=0)
         h.register_goal("分析财务预算", allowed_tool_categories={"read", "finance"},
                         baseline_entities=baseline_entities)
-        h._shadow_mode = False          # 关观测期,直接进入实判
+        h._shadow_mode = False
         h._block_threshold, h._warn_threshold = 0.25, 0.18
         return h
 
@@ -299,11 +263,9 @@ def test_harness_action_wiring():
         tc.add_node(n)
         return n
 
-    # —— penalize_tool:get_balance 本在 finance 允许集,基线判 0.0 ——
     h1 = fresh({"预算", "收支"})
     check(h1.check(node(tool="get_balance")).scores["tool"] == 0.0,
           "基线:允许的工具 get_balance 工具分 = 0.0")
-    # 注入一条 penalize_tool 学习规则(模拟之前 BLOCK 学到的)→ 应立即改变判定
     h1._policy.setdefault("rules", []).append({
         "id": "r1", "source": "harness_learned",
         "action": {"type": "penalize_tool", "tool_pattern": "get_balance"}})
@@ -312,7 +274,6 @@ def test_harness_action_wiring():
     check(r1.scores["tool"] == 1.0 and r1.is_blocked,
           "penalize_tool 生效:同一工具被抬到 1.0 并 BLOCK")
 
-    # —— restrict_scope:大基线下加 2 个新实体,基线分低(0.2),规则应抬到 1.0 ——
     big = {f"e{i}" for i in range(10)}
     h2 = fresh(big)
     base_scope = h2.check(node(entities=["e0", "x1", "x2"])).scores["scope"]
@@ -324,16 +285,14 @@ def test_harness_action_wiring():
     r2 = h2.check(node(entities=["e0", "x1", "x2"]))
     check(r2.scores["scope"] == 1.0, "restrict_scope 生效:超上限 scope 抬到 1.0")
 
-    # —— 端到端:一次真实 BLOCK → 【P0-1 新行为】规则进**影子**(不生效),不再立即重建索引 ——
     h3 = fresh({"预算"})
-    h3.check(node(tool="delete_everything"))   # delete 类越权 → BLOCK → 影子候选
+    h3.check(node(tool="delete_everything"))
     check(not h3._is_penalized_tool("delete_everything"),
           "P0-1:BLOCK 后规则进影子,**不立即生效**(未重建索引)")
     shadow = h3._policy.get("shadow_rules", [])
     check(len(shadow) == 1 and shadow[0]["action"]["type"] == "penalize_tool"
           and shadow[0]["shadow"]["status"] == "observing",
           "P0-1:影子规则已入库且处于 observing")
-    # 手工 promote 后应立即生效(升迁路径与自动升迁同构)
     h3._promote_rule(shadow[0])
     check(h3._is_penalized_tool("delete_everything"),
           "P0-1:promote 后规则生效(索引已重建)")
@@ -350,7 +309,6 @@ def test_harness_thread_safety():
 
     def worker(k):
         try:
-            # 每线程在自己的 context 里注册基线(contextvar 线程独立),再并发 check
             h.register_goal(f"目标{k}", allowed_tool_categories={"read"},
                             baseline_entities={"e"})
             for i in range(M):
@@ -366,7 +324,6 @@ def test_harness_thread_safety():
     for t in ts: t.join()
 
     check(not errors, f"{N} 线程并发 check 无异常(否则: {errors[:2]})")
-    # 锁保护下 _run_count 无丢增量(无锁时 += 竞态会丢)
     check(h._run_count == N * M, f"_run_count 无丢增量({h._run_count}=={N*M})")
     check(len(h._delta_history) == N * M, f"_delta_history 无丢({len(h._delta_history)}=={N*M})")
 
@@ -380,11 +337,10 @@ def test_harness_delta_history_bounded():
     h = Harness(agent_id="t2", thought_chain=tc,
                 policy_path=tempfile.mktemp(suffix=".yaml"), shadow_rounds=rounds)
     h.register_goal("目标", allowed_tool_categories={"read"}, baseline_entities={"e"})
-    for i in range(rounds * 20):        # 远超 shadow_rounds
+    for i in range(rounds * 20):
         node = ThoughtNode.create(session_id="s", agent_id="t2",
                                   type="reasoning", content=f"n{i}", conf=0.9)
         tc.add_node(node); h.check(node)
-    # 仅 shadow 期(前 rounds 次)append,校准后不再 append → 上限=rounds,不随 run_count 无界增长
     check(len(h._delta_history) <= rounds,
           f"_delta_history 有界(≤{rounds}),实得 {len(h._delta_history)}")
     check(h._run_count == rounds * 20, "run_count 仍完整计数(每次 check 都记)")
@@ -400,7 +356,7 @@ def test_orchestration_request_log_bounded():
     try:
         os_ = Foxclaw(data_dir=d, shadow_rounds=50)
         os_.finance_runtime.set_balance("default", 100000)
-        for _ in range(1200):           # 远超 maxlen=1000
+        for _ in range(1200):
             os_.orchestrator.route_request(CrossAgentRequest(
                 from_agent="admin", to_agent="finance", request_type="budget_request",
                 payload={"amount": 10, "category": "travel", "account": "default"},
@@ -419,8 +375,6 @@ def test_hmr_adapter_stats_lock():
     hmr = create_memory_backend(storage_path=tempfile.mkdtemp(prefix="hmrlock_"))
     if not hasattr(hmr, "_lock"):
         print("  ~ MockHMR(无 vendor/hmr)无 _lock,跳过"); return
-    # 白盒:主线程持锁 → 另一线程的 stats() 必须等锁释放才完成(证明 stats 已进锁)。
-    # 补锁前 stats 不持锁 → 会在持锁期间直接完成,order 顺序相反。
     order = []
     hmr._lock.acquire()
     def call_stats():
@@ -430,7 +384,6 @@ def test_hmr_adapter_stats_lock():
     t.join(timeout=5)
     check(order == ["released", "stats_done"],
           f"stats() 应等 _lock 释放才完成(证明补锁生效),实得 {order}")
-    # get_system_status 同样补了锁
     hmr._lock.acquire()
     order2 = []
     def call_status():

package/python/tests/test_governance_audit.py

@@ -16,7 +16,6 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-# 隔离项目 .env(本测试不依赖任何真实配置;与批次 2 的隔离策略一致)
 os.environ.setdefault("FOXCLAW_SKIP_DOTENV", "1")
 os.environ.setdefault("HKC_EMBEDDING", "stub")
 
@@ -46,8 +45,6 @@ def _gov_events(spine):
     return [e for e in spine.history("governance.", 500)]
 
 
-# ── 1. 审计器单元层 ─────────────────────────────────────────
-
 def test_auditor_unit(test_dir):
     print("\n【1】审计器单元:decision_id / 事件 / 落盘 / fail-safe")
     d1, d2 = new_decision_id(), new_decision_id()
@@ -60,25 +57,22 @@ def test_auditor_unit(test_dir):
                      detail={"stage": 2}, correlation_id="corr_test_1")
     evs = _gov_events(spine)
     check(len(evs) == 1, f"脊柱有 1 条 governance.decision(实际 {len(evs)})")
-    p = evs[0]["payload"]                     # history() 返回 Event.to_dict()
+    p = evs[0]["payload"]
     check(evs[0]["topic"] == TOPIC, "事件主题 governance.decision")
     check(p["decision_id"] == did and p["layer"] == "permission"
           and p["verdict"] == "deny" and p["reason"] == "命中 deny 规则",
           "事件 payload 字段完整")
     check(evs[0]["correlation_id"] == "corr_test_1", "correlation_id 透传到事件")
 
-    # 显式 decision_id 被尊重(P3-4:PolicyGate 生成后交给审计器,不能再换一个)
     did2 = aud.record(layer="skill", actor="", action="invoke:x", verdict="success",
                       decision_id="dec_explicit01")
     check(did2 == "dec_explicit01", "显式 decision_id 原样返回")
 
-    # 落盘与事件一致
     recs = aud.read()
     check(len(recs) == 2, f"落盘 2 条(实际 {len(recs)})")
     check(recs[0]["decision_id"] == "dec_explicit01", "read() 新→旧排序")
     check(recs[1]["correlation_id"] == "corr_test_1", "落盘记录含 correlation_id")
 
-    # fail-safe:spine 爆炸不影响 record
     class BoomSpine:
         def publish(self, *a, **k):
             raise RuntimeError("spine boom")
@@ -87,7 +81,6 @@ def test_auditor_unit(test_dir):
                        verdict="warn", reason="语义漂移")
     check(did3.startswith("dec_"), "spine 异常时 record 仍返回 decision_id(fail-safe)")
 
-    # 开关
     os.environ[ENV_SWITCH] = "0"
     try:
         check(attach(spine, test_dir) is None, f"{ENV_SWITCH}=0 时 attach 返回 None")
@@ -96,8 +89,6 @@ def test_auditor_unit(test_dir):
     check(attach(spine, test_dir) is not None, "默认(未设开关)attach 正常返回")
 
 
-# ── 2. PolicyGate(P1-2/P3-4)─────────────────────────────────
-
 def _make_gate(test_dir, spine=None):
     from foxclaw.kernel.policy_gate import PolicyGate
     from foxclaw.skills.permission import evaluate
@@ -117,12 +108,10 @@ def test_policy_gate(test_dir):
     print("\n【2】PolicyGate:decision_id(P3-4)+ 非 allow 审计(P1-2)")
     gate, aud, spine = _make_gate(test_dir)
 
-    # allow:有 decision_id,但**不**记审计(高频常态不淹没审计流)
     v_allow = gate.check_action(_make_skill(), {})
     check(v_allow.decision_id.startswith("dec_"), "allow 裁决也带 decision_id(供执行审计 join)")
     check(len(_gov_events(spine)) == 0, "allow 不记 governance 事件")
 
-    # deny:记审计,layer=permission,decision_id 一致
     from foxclaw.skills.permission import PermissionRules
     rules = PermissionRules(deny=["demo.*"])
     v_deny = gate.check_action(_make_skill(), {}, rules=rules)
@@ -135,13 +124,11 @@ def test_policy_gate(test_dir):
     check(p["decision_id"] == v_deny.decision_id, "审计 decision_id 与 Verdict 一致(P3-4)")
     check(p["detail"]["stage"] == 2, "detail 含四阶段信息")
 
-    # ask → confirm
     v_ask = gate.check_action(_make_skill("x.pay", side_effect="pay"), {})
     check(v_ask.level == "confirm", "ask 归一为 confirm(行为不变)")
     evs = _gov_events(spine)
     check(len(evs) == 2 and evs[1]["payload"]["verdict"] == "confirm", "confirm 也记审计")
 
-    # 推理准入:BLOCK 记,PASS 不记
     from foxclaw.harness.harness import HarnessResult
     class FakeHarness:
         def __init__(self, status): self._s = status
@@ -159,14 +146,11 @@ def test_policy_gate(test_dir):
     gate.check_reasoning(FakeHarness("PASS"), FakeNode())
     check(len(_gov_events(spine)) == 3, "PASS 不记审计")
 
-    # 向后兼容:旧式位置参数构造(无 decision_id)仍可用
     from foxclaw.kernel.policy_gate import Verdict
     v_old = Verdict(True, "allow", "无动作评估器(降级放行)", "permission", None)
     check(v_old.decision_id == "" and v_old.allowed, "Verdict 位置参数构造向后兼容")
 
 
-# ── 3. Orchestrator(P1-3)───────────────────────────────────
-
 class _FakeCaps:
     def __init__(self, agents): self._agents = agents
     def get(self, name): return self._agents if name == "agents" else None
@@ -185,7 +169,6 @@ def test_orchestrator(test_dir):
     from foxclaw.orchestration import Orchestrator, CrossAgentRequest
     aud, spine = _fresh_auditor(test_dir)
 
-    # 三种终态 + 目标不存在(P1-0 路径)
     agents = {"finance": _FakeAgent([("approved", "预算充足"),
                                      ("rejected", "超出月度预算")])}
     orch = Orchestrator(_FakeCaps(agents), auditor=aud)
@@ -211,33 +194,29 @@ def test_orchestrator(test_dir):
           and evs[2]["payload"]["correlation_id"] == r3.id,
           "correlation_id == req.id(协商链 join 键)")
 
-    # 协商链:拒绝 → 让步 → 批准,两轮裁决同一 correlation_id
     agents2 = {"finance": _FakeAgent([("rejected", "太贵"),
                                       ("approved", "这个价可以")])}
     requester = _FakeAgent([])
-    requester.concede = lambda req, verdict: {"amount": 50}   # 让步:降价
+    requester.concede = lambda req, verdict: {"amount": 50}
     orch2 = Orchestrator(_FakeCaps({"finance": agents2["finance"],
                                     "admin": requester}), auditor=aud)
     req = CrossAgentRequest(from_agent="admin", to_agent="finance",
                             request_type="budget_request", payload={"amount": 500})
     final = orch2.negotiate(req)
     check(final.status == "approved", "协商后获批(行为不变)")
-    evs2 = _gov_events(spine)[3:]     # 前面 3 条之后
+    evs2 = _gov_events(spine)[3:]
     check(len(evs2) == 2, f"协商两轮裁决各记一条(实际 {len(evs2)})")
     check(all(e["payload"]["correlation_id"] == req.id for e in evs2),
           "多轮裁决共用 req.id——协商链可 join(P3-4 跨层关联)")
     check(evs2[0]["payload"]["verdict"] == "deny" and evs2[1]["payload"]["verdict"] == "allow",
           "协商链 deny→allow 轨迹完整")
 
-    # 无 auditor:standalone 不崩、不记
     orch3 = Orchestrator(_FakeCaps({}), auditor=None)
     orch3.route_request(CrossAgentRequest(from_agent="a", to_agent="b",
                                           request_type="info_request", payload={}))
     check(len(_gov_events(spine)) == 5, "auditor=None 时不记审计(standalone 兼容)")
 
 
-# ── 4. SkillAdapter(P2-0/P3-4 核心:裁决→执行 join)──────────
-
 def test_skill_adapter(test_dir):
     print("\n【4】SkillAdapter:执行终态审计 + 裁决↔执行 decision_id join(P2-0/P3-4)")
     from foxclaw.skills import SkillRegistry, SkillAdapter, SkillSpec
@@ -246,7 +225,6 @@ def test_skill_adapter(test_dir):
     reg = SkillRegistry()
     adapter = SkillAdapter(reg, policy_gate=gate)
 
-    # ① 只读 skill 成功执行 → skill success 审计,correlation_id == 权限裁决 decision_id
     ok_skill = SkillSpec(id="demo.read", name="读", description="只读",
                          side_effect="read", handler=lambda **k: {"value": 42})
     res = adapter.invoke(ok_skill, {})
@@ -258,19 +236,15 @@ def test_skill_adapter(test_dir):
     corr = p["correlation_id"]
     check(corr.startswith("dec_"), f"执行审计带裁决 decision_id 作 correlation_id: {corr}")
 
-    # ② 该 correlation_id 能 join 到真实裁决:再触发一次**非 allow** 裁决,
-    #    验证 permission 记录的 decision_id 与后续执行审计的 correlation_id 同链
     pay_skill = SkillSpec(id="demo.pay", name="付", description="支付",
                           side_effect="pay", handler=lambda **k: {"done": True})
-    res2 = adapter.invoke(pay_skill, {}, confirmed=True)   # 已确认 → allow → 执行
+    res2 = adapter.invoke(pay_skill, {}, confirmed=True)
     check(res2.success, "已确认的支付 skill 执行成功")
-    # 手工复演同参裁决,验证 decision_id 链:invoke 内部那次裁决的 id == 执行审计 correlation_id
     exec_recs = [e["payload"] for e in _gov_events(spine) if e["payload"]["layer"] == "skill"]
     check(len(exec_recs) == 2, "两次成功执行各记一条")
     check(all(r["correlation_id"].startswith("dec_") for r in exec_recs),
           "每条执行审计都挂在某个裁决 decision_id 上")
 
-    # ③ deny:permission 记裁决,skill 层**不重复**记执行
     adapter_deny = SkillAdapter(reg, policy_gate=gate,
                                 rules=PermissionRules(deny=["evil.*"]))
     evil = SkillSpec(id="evil.wipe", name="清", description="危险",
@@ -283,7 +257,6 @@ def test_skill_adapter(test_dir):
     check(len(perm_recs) == 1 and perm_recs[0]["verdict"] == "deny", "deny 裁决被记录")
     check(len(skill_recs_after) == 2, "deny 后 skill 层不重复记录(仍只有前两条执行审计)")
 
-    # ④ 断路器出口:权限过了但断路器开 → skill deny 审计,correlation_id 挂裁决
     from foxclaw.skills.lifecycle import CircuitBreaker
     br = CircuitBreaker()
     for _ in range(10):
@@ -299,14 +272,8 @@ def test_skill_adapter(test_dir):
     check(last["correlation_id"].startswith("dec_"), "断路器审计也挂在裁决 decision_id 上")
 
 
-# ── 5. WS 可见性 + 真实装配端到端 ───────────────────────────
-
 def test_ws_visibility_and_wiring(test_dir):
     print("\n【5】WS 可见性 + 真实装配端到端")
-    # governance.decision 不能被 WS 静音逻辑吞掉(验收:governance.* 事件 WS 可见)。
-    # _WS_MUTED 是 api 投影闭包的局部变量,无法 import —— 改为源码级断言:静音规则只有
-    # 「agent.cognition.* 前缀」与「_WS_MUTED 元组」两条,二者都不得命中 governance.*。
-    # 这同时是一道防退化闸:将来若有人把 governance.* 加进静音列表,本测试会红。
     import inspect, re as _re
     import foxclaw.api as _api_mod
     src = inspect.getsource(_api_mod)
@@ -316,7 +283,6 @@ def test_ws_visibility_and_wiring(test_dir):
     check(not "governance.decision".startswith("agent.cognition."),
           "governance.decision 不命中 agent.cognition.* 静音前缀")
 
-    # 真实装配:三处同一 auditor;一次真共享写入之外的治理动作落盘
     from foxclaw import Foxclaw
     d = tempfile.mkdtemp(prefix="foxclaw_gov_e2e_", dir=test_dir)
     o = Foxclaw(data_dir=d, shadow_rounds=2)
@@ -324,7 +290,6 @@ def test_ws_visibility_and_wiring(test_dir):
     check(o.policy_gate.auditor is o.governance_auditor, "PolicyGate 持同一 auditor")
     check(o.orchestrator._auditor is o.governance_auditor, "Orchestrator 持同一 auditor")
 
-    # 端到端裁决:目标不存在的跨 Agent 请求 → 审计事件 + 落盘
     from foxclaw.orchestration import CrossAgentRequest
     o.orchestrator.route_request(CrossAgentRequest(
         from_agent="admin", to_agent="ghost", request_type="info_request", payload={}))

package/python/tests/test_governance_middleware.py

@@ -35,13 +35,10 @@ def _sess():
 def test_standalone_block():
     print("\n【1】独立可用 + 工具越权拦截")
     gov = _sess()
-    # 正常只读:不抛(可能 PASS/WARN,但绝不 BLOCK)
     r_ok = gov.observe("call get_balance to read balance", tool="get_balance")
     check(not r_ok.blocked, "只读工具 get_balance 不被拦")
-    # 越权:delete 不在 read 允许集 → 硬拦
     r_bad = gov.observe("call delete_account", tool="delete_account")
     check(r_bad.blocked and r_bad.dimension == "tool", "delete_account 被 BLOCK(维度=tool)")
-    # guard 风格:越权抛异常
     raised = False
     try:
         gov.guard("call drop_table", tool="drop_table")
@@ -56,7 +53,7 @@ def test_decorator_sync_async():
 
     @governed(gov)
     def delete_row(x):
-        return f"deleted {x}"      # 不该被执行
+        return f"deleted {x}"
 
     executed = {"sync": False}
     try:
@@ -78,7 +75,6 @@ def test_decorator_sync_async():
             return False
     check(not asyncio.run(run()), "异步:越权协程被拦,未执行")
 
-    # 正常只读函数正常执行
     @governed(gov, tool_name="get_balance")
     def read_balance():
         return 100
@@ -96,7 +92,6 @@ def test_audit_and_loop():
               for n in audit), "越权步骤在审计链里标为 BLOCK")
     check(gov.summary()["blocked_this_session"] == 1, "摘要记录本会话拦截数")
 
-    # 循环检测:反复同一工具 → loop 告警
     gov2 = _sess()
     loop_hit = None
     for _ in range(9):
@@ -108,7 +103,6 @@ def test_audit_and_loop():
 
 def test_import_decoupling():
     print("\n【4】物理解耦:导入治理中间件不连带拉入 Agent 框架")
-    # 必须在**全新子进程**里验(本进程里其它测试早已 import 了 agents,sys.modules 被污染)
     code = (
         "import sys, foxclaw.governance;"
         "bad=[m for m in ('foxclaw.agents.agents','foxclaw.skills',"