codebee 0.1.29 → 0.1.30

package/CHANGELOG.md

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

package/README.md

@@ -23,11 +23,25 @@ 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.
+- 微信直连配置更省事：「扫描」自动找本机 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,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/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 {})

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)
@@ -1427,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:
@@ -3077,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:
@@ -3100,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", ""))
@@ -3107,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)
 
@@ -3125,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 路径恒空）
@@ -3276,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) 报告
@@ -3285,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("## 路由依据")
@@ -3637,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/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:

package/app/core/store.py

@@ -104,12 +104,12 @@ def create_task(payload):
     if not wd.is_dir():
         raise ValueError("工作目录不存在: %s" % workdir)
     mode = payload.get("mode")
-    if mode not in ("auto", "manual"):
-        mode = "manual" if payload.get("implementer") else "auto"
+    if mode not in ("auto", "fast", "expert", "manual"):
+        mode = "manual" if payload.get("implementer") else "auto"
     difficulty = payload.get("difficulty")
     if difficulty not in ("auto", "easy", "hard", "default"):
         difficulty = "auto"
-    task = {
+    task = {
         "id": _new_id("t"), "type": flow["id"], "engine": flow["engine"],
         "title": title, "goal": goal,
         "context": _text(payload.get("context"), "context"),
@@ -119,8 +119,16 @@ def create_task(payload):
         "implementer": payload.get("implementer") or "",
         "attachments": [],
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "status": "created",
-    }
+        "status": "created",
+    }
+    thinking = str(payload.get("thinking") or "standard").strip().lower()
+    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    if flow["engine"] == "direct":
+        task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
+                                            "direct_provider_id")[:80]
+        task["direct_model"] = _text(payload.get("direct_model"), "direct_model")[:160]
+        if task["direct_model"] and not task["direct_provider_id"]:
+            raise ValueError("指定对话模型时必须同时指定厂商")
     # 代码版本：仅当引用合法才固化（流水线执行前据此检出任务分支）
     from . import gitmod
     git_rev = _text(payload.get("git_rev"), "git_rev")
@@ -133,8 +141,8 @@ def create_task(payload):
         task["git_rev"] = git_rev
     if flow["engine"] == "code":
         task["verify_command"] = _text(payload.get("verify_command"), "verify_command")
-    elif flow["engine"] == "direct":
-        pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
+    elif flow["engine"] == "direct":
+        pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
     else:
         ms = _text(payload.get("manuscript") or flow.get("manuscript") or "manuscript.md",
                    "manuscript")
@@ -478,7 +486,7 @@ def load_all():
 
 # ---------------------------------------------------------------- 运行（含管理操作）
 
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
@@ -488,8 +496,21 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
         "started_at": None, "ended_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
-        "verdict": None, "summary": "",
-    }
+        "verdict": None, "summary": "",
+    }
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        try:
+            from . import usage
+            eta = usage.estimate(
+                task_type=task.get("type") or "", mode=task.get("mode") or "auto",
+                thinking=task.get("thinking") or "standard",
+                rounds=task.get("rounds"))
+            run["estimated_duration_s"] = eta.get("estimated_duration_s")
+            run["estimated_p90_s"] = eta.get("p90_duration_s")
+            run["estimate_source"] = eta.get("duration_source")
+        except Exception:
+            pass
     rdir = paths.RUNS_DIR / run["id"]
     (rdir / "steps").mkdir(parents=True, exist_ok=True)
     with LOCK:
@@ -814,12 +835,36 @@ def run_workdir(run_id):
 _SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".idea", ".vscode"}
 
 # 构建产物/依赖缓存目录：里面的文件是工具链再生成的，不是任务成品
-_BUILD_DIRS = {
+_BUILD_DIRS = {
     "target", "build", "dist", "out", "bin", "obj",           # 通用构建输出
     "surefire", "failsafe-reports", "test-output", "reports",  # 测试/报告输出
     ".next", ".nuxt", ".output", ".gradle", ".gradle-home",    # 前端/Gradle
     "__MACOSX",
-}
+}
+
+# CLI 自身的历史/评审中间件不属于用户成果。它们通常落在工作目录根部，
+# 只按隐藏目录过滤会漏掉 Aider 的 .aider.* 与流程生成的 *_review.json。
+_PROCESS_ARTIFACT_NAMES = {
+    ".aider.chat.history.md", ".aider.input.history", ".aider.input.history.md",
+    ".aider.tags.cache.v4", ".aider.tags.cache.v3", ".aider.conf.yml",
+}
+_PROCESS_ARTIFACT_SUFFIXES = ("_review.json", ".review.json")
+_PROCESS_ARTIFACT_PREFIXES = ("tutti_prompt_", "_tutti_prompt_")
+
+
+def _is_process_artifact(rel_name):
+    """判断工作目录文件是否为 CLI/评审过程产物，而非可交付成果。"""
+    name = str(rel_name or "").replace("\\", "/")
+    base = name.rsplit("/", 1)[-1].lower()
+    if base in _PROCESS_ARTIFACT_NAMES:
+        return True
+    if base.startswith(".") and base.startswith(".aider"):
+        return True
+    if base.endswith(_PROCESS_ARTIFACT_SUFFIXES):
+        return True
+    if base.startswith(_PROCESS_ARTIFACT_PREFIXES):
+        return True
+    return False
 
 
 def task_first_start(task_id, fallback=""):
@@ -880,7 +925,10 @@ def run_artifacts(run_id, limit=200):
                 continue
             if st.st_mtime < t0:
                 continue
-            files.append({"name": str(p.relative_to(root)).replace("\\", "/"),
+            rel_name = str(p.relative_to(root)).replace("\\", "/")
+            if _is_process_artifact(rel_name):
+                continue
+            files.append({"name": rel_name,
                           "size": st.st_size, "mtime": int(st.st_mtime)})
             if len(files) >= 800:  # 防超大目录拖垮接口；截断后再排序取最新
                 break

package/app/core/task_compile.py

@@ -69,6 +69,9 @@ def compile_task(task):
         "dimension": dimension,
         "difficulty": difficulty,
         "difficulty_reason": difficulty_reason,
+        "thinking": (str(raw.get("thinking") or "standard").lower()
+                     if str(raw.get("thinking") or "standard").lower()
+                     in ("auto", "low", "standard", "high") else "auto"),
         "capabilities": _capabilities(raw, dimension, engine),
         "deliverable": deliverable,
         "quality_dimensions": rubric,
@@ -97,26 +100,37 @@ def code_workflow(task, difficulty, plan=None, mode="auto", planned=True):
     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"
+    risk_text = " ".join(str(task.get(k) or "") for k in ("title", "goal", "context")).lower()
+    high_risk = bool(any(k in risk_text for k in (
+        "安全", "权限", "鉴权", "认证", "加密", "密钥", "注入", "迁移", "数据库",
+        "并发", "竞态", "支付", "public api", "公共 api", "breaking change",
+        "security", "permission", "auth", "migration", "concurrency")))
+    fast_mode = mode == "fast"
+    expert_mode = mode == "expert"
+    easy_auto = (mode == "auto" and difficulty == "easy") or fast_mode
 
     review_required = True
     max_repairs = 2
     allow_switch = True
     reason = "复杂或手动任务使用完整质量门禁"
     if easy_auto:
-        review_required = not has_verify
+        review_required = high_risk or 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
+            review_required = high_risk or 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"])))
+                max_repairs = max(1 if not has_verify else 0,
+                                  min(1, int(rec["max_repair_rounds"])))
         except (TypeError, ValueError):
             pass
-    elif mode == "auto" and difficulty == "hard":
+    elif expert_mode or (mode == "auto" and difficulty == "hard"):
+        review_required = True
+        max_repairs = 2
+        allow_switch = True
         try:
             if "max_repair_rounds" in rec:
                 max_repairs = max(1, min(2, int(rec["max_repair_rounds"])))
@@ -148,6 +162,13 @@ def content_workflow(task, difficulty, plan=None, mode="auto"):
     light_types = {"email", "weekly_report", "translation"}
     deep_types = {"novel", "research", "tech_proposal"}
 
+    if mode == "fast":
+        return {"outline": False, "reviewers": 1, "review_rounds": 1,
+                "reason": "快速模式省略独立大纲，仅保留一次快速评审"}
+    if mode == "expert":
+        return {"outline": True, "reviewers": 2,
+                "review_rounds": min(requested_rounds, 3),
+                "reason": "专家模式启用完整大纲、多评审与修订门禁"}
     if mode != "auto":
         return {"outline": True, "reviewers": 0,
                 "review_rounds": requested_rounds,