codebee 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -6,6 +6,29 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.30（2026-09-21）
+
+### ✨ 新功能
+
+- 微信直连配置更省事：新增「扫描」按钮自动找出本机全部 Python（标注位数与是否已装依赖，点选即回填）；选中未装依赖的 64 位解释器可「一键安装 wechatauto-replica」，不用再自己开 conda 敲命令。
+- 桌面蜜蜂右键新增「群摘要」：直达群摘要面板（已打开的页面只聚焦不重复开）。
+- 直连任务可选指定厂商与模型。
+
+### 🛠 问题修复
+
+- 修复没装 Pillow 的电脑上蜜蜂永远显示手绘丑蜜蜂：现在用系统自带能力直接显示新形象贴图（普通用户升级即变好看，无需装任何额外依赖）。
+- 禅道自动化四个开关与扫描间隔紧凑排成一行。
+
+## v0.1.29（2026-09-21）
+
+### ✨ 新功能
+
+- 升级后蜜蜂自动换新装：修复「升级后还是旧的丑蜜蜂」——服务重启后旧蜜蜂会自动让位，由新服务拉起带新形象的新蜜蜂（此前旧蜜蜂占着位置永不退场）。
+
+### 🛠 问题修复
+
+- 去掉蜜蜂底部的任务进度条（真机截图反馈）：窗口收紧贴着蜂体，画面更干净。
+
 ## v0.1.28（2026-09-21）
 
 ### 🛠 问题修复

package/README.md

@@ -21,8 +21,30 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
+### ✨ 新功能 · New
+
+- 微信直连配置更省事：「扫描」自动找本机 Python（标注位数与依赖状态，点选即用），选中后可一键安装 wechatauto-replica。
+- WeChat setup is now effortless: a Scan button finds local Pythons (with bitness and dependency badges), and one click installs wechatauto-replica.
+
+- 桌面蜜蜂右键新增「群摘要」：直达群摘要面板，已打开的页面只聚焦不重复开。
+- The desktop bee's right-click menu now has "Group Digests" — it focuses the existing page instead of opening a duplicate.
+
+- 没装 Pillow 的电脑上蜜蜂也会显示新形象贴图了（修复手绘丑蜜蜂问题）。
+- Bees now show the new artwork even without Pillow installed (fixes the ugly hand-drawn fallback).
+
 ### 🛠 问题修复 · Fixes
 
+- 禅道自动化开关与扫描间隔紧凑排成一行。
+- ZenTao automation toggles and the scan interval now fit on one tidy row.
+
+### 上一版亮点 · Previous release
+
+- 升级后蜜蜂自动换新装：服务重启后旧蜜蜂自动让位，新蜜蜂带新形象上线。
+- After upgrading, the desktop bee swaps itself for the new look: the old bee steps aside when the service restarts.
+
+- 去掉蜜蜂底部的任务进度条，窗口更干净。
+- Removed the task progress bar under the desktop bee for a cleaner look.
+
 - 「关于与更新」页的版本信息与更新说明改为左对齐阅读，不再整块居中。
 - The version info and release notes on the About page are now left-aligned for easier reading.
 

package/app/core/builtin_agent.py

@@ -39,11 +39,40 @@ _SYSTEM_PROMPT = """你是 CodeBee 的内置执行智能体，直接完成用户
 - 回答用户的语言与用户一致（默认中文）。直接给结论和内容，不要输出任何机器标记或协议行。"""
 
 
-def resolve():
+def resolve(provider_id="", model="", difficulty="default"):
     """选内置智能体可用的 (provider, model)：编排者配置优先，否则首个可用供应商。
 
     返回 {prov, model, provider_id, provider_name} 或 None（无可用供应商 → 调用方
     回退 CLI 路径）。"""
+    provider_id = str(provider_id or "").strip()
+    model = str(model or "").strip()
+    if provider_id:
+        for p in modelhub.providers():
+            if p.get("id") != provider_id or not p.get("enabled", True) or not p.get("api_key"):
+                continue
+            selected = model
+            if selected:
+                try:
+                    enabled_names = [m.get("name") for m in modelhub._enabled_models(p)]
+                except Exception:
+                    enabled_names = []
+                if selected not in enabled_names:
+                    return None
+            if not selected:
+                selected = (p.get("model_hard") if difficulty == "hard" else
+                            p.get("model_easy") if difficulty == "easy" else
+                            p.get("model") or "").strip()
+            if not selected:
+                try:
+                    names = modelhub._enabled_models(p)
+                except Exception:
+                    names = []
+                selected = names[0]["name"] if names else ""
+            if selected:
+                return {"prov": p, "model": selected,
+                        "provider_id": p.get("id") or "",
+                        "provider_name": p.get("name") or p.get("id") or ""}
+        return None
     orch = None
     try:
         orch = modelhub.resolve_orchestrator()
@@ -57,7 +86,9 @@ def resolve():
     for p in modelhub.providers():
         if not p.get("enabled", True) or not p.get("api_key"):
             continue
-        m = (p.get("model") or "").strip()
+        m = ((p.get("model_hard") if difficulty == "hard" else
+              p.get("model_easy") if difficulty == "easy" else
+              p.get("model")) or "").strip()
         if not m:
             try:
                 names = modelhub._enabled_models(p)
@@ -534,6 +565,9 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
             for kk in keys:
                 url, headers, body = _build_request(proto, pbase, kk["key"], model,
                                                     system, msgs, tools_ok)
+                effort = str(bi.get("reasoning_effort") or "").strip().lower()
+                if effort in ("low", "medium", "high") and proto != "google":
+                    body["reasoning_effort"] = effort
                 status, data, err = _post_interruptible(url, headers, body,
                                                         allow_private, timeout,
                                                         cancel_event)

package/app/core/dispatch.py

@@ -103,7 +103,9 @@ def _online_model_bonus(entry, task_type, role):
         rate = float(metrics.get("success_rate") or 0.0)
         success_score = max(-6.0, min(6.0, (rate - 0.75) * 18.0))
         p95 = max(0.0, float(metrics.get("p95_duration_s") or 0.0))
-        latency_score = -min(4.0, max(0.0, (p95 - 45.0) / 12.0))
+        # 模型链也必须让真实延迟影响排序，不能让 P95 数分钟的链靠静态质量分
+        # 长期压在十几秒的健康链前面。
+        latency_score = -min(12.0, max(0.0, (p95 - 30.0) / 8.0))
         cost = max(0.0, float(metrics.get("avg_cost_usd") or 0.0))
         cost_score = -min(3.0, max(0.0, (cost - 0.01) / 0.01))
         total = round(success_score + latency_score + cost_score, 2)

package/app/core/flows.py

@@ -36,7 +36,7 @@ BUILTIN_FLOWS = [
      "note": "CodeBee 直连模型 API 干活（无 CLI 进程），无可用供应商时回退本机 CLI；无拆解/评审（快）"},
     {"id": "code", "name": "代码", "icon": "i-code", "engine": "code", "builtin": True,
      "goal_hint": "要实现/修复什么（一句话）",
-     "note": "实现 → 验证命令 → 跨厂商评审 → 自动修复/换将"},
+     "note": "按难度动态编排：简单任务走实现+验证短链，复杂任务增加规划、评审、修复与换将"},
     {"id": "novel", "name": "小说", "icon": "i-book-open", "engine": "review", "builtin": True,
      "manuscript": "manuscript.md",
      "rubric": ["情节", "人物", "文笔", "节奏", "吸引力"],

package/app/core/jobs.py

@@ -86,6 +86,17 @@ def configure(max_workers):
     return _target
 
 
+def capacity_status():
+    """返回当前并发槽状态，供会产生管理记录的入口做无副作用预检。"""
+    with _pool_lock:
+        return {
+            "accepting": not _restart_drain and _alive < _target,
+            "active": _alive,
+            "limit": _target,
+            "restarting": _restart_drain,
+        }
+
+
 def start_worker():
     """加载并发保护配置；线程只在真实任务到达时创建。"""
     global _started
@@ -309,6 +320,18 @@ def _run_job(job):
             pass
     finally:
         if run_id:
+            # 执行线程退出就是生命周期的最后边界。流水线分支若意外提前 return、
+            # 或内部吞掉异常却漏写终态，旧逻辑会让 run/task 永久停在 running。
+            try:
+                from . import store
+                latest = store.get_run(run_id)
+                if latest and latest.get("status") == "running":
+                    store.update_run(
+                        run_id, expected_status="running", status="failed",
+                        ended_at=_now(),
+                        error="执行流程已退出但未写入完成状态，已自动标记失败；可重试")
+            except Exception:
+                pass
             CANCELS.pop(run_id, None)
             try:
                 _maybe_auto_resume(run_id)

package/app/core/modelhub.py

@@ -2016,6 +2016,12 @@ def bind_agent(agent, difficulty="default", task_type="", role=""):
     a = dict(agent)
     a["binding_configured"] = configured
     a["binding_mode"] = binding_mode
+    # 统一思考档位：支持该能力的 CLI（当前 Codex）会把它下发为原生参数；
+    # 其他 CLI 仍通过 difficulty 的模型路由获得相同的快/标准/深思语义。
+    explicit_thinking = str(agent.get("_thinking") or "").strip().lower()
+    a["reasoning_effort"] = ({"low": "low", "standard": "medium", "high": "high"}
+                              .get(explicit_thinking)
+                              or {"easy": "low", "hard": "high"}.get(difficulty, "medium"))
     if not r:
         return a
     merged = dict(agent.get("env") or {})

package/app/core/pipeline.py

@@ -928,6 +928,10 @@ def _run_code(run, task, agents, ev, stats, mode):
     # ---- 难度（影响模型选择）：用户指定 > 启发式 > 规划器判定
     difficulty = task.get("difficulty") or "auto"
     explicit = difficulty in ("easy", "hard")
+    if mode == "fast":
+        difficulty, explicit = "easy", True
+    elif mode == "expert":
+        difficulty, explicit = "hard", True
     if not explicit:
         difficulty = modelhub.classify_difficulty(task["goal"], task.get("verify_command"))
 
@@ -944,14 +948,21 @@ def _run_code(run, task, agents, ev, stats, mode):
                          error="没有可用智能体", ended_at=_now())
         return
 
-    # ---- 规划
-    if mode == "auto":
+    # 项目记忆既给规划器，也给快速路径的实现者；不能因省掉独立规划而漏掉。
+    user_context_len = len(task.get("context") or "")
+    project_memory = _read_project_memory(workdir)
+    if project_memory:
+        task = dict(task, context=(task.get("context") or "") + "\n\n" + project_memory)
+
+    # ---- 规划。低风险短任务直接把目标作为单步计划，省掉一次独立模型调用；
+    # 附件或较长的用户背景仍先规划，避免快速路径漏读约束。
+    fast_path = (mode == "fast" or
+                 (mode == "auto" and difficulty == "easy"
+                  and not task.get("attachments")
+                  and user_context_len < 600))
+    planned = False
+    if mode == "auto" and not fast_path:
         _wait_gate(run_id, ev)
-        # 项目记忆注入（借鉴 agentmemory 持久记忆）：同工作目录此前代码任务留下的
-        # 架构事实，让规划器不再对代码库一无所知
-        _pm = _read_project_memory(workdir)
-        if _pm:
-            task = dict(task, context=(task.get("context") or "") + "\n\n" + _pm)
         plan_step, plan_log = store.add_step(run_id, "plan", impl["id"], impl.get("label"),
                                              note=route.get("implementer", ""))
         plan = planner.make_code_plan(_steered_task(run_id, task),
@@ -967,21 +978,39 @@ def _run_code(run, task, agents, ev, stats, mode):
                               plan["source"], difficulty,
                               "；".join(s["title"] for s in plan["steps"])[:160]),
                           duration_s=0.1 if impl.get("mode") == "mock" else None)
+        planned = True
+    elif fast_path:
+        plan = {
+            "source": "dynamic-fast-path",
+            "difficulty": "easy",
+            "steps": [{"title": "直接实现并自检", "detail": task["goal"]}],
+            "workflow": {
+                "review_required": not bool(task.get("verify_command")),
+                "max_repair_rounds": 1,
+                "allow_switch": False,
+            },
+        }
     else:
         plan = {"source": "manual", "steps": [{"title": "实现任务", "detail": task["goal"]}]}
-    store.update_run(run_id, plan=plan, difficulty=difficulty)
+    workflow = task_compile.code_workflow(
+        task, difficulty, plan=plan, mode=mode, planned=planned)
+    store.update_run(run_id, plan=plan, difficulty=difficulty, workflow=workflow)
     subtasks = plan["steps"]
     # 计划落盘（planning-with-files）：磁盘上的计划与 spec/evidence 同居任务档案
     _write_task_plan(task, workdir, plan)
 
     # ---- 评审者（有会话延续时评审者仍用新鲜上下文，避免偏见）
-    if mode == "auto":
+    if not workflow["review_required"]:
+        reviewer = None
+        route["reviewer"] = workflow["reason"]
+    elif mode == "auto":
         reviewer, route["reviewer"] = router.pick_reviewer(agents, impl, "code", stats)
     else:
         reviewer, route["reviewer"] = _pick_reviewer_legacy(agents, impl)
     _record_actual_route(run_id, task, agents, stats, impl, reviewer=reviewer,
                          implement_reason=route.get("implementer", ""),
-                         review_reason=route.get("reviewer", ""))
+                         review_reason=route.get("reviewer", ""),
+                         direct=not workflow["review_required"])
     store.update_run(run_id, route=route)
 
     def implement_all(impl_agent, prefix_note):
@@ -1078,7 +1107,8 @@ def _run_code(run, task, agents, ev, stats, mode):
                         run_id, task, agents, stats, other,
                         implementers=[other], reviewer=reviewer,
                         implement_reason=note,
-                        review_reason=route.get("reviewer", ""))
+                        review_reason=route.get("reviewer", ""),
+                        direct=not workflow["review_required"])
                     return True
                 res_err = "%s；换将后仍失败：%s" % (note, (res.get("error") or "")[:200])
             else:
@@ -1091,6 +1121,17 @@ def _run_code(run, task, agents, ev, stats, mode):
 
     def review_and_score():
         verify_pass, verify_ran = _run_verify(run_id, task, workdir, ev)
+        if not workflow["review_required"]:
+            return {
+                "pass": verify_pass,
+                "scores": {},
+                "issues": ([] if verify_pass else [{
+                    "severity": "high", "title": "验证命令未通过",
+                    "detail": "动态短链省略模型评审，先修复确定性验证失败。",
+                }]),
+                "summary": "低风险短链：确定性验证%s，模型评审已省略。" %
+                           ("通过" if verify_pass else "未通过"),
+            }, verify_pass, verify_ran
         # gate 验证（借鉴 pi-subagents 的 gate:"npm test"）：verify 失败时先跳过
         # 模型评审直接进修复轮——评审此时只能复述「验证没过」，白烧一次调用。
         # 连续失败 >=2 轮后恢复评审参与诊断（模型能看出编译错误之外的病灶）。
@@ -1138,7 +1179,8 @@ def _run_code(run, task, agents, ev, stats, mode):
                     implementers=[impl], reviewer=reviewer,
                     implement_reason="修复轮由 %s 完成" %
                     (impl.get("label") or impl.get("id")),
-                    review_reason=route.get("reviewer", ""))
+                    review_reason=route.get("reviewer", ""),
+                    direct=not workflow["review_required"])
             if impl.get("mode") == "mock" and res["ok"]:
                 pass  # mock 不产生真实变更
         review_json, verify_pass, verify_ran = review_and_score()
@@ -1149,10 +1191,10 @@ def _run_code(run, task, agents, ev, stats, mode):
             "passed": passed})
         if passed:
             break
-        if round_no < router.MAX_REPAIR_ROUNDS and not switched:
+        if round_no < workflow["max_repair_rounds"] and not switched:
             round_no += 1
             continue
-        if mode == "auto" and not switched:
+        if mode == "auto" and workflow["allow_switch"] and not switched:
             ex = (impl["id"],)
             if impl.get("mode") == "real":
                 ex += ("mock-a", "mock-b")  # 真实实现者失败时不降级到 mock
@@ -1166,7 +1208,8 @@ def _run_code(run, task, agents, ev, stats, mode):
                     run_id, task, agents, stats, impl,
                     implementers=[impl], reviewer=reviewer,
                     implement_reason=note,
-                    review_reason=route.get("reviewer", ""))
+                    review_reason=route.get("reviewer", ""),
+                    direct=not workflow["review_required"])
                 switched = True
                 round_no += 1
                 continue
@@ -1178,18 +1221,27 @@ def _run_code(run, task, agents, ev, stats, mode):
     verdict = {
         "type": "code", "engine": "code", "pass": overall_pass, "mode": mode,
         "verify_ran": verify_ran, "verify_pass": verify_pass,
-        "review_pass": bool(review_json.get("pass")),
+        "review_pass": (bool(review_json.get("pass"))
+                        if workflow["review_required"] else None),
+        "review_skipped": not workflow["review_required"],
         "scores": scores, "overall_score": overall_score,
         "issues": review_json.get("issues") or [],
-        "reviewer": reviewer["id"],
+        "reviewer": reviewer["id"] if reviewer else "",
         "route": route, "repairs": repairs, "switched": switched,
+        "workflow": workflow,
     }
 
     lines = [
         "# 代码任务报告：%s" % task["title"], "",
         "- 结论：**%s**" % ("✅ 通过" if overall_pass else "❌ 未通过"),
         "- 编排模式：%s　实现者：%s　评审者：%s" % (
-            "智能" if mode == "auto" else "手动", impl.get("label"), reviewer.get("label")),
+            "智能" if mode == "auto" else "手动", impl.get("label"),
+            reviewer.get("label") if reviewer else "按验证结果省略"),
+        "- 动态步骤：规划 %s；实现 %d 步；验证 %s；评审 %d 人；最多修复 %d 轮；换将 %s" % (
+            "独立执行" if workflow["planning"] == "llm" else "并入实现",
+            workflow["implementation_steps"], "有" if workflow["verification"] else "无",
+            workflow["reviewers"], workflow["max_repair_rounds"],
+            "允许" if workflow["allow_switch"] else "关闭"),
         "- 验证命令：%s → %s" % (task.get("verify_command") or "（未配置）",
                                  "通过" if verify_pass else "未通过"),
         "- 综合评分：%s　修复/换将：%s" % (
@@ -1229,7 +1281,8 @@ def _run_code(run, task, agents, ev, stats, mode):
                      summary="代码任务%s（验证%s / 评审%s%s）" % (
                          "通过" if overall_pass else "未通过",
                          "通过" if verify_pass else "未通过",
-                         "通过" if review_json.get("pass") else "未通过",
+                         (("通过" if review_json.get("pass") else "未通过")
+                          if workflow["review_required"] else "按策略省略"),
                          "，%d 轮修复" % (len(repairs) - 1) if len(repairs) > 1 else ""),
                      ended_at=_now())
 
@@ -1379,12 +1432,27 @@ def _run_direct(run, task, agents, ev, stats, mode):
     route = {}
     resume_ctx = _valid_resume(task, agents)
     bi = None
-    if resume_ctx is None and not (mode == "manual" and task.get("implementer")):
+    direct_provider = (task.get("direct_provider_id") or "").strip()
+    direct_model = (task.get("direct_model") or "").strip()
+    direct_difficulty = ("hard" if task.get("thinking") == "high" else
+                         "easy" if task.get("thinking") == "low" else "default")
+    if resume_ctx is None and direct_provider:
+        bi = builtin_agent.resolve(direct_provider, direct_model, direct_difficulty)
+        if bi is None:
+            store.update_run(run_id, expected_status="running", status="failed",
+                             error="指定的对话厂商或模型不可用，请改用自动推荐或检查配置",
+                             ended_at=_now())
+            return
+    elif resume_ctx is None and not (mode == "manual" and task.get("implementer")):
         try:
-            bi = builtin_agent.resolve()
+            bi = builtin_agent.resolve(difficulty=("hard" if task.get("thinking") == "high"
+                                                   else "easy" if task.get("thinking") == "low"
+                                                   else "default"))
         except Exception:
             bi = None
     if bi is not None:
+        bi["reasoning_effort"] = {"low": "low", "standard": "medium", "high": "high"}.get(
+            task.get("thinking"), "medium")
         impl = None
         route["implementer"] = "CodeBee（%s · %s）" % (bi["provider_name"], bi["model"])
     elif resume_ctx is not None:
@@ -3029,6 +3097,11 @@ def _run_content_review(run, task, agents, ev, stats, mode):
     step_wd = _resume_workdir(resume_ctx, workdir) if resume_ctx else workdir
     difficulty = task.get("difficulty") or (
         "hard" if threshold >= 8.5 else "easy" if threshold <= 6 else "default")
+    if mode == "fast":
+        difficulty = "easy"
+    elif mode == "expert":
+        difficulty = "hard"
+    workflow = task_compile.content_workflow(task, difficulty, mode=mode)
 
     # ---- 路由
     if resume_ctx is not None:
@@ -3052,6 +3125,10 @@ def _run_content_review(run, task, agents, ev, stats, mode):
         else:
             critics = _pick_critics_manual(agents, task)
 
+    critic_pool = list(critics)
+    if mode != "manual":
+        critics = critic_pool[:workflow["reviewers"]]
+
     _record_actual_route(run_id, task, agents, stats, impl, critics=critics,
                          implement_reason=route.get("author", ""),
                          review_reason=route.get("critics", ""))
@@ -3059,7 +3136,8 @@ def _run_content_review(run, task, agents, ev, stats, mode):
     # ---- 规划（小说为模板计划）
     _wait_gate(run_id, ev)
     plan = planner.make_novel_plan(_steered_task(run_id, task), impl, critics)
-    store.update_run(run_id, plan=plan, route=route, difficulty=difficulty)
+    store.update_run(run_id, plan=plan, route=route, difficulty=difficulty,
+                     workflow=workflow)
 
     ms_path = os.path.join(workdir, ms_name)
 
@@ -3077,9 +3155,17 @@ def _run_content_review(run, task, agents, ev, stats, mode):
 
     # 编排者大纲：只对真实执行有意义；失败静默退回无大纲（喂入带指令的任务副本）
     outline = (planner.make_review_outline(_steered_task(run_id, task))
-               if impl.get("mode") != "mock" else None)
+               if workflow["outline"] and impl.get("mode") != "mock" else None)
     if outline:
-        store.update_run(run_id, outline=outline)
+        workflow = task_compile.content_workflow(
+            task, difficulty, plan=outline, mode=mode)
+        if mode != "manual":
+            critics = critic_pool[:workflow["reviewers"]]
+        store.update_run(run_id, outline=outline, workflow=workflow)
+        _record_actual_route(run_id, task, agents, stats, impl, critics=critics,
+                             implement_reason=route.get("author", ""),
+                             review_reason=route.get("critics", ""))
+    rounds = workflow["review_rounds"]
 
     # 1) 起草
     bestof_improvements = ""   # 赛马败者精华（真实路径由选择器填充；mock 路径恒空）
@@ -3228,6 +3314,7 @@ def _run_content_review(run, task, agents, ev, stats, mode):
         "overall": overall, "mode": mode,
         "threshold": threshold, "rounds_used": history_rounds[-1]["round"] if history_rounds else 0,
         "scores": final_means, "history": history_rounds, "route": route,
+        "workflow": workflow,
     }
 
     # 3) 报告
@@ -3237,8 +3324,12 @@ def _run_content_review(run, task, agents, ev, stats, mode):
              % ("✅ 达到发布标准" if publishable else "❌ 未达标，建议再修",
                 overall, threshold, verdict["rounds_used"]),
              "- 编排模式：%s　起草/修订：%s　评审组：%s" % (
-                 "智能" if mode == "auto" else "手动",
-                 impl.get("label"), "、".join(a.get("label") for a in critics))]
+                 {"auto": "自动", "fast": "快速", "expert": "专家",
+                  "manual": "手动"}.get(mode, mode),
+                 impl.get("label"), "、".join(a.get("label") for a in critics)),
+             "- 动态步骤：大纲 %s；评审 %d 人；最多 %d 轮（%s）" % (
+                 "启用" if workflow["outline"] else "省略",
+                 len(critics), rounds, workflow["reason"])]
     if route:
         lines.append("")
         lines.append("## 路由依据")
@@ -3589,6 +3680,7 @@ def execute_run(run_id):
     for _agent in agents:
         if isinstance(_agent, dict):
             _agent["_dispatch_task_type"] = task.get("type") or "direct"
+            _agent["_thinking"] = task.get("thinking") or "auto"
     store.update_run(run_id, route_plan={
         "task": task_spec,
         "implement": router.route_plan(agents, "implement", task_spec, stats),

package/app/core/planner.py

@@ -114,11 +114,13 @@ def _log_usage(source, role, task, res, agent=None, tool="", model="", provider=
     except Exception:
         pass
 
-CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
-并判定任务难度。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"difficulty": "easy 或 hard", "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
-难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
-子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
+CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
+并判定任务难度和后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
+{"difficulty": "easy 或 hard", "workflow": {"review_required": true, "max_repair_rounds": 0, "allow_switch": false}, "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
+难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
+质量步骤判定：涉及安全、数据迁移、并发、权限、公共 API 或跨模块改动时必须评审；
+有明确自动验收的低风险小改可不做模型评审。max_repair_rounds 取 0-2，只有复杂任务才建议换将。
+子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
 
 ## 先探索再计划（重要，借鉴 OpenSpec explore）
 拆解之前先用你的读文件/搜索工具**实际查看工作目录**，找到目标相关的真实文件与函数，再据此拆解。
@@ -135,9 +137,12 @@ __CONTEXT__
 ## 验收命令（最终必须通过）
 __VERIFY__"""
 
-REVIEW_OUTLINE_PROMPT = """你是内容主编。请为下面的创作任务拟一份写作大纲（要点列表，3-8 条），
-只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"outline": ["要点1", "要点2", ...]}
+REVIEW_OUTLINE_PROMPT = """你是内容主编。请为下面的创作任务拟一份写作大纲（要点列表，3-8 条），
+并按内容风险建议后续质量步骤。
+只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
+{"outline": ["要点1", "要点2", ...], "workflow": {"reviewers": 1, "review_rounds": 1}}
+reviewers 取 1-2，review_rounds 取 1-3；研究报告、技术方案、长文和高发布门槛应增加，
+普通邮件、短翻译、工作汇报等低风险短内容保持 1。
 
 ## 创作任务
 __GOAL__
@@ -403,9 +408,27 @@ def _norm_subtasks(data):
     return steps or None
 
 
-def _plan_difficulty(data):
+def _plan_difficulty(data):
     d = str((data or {}).get("difficulty") or "").lower()
-    return d if d in ("easy", "hard") else None
+    return d if d in ("easy", "hard") else None
+
+
+def _plan_workflow(data):
+    """规范化规划器给出的后续步骤建议；最终安全下限由任务编译器裁决。"""
+    raw = (data or {}).get("workflow")
+    if not isinstance(raw, dict):
+        return None
+    out = {}
+    if isinstance(raw.get("review_required"), bool):
+        out["review_required"] = raw["review_required"]
+    try:
+        if "max_repair_rounds" in raw:
+            out["max_repair_rounds"] = max(0, min(2, int(raw["max_repair_rounds"])))
+    except (TypeError, ValueError):
+        pass
+    if isinstance(raw.get("allow_switch"), bool):
+        out["allow_switch"] = raw["allow_switch"]
+    return out or None
 
 
 def _orchestrator():
@@ -437,9 +460,10 @@ def make_code_plan(task, planner_agent, workdir, ev=None, resume=None, log_path=
     _log_usage("plan", "plan", task, res, agent=planner_agent)
     data = runner.extract_json(res.get("text") or "")
     steps = _norm_subtasks(data)
-    if steps:
-        return {"source": "llm(%s)" % planner_agent["id"], "steps": steps,
-                "difficulty": _plan_difficulty(data)}
+    if steps:
+        return {"source": "llm(%s)" % planner_agent["id"], "steps": steps,
+                "difficulty": _plan_difficulty(data),
+                "workflow": _plan_workflow(data)}
     return _fallback_code_plan(task, "LLM 计划解析失败，退化为单步模板")
 
 
@@ -468,8 +492,9 @@ def _orch_code_plan(task, prov, model, log_path=None):
     if not steps:
         _append_log(log_path, "编排者计划返回内容无法解析为子任务，回退 CLI")
         return None
-    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
-            "steps": steps, "difficulty": _plan_difficulty(data)}
+    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
+            "steps": steps, "difficulty": _plan_difficulty(data),
+            "workflow": _plan_workflow(data)}
 
 
 def make_review_outline(task):
@@ -492,8 +517,20 @@ def make_review_outline(task):
     if not isinstance(outline, list):
         return None
     items = [str(x).strip()[:120] for x in outline if str(x).strip()][:8]
-    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
-            "items": items} if items else None
+    if not items:
+        return None
+    workflow = data.get("workflow") if isinstance(data.get("workflow"), dict) else {}
+    try:
+        reviewers = max(1, min(2, int(workflow.get("reviewers") or 1)))
+    except (TypeError, ValueError):
+        reviewers = 1
+    try:
+        review_rounds = max(1, min(3, int(workflow.get("review_rounds") or 1)))
+    except (TypeError, ValueError):
+        review_rounds = 1
+    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
+            "items": items,
+            "workflow": {"reviewers": reviewers, "review_rounds": review_rounds}}
 
 
 def make_novel_plan(task, author, critics):