codebee 0.1.28 → 0.1.29

package/CHANGELOG.md

@@ -6,6 +6,16 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.29（2026-09-21）
+
+### ✨ 新功能
+
+- 升级后蜜蜂自动换新装：修复「升级后还是旧的丑蜜蜂」——服务重启后旧蜜蜂会自动让位，由新服务拉起带新形象的新蜜蜂（此前旧蜜蜂占着位置永不退场）。
+
+### 🛠 问题修复
+
+- 去掉蜜蜂底部的任务进度条（真机截图反馈）：窗口收紧贴着蜂体，画面更干净。
+
 ## v0.1.28（2026-09-21）
 
 ### 🛠 问题修复

package/README.md

@@ -21,8 +21,16 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
+### ✨ 新功能 · New
+
+- 升级后蜜蜂自动换新装：服务重启后旧蜜蜂自动让位，新蜜蜂带新形象上线。
+- After upgrading, the desktop bee swaps itself for the new look: the old bee steps aside when the service restarts.
+
 ### 🛠 问题修复 · Fixes
 
+- 去掉蜜蜂底部的任务进度条，窗口更干净。
+- 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/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

@@ -309,6 +309,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/pipeline.py

@@ -944,14 +944,20 @@ 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 == "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 +973,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 +1102,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 +1116,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 +1174,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 +1186,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 +1203,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 +1216,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 +1276,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())
 

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):

package/app/core/router.py

@@ -11,6 +11,7 @@ CAPABILITY = {
 }
 
 MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
+AUTO_CRITIC_LIMIT = 2  # 自动内容评审只取综合分前两名；手工模式仍尊重完整名单
 
 
 def _task_type(ttype):
@@ -62,7 +63,9 @@ def _online_bonus(agent, role, ttype):
         rate = float(metrics.get("success_rate") or 0.0)
         success_score = max(-8.0, min(8.0, (rate - 0.75) * 24.0))
         p95 = max(0.0, float(metrics.get("p95_duration_s") or 0.0))
-        latency_score = -min(6.0, max(0.0, (p95 - 45.0) / 10.0))
+        # 旧上限 -6 抵不过 CLI 静态能力 10 分差，P95 两三分钟的模型仍会
+        # 压过十几秒的健康模型。加大惩罚，让真实延迟足以改变自动选择。
+        latency_score = -min(18.0, max(0.0, (p95 - 30.0) / 7.0))
         cost = max(0.0, float(metrics.get("avg_cost_usd") or 0.0))
         cost_score = -min(4.0, max(0.0, (cost - 0.01) / 0.01))
         total = round(success_score + latency_score + cost_score, 1)
@@ -199,14 +202,18 @@ def pick_reviewer(agents, impl, ttype, stats=None):
     return impl, "（自评：仅有实现者一个智能体可用）"
 
 
-def pick_critics(agents, ttype, stats=None, impl=None):
-    """小说评审组：全部真实智能体（排除作者本人——自评是最典型的同族盲区）；
-    面板与作者同厂商时在路由依据里明示，供用户决定是否补充其他厂商。
-    没有任何真实智能体时用内置 mock。"""
-    stats = stats or history.agent_stats()
-    real = [a for a in agents if a.get("mode") == "real" and (not impl or a["id"] != impl["id"])]
-    if real:
-        note = "全部真实智能体参与（按历史表现自动选择）"
+def pick_critics(agents, ttype, stats=None, impl=None):
+    """自动内容评审组选综合分前两名（排除作者本人）。
+
+    旧逻辑让全部已启用 CLI 串行参与每章和全局评审；一条慢/失效链就会把
+    任务拖长数分钟。两名保留交叉判断并封顶默认调用数；手工模式不走这里。
+    """
+    stats = stats or history.agent_stats()
+    real = [a for a in agents if a.get("mode") == "real" and (not impl or a["id"] != impl["id"])]
+    if real:
+        ranked = sorted(real, key=lambda a: score(a, "review", ttype, stats)[0], reverse=True)
+        real = ranked[:AUTO_CRITIC_LIMIT]
+        note = "按成功率与延迟选择前 %d 名评审（共 %d 名候选）" % (len(real), len(ranked))
         if impl and impl.get("mode") == "real" \
                 and all(a.get("kind") == impl.get("kind") for a in real):
             note += "；评审组与作者同为 %s，建议启用其他厂商 CLI 交叉评审" % impl.get("kind")

package/app/core/selfupdate.py

@@ -188,16 +188,21 @@ def apply_upgrade(port=None):
         return {"error": "升级任务创建失败，请稍后重试"}
     try:
         jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
-    except Exception:
-        # run 已持久化；启动失败时显式收口，版本页不能停在误导性的待启动状态。
-        log.exception("selfupdate: 升级任务启动失败 run=%s", run["id"])
-        try:
-            store.update_run(run["id"], status="failed",
-                             error="升级任务启动失败，本次未排队，请稍后重试",
-                             ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+    except Exception as exc:
+        # run 已持久化；启动失败时显式收口，版本页不能停在误导性的待启动状态。
+        log.exception("selfupdate: 升级任务启动失败 run=%s", run["id"])
+        if isinstance(exc, jobs.JobsBusyError):
+            message = "升级未启动：%s" % str(exc)
+        else:
+            # 仅并发保护类错误可直接展示；其他内部异常继续隐藏实现细节。
+            message = "升级任务启动失败，本次未排队，请稍后重试"
+        try:
+            store.update_run(run["id"], status="failed",
+                             error=message,
+                             ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
         except Exception:
             log.exception("selfupdate: 升级运行失败收口失败 run=%s", run["id"])
-        return {"error": "升级任务启动失败，本次未排队，请稍后重试", "run_id": run["id"]}
+        return {"error": message, "run_id": run["id"]}
     return {"run_id": run["id"]}
 
 

package/app/core/task_compile.py

@@ -85,3 +85,93 @@ def summary(spec):
         spec.get("type") or "direct", spec.get("engine") or "direct",
         spec.get("difficulty") or "default",
         "、".join(spec.get("capabilities") or []) or "通用")
+
+
+def code_workflow(task, difficulty, plan=None, mode="auto", planned=True):
+    """把难度、验收能力和规划建议收敛成代码任务的实际步骤策略。
+
+    自动模式允许低风险任务走短链；手动模式与高风险任务保留完整质量门禁。
+    规划器只能在安全边界内减少步骤，不能让无确定性验证的任务跳过评审。
+    """
+    task = task if isinstance(task, Mapping) else {}
+    rec = (plan or {}).get("workflow") if isinstance(plan, Mapping) else None
+    rec = rec if isinstance(rec, Mapping) else {}
+    has_verify = bool(str(task.get("verify_command") or "").strip())
+    easy_auto = mode == "auto" and difficulty == "easy"
+
+    review_required = True
+    max_repairs = 2
+    allow_switch = True
+    reason = "复杂或手动任务使用完整质量门禁"
+    if easy_auto:
+        review_required = not has_verify
+        max_repairs = 1
+        allow_switch = False
+        reason = ("低风险任务以确定性验证代替模型评审"
+                  if has_verify else "低风险任务无验证命令，保留一次模型评审")
+        if isinstance(rec.get("review_required"), bool):
+            review_required = rec["review_required"] or not has_verify
+        try:
+            if "max_repair_rounds" in rec:
+                max_repairs = max(0, min(1, int(rec["max_repair_rounds"])))
+        except (TypeError, ValueError):
+            pass
+    elif mode == "auto" and difficulty == "hard":
+        try:
+            if "max_repair_rounds" in rec:
+                max_repairs = max(1, min(2, int(rec["max_repair_rounds"])))
+        except (TypeError, ValueError):
+            pass
+        if isinstance(rec.get("allow_switch"), bool):
+            allow_switch = rec["allow_switch"]
+        reason = "复杂任务保留规划、验证与模型评审"
+
+    return {
+        "planning": "llm" if planned else "inline",
+        "implementation_steps": len((plan or {}).get("steps") or []) or 1,
+        "verification": has_verify,
+        "review_required": review_required,
+        "reviewers": 1 if review_required else 0,
+        "max_repair_rounds": max_repairs,
+        "allow_switch": allow_switch,
+        "reason": reason,
+    }
+
+
+def content_workflow(task, difficulty, plan=None, mode="auto"):
+    """为非连载内容任务生成动态大纲/评审/修订策略。"""
+    task = task if isinstance(task, Mapping) else {}
+    ttype = str(task.get("type") or "doc")
+    requested_rounds = max(1, min(5, int(task.get("rounds") or 2)))
+    rec = (plan or {}).get("workflow") if isinstance(plan, Mapping) else None
+    rec = rec if isinstance(rec, Mapping) else {}
+    light_types = {"email", "weekly_report", "translation"}
+    deep_types = {"novel", "research", "tech_proposal"}
+
+    if mode != "auto":
+        return {"outline": True, "reviewers": 0,
+                "review_rounds": requested_rounds,
+                "reason": "手动模式尊重用户指定的评审组与轮数"}
+
+    if ttype in light_types and difficulty != "hard":
+        return {"outline": False, "reviewers": 1, "review_rounds": 1,
+                "reason": "轻量内容省略独立大纲，只做一次快速评审"}
+
+    outline = ttype in deep_types or difficulty == "hard"
+    reviewers = 2 if outline else 1
+    review_rounds = min(requested_rounds, 2 if outline else 1)
+    try:
+        if "reviewers" in rec:
+            reviewers = max(1, min(2, int(rec["reviewers"])))
+        if "review_rounds" in rec:
+            review_rounds = max(1, min(requested_rounds, 3,
+                                       int(rec["review_rounds"])))
+    except (TypeError, ValueError):
+        pass
+    # 深度类型至少保留一轮评审，但允许规划器把双评审降成一名；高门槛强制双评审。
+    if float(task.get("threshold") or 7.0) >= 8.5:
+        reviewers = 2
+    return {"outline": outline, "reviewers": reviewers,
+            "review_rounds": review_rounds,
+            "reason": ("深度内容保留大纲和多轮质量门禁" if outline
+                       else "标准内容使用单评审短链")}

package/app/main.py

@@ -52,6 +52,7 @@ def _utf8_bytes(data):
         return data.decode("utf-8", "replace").encode("utf-8")
 
 PORT = 8765  # main() 启动时更新；/api/connect 组装扫码地址用
+_BOOT_TS = time.time()  # 服务进程启动时间戳：/api/pet_state 下发，蜜蜂据此识别「服务换人了」并让位
 
 # 写接口统一限制 JSON 请求体，避免误传文件或异常客户端把 worker 线程和
 # 内存拖垮。16 MiB 足够覆盖任务上下文、故事圣经和附件清单（附件本体走
@@ -1468,6 +1469,7 @@ class Handler(BaseHTTPRequestHandler):
         「刚完工/刚出事」。设置随响应回传，蜜蜂轮询到 pet_enabled=false 自行
         退出——关闭桌宠不需要专门的信号通道。
         """
+        global _BOOT_TS
         st = settings.load()
         rows = []
         n_run = n_q = 0
@@ -1500,6 +1502,10 @@ class Handler(BaseHTTPRequestHandler):
             dg = {"unseen": 0, "latest": None}
         return self._json(200, {
             "ok": True, "ts": int(time.time()), "port": PORT,
+            # boot：本服务进程的启动时间戳。蜜蜂记住首次见到的值，值变了说明
+            # 服务换了个进程（升级重启）——旧蜜蜂自行退场让新服务 spawn 新蜜蜂
+            # （旧形象常驻的根因：同端口轮询永远正常，旧进程从不自离）。
+            "boot": _BOOT_TS,
             "settings": {"pet_enabled": bool(st.get("pet_enabled", True)),
                          "pet_mode": str(st.get("pet_mode") or "always"),
                          "pet_skin": str(st.get("pet_skin") or "plush")},

package/app/pet.py

@@ -82,6 +82,8 @@ def parse_snapshot(raw):
             "error": str(t.get("error") or ""),
         })
     return {
+        # boot：服务进程启动标识（值变化=服务换人，本宠让位给新服务的蜜蜂）
+        "boot": raw.get("boot") or None,
         "settings": {
             "pet_enabled": bool(st.get("pet_enabled", True)),
             "pet_mode": str(st.get("pet_mode") or "always"),
@@ -309,7 +311,6 @@ KEY_RGB = (1, 2, 3)
 WIN_W, WIN_H = 170, 150          # 手绘回落模式的窗口尺寸
 SPRITE_DIR = Path(__file__).resolve().parent
 SPRITE_DISP_H = 112              # 精灵显示高度（宽等比）
-PROG_H = 16                      # 底部进度条预留高度（有进度时才显示）
 
 
 def _pid_alive(pid):
@@ -371,6 +372,9 @@ _BROWSER_EXES = {
 }
 
 
+petWindow = None
+
+
 def _window_process_name(hwnd):
     """取顶层窗口所属进程的可执行文件名（小写）；失败返回空串。"""
     try:
@@ -438,6 +442,38 @@ def _focus_codebee_window(ignore_hwnd=None):
         return False
 
 
+def _show_pet_window(ignore_hwnd=None):
+    """复用桌宠拉起的 CodeBee 浏览器窗口；窗口已关闭时返回 False。"""
+    global petWindow
+    try:
+        if os.name != "nt":
+            return False
+        import ctypes
+        user32 = ctypes.windll.user32
+        if petWindow and user32.IsWindow(petWindow):
+            if user32.IsIconic(petWindow):
+                user32.ShowWindow(petWindow, 9)   # SW_RESTORE
+            user32.SetForegroundWindow(petWindow)
+            return True
+        petWindow = None
+        hwnd = _find_codebee_window(ignore_hwnd)
+        if not hwnd:
+            return False
+        petWindow = hwnd
+        if user32.IsIconic(hwnd):
+            user32.ShowWindow(hwnd, 9)
+        user32.SetForegroundWindow(hwnd)
+        return True
+    except Exception:
+        return False
+
+
+def openPetWindow(port, ignore_hwnd=None):
+    if os.name == "nt" and _show_pet_window(ignore_hwnd):
+        return
+    webbrowser.open("http://127.0.0.1:%d" % port)
+
+
 class PetApp:
     """蜜蜂窗口：蜜蜂本体（精灵/手绘）+ 状态机动画 + 悬停任务清单 + 右键菜单。"""
 
@@ -485,6 +521,7 @@ class PetApp:
         # 运行态
         self.snap = None
         self.miss = 0
+        self.boot = None    # 首次见到的服务 boot 标识；变化=服务换进程，本宠让位
         self.prev_active = set()
         self.mood_kind, self.mood_until = "", 0.0
         self.last_busy = time.time()
@@ -638,18 +675,19 @@ class PetApp:
     def _size_for(self, frames):
         fw = max(f.width() for lst in frames.values() for f in lst)
         fh = max(f.height() for lst in frames.values() for f in lst)
-        return int(fw) + 8, int(fh) + PROG_H + 4
+        return int(fw) + 8, int(fh) + 4
 
     # ---- 蜜蜂绘制（精灵模式：贴图 + 状态点缀画件）----
-    # 用户拍板去掉：右上徽章、左侧速度线、底部影子（真机截图圈删）——
-    # 窗口贴着蜂体开，点缀只留睡觉 Zzz / 庆祝星光 / 底部进度条。
+    # 用户拍板去掉：右上徽章、左侧速度线、底部影子（真机截图圈删）、
+    # 底部任务进度条（2026-09-21 真机截图圈删）——
+    # 窗口贴着蜂体开，点缀只留睡觉 Zzz / 庆祝星光。
     def _build_sprite(self):
         cv = self.cv
-        cx, cy = self.win_w // 2, (self.win_h - PROG_H) // 2 + 2
+        cx, cy = self.win_w // 2, self.win_h // 2 + 2
         self._spr_c = (cx, cy)
         self.spr = cv.create_image(cx, cy, image=self.frames["alert"][0],
                                    anchor="center")
-        hw, hh = self.win_w / 2, (self.win_h - PROG_H) / 2
+        hw, hh = self.win_w / 2, self.win_h / 2
         self.zzz = [cv.create_text(cx + hw - 12, cy - hh + 14, text="z",
                                    fill="#8A93A6",
                                    font=("Segoe UI", 11, "italic bold")),
@@ -671,15 +709,6 @@ class PetApp:
         for grp in (self.zzz, self.spark):
             for i in grp:
                 cv.itemconfigure(i, state="hidden")
-        # 底部进度条（工作且有步骤进度才出现）
-        self.pbar_bg = cv.create_rectangle(cx - 34, self.win_h - 7,
-                                           cx + 34, self.win_h - 2,
-                                           fill="#202A36", outline="#3A4654")
-        self.pbar_fg = cv.create_rectangle(cx - 33, self.win_h - 6,
-                                           cx - 32, self.win_h - 3,
-                                           fill="#7ED07E", outline="")
-        cv.itemconfigure(self.pbar_bg, state="hidden")
-        cv.itemconfigure(self.pbar_fg, state="hidden")
         self.ox = self.oy = 0.0
         self._t0 = time.time()
 
@@ -867,14 +896,6 @@ class PetApp:
         self._palette = {i: cv.itemcget(i, "fill")
                          for i in (self.body, self.belly)}
 
-        # —— 贴地件：进度条（用户拍板去掉影子）——
-        self.pbar_bg = cv.create_rectangle(46, 139, 128, 147, fill="#202A36",
-                                           outline="#3A4654")
-        self.pbar_fg = cv.create_rectangle(47, 140, 48, 146, fill="#7ED07E",
-                                           outline="")
-        cv.itemconfigure(self.pbar_bg, state="hidden")
-        cv.itemconfigure(self.pbar_fg, state="hidden")
-
         # 动画游标
         self.ox = self.oy = 0.0
         self._t0 = time.time()
@@ -923,26 +944,9 @@ class PetApp:
                 cv.itemconfigure(self.body, fill=self._palette[self.body])
                 cv.itemconfigure(self.belly, fill=self._palette[self.belly])
                 cv.itemconfigure(self.gloss, state="normal")
-        # —— 共同：Zzz / 星光 / 进度条（徽章与速度线已按用户要求移除）——
+        # —— 共同：Zzz / 星光（徽章、速度线、进度条均已按用户要求移除）——
         self._show(self.zzz, False)
         self._show(self.spark, False)
-        prog = []
-        if st == "work" and self.snap:
-            prog = [t for t in self.snap["tasks"]
-                    if t["run_status"] == "running" and t["steps_total"]]
-        if prog:
-            done = sum(t["steps_done"] for t in prog)
-            total = sum(t["steps_total"] for t in prog)
-            ratio = max(0.0, min(1.0, done / float(total)))
-            x0 = (self.win_w // 2) - 34
-            cv.itemconfigure(self.pbar_bg, state="normal")
-            cv.itemconfigure(self.pbar_fg, state="normal")
-            cv.coords(self.pbar_bg, x0, self.win_h - 7, x0 + 68,
-                      self.win_h - 2)
-            cv.coords(self.pbar_fg, x0 + 1, self.win_h - 6,
-                      x0 + 1 + 66 * ratio, self.win_h - 3)
-        else:
-            self._show([self.pbar_bg, self.pbar_fg], False)
 
     def _post_settings(self, body):
         """合并并串行发送设置，保证快速连点时最后一次选择最终生效。"""
@@ -1029,6 +1033,15 @@ class PetApp:
         else:
             self.miss = 0
         if snap is not None:
+            # 服务换人检测（升级重启同端口场景）：boot 与首次见到的不一致，
+            # 说明响应来自新进程——本进程是旧代码的遗老，立即让位，新服务的
+            # 看护会 spawn 带新形象的新蜜蜂（旧形象常驻的根因修复）。
+            boot = snap.get("boot")
+            if boot:
+                if self.boot is None:
+                    self.boot = boot
+                elif boot != self.boot:
+                    return self._bye()
             self._reconcile_desired_settings(snap, confirmed_at_poll_start)
             if not snap["settings"]["pet_enabled"]:
                 return self._bye()
@@ -1375,12 +1388,7 @@ class PetApp:
 
     def _open_ui(self):
         try:
-            url = "http://127.0.0.1:%d" % self.port
-            # 已开过就不新开：Windows 上先找现有 CodeBee 浏览器窗口置前，
-            # 找不到（没开/标签不在前台）才回退 webbrowser.open 新开。
-            if os.name == "nt" and _focus_codebee_window(self.root.winfo_id()):
-                return
-            webbrowser.open(url)
+            openPetWindow(self.port, self.root.winfo_id())
         except Exception:
             pass
 

package/app/ui/app.js

@@ -8513,16 +8513,29 @@ function ztHarvestProfiles() {
   });
 }
 
-function ztProfAdd() {
+async function ztProfAdd() {
   S.ztProfiles = ztHarvestProfiles();
-  S.ztProfiles.push({ product: 0, assigned_to: "", severity_cap: 0, our_sides: ["backend"],
+  // 新档案必须来自禅道产品清单。先拉清单，再自动选第一个尚未配置的产品，
+  // 避免生成 product=0 的空卡，用户随后保存才看到“缺产品 ID”。
+  if (!(S.ztProducts || []).length) {
+    if (!($("zt-base-url") && $("zt-base-url").value.trim())) {
+      toast(t("请先测试并保存禅道连接，再添加产品"), true);
+      return;
+    }
+    await ztFetchCatalog(false);
+    S.ztProfiles = ztHarvestProfiles();
+  }
+  const used = new Set(S.ztProfiles.map((p) => String(p.product || "")));
+  const next = (S.ztProducts || []).find((p) => p.id && !used.has(String(p.id)));
+  if (!next) {
+    toast(t((S.ztProducts || []).length ? "禅道产品均已添加" : "未拉到可用产品，请先测试连接"), true);
+    return;
+  }
+  S.ztProfiles.push({ product: Number(next.id), assigned_to: "", severity_cap: 0, our_sides: ["backend"],
     repos: { backend: {}, frontend: {} }, repo_hints: { backend: "", frontend: "" },
     owners: { backend: "", frontend: "", not_ours: "" }, module_routes: [] });
   renderZentaoProfiles();
-  // 首次添加时自动拉清单，避免用户只能盲填产品 ID；拉不到仍保留手填回退。
-  if (!(S.ztProducts || []).length && $("zt-base-url") && $("zt-base-url").value.trim()) {
-    ztFetchCatalog(false);
-  }
+  ztFetchMods(S.ztProfiles.length - 1, true);
 }
 
 function ztProfDel(i) {
@@ -8672,6 +8685,13 @@ function ztFormPayload() {
 
 async function saveZentao() {
   const payload = ztFormPayload();
+  if ((payload.product_profiles || []).some((p) => !p.product)) {
+    toast(t("请选择禅道产品后再保存"), true);
+    const empty = Array.from(document.querySelectorAll("#zt-profiles .zt-p-product"))
+      .find((el) => !parseInt(el.value || "", 10));
+    if (empty) empty.focus();
+    return;
+  }
   try {
     await api("/api/zentao/config", { method: "POST", body: JSON.stringify(payload) });
   } catch (e) { toast(t("保存失败：") + e.message, true); return; }
@@ -10601,6 +10621,11 @@ function collapseDrawerIfMobile() {
 function switchTab(name) {
   if (name === "__phone") { openPhoneConnect(); return; }  // 手机连接是弹框，不切页
   if (name === "__guide") { welcomeOpen(); return; }       // 帮助中心是弹层，不切页（设置导航「软件」组）
+  if (name === "__wxdigest") {                              // 群聊汇报沿用全局蜜蜂面板
+    beeRefresh().finally(() => beeToggle(true));
+    collapseDrawerIfMobile();
+    return;
+  }
   // 导航收进「设置」：进设置后左栏整体换成设置导航，内容铺满
   S.tab = name;
   if (SET_TABS.has(name)) localStorage.setItem("orch.setTab", name);
@@ -11314,7 +11339,7 @@ function bindCmdK() {
 
 /* ------------------------------------------------ 群摘要蜜蜂坞（core/wxdigest.py）
  * 右下角悬浮蜜蜂：未读摘要徽章+气泡；面板看各群摘要、配置监控文件夹。
- * 桌面蜜蜂 pet.py 的网页侧搭档；未启用且无数据时整坞隐藏（不占视线）。
+ * 桌面蜜蜂 pet.py 的网页侧搭档；入口始终可见，未配置时也能直接打开设置。
  * 60s 轮询 /api/wxdigest；打开面板即 POST seen 清零未读。 */
 const Bee = { view: null, lastUnseen: 0, bubT: 0, selGroups: null };
 
@@ -11325,9 +11350,7 @@ async function beeRefresh() {
   let v;
   try { v = await api("/api/wxdigest"); } catch (e) { return; }   // 静默：不打扰主流程
   Bee.view = v;
-  const on = !!(v.config && v.config.enabled) ||
-    (v.digests && v.digests.length) || v.unseen > 0;
-  beeShow($("bee-dock"), on);
+  beeShow($("bee-dock"), true);
   beeShow($("bee-badge"), v.unseen > 0);
   if (v.unseen > 0) $("bee-badge").textContent = v.unseen > 99 ? "99+" : String(v.unseen);
   if (v.unseen > Bee.lastUnseen && !beePanelOpen()) {   // 新摘要到：气泡 6s

package/app/ui/i18n.js

@@ -2005,6 +2005,10 @@
     "还没有认领过 Bug——配置好连接与产品档案后点「立即扫描」。": "No bugs claimed yet — set up connection and product profiles, then click \"Scan Now\".",
     "还没有产品档案——点「＋ 添加产品」，填产品 ID 与两端仓库。": "No product profiles yet — click \"＋ Add product\" and fill the product ID and repos.",
     "还没有产品档案——先测试连接，再从禅道选择产品，无需自己查 ID。": "No product profiles yet — test the connection, then select a product from ZenTao; no ID lookup needed.",
+    "请先测试并保存禅道连接，再添加产品": "Test and save the ZenTao connection before adding a product.",
+    "禅道产品均已添加": "All ZenTao products have already been added.",
+    "未拉到可用产品，请先测试连接": "No available products were found. Test the connection first.",
+    "请选择禅道产品后再保存": "Select a ZenTao product before saving.",
     "先填产品 ID 再拉模块清单": "Fill the product ID before fetching modules",
     "先选产品再拉模块清单": "Pick a product before fetching modules",
     "拉取失败": "Fetch failed",
@@ -2200,6 +2204,7 @@
 
     // —— 群摘要蜜蜂坞（wxdigest）——
     "群摘要": "Group Digests",
+    "微信群聊汇报": "WeChat Group Reports",
     "启用定时扫描": "Enable scheduled scanning",
     "监控文件夹": "Watched folder",
     "间隔（分钟）": "Interval (min)",

package/app/ui/index.html

@@ -178,6 +178,7 @@
       <button class="set-item active" data-sub="tasks" data-i18n="任务"><svg class="ico" aria-hidden="true"><use href="#i-tasks"></use></svg>任务</button>
       <button class="set-item" data-sub="runs" data-i18n="运行记录"><svg class="ico" aria-hidden="true"><use href="#i-history"></use></svg>运行记录</button>
       <button class="set-item" data-sub="automation" data-i18n="自动化"><svg class="ico" aria-hidden="true"><use href="#i-calendar-days"></use></svg>自动化</button>
+      <button class="set-item" data-sub="__wxdigest" data-i18n="微信群聊汇报"><svg class="ico" aria-hidden="true"><use href="#i-bee"></use></svg>微信群聊汇报</button>
       <button class="set-item" data-sub="zentao" data-i18n="禅道"><svg class="ico" aria-hidden="true"><use href="#i-search"></use></svg>禅道</button>
       <button class="set-item" data-sub="usage" data-i18n="用量统计"><svg class="ico" aria-hidden="true"><use href="#i-chart"></use></svg>用量统计</button>
       <div data-i18n="配置" class="set-group">配置</div>
@@ -557,12 +558,12 @@
           <label data-i18n="密码">密码</label><input id="zt-password" type="password" placeholder="" autocomplete="new-password">
         </div>
         <h3 data-i18n="自动化" class="sec-title">自动化</h3>
-        <div class="zt-grid zt-grid-toggles">
+        <div class="zt-grid zt-grid-toggles zt-auto-options">
           <label class="toggle" title="模块路由没命中时，用 AI 读 Bug 描述判端（前端/后端/双端/非我方）；关掉则未命中模块的 Bug 留人工" data-i18n-title="模块路由没命中时，用 AI 读 Bug 描述判端（前端/后端/双端/非我方）；关掉则未命中模块的 Bug 留人工"><input id="zt-triageai" type="checkbox"><span data-i18n="AI 排查兜底">AI 排查兜底</span></label>
           <label class="toggle" title="修复任务评审通过后，自动到禅道 resolve（fixed）并回评论" data-i18n-title="修复任务评审通过后，自动到禅道 resolve（fixed）并回评论"><input id="zt-autoresolve" type="checkbox"><span data-i18n="自动 resolve Bug">自动 resolve Bug</span></label>
           <label class="toggle" title="把任务分支自动合并回基线分支（需配置基线分支；合并失败不 resolve 不转派，留人工）" data-i18n-title="把任务分支自动合并回基线分支（需配置基线分支；合并失败不 resolve 不转派，留人工）"><input id="zt-automerge" type="checkbox"><span data-i18n="自动合并代码">自动合并代码</span></label>
           <label class="toggle" title="按下面的间隔定时扫描；关掉后仍可手动「立即扫描」" data-i18n-title="按下面的间隔定时扫描；关掉后仍可手动「立即扫描」"><input id="zt-poll" type="checkbox"><span data-i18n="定时扫描">定时扫描</span></label>
-          <label data-i18n="扫描间隔（小时）">扫描间隔（小时）</label><input id="zt-interval" type="number" min="1" max="168" step="1">
+          <label class="zt-interval-field"><span data-i18n="扫描间隔（小时）">扫描间隔（小时）</span><input id="zt-interval" type="number" min="1" max="168" step="1"></label>
         </div>
         <div class="ops"><button id="btn-zentao-save" class="primary small"><span data-i18n="保存配置">保存配置</span></button></div>
         <h3 data-i18n="产品档案" class="sec-title">产品档案</h3>
@@ -1107,10 +1108,10 @@
 
 <!-- 群摘要蜜蜂坞（右下角悬浮蜜蜂）：桌面蜜蜂 pet.py 的网页侧搭档。
      未读摘要时徽章+气泡提醒，点开面板看各群摘要/配置监控文件夹；
-     未启用且无数据时整坞隐藏（不占视线）。后端 core/wxdigest.py。 -->
-<div id="bee-dock" class="hidden">
+     未配置时也保持入口可见，避免功能存在却无处开启。后端 core/wxdigest.py。 -->
+<div id="bee-dock">
   <div id="bee-bubble" class="hidden"></div>
-  <button id="bee-fab" aria-label="群摘要" data-i18n-aria="群摘要" data-i18n-title="群摘要" title="群摘要">
+  <button id="bee-fab" aria-label="微信群聊汇报" data-i18n-aria="微信群聊汇报" data-i18n-title="微信群聊汇报" title="微信群聊汇报">
     <svg class="ico ico-lg" aria-hidden="true"><use href="#i-bee"></use></svg>
     <span id="bee-badge" class="hidden"></span>
   </button>

package/app/ui/style.css

@@ -5521,3 +5521,34 @@ button.request-busy > * { opacity: .18; }
   line-height: 1.6;
 }
 #su-info.empty { text-align: center; }
+
+/* ---------------- 禅道·添加产品与自动化布局（追加于文件尾） ---------------- */
+.zt-prof .head .name {
+  display: flex; flex: 1 1 280px; min-width: 0; align-items: center; gap: 8px;
+  overflow: visible; white-space: normal;
+}
+.zt-prof .head .zt-p-product {
+  width: min(360px, 100%); min-width: 180px; flex: 1 1 240px;
+}
+.zt-auto-options {
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 12px 18px; align-items: start;
+}
+@media (min-width: 901px) {
+  .zt-auto-options { grid-template-columns: repeat(5, minmax(0, 1fr)); }
+}
+.zt-auto-options > .toggle {
+  min-height: 38px; margin: 0; align-self: end;
+}
+.zt-auto-options .zt-interval-field {
+  display: grid; grid-template-columns: 1fr; gap: 6px; min-width: 0;
+  color: var(--muted); font-size: 12.5px;
+}
+.zt-auto-options .zt-interval-field input {
+  width: 100%; max-width: none; box-sizing: border-box;
+}
+@media (max-width: 640px) {
+  .zt-auto-options { grid-template-columns: 1fr 1fr; }
+  .zt-auto-options .zt-interval-field { grid-column: 1 / -1; }
+  .zt-prof .head .zt-p-product { min-width: 0; }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {