codebee 0.1.28 → 0.1.30

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/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")
@@ -188,16 +195,23 @@ 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 已持久化；启动失败时显式收口，版本页不能停在误导性的待启动状态。
+        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:
+            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/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,
@@ -85,3 +88,111 @@ 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())
+    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 = 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 = high_risk or rec["review_required"] or not has_verify
+        try:
+            if "max_repair_rounds" in rec:
+                max_repairs = max(1 if not has_verify else 0,
+                                  min(1, int(rec["max_repair_rounds"])))
+        except (TypeError, ValueError):
+            pass
+    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"])))
+        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 == "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,
+                "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/core/usage.py

@@ -655,11 +655,19 @@ def summary(days=30, recent_limit=30):
     }
 
 
-def estimate(task_type="", days=90):
-    """同类任务开跑前成本预估（借鉴 omnigent 的 pre-run estimate；数据源就是本台账）。
-
-    同一 run 的多条步骤记录加总为一个样本，优先用成功 run，给中位数/平均/P90。
-    task_type 为空=全类型。无样本时 samples=0，前端不展示。"""
+_DURATION_BASELINES = {
+    "direct": 90, "rank_scan": 240, "email": 180, "weekly_report": 240,
+    "translation": 240, "speech": 360, "video_script": 360, "article": 480,
+    "doc": 480, "resume": 420, "code": 600, "tech_proposal": 720,
+    "research": 900, "novel": 720, "serial_novel": 2400,
+}
+
+
+def estimate(task_type="", days=90, mode="auto", thinking="standard", rounds=None):
+    """同类任务开跑前成本与耗时预估（数据源为本地用量台账）。
+
+    同一 run 的多条步骤记录加总为一个样本，优先用成功 run，给中位数/平均/P90。
+    无历史样本时使用流程级保守基线；模式与思考程度只做透明倍率修正。"""
     span = max(1, min(3650, int(days or 90)))
     with LOCK:
         records = _iter_records(span)
@@ -671,24 +679,53 @@ def estimate(task_type="", days=90):
         rid = str(r.get("run_id") or "")
         if not rid:
             continue
-        g = runs.setdefault(rid, {"tokens": 0, "cost": 0.0, "ok": False})
-        g["tokens"] += _num(r, "total")
-        g["cost"] += _parse_float(r.get("cost_usd"))
+        g = runs.setdefault(rid, {"tokens": 0, "cost": 0.0,
+                                  "duration": 0.0, "ok": False})
+        g["tokens"] += _num(r, "total")
+        g["cost"] += _parse_float(r.get("cost_usd"))
+        g["duration"] += max(0.0, _parse_float(r.get("duration_s")))
         if r.get("ok"):
             g["ok"] = True
     ok_runs = [g for g in runs.values() if g["ok"]]
     basis = ok_runs or list(runs.values())
-    if not basis:
-        return {"task_type": task_type or "", "days": span, "samples": 0}
+    mode_factor = {"fast": 0.60, "auto": 1.0, "expert": 1.65,
+                   "manual": 1.0}.get(str(mode or "auto"), 1.0)
+    thinking_factor = {"low": 0.78, "standard": 1.0, "high": 1.45,
+                       "auto": 1.0}.get(str(thinking or "standard"), 1.0)
+    factor = mode_factor * thinking_factor
+    try:
+        if rounds is not None and int(rounds) > 2:
+            factor *= 1.0 + min(3, int(rounds) - 2) * 0.18
+    except (TypeError, ValueError):
+        pass
+    if not basis:
+        baseline = _DURATION_BASELINES.get(task_type, 480)
+        median_s = max(30, int(baseline * factor))
+        return {"task_type": task_type or "", "days": span, "samples": 0,
+                "estimated_duration_s": median_s,
+                "p90_duration_s": max(median_s + 30, int(median_s * 1.7)),
+                "duration_source": "baseline"}
     toks = sorted(g["tokens"] for g in basis)
-    costs = sorted(g["cost"] for g in basis)
+    costs = sorted(g["cost"] for g in basis)
+    durations = sorted(g["duration"] for g in basis if g["duration"] > 0)
     n = len(toks)
     mid = n // 2
     med = toks[mid] if n % 2 else (toks[mid - 1] + toks[mid]) / 2.0
     med_c = costs[mid] if n % 2 else (costs[mid - 1] + costs[mid]) / 2.0
     import datetime
-    import math
-    return {
+    import math
+    if durations:
+        dn = len(durations)
+        dmid = dn // 2
+        dmed = (durations[dmid] if dn % 2
+                else (durations[dmid - 1] + durations[dmid]) / 2.0)
+        dp90 = durations[max(0, min(dn - 1, math.ceil(0.9 * dn) - 1))]
+        duration_source = "history"
+    else:
+        dmed = _DURATION_BASELINES.get(task_type, 480)
+        dp90 = dmed * 1.7
+        duration_source = "baseline"
+    return {
         "task_type": task_type or "",
         "days": span,
         "samples": n,
@@ -697,6 +734,10 @@ def estimate(task_type="", days=90):
         "median_tokens": int(med),
         "p90_tokens": toks[max(0, min(n - 1, math.ceil(0.9 * n) - 1))],
         "avg_cost_usd": round(sum(costs) / n, 4),
-        "median_cost_usd": round(med_c, 4),
+        "median_cost_usd": round(med_c, 4),
+        "estimated_duration_s": max(30, int(dmed * factor)),
+        "p90_duration_s": max(60, int(dp90 * factor)),
+        "duration_samples": len(durations),
+        "duration_source": duration_source,
         "since": (datetime.date.today() - datetime.timedelta(days=span - 1)).isoformat(),
     }