foxclaw 0.1.2 → 0.1.3

package/python/foxclaw/agents/impl/finance.py

@@ -5,7 +5,6 @@ from datetime import datetime
 from ..base import CognitiveAgent
 from ._helpers import _fmt_mem
 
-# 分析/建议类意图:即使这句话里带了金额,也要走 LLM 给结论,而不是只回一张记账回执
 _ADVICE_WORDS = ("分析", "建议", "怎么", "如何", "多少", "预算", "超支", "优化", "规划",
                  "趋势", "为什么", "要不要", "合算", "划算", "省", "控制", "总结",
                  "报告", "够不够", "对比", "排名", "异常", "提醒", "合理", "占比",
@@ -39,7 +38,6 @@ def _should_autorecord(task: str) -> bool:
         return False
     if settled:
         return True
-    # 没有完成态动词时,只有「金额 + 明确消费类目」这种报备才记(洗车 100)
     return not _wants_advice(t)
 
 
@@ -52,7 +50,6 @@ class FinanceAgent(CognitiveAgent):
         """挂载财务内核(FinanceRuntime):记忆+推理+Policy 守门人。"""
         self.fin = runtime
 
-    # ── 编排协作(P3:财务领域态势 + 预算守门人,从编排层下沉至此)──────
     def situation(self) -> dict:
         rt = getattr(self, "fin", None)
         if rt is None:
@@ -85,8 +82,6 @@ class FinanceAgent(CognitiveAgent):
                           entity=req.payload.get("entity", "差旅"),
                           account=req.payload.get("account", "default"))
         bal = rt.account_balances.get(txn.account)
-        # Step3:模糊情形的 LLM 裁决(默认关;FOXCLAW_FINANCE_LLM_ARBITER=1 才启用)。
-        # 安全不变量:LLM 只在规则已批准的模糊带被咨询、只能 approve→confirm、出错→confirm、永不 reject。
         import os as _os
         _llm_on = _os.environ.get("FOXCLAW_FINANCE_LLM_ARBITER", "") == "1"
         rv = FinanceGatekeeperReasoner(
@@ -95,7 +90,6 @@ class FinanceAgent(CognitiveAgent):
         req.status = {"approve": "approved", "confirm": "needs_confirmation",
                       "reject": "rejected"}[rv.decision]
         req.verdict = rv.rationale
-        # 附证据链(可审计;新增字段,鸭子类型透传,不改既有行为)
         try:
             req.evidence = [e.to_dict() for e in rv.evidence]
             req.reason_source = rv.source
@@ -114,7 +108,7 @@ class FinanceAgent(CognitiveAgent):
         try:
             rec = fin.record_text(task)
         except Exception:
-            return ""            # 记账失败不阻断对话,退回普通财务回答
+            return ""
         if not rec.get("recorded"):
             return ""
         ack = rec.get("ack") or ""
@@ -128,16 +122,15 @@ class FinanceAgent(CognitiveAgent):
                 tags=["finance", "ledger"],
             )
         except Exception:
-            pass      # 记忆写入失败不影响账已经记上这件事
+            pass
         return ack
 
-    def analyze_finances(self, period: str = None, current_balance: float = None) -> dict:
+    def analyze_finances(self, period: str | None = None, current_balance: float | None = None) -> dict:
         """调用财务内核做综合分析,并把关键洞察写入 ThoughtChain。"""
         fin = getattr(self, "fin", None)
         if fin is None:
             return {"error": "财务内核未挂载"}
         report = fin.analyze(period=period, current_balance=current_balance)
-        # 把守门人裁决写进推理链(受 Harness 监督)
         verdicts = report.get("gatekeeper_verdicts", [])
         self._think(
             content=f"财务分析完成:{report['transaction_count']} 笔交易,"
@@ -168,9 +161,6 @@ class FinanceAgent(CognitiveAgent):
     _recall_query = lambda self, task: f"财务 {task}"
 
     async def _execute(self, task, context, session_id, memories):
-            # 第一线:零星花钱报备(「今天买了一件衣服花了 105 块」)。
-            # 解析→记账→回执全走确定性规则,不让 LLM 碰金额;回执本身就是答案,
-            # 没有分析意图时不必再等一次 LLM 往返。
             ledger_ack = self._auto_record(task)
             if ledger_ack and not _wants_advice(task):
                 return ledger_ack, {}
@@ -181,14 +171,12 @@ class FinanceAgent(CognitiveAgent):
                 conf=0.93,
             )
 
-            # 构建财务上下文
             finance_context = ""
             if memories:
                 finance_context = "历史财务记录：\n" + "\n".join([
                     _fmt_mem(m, 100) for m in memories[:5]
                 ])
 
-            # 接入财务内核:若已挂载且有交易数据,做真实结构化分析,作为 LLM 的依据
             kernel_insight = ""
             fin = getattr(self, "fin", None)
             if fin is not None and getattr(fin, "transactions", None):
@@ -205,20 +193,16 @@ class FinanceAgent(CognitiveAgent):
                     if anomalies:
                         parts.append(f"· 检测到 {len(anomalies)} 笔异常支出")
                     if parts:
-                        # 注:标签用产品级措辞(不带"内核"等内部实现词),避免 LLM 回复把内部
-                        # 架构词汇透给终端用户(深层实现对用户保密;多 Agent 作卖点可讲)。
                         kernel_insight = ("\n\n【财务分析结果(基于真实交易,请据此回答)】\n"
                                           + "\n".join(parts))
-                        # 把证据链摘要沉淀到 ThoughtChain(可审计)
                         self._think(
                             content=f"财务内核证据链:{len(ec)} 条决策,{len(anomalies)} 异常",
                             node_type="reflection", conf=0.9,
                         )
                 except Exception:
-                    pass   # 内核分析失败不阻断,降级为纯 LLM 回答
+                    pass
 
             if ledger_ack:
-                # 已落账的明细必须交给 LLM:否则它会重复"确认记账",甚至自己再报一遍数字
                 kernel_insight = ("\n\n【刚刚已记账(已落账,请据此回答,不要重复报账)】\n"
                                   + ledger_ack + kernel_insight)
 
@@ -237,7 +221,6 @@ class FinanceAgent(CognitiveAgent):
                 conf=0.90,
             )
 
-            # 记忆财务决策
             self._store_memory(
                 content=f"财务分析：{task[:80]}\n结论：{response[:200]}",
                 mem_type="decision",

package/python/foxclaw/agents/impl/office.py

@@ -23,8 +23,6 @@ class OfficeAgent(CognitiveAgent):
     AGENT_NAME = "办公学习 Agent"
     ALLOWED_TOOL_CATEGORIES = {"read", "write", "network", "calendar"}
 
-    # 日程类任务的触发词:命中则按"行政"话术走(不索要 knowledge JSON)。
-    # 与 skills/schedule-itinerary/SKILL.md 的 triggers 保持一致。
     SCHEDULE_HINTS = ("日程", "行程", "会议", "出差", "预约", "日历", "路线", "几点", "提醒")
 
     def attach_runtime(self, runtime):
@@ -38,7 +36,6 @@ class OfficeAgent(CognitiveAgent):
         """
         self.itin = runtime
 
-    # ── 编排协作(P3:领域态势从编排层下沉至此)──────
     def situation(self) -> dict:
         """一次自报两个领域:学习 + 行程。编排层按 `domains` 聚合(缺一个不影响另一个)。"""
         return {"domains": {"learning": self._learning_status(),
@@ -83,11 +80,8 @@ class OfficeAgent(CognitiveAgent):
         return [{"domain": "itinerary", "severity": "critical", "msg": c["reason"]}
                 for c in conflicts]
 
-    # ── 行程/日程(原 AdminAgent)────────────────────────────────
-    # 差旅预算让步:每轮降一档;低于原始的 60% 就不再让(那已不是同一趟出差了,
-    # 硬压下去只会规划出一个没法执行的行程 —— 宁可认输转由人决定)。
-    CONCEDE_STEP = 0.75          # 每轮降到上一轮的 75%(改高铁/换酒店/减一天的量化近似)
-    CONCEDE_FLOOR = 0.60         # 相对**原始**申请额的下限
+    CONCEDE_STEP = 0.75
+    CONCEDE_FLOOR = 0.60
 
     def concede(self, req, verdict: str):
         """【协商闭环·发起方】差旅预算被财务守门人拒 → 降标准重报。
@@ -104,11 +98,9 @@ class OfficeAgent(CognitiveAgent):
         if amount <= 0:
             return None
         original = float(req.payload.get("_original_amount") or amount)
-        # 降一档,但**夹到下限**而不是跌破就放弃 —— 否则步长过冲时会在下限之上提前认输
-        # (8000→6000→(4500 破线)放弃),白白浪费 4800 这个本来能过的方案。
         new_amount = max(round(amount * self.CONCEDE_STEP), round(original * self.CONCEDE_FLOOR))
         if new_amount <= 0 or new_amount >= amount:
-            return None                      # 已到下限,再降就破线 → 认输(维持 rejected,不硬闯)
+            return None
         p = dict(req.payload)
         p["amount"] = new_amount
         p["_original_amount"] = original
@@ -154,14 +146,12 @@ class OfficeAgent(CognitiveAgent):
         )
         return report
 
-    # ── 学习/知识(原 OfficeAgent)────────────────────────────────
     @staticmethod
     def _strip_knowledge_json(text: str) -> str:
         """从回复中剥离 {"new_knowledge": [...]} 结构化块,只保留自然语言。"""
         if not text or "new_knowledge" not in text:
             return text
         import re
-        # 去掉 {"new_knowledge": [ ... ]} 整块(含可能的 markdown 代码围栏)
         cleaned = re.sub(r'`{0,3}\s*\{\s*"new_knowledge".*?\}\s*\]\s*\}\s*`{0,3}',
                          '', text, flags=re.DOTALL)
         return cleaned.strip()
@@ -172,8 +162,6 @@ class OfficeAgent(CognitiveAgent):
         if rt is None:
             return {"error": "学习内核未挂载"}
         report = rt.analyze()
-        # 给前端「知识库」轮播提供知识条目明细:analyze 本身只有统计、无明细,
-        # 否则前端读 analysis.items 拿不到 → 一直显示"知识库为空"(即便已录入)。
         try:
             with rt._lock:
                 _vals = list(rt.items.values())
@@ -220,7 +208,7 @@ Hermes 自学原则（像赫尔墨斯那样）：
 你的知识是活的，会生长的。"""
 
     _task_entities = lambda self, task: ["学习", "知识", "文档", "日程", "行程", "会议"]
-    _recall_topk = 8   # 办公学习 Agent 广泛召回
+    _recall_topk = 8
 
     def _recall_query(self, task: str) -> str:
         """学习 + 日程两类记忆都要召回(合并后单一 Agent 覆盖两个域)。"""
@@ -244,7 +232,6 @@ Hermes 自学原则（像赫尔墨斯那样）：
                 f"- {_fmt_mem(m, 80)}" for m in memories[:6]
             ])
 
-        # 接入学习内核:若已挂载且有知识点,做真实分析(待复习/掌握度)作为依据
         kernel_insight = ""
         learn_rt = getattr(self, "learn_rt", None)
         if learn_rt is not None and getattr(learn_rt, "items", None):
@@ -262,9 +249,8 @@ Hermes 自学原则（像赫尔墨斯那样）：
                     node_type="reflection", conf=0.9,
                 )
             except Exception:
-                pass   # 内核失败不阻断,降级纯 LLM
+                pass
 
-        # 接入行程内核:若已挂载且有路点,做真实规划(路线/冲突)作为 LLM 依据
         itin = getattr(self, "itin", None)
         if itin is not None and getattr(itin, "waypoints", None):
             try:
@@ -285,7 +271,7 @@ Hermes 自学原则（像赫尔墨斯那样）：
                         node_type="reflection", conf=0.9,
                     )
             except Exception:
-                pass   # 内核失败不阻断,降级纯 LLM
+                pass
 
         if schedule:
             prompt = f"""行程/日程任务：{task}
@@ -310,13 +296,11 @@ Hermes 自学原则（像赫尔墨斯那样）：
 
         new_knowledge_count = 0
         if not schedule:
-            # 提取并存储新知识(括号平衡解析:正确处理内容含 []{} 的情况)
             try:
                 start = response.find('{"new_knowledge"')
                 if start < 0:
                     start = response.find('{ "new_knowledge"')
                 if start >= 0:
-                    # 从 start 起做花括号配对,找到完整 JSON 对象的结束位置
                     depth, end, in_str, esc = 0, -1, False, False
                     for i in range(start, len(response)):
                         c = response[i]
@@ -346,9 +330,8 @@ Hermes 自学原则（像赫尔墨斯那样）：
                             )
                             new_knowledge_count += 1
             except Exception:
-                pass  # 解析失败不影响主流程
+                pass
 
-            # 从返回文本中剥离 new_knowledge JSON 块(不展示给用户)
             response = self._strip_knowledge_json(response)
 
         self._think(

package/python/foxclaw/agents/impl/supervisor.py

@@ -8,12 +8,13 @@ from datetime import datetime
 from ..base import CognitiveAgent
 from ...planning import planner as P
 from ._helpers import _with_prior, _dispatch_failed, _extract_step_results, PRIOR_MAX_CHARS
+from typing import Any, cast
 
 class SupervisorAgent(CognitiveAgent):
     AGENT_ID = "supervisor"
     AGENT_NAME = "主管 Agent"
     ALLOWED_TOOL_CATEGORIES = {"read", "write", "calendar", "finance", "network"}
-    IS_ROUTER = True  # 调度层:豁免语义漂移拦截(接收任意输入是其本职)
+    IS_ROUTER = True
 
     @property
     def _role_prompt(self) -> str:
@@ -37,11 +38,6 @@ class SupervisorAgent(CognitiveAgent):
     def register_subagents(self, subagents: dict):
         """注入可调度的子 Agent 登记表。"""
         self._subagents = subagents
-        # 【深审硬化·消除懒建 race】主管单例会被并发任务共享,_scheduler/_steering_queue 原先在
-        # _schedule/_dispatch_parallel 里 `if not hasattr` 懒建——并发下是 check-then-act race
-        # (现因 steering 队列 batch 隔离 + scheduler 无状态而良性,但依赖此实现细节脆弱)。改在
-        # 本方法(Foxclaw 启动时单线程调一次)**预建**,并发任务到达时属性已就绪、不再 race。
-        # 保留下游懒建作 standalone(未 register)兜底。
         from ...core.scheduler import CognitiveScheduler
         from ...core.steering_queue import SteeringQueue
         if not hasattr(self, "_scheduler"):
@@ -72,12 +68,10 @@ class SupervisorAgent(CognitiveAgent):
         orch = getattr(self, "orch", None)
         if orch is None:
             return {"error": "编排引擎未挂载"}
-        from foxclaw.orchestration import CrossAgentRequest
+        from foxclaw.orchestration import CrossAgentRequest, RequestType
         req = CrossAgentRequest(from_agent=from_agent, to_agent=to_agent,
-                                request_type=request_type, payload=payload,
+                                request_type=cast(RequestType, request_type), payload=payload,
                                 reason=reason)
-        # 走协商闭环:被拒时给发起方让步重报的机会。对未实现 concede 的 Agent 而言
-        # 只会跑一轮 → 与原先的一次性 route_request 逐字等价(零行为变更)。
         result = orch.negotiate(req)
         rounds = len(result.negotiation) or 1
         self._think(
@@ -87,24 +81,18 @@ class SupervisorAgent(CognitiveAgent):
         )
         return result.to_dict()
 
-    # 路由关键词表:无 LLM 时也能基于关键词分发。
-    # 拓扑 5 → 3 后:原行政(日程/行程)关键词并入办公;"助手"那组(整理/汇总/沟通)
-    # 不再有归属 —— 它们正是主管自己该干的兜底活,未命中 → 主管自答。
     ROUTING_KEYWORDS = {
         "finance": ["收支", "支出", "预算", "理财", "投资", "储蓄", "财务", "消费", "报销", "账"],
         "office":  ["学习", "论文", "知识", "总结", "研究", "文档", "写作", "资料", "搜索", "查",
                     "日程", "行程", "会议", "出差", "预约", "日历", "计划表", "提醒",
-                    # 原助手的"整理/汇总/邮件"归办公:那是内容活,主管只兜底通用与协调
                     "整理", "汇总", "邮件", "纪要"],
     }
 
-    # 子 Agent 职责描述(P0-1 LLM 规划用):喂给 submit_plan 工具做 agent 枚举约束
     SUBAGENT_DESC = {
         "finance": "财务 Agent：理财、收支、预算、风控、对账",
         "office": "办公学习 Agent：学习、知识管理、研究、写作、日程与行程安排",
     }
 
-    # 元问题关键词:这类"系统级/自我介绍"问题由主管自己回答,不分派
     META_KEYWORDS = ["你会做什么", "你能做什么", "你是谁", "你能干", "你会干",
                      "介绍一下", "介绍下", "自我介绍", "有什么功能", "能帮我做什么",
                      "你都能", "怎么用", "如何使用", "你好", "在吗", "干什么",
@@ -141,18 +129,15 @@ class SupervisorAgent(CognitiveAgent):
         """
         if self._is_expense_report(task):
             return "finance"
-        # 关键词命中计数走统一原语(negation=False,与原计数逐字一致)
         scores = {aid: P.keyword_hits(task, kws)
                   for aid, kws in self.ROUTING_KEYWORDS.items()}
-        best = max(scores, key=scores.get)
+        best = max(scores, key=lambda k: scores[k])
         if scores[best] > 0:
             return best
-        # 关键词不明:用调度意图做辅助判断
         if sched is not None:
             intent = getattr(getattr(sched, "intent", None), "category", None)
             if intent in ("reasoning", "memory"):
-                return "office"     # 推理/记忆类 → 知识研究 Agent
-        # 无明确归属 → 主管自答(dispatch 见 target 不在 subagents 即走 _dispatch_fallback)
+                return "office"
         return "supervisor"
 
     def _coerce_agent(self, ag: str, subtask: str, subagents: dict) -> str:
@@ -175,13 +160,6 @@ class SupervisorAgent(CognitiveAgent):
         return (any(P.keyword_hits(task, kws) for kws in self.ROUTING_KEYWORDS.values())
                 or self._is_expense_report(task))
 
-    # 【已删除 · 请勿凭记忆加回】这里原有一个 `_llm_classify(task) -> Optional[str]`:
-    # 关键词未命中时用一次 LLM 把任务分诊到领域 Agent。它已被「无关键词命中 → 主管直接
-    # 自答」分支取代并成为死代码(全仓库零调用点),故删除。当时的取舍:每次分诊要多一次
-    # 约 5s 的串行 LLM 往返,正面对话不值当,于是改为主管自答。P1-1 后该分支在
-    # pipeline/supervisor_stages.py 的 route(决策)/dispatch(执行)两个 stage 里。
-    # 如需恢复精修,应从 git 历史取回本方法,并同时改回那两个 stage、补回对应测试
-    # —— 只加回方法不接线等于再制造一处死代码。
 
     def _plan_task(self, task: str, sched=None):
         """用 planner 判断任务是否需要拆解(多步)。
@@ -203,7 +181,6 @@ class SupervisorAgent(CognitiveAgent):
             p = ahs_plan(task, reg)
             if len(p.tasks) <= 1:
                 return None, None
-            # 为每个子任务单独算路由(关键词为主)→ planner 拆解真正落到不同 Agent
             step_routes = [(t.name, self._route(t.name)) for t in p.tasks]
             return p, step_routes
         except Exception:
@@ -233,7 +210,7 @@ class SupervisorAgent(CognitiveAgent):
             return None
         steps = result["steps"]
         if len(steps) <= 1:
-            return None            # 单步 → 交回 _route 关键词路由，不改变单步行为
+            return None
         from ...skills.pipeline import Plan, PlanTask
         n = len(steps)
         parallel = result.get("flow") == "parallel"
@@ -309,8 +286,6 @@ class SupervisorAgent(CognitiveAgent):
         from ...core.scheduler import CognitiveScheduler, SystemContext
         if not hasattr(self, "_scheduler"):
             self._scheduler = CognitiveScheduler()
-        # 系统上下文:活跃 Agent 数 = 当前持有活跃 session 的子 Agent 数
-        # (用真实可得的 _session_id 判断忙碌,而非不存在的 is_busy 属性)
         active = sum(1 for a in subagents.values()
                      if getattr(a, "_session_id", None))
         ctx = SystemContext(active_agents=active, queue_depth=0, system_load=0.1)
@@ -322,10 +297,10 @@ class SupervisorAgent(CognitiveAgent):
 
         (原先每步都只拿到同一份原始 context,等于 N 个互不相干的任务排队跑——
          「查本月餐饮花了多少,再据此定预算」的第 2 步根本拿不到第 1 步的数字。)"""
-        pm = getattr(self, "_process_manager", None)
+        pm: Any = getattr(self, "_process_manager", None)
         bus = getattr(self, "_system_bus", None)
         steps_out = []
-        prior = []                 # 已完成步骤的结果,供后续步骤参考
+        prior: list[Any] = []
         any_blocked = False
         for idx, (subtask, ag) in enumerate(step_routes, 1):
             if ag not in subagents:
@@ -337,10 +312,6 @@ class SupervisorAgent(CognitiveAgent):
             )
             if proc:
                 pm.mark_running(proc.process_id)
-            # _no_emit:子 Agent 不自发 execution.completed,由下方主管统一发(带 schedule),避免双发
-            # prior_steps 同时也放进 context,便于管线/Agent 按结构化方式取用
-            # 补超时(D 类修复):与 _dispatch_single / _dispatch_parallel 三处标准一致,
-            # 子 Agent 卡死不再让整条多步链永久挂起。
             _timeout = float(context.get("parallel_timeout", 120))
             try:
                 sub_result = await asyncio.wait_for(
@@ -356,25 +327,16 @@ class SupervisorAgent(CognitiveAgent):
             sub_output = sub_result.get("result", "")
             if isinstance(sub_output, dict):
                 sub_output = json.dumps(sub_output, ensure_ascii=False)
-            # 未完成(含超时)一律视为 blocked —— 不得让超时步骤被当成
-            # 成功结果进入 prior 链,否则后续步骤会基于"不存在的产出"继续推理。
             blocked = sub_result.get("error") in ("harness_blocked", "subagent_timeout")
             any_blocked = any_blocked or blocked
             if proc:
                 (pm.mark_failed(proc.process_id, reason=sub_result.get("error") or "")
                  if blocked else pm.mark_completed(proc.process_id))
-            # 展示用的 subtask 保留**原始**文本(不含前序上下文前言,免污染 UI)
             steps_out.append({"step": idx, "subtask": subtask, "agent": ag,
                               "output": str(sub_output)[:200], "blocked": blocked})
-            if not blocked and sub_output:      # 被拦截/空输出的步骤无可参考内容,不入链
-                # 入链即截断:渲染时本就只用最近 PRIOR_MAX_STEPS 步 × PRIOR_MAX_CHARS 字符,
-                # 存全量纯属浪费——且 prior 会被 list(prior) 复制进**每个**后续步骤的 context,
-                # 长链 + 大输出会滚成可观的内存与拷贝开销。
+            if not blocked and sub_output:
                 prior.append({"step": idx, "agent": ag,
                               "output": str(sub_output)[:PRIOR_MAX_CHARS]})
-            # 【P1-1】execution.completed 不再逐子任务手动 publish——改由 base 模板
-            # `_emit_execution` 统一发一条**任务级**事件(子 Agent 均带 _no_emit=True)。
-            # 无总线(部分测试/独立调用)→ 主管手动兜底沉淀记忆,与单步路径一致
             if bus is None and not blocked:
                 self._store_memory(
                     content=f"任务「{subtask}」由 {ag} 处理。要点:{str(sub_output)[:200]}",
@@ -418,18 +380,16 @@ class SupervisorAgent(CognitiveAgent):
             self._steering_queue = SteeringQueue(lease_seconds=120)
         q = self._steering_queue
         batch = f"batch_{session_id}"
-        pm = getattr(self, "_process_manager", None)
+        pm: Any = getattr(self, "_process_manager", None)
         bus = getattr(self, "_system_bus", None)
         timeout = float(context.get("parallel_timeout", 120))
 
         agents_involved = sorted({ag for _, ag in step_routes})
-        # fork 记录(串行,主管自身 think 不并发)
         self._think(
             content=f"并行 fork {len(step_routes)} 个子任务 → {agents_involved}",
             node_type="tool_intent", tool_name="fork_parallel", conf=0.9,
         )
 
-        # 按 Agent 分组:不同组并行,同组内串行(护 per-agent 会话态)
         groups: dict[str, list] = {}
         for idx, (subtask, ag) in enumerate(step_routes):
             if ag not in subagents:
@@ -456,8 +416,6 @@ class SupervisorAgent(CognitiveAgent):
                     q.publish(batch, ag, {"idx": idx, "subtask": subtask, "agent": ag,
                                           "output": str(out)[:200], "blocked": blocked,
                                           "failed": False})
-                    # 【P1-1】execution.completed 不再逐子任务手动 publish——
-                    # 改由 base 模板 `_emit_execution` 统一发任务级事件。
                 except asyncio.TimeoutError:
                     if proc:
                         pm.mark_failed(proc.process_id, reason="timeout")
@@ -475,7 +433,6 @@ class SupervisorAgent(CognitiveAgent):
         await asyncio.gather(*[run_group(ag, items) for ag, items in groups.items()])
         wall_ms = round((time.perf_counter() - t0) * 1000, 1)
 
-        # join:租约收集(不丢不重)→ 按 idx 还原原始顺序 → ack
         leased = q.lease(batch, max_items=len(step_routes) * 2)
         steps_out = []
         for it in leased:
@@ -485,13 +442,11 @@ class SupervisorAgent(CognitiveAgent):
 
         any_blocked = any(s.get("blocked") for s in steps_out)
         any_failed = any(s.get("failed") for s in steps_out)
-        # join 记录(串行)
         self._think(
             content=f"并行 join:{len(steps_out)}/{len(step_routes)} 步汇聚,"
                     f"墙钟 {wall_ms}ms,blocked={any_blocked},failed={any_failed}",
             node_type="reflection", conf=0.88,
         )
-        # 无总线时兜底沉淀记忆(与顺序路径一致)
         if bus is None:
             for s in steps_out:
                 if not s.get("blocked") and not s.get("failed"):
@@ -518,11 +473,6 @@ class SupervisorAgent(CognitiveAgent):
             "thought_summary": self.thought_chain.get_summary(self.AGENT_ID),
         }
 
-    # ── 【P1-1】主管 pipeline 化:不再重写 run_task ────────────────────
-    # 生命周期(会话/召回/返回体/Harness 兜底/hooks/流式/中断/统一 _emit_execution)
-    # 全部走 base 的 _run_task_core;路由分发逻辑拆成 7 个 pipeline stage
-    # (foxclaw/pipeline/supervisor_stages.py:recall→meta_check→schedule→route→plan→
-    # dispatch→aggregate)。本类只保留:pipeline 覆盖、领域钩子、恢复记账、分发执行体。
 
     def _cognitive_pipeline(self):
         """主管的认知管线:SUPERVISOR_STAGES(路由分发),而非领域 Agent 的 DEFAULT_STAGES。"""
@@ -537,8 +487,6 @@ class SupervisorAgent(CognitiveAgent):
         """主管的目标基线实体(旧 run_task 用 _extract_entities 开会话,逐字保留)。"""
         return self._extract_entities(task)
 
-    # 崩溃/重启恢复记账已上移到 base 生命周期钩子(领域 Agent 此前完全没接线,跑一半崩掉
-    # 在恢复扫描里不可见);主管只是"恰好也装着 _recovery",无需再覆盖。
 
     async def _dispatch_single(self, task, target, sched, session_id,
                                subagents, context, memories, plan_obj) -> dict:
@@ -546,8 +494,7 @@ class SupervisorAgent(CognitiveAgent):
         ① execution.completed 不再在此手动 publish——改由 base 模板 `_emit_execution`
           统一发一条**任务级**事件(子 Agent 调用带 _no_emit=True 仍不双发);
         ② 返回体不再带 session_id/agent/thought_summary(由 base 模板统一组装)。"""
-        # 创建进程(任务即进程),携带调度决策 → 状态 scheduled
-        pm = getattr(self, "_process_manager", None)
+        pm: Any = getattr(self, "_process_manager", None)
         proc = pm.create(task, agent_id=target, schedule=sched.to_dict()) if pm else None
 
         self._think(
@@ -556,35 +503,25 @@ class SupervisorAgent(CognitiveAgent):
             tool_name=f"dispatch_{target}",
             conf=0.92,
         )
-        # 进程进入 running
         if proc:
             pm.mark_running(proc.process_id)
-        # _no_emit:子 Agent 不自发,主管任务级统一 emit(见 base._emit_execution),避免双发
-        #
-        # 补超时(D 类修复:同文件内标准一致性)。此前只有并行路径
-        # (_dispatch_parallel)有 asyncio.wait_for,单步/链式路径直接 await ——
-        # 子 Agent 卡死(LLM 挂起/工具阻塞)会让主管任务**永久挂起**,且无日志
-        # 无告警无释放。同一语义必须两套标准一致,超时值同样取 parallel_timeout。
         _timeout = float(context.get("parallel_timeout", 120))
         try:
             sub_result = await asyncio.wait_for(
                 subagents[target].run_task(task, {**context, "_no_emit": True}),
                 timeout=_timeout)
         except asyncio.TimeoutError:
-            # 诚实交代:不伪造子 Agent 的产出,明确回报"超时未完成"
             _note = f"子 Agent {target} 执行超时({_timeout:g}s),已中止并如实回报未完成结果"
             if proc:
                 pm.mark_failed(proc.process_id, reason="subagent_timeout")
             self._think(content=_note, node_type="decision", conf=0.95)
             sub_result = {"result": _note, "error": "subagent_timeout", "agent": target}
 
-        # 汇聚子 Agent 结果
         sub_output = sub_result.get("result", "")
         if isinstance(sub_output, dict):
             sub_output = json.dumps(sub_output, ensure_ascii=False)
         blocked = sub_result.get("error") == "harness_blocked"
 
-        # 进程终态:被拦截/出错→failed,否则→completed
         if proc:
             if blocked:
                 pm.mark_failed(proc.process_id, reason="harness_blocked")
@@ -597,8 +534,6 @@ class SupervisorAgent(CognitiveAgent):
             conf=0.88,
         )
 
-        # 记忆沉淀:正常由真值管线(事件驱动,经 base._emit_execution)负责;
-        # 无总线时(如部分测试场景)主管手动兜底,避免丢记忆。
         bus = getattr(self, "_system_bus", None)
         if bus is None:
             self._store_memory(
@@ -646,11 +581,9 @@ class SupervisorAgent(CognitiveAgent):
         (因中文无大小写,原首字母逻辑对中文无效)。
         """
         keywords = []
-        # 英文:首字母大写的词
         for word in text.split():
             if len(word) > 3 and word[0].isupper():
                 keywords.append(word)
-        # 中文:命中路由关键词的领域词(作为实体线索)
         for kws in self.ROUTING_KEYWORDS.values():
             for kw in kws:
                 if kw in text and kw not in keywords:

package/python/foxclaw/agents/mixins/_context.py

@@ -8,45 +8,22 @@ from ...core.thought_chain import ThoughtNode
 from ...harness.harness import HarnessResult
 
 
-# 每任务(per asyncio-Task / per-thread)会话状态。放在 contextvar 而非实例属性,使同一
-# Agent 实例并发处理多个顶层任务时,各任务的会话指针互不覆盖(asyncio 每个 Task 自动持
-# 独立 context 副本;旧实现下 await 后的推理节点会被最后启动的会话吞掉——已实测复现)。
-# 写法:单个 module 级 contextvar 承载一个 dict、按"每实例 token"分槽:
-#   ① GC 友好(只有一个 contextvar,不随实例增长);
-#   ② 支持 supervisor→subagent 的同任务嵌套(不同实例 token 不冲突,互不覆盖);
-#   ③ copy-on-write —— 一个任务的 set 生成新 dict,不影响其它任务。
 _agent_ctx: contextvars.ContextVar = contextvars.ContextVar(
     "foxclaw_agent_ctx", default=None)
 
-# 抑制记忆写入(随 to_thread/asyncio.run 上下文复制传播):MCP ask_foxclaw 驱动的外部任务
-# 不写入 HMR,防外部客户端灌垃圾污染你的个人记忆。默认 False(正常任务照写)。
 _suppress_memory: contextvars.ContextVar = contextvars.ContextVar(
     "foxclaw_suppress_memory", default=False)
 
-# act 阶段 LLM 流式回调(D1,随 to_thread/asyncio.run 上下文复制传播):run_task_stream 设它,
-# 承载 {"on_token": cb, "stop_event": ev};_call_llm 读到非 None 则走 router.stream 逐 token 回调
-# + 累积返回完整串(返回值语义不变)。默认 None = 非流式(走 router.complete,行为逐字不变)。
 _act_stream: contextvars.ContextVar = contextvars.ContextVar(
     "foxclaw_act_stream", default=None)
 
-# 断点续跑(P1):{步骤指纹: {"name": 工具名, "result": 上次结果}}。run_task 带
-# `context={"_resume_task_id": ...}` 时由 _run_task_core 从 recovery 日志装载,工具轮命中
-# 同指纹步骤则复用结果、不再重复执行(避免重跑联网/副作用)。默认 None = 正常执行,行为不变。
 _resume_steps: contextvars.ContextVar = contextvars.ContextVar(
     "foxclaw_resume_steps", default=None)
 
-# E2 推理上下文注入(随 to_thread/asyncio.run 上下文复制传播):pre_reasoning(agent_start)钩子
-# 返回的 additional_context 存这里,_call_llm 前插为一条 user 消息注入推理。默认 None = 不注入
-# (无钩子/钩子未返回上下文时行为逐字不变)。
 _reasoning_inject: contextvars.ContextVar = contextvars.ContextVar(
     "foxclaw_reasoning_inject", default=None)
 
 
-# 执行证据(存在会话槽里,与污点同寿命):每次工具轮把「这一步有没有凭据」记下来,
-# 最终由 stream_reply 一次性交给端点做 SSE `event: evidence`,前端展示给人核对。
-# 放会话槽而非实例属性:同一 Agent 并发两个任务时证据不得串台。
-
-
 def _evidence_reset(agent) -> None:
     tok = getattr(agent, "_ctx_token", None)
     if tok is not None: