codebee 0.1.29 → 0.1.31

package/CHANGELOG.md

@@ -6,6 +6,30 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.31（2026-09-21）
+
+### ✨ 新功能
+
+- 群摘要搬进正式页面：设置 →「微信群聊汇报」现在是完整页面——配置（监控文件夹/微信直连/Python 扫描与一键安装/监听群）和各群摘要列表一体呈现，不再挤在右下角悬浮小窗里。
+- 桌面蜜蜂右键「群摘要」直达该页面（已打开的页面只聚焦不重复开）。
+
+### 🛠 问题修复
+
+- 修复微信直连「选不中 Python」：此前每分钟的自动刷新会把用户刚选好但还没保存的路径悄悄冲回旧值，现在改过路径后不再回填覆盖，保存成功后才更新。
+
+## v0.1.30（2026-09-21）
+
+### ✨ 新功能
+
+- 微信直连配置更省事：新增「扫描」按钮自动找出本机全部 Python（标注位数与是否已装依赖，点选即回填）；选中未装依赖的 64 位解释器可「一键安装 wechatauto-replica」，不用再自己开 conda 敲命令。
+- 桌面蜜蜂右键新增「群摘要」：直达群摘要面板（已打开的页面只聚焦不重复开）。
+- 直连任务可选指定厂商与模型。
+
+### 🛠 问题修复
+
+- 修复没装 Pillow 的电脑上蜜蜂永远显示手绘丑蜜蜂：现在用系统自带能力直接显示新形象贴图（普通用户升级即变好看，无需装任何额外依赖）。
+- 禅道自动化四个开关与扫描间隔紧凑排成一行。
+
 ## v0.1.29（2026-09-21）
 
 ### ✨ 新功能

package/README.md

@@ -23,11 +23,33 @@ 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.
+- 群摘要搬进正式页面：设置 →「微信群聊汇报」里配置与摘要列表一体呈现，右下角悬浮小窗已移除；桌面蜜蜂右键「群摘要」直达。
+- Group digests now live on a proper settings page (config + digest list in one place); the floating bottom-right widget is gone, and the desktop bee links straight to it.
+
+### 🛠 问题修复 · Fixes
+
+- 修复「选不中 Python」：自动刷新不再冲掉你刚选好但还没保存的路径。
+- Fixed "can't pick a Python": background refresh no longer wipes a freshly chosen but unsaved path.
+
+- 微信直连配置更省事：「扫描」自动找本机 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.
 

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,11 @@ 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()
+                # reasoning_effort 是 OpenAI wire 字段；Anthropic thinking 使用
+                # 另一套对象结构，向兼容网关硬塞该字段会直接得到 400。
+                if effort in ("low", "medium", "high") and proto == "openai":
+                    body["reasoning_effort"] = effort
                 status, data, err = _post_interruptible(url, headers, body,
                                                         allow_private, timeout,
                                                         cancel_event)

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

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 {})
@@ -2997,16 +3003,17 @@ def resolve_orchestrator():
     return prov, model
 
 
-def _chat_cache_path(provider_id, model_name, prompt, max_tokens):
+def _chat_cache_path(provider_id, model_name, prompt, max_tokens, reasoning_effort=""):
     """§07 T2.2：精确匹配响应缓存的落盘路径（只缓存 ok 的幂等调用）。"""
     import hashlib as _h
-    key = "|".join([str(provider_id), str(model_name), str(max_tokens), str(prompt)])
+    key = "|".join([str(provider_id), str(model_name), str(max_tokens),
+                    str(reasoning_effort or ""), str(prompt)])
     name = _h.sha256(key.encode("utf-8")).hexdigest()[:24]
     return paths.DATA_DIR / "chat_cache" / (name + ".json")
 
 
 def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_ttl=0,
-         on_delta=None):
+         on_delta=None, reasoning_effort=""):
     """直连供应商 API 做一次对话（编排者规划 / 连通性测试）。
 
     支持 anthropic / openai / google 三种协议；复用 SSRF 防护。
@@ -3020,7 +3027,8 @@ def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_tt
     """
     if cache_ttl > 0:
         try:
-            cache_path = _chat_cache_path(provider_id, model_name, prompt, max_tokens)
+            cache_path = _chat_cache_path(provider_id, model_name, prompt, max_tokens,
+                                          reasoning_effort)
             if cache_path.is_file():
                 age = time.time() - cache_path.stat().st_mtime
                 if age <= cache_ttl:
@@ -3067,6 +3075,9 @@ def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_tt
                 headers = {"Authorization": "Bearer " + use_key}
             body = {"model": model_name, "max_tokens": max_tokens,
                     "messages": [{"role": "user", "content": prompt}]}
+            effort = str(reasoning_effort or "").strip().lower()
+            if proto == "openai" and effort in ("low", "medium", "high"):
+                body["reasoning_effort"] = effort
         return url, headers, body
 
     last_err = ""
@@ -3150,7 +3161,8 @@ def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_tt
     # §07 T2.2：cache_ttl>0 时落盘缓存（仅 ok 结果，原子写）
     if cache_ttl > 0:
         try:
-            cache_path = _chat_cache_path(provider_id, model_name, prompt, max_tokens)
+            cache_path = _chat_cache_path(provider_id, model_name, prompt, max_tokens,
+                                          reasoning_effort)
             cache_path.parent.mkdir(parents=True, exist_ok=True)
             tmp = cache_path.with_suffix(".tmp")
             import json as _json

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"))
 
@@ -952,9 +956,10 @@ def _run_code(run, task, agents, ev, stats, mode):
 
     # ---- 规划。低风险短任务直接把目标作为单步计划，省掉一次独立模型调用；
     # 附件或较长的用户背景仍先规划，避免快速路径漏读约束。
-    fast_path = (mode == "auto" and difficulty == "easy"
-                 and not task.get("attachments")
-                 and user_context_len < 600)
+    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)
@@ -1230,7 +1235,8 @@ def _run_code(run, task, agents, ev, stats, mode):
         "# 代码任务报告：%s" % task["title"], "",
         "- 结论：**%s**" % ("✅ 通过" if overall_pass else "❌ 未通过"),
         "- 编排模式：%s　实现者：%s　评审者：%s" % (
-            "智能" if mode == "auto" else "手动", impl.get("label"),
+            {"auto": "自动", "fast": "快速", "expert": "专家",
+             "manual": "手动"}.get(mode, mode), impl.get("label"),
             reviewer.get("label") if reviewer else "按验证结果省略"),
         "- 动态步骤：规划 %s；实现 %d 步；验证 %s；评审 %d 人；最多修复 %d 轮；换将 %s" % (
             "独立执行" if workflow["planning"] == "llm" else "并入实现",
@@ -1427,12 +1433,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:
@@ -2921,7 +2942,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                  "通过" if chapters_pass else "未通过",
                  "通过" if global_pass else "未通过"),
              "- 编排模式：%s　作者：%s　评审组：%s" % (
-                 "智能" if mode == "auto" else "手动",
+                 {"auto": "自动", "fast": "快速", "expert": "专家",
+                  "manual": "手动"}.get(mode, mode),
                  impl.get("label"), "、".join(a.get("label") for a in critics)),
              "", "## 各章得分（章阈值 %.1f）" % threshold_ch, "",
              "| 章 | 标题 | " + " | ".join(dims) + " | 均分 | 达标 | 轮次 | 字数 |",
@@ -3077,6 +3099,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:
@@ -3100,6 +3127,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", ""))
@@ -3107,7 +3138,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)
 
@@ -3125,9 +3157,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 路径恒空）
@@ -3276,6 +3316,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) 报告
@@ -3285,8 +3326,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("## 路由依据")
@@ -3637,6 +3682,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

@@ -327,8 +327,9 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
             # 否则 stop_reason=max_tokens、正文为空（实测 2048 全被思考吞掉）
             # 流式回调把增量实时写进步骤日志，直连生成不再是一行标题的黑箱
             cb = _log_streamer(log_path)
-            res = modelhub.chat(prov["id"], model, prompt,
-                                max_tokens=16000, timeout=300, on_delta=cb)
+            res = modelhub.chat(prov["id"], model, prompt,
+                                max_tokens=16000, timeout=300, on_delta=cb,
+                                reasoning_effort=_reasoning_effort(task))
             cb.flush()
             _log_usage("outline", "outline", task, res, model=model,
                        provider=prov.get("name", prov.get("id", "")),
@@ -431,12 +432,33 @@ def _plan_workflow(data):
     return out or None
 
 
-def _orchestrator():
-    """编排者可用时返回 (provider, model)，否则 None。"""
-    try:
-        return modelhub.resolve_orchestrator()
-    except Exception:
-        return None
+def _orchestrator():
+    """编排者可用时返回 (provider, model)，否则 None。"""
+    try:
+        return modelhub.resolve_orchestrator()
+    except Exception:
+        return None
+
+
+def _reasoning_effort(task):
+    """把任务级思考程度映射为直连编排者支持的 reasoning 参数。"""
+    task = task if isinstance(task, dict) else {}
+    selected = str(task.get("thinking") or "standard").strip().lower()
+    if selected in ("low", "standard", "high"):
+        return {"low": "low", "standard": "medium", "high": "high"}[selected]
+    mode = str(task.get("mode") or "auto").lower()
+    difficulty = str(task.get("difficulty") or "auto").lower()
+    ttype = str(task.get("type") or "").lower()
+    try:
+        threshold = float(task.get("threshold") or 7.0)
+    except (TypeError, ValueError):
+        threshold = 7.0
+    if mode == "fast" or difficulty == "easy" or threshold <= 6.0:
+        return "low"
+    if (mode == "expert" or difficulty == "hard" or threshold >= 8.5
+            or ttype in ("research", "tech_proposal", "serial_novel")):
+        return "high"
+    return "medium"
 
 
 def make_code_plan(task, planner_agent, workdir, ev=None, resume=None, log_path=None):
@@ -479,7 +501,8 @@ def _orch_code_plan(task, prov, model, log_path=None):
                          .replace("__GOAL__", task["goal"])
                          .replace("__CONTEXT__", task.get("context") or "（无）")
                          .replace("__VERIFY__", task.get("verify_command") or "（未配置）")),
-                        max_tokens=8000, timeout=300, on_delta=cb)
+                        max_tokens=8000, timeout=300, on_delta=cb,
+                        reasoning_effort=_reasoning_effort(task))
     cb.flush()
     _log_usage("plan", "plan", task, res, model=model,
                provider=prov.get("name", prov.get("id", "")))
@@ -507,7 +530,8 @@ def make_review_outline(task):
                         (REVIEW_OUTLINE_PROMPT
                          .replace("__GOAL__", task["goal"])
                          .replace("__CONTEXT__", task.get("context") or "（无）")),
-                        max_tokens=8000, timeout=300)
+                        max_tokens=8000, timeout=300,
+                        reasoning_effort=_reasoning_effort(task))
     _log_usage("outline", "outline", task, res, model=model,
                provider=prov.get("name", prov.get("id", "")))
     if not res["ok"]:

package/app/core/repeat_guard.py

@@ -6,7 +6,7 @@
   监听 tools/post-execute，按 (tool, canonical_args) 跟踪，3/5/8 阈值注入 user-message 提醒。
 
 Tutti 的 "tool" 对应到 "step role"，"canonical_args" 对应到 prompt 模板指纹。
-阈值更宽松（5/10/15），因 Tutti 步骤级别比 dsh 工具调用粗。
+步骤级调用代价远高于普通工具调用，因此第 3 次提醒、第 5 次强制停止。
 """
 from __future__ import annotations
 
@@ -18,7 +18,7 @@ import time
 log = logging.getLogger(__name__)
 
 # 渐进阈值：第 N 次命中时给提醒；最后一次及以上时强制停止。
-DEFAULT_THRESHOLDS = (5, 10, 15)
+DEFAULT_THRESHOLDS = (3, 5)
 
 REMINDER_TEMPLATE = (
     "⚠️ 提醒：上一步使用了几乎相同的输入（已连续 {count} 次调用 {role}）。"
@@ -121,4 +121,4 @@ class RepeatGuard:
 
 
 # 模块级默认实例（pipeline 接线用；run_id 入键天然隔离多任务，测试无需替换）
-guard = RepeatGuard()
+guard = RepeatGuard()

package/app/core/runner.py

@@ -58,13 +58,52 @@ def find_git_bash():
     return None
 
 
-def resolve_command(command):
+def resolve_command(command):
     """命令名 → 可直接 spawn 的 argv 前缀（.cmd/.bat 垫片必须经 cmd /c）。"""
     path = shutil.which(command) or command
     low = path.lower()
     if low.endswith(".cmd") or low.endswith(".bat"):
         return ["cmd", "/c", path]
-    return [path]
+    return [path]
+
+
+def _git_repo_issue(workdir):
+    """返回工作目录 Git 仓库的可读性问题；无 Git 仓库时返回空串。
+
+    Aider 会在启动后自行读取索引。索引包缺失时它通常先写入 .gitignore，
+    再在深层调用中才报错，用户会误以为任务卡住；提前做一次廉价预检能把
+    错误变成可操作的任务失败信息。
+    """
+    if not workdir or not os.path.isdir(workdir):
+        return ""
+    git_dir = os.path.join(workdir, ".git")
+    if not os.path.exists(git_dir):
+        return ""
+    try:
+        probe = subprocess.run(
+            ["git", "-C", workdir, "rev-parse", "--git-dir"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, timeout=5, check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return "Git 命令不可用，无法读取仓库；请安装 Git 或改用非 Aider 实现器"
+    if probe.returncode != 0:
+        detail = (probe.stderr or probe.stdout or "仓库元数据不可读").strip()
+        return "Git 仓库不可读：%s；请先执行 git fsck/恢复 .git 对象后重试" % detail[-300:]
+    try:
+        probe = subprocess.run(
+            ["git", "-C", workdir, "status", "--porcelain", "--untracked-files=no"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, timeout=8, check=False,
+        )
+    except subprocess.TimeoutExpired:
+        return "Git 仓库检查超时；请先执行 git status/git fsck 修复后重试"
+    except OSError:
+        return "Git 命令不可用，无法读取仓库；请安装 Git 或改用非 Aider 实现器"
+    if probe.returncode != 0:
+        detail = (probe.stderr or probe.stdout or "仓库对象或索引不可读").strip()
+        return "Git 仓库损坏或对象缺失：%s；请先执行 git fsck 并恢复仓库后重试" % detail[-300:]
+    return ""
 
 
 def _npm_shim_bypass(argv):
@@ -844,8 +883,9 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
     stdin_text = None
     tmp_files = []
     imgs = [str(p) for p in (images or []) if p]
-    if kind == "codex":
-        cp = agent.get("codex_provider")
+    if kind == "codex":
+        cp = agent.get("codex_provider")
+        reasoning = str(agent.get("reasoning_effort") or "").strip().lower()
         if sid:
             # resume 子命令不支持 -s 也不支持 --full-auto（0.154 实测：
             # "unexpected argument '--full-auto'"）——读/写模式都用 -c sandbox_mode
@@ -855,16 +895,18 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
             if model:
                 argv += ["-m", model]
             argv += ["-c", 'sandbox_mode="%s"' % _codex_sandbox(readonly)]
-            if cp:
-                argv += _codex_provider_args(cp)
+            if cp:
+                argv += _codex_provider_args(cp)
         else:
             argv = resolve_command(agent["command"]) + [
                 "exec", "--skip-git-repo-check", "--json",
                 "-s", _codex_sandbox(readonly)]
             if model:
                 argv += ["-m", model]
-            if cp:
-                argv += _codex_provider_args(cp)
+            if cp:
+                argv += _codex_provider_args(cp)
+        if reasoning in ("low", "medium", "high", "xhigh"):
+            argv += ["-c", 'model_reasoning_effort="%s"' % reasoning]
         # codex exec 与 exec resume 都支持 -i：图片直接附到 prompt（exec resume 的
         # -i 附在恢复后发送的首条消息上，即本次 stdin prompt）
         for p in imgs:
@@ -912,10 +954,11 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
         if model:
             argv += ["-m", model]
         stdin_text = prompt
-    elif kind == "aider":
-        argv = resolve_command(agent["command"]) + [
-            "--yes-always", "--no-auto-commits", "--no-check-update",
-            # 网关自定义模型名（glm-5.1 等）litellm 全都不认识，警告页+建议列表
+    elif kind == "aider":
+        argv = resolve_command(agent["command"]) + [
+            "--yes-always", "--no-auto-commits", "--no-check-update",
+            "--no-gitignore", "--no-pretty", "--no-stream",
+            # 网关自定义模型名（glm-5.1 等）litellm 全都不认识，警告页+建议列表
             # 纯属刷屏（2026-09-20 实测占满步骤日志头部）
             "--no-show-model-warnings", "--message", prompt]
         if model:
@@ -987,7 +1030,7 @@ def _stall_timeout(env_name, default):
         return default
 
 
-def run_agent(agent, prompt, workdir=None, readonly=True,
+def run_agent(agent, prompt, workdir=None, readonly=True,
               timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None, resume=None,
               images=None, require_tools=False):
     """执行一次智能体调用，返回统一结构
@@ -1010,7 +1053,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     orch_timeout_ms = (agent.get("orch") or {}).get("timeout_ms")
     if orch_timeout_ms:
         timeout = float(orch_timeout_ms) / 1000.0
-    kind = agent.get("kind", "generic")
+    kind = agent.get("kind", "generic")
+    if kind == "aider":
+        repo_issue = _git_repo_issue(workdir)
+        if repo_issue:
+            return {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
+                    "tokens": 0, "usage": None, "error": repo_issue,
+                    "error_code": ErrorCode.VENDOR_ERROR, "raw": None,
+                    "kind": kind, "model": agent.get("model")}
     if kind == "codex":
         stall_t = _stall_timeout("TUTTI_CODEX_STALL_TIMEOUT", 600)
     elif kind == "claude":

package/app/core/selfupdate.py

@@ -176,10 +176,17 @@ def apply_upgrade(port=None):
         _PENDING_PORT = int(port) if port else None
     except (TypeError, ValueError):
         _PENDING_PORT = None
-    if install_mode() != "npm":
-        return {"error": "当前安装方式不支持自动升级（见版本页说明）"}
-    from . import store, jobs
-    try:
+    if install_mode() != "npm":
+        return {"error": "当前安装方式不支持自动升级（见版本页说明）"}
+    from . import store, jobs
+    capacity = jobs.capacity_status()
+    if not capacity["accepting"]:
+        if capacity["restarting"]:
+            return {"error": "服务正在完成升级重启，请稍后再试"}
+        return {"error": "当前有 %d 个任务运行，已达并发保护上限（%d）；"
+                         "升级未启动且不会排队，请在任务结束后重试"
+                         % (capacity["active"], capacity["limit"])}
+    try:
         run = store.create_run(
             "mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
             entry_id="__self__", op="selfupgrade")
@@ -190,10 +197,12 @@ def apply_upgrade(port=None):
         jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
     except Exception as exc:
         # run 已持久化；启动失败时显式收口，版本页不能停在误导性的待启动状态。
-        log.exception("selfupdate: 升级任务启动失败 run=%s", run["id"])
         if isinstance(exc, jobs.JobsBusyError):
             message = "升级未启动：%s" % str(exc)
+            log.warning("selfupdate: 升级任务因并发满载未启动 run=%s: %s",
+                        run["id"], exc)
         else:
+            log.exception("selfupdate: 升级任务启动失败 run=%s", run["id"])
             # 仅并发保护类错误可直接展示；其他内部异常继续隐藏实现细节。
             message = "升级任务启动失败，本次未排队，请稍后重试"
         try: