codebee 0.1.49 → 0.1.51

package/app/core/pipeline.py

@@ -419,7 +419,25 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
     def _log(line):
         lines.append(str(line))
 
-    res = builtin_agent.run(bi, prompt, workdir, cancel_event=ev, log=_log, images=images)
+    # 思考过程可视化（2026-09-22 用户诉求）：模型的思维链/正文/工具活动边收边
+    # 落进步骤记录（store.stream_step 内部节流），对话时间线 2s 轮询即能读到
+    # 「它正在想什么」——此前整轮只有三点打字动画。
+    live = {"thinking": "", "text": ""}
+
+    def _on_reason(chunk):
+        live["thinking"] += chunk or ""
+        store.stream_step(run_id, step["n"], thinking=live["thinking"])
+
+    def _on_stream(acc):
+        live["text"] = acc or ""
+        store.stream_step(run_id, step["n"], text=live["text"])
+
+    def _on_activity(line):
+        store.stream_step(run_id, step["n"], activity=str(line or "")[:200])
+
+    res = builtin_agent.run(bi, prompt, workdir, cancel_event=ev, log=_log, images=images,
+                            on_reason=_on_reason, on_stream=_on_stream,
+                            on_activity=_on_activity)
     if followups and res.get("ok"):
         clean, fups = _parse_followups(res.get("text") or "")
         if fups:
@@ -427,6 +445,10 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
             res["followups"] = fups
     if log_abs:
         try:
+            # 思考过程同时进步骤日志（日志抽屉与对话气泡同源，便于事后复盘）
+            think = (res.get("reasoning") or "").strip()
+            if think:
+                lines.append("[思考过程]\n" + think)
             log_abs.write_text("\n".join(lines) + "\n", encoding="utf-8")
         except Exception:
             pass
@@ -550,7 +572,9 @@ def _finish_step_result(run_id, step, res, role, agent, start):
                       # 智能体的最终回答（runner 已从 JSONL 事件流里抽出 agent_message）。
                       # 对话视图直读这个；日志文件是全量事件流，塞进气泡就成了「看日志」。
                       output=(res.get("text") or ""),
-                      followups=res.get("followups"))
+                      followups=res.get("followups"),
+                      # 思考过程（内置智能体流式抓取）：落进步骤记录，对话气泡折叠展示
+                      thinking=res.get("reasoning") or None)
     # 错误台账：失败/超时各记一条结构化记录（遥测与诊断包的数据源）。
     # 用户主动取消不入账——那不是产品问题；detail 只存脱敏后的失败摘录。
     if status in ("failed", "timeout"):
@@ -1090,29 +1114,53 @@ def _run_code(run, task, agents, ev, stats, mode):
                 and _code_bestof(run, task, impl_agent, difficulty, ev)):
             return True
         # 实现步失败不立刻判死：2026-09-16 实测配额烧干时 5 连跑全在同一条 CLI 上
-        # 失败收场，而健康的 opencode 一直在旁观望——跨 CLI 换将重试一次
-        # （mode=manual 尊重用户指定，不换）。
+        # 失败收场，而健康的 opencode 一直在旁观望——跨 CLI 换将重试
+        # （mode=manual 尊重用户指定，不换）。2026-09-22 续修：配额/限流类死亡
+        # 是确定性秒死，允许继续走查候选名单（同上游让位异上游）；其余死因
+        # （超时等）仍只换一次，防着在坏候选上再烧一整个超时。
         if mode == "auto" and impl_agent.get("mode") == "real":
-            ex = {impl_agent["id"], "mock-a", "mock-b"}
-            other, other_reason = router.pick(agents, "implement", "code", stats,
-                                              exclude=ex)
-            if other is not None and other.get("mode") == "real":
+            tried = {impl_agent["id"], "mock-a", "mock-b"}
+            notes = []
+            dead_ups = []  # 配额死亡候选的上游集合：换将优先异上游
+            prev_id = impl_agent["id"]
+            other = None
+            while True:
+                other, other_reason = router.pick_switch_candidate(
+                    agents, "implement", "code", stats,
+                    exclude=tried, dead_upstreams=dead_ups)
+                if other is None or other.get("mode") != "real":
+                    other = None
+                    break
                 note = "实现步失败自动换将 %s → %s：%s。失败原因：%s" % (
-                    impl_agent["id"], other["id"], other_reason,
+                    prev_id, other["id"], other_reason,
                     (res.get("error") or "")[:200])
                 ok2, res = _run_one(other)
                 if ok2:
-                    store.update_run(run_id, error="", route_note=note)
+                    route_note = "；".join(notes + [note])
+                    store.update_run(run_id, error="", route_note=route_note)
                     _record_actual_route(
                         run_id, task, agents, stats, other,
                         implementers=[other], reviewer=reviewer,
-                        implement_reason=note,
+                        implement_reason=route_note,
                         review_reason=route.get("reviewer", ""),
                         direct=not workflow["review_required"])
                     return True
-                res_err = "%s；换将后仍失败：%s" % (note, (res.get("error") or "")[:200])
+                notes.append(note)
+                tried.add(other["id"])
+                prev_id = other["id"]
+                if runner._quota_error(res.get("error") or ""):
+                    ups = router.agent_upstreams(other["id"])
+                    if ups:
+                        dead_ups.append(ups)
+                else:
+                    break  # 非配额死因：只换一次就收手
+            tail_err = (res.get("error") or "")[:200]
+            if notes:
+                res_err = "；".join(notes) + "；换将后仍失败：%s" % tail_err
+            elif other is None:
+                res_err = "实现步骤失败（无其他真实 CLI 可换将）: %s" % tail_err
             else:
-                res_err = "实现步骤失败（无其他真实 CLI 可换将）: %s" % res.get("error")
+                res_err = "实现步骤失败: %s" % tail_err
         else:
             res_err = "实现步骤失败: %s" % res.get("error")
         store.update_run(run_id, expected_status="running", status="failed",
@@ -2085,20 +2133,6 @@ def _weakest_chapters(chapter_scores, global_means, threshold, limit=2):
     return cand[:limit]
 
 
-def _inject_detection(tpl, text, task):
-    """把确定性检测行（AI 味/叙事架构/节奏）插进评审提示词。
-
-    命中才插，位置固定为「## 待评审稿件」之前——与技能包/圣经/知识库注入
-    同一位置，保持前缀稳定（§07 T1.2' 前缀缓存）。单稿件评审与连载逐章
-    评审共用本函数：此前连载逐章完全没有这条参考线（旗舰场景漏挂）。
-    """
-    det = aiflavor.report_line(text, task.get("type"))
-    if not det:
-        return tpl
-    block = "## 确定性检测结果（供评审参考）\n%s\n\n" % det
-    return tpl.replace("## 待评审稿件", block + "## 待评审稿件", 1)
-
-
 def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route, resume_ctx, difficulty):
     """连载流水线：大纲 → 逐章起草/评审/修订 → 全局一致性评审 → 合并成书。"""
     import json as _json
@@ -2175,9 +2209,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         if kb:
             tpl = tpl.replace("## 待评审稿件", "%s\n\n## 待评审稿件" % kb, 1)
         # 确定性检测（AI 味/叙事架构/节奏）此前只挂在单稿件评审上，连载逐章
-        # 评审从未拿到——连载是我们的旗舰场景，逐章节奏与钩子恰恰最需要这条
-        # 参考线。与单稿件一致：命中才追加，只作参考不直接扣分。
-        tpl = _inject_detection(tpl, text, task)
+        # 从未拿到——逐章节奏与钩子恰恰最需要这条参考线（命中才追加，不扣分）
+        tpl = aiflavor.inject_into_prompt(tpl, text, task.get("type"))
         return tpl.replace("__DIMKEYS__", dimkey).replace(
             "__MANUSCRIPT__", text or "（稿件为空！）")
 
@@ -2338,50 +2371,92 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
 
         def run_critique(text, rnd, note_extra="", critic_sids=None, event_check=""):
             """一轮多维评审：返回 (cj_by_agent, scored)。变体赛马与主循环共用。
-            event_check：本章大纲核对块（逐项目标审稿），随评审下发并回收标记块。"""
+            event_check：本章大纲核对块（逐项目标审稿），随评审下发并回收标记块。
+
+            多评审并发跑（2026-09-22）：评审占运行总时长的六成以上，而各评审之间
+            互不依赖（同一份稿件、各自视角），串行等待纯属浪费——每位评审的墙上
+            时间直接叠加。与「同章多稿赛马」「best-of 候选」同一套线程范式（那两处
+            早已多线程调用 _run_step）。共享结构的写入全部收敛到 join 之后按
+            critics 原顺序合并，保证与串行版逐字节同结果（ev_check 取第一份非空、
+            issues/ledger 的先后顺序都不变），只在耗时上取并行收益。"""
             cj_map, sids = {}, dict(critic_sids or {})
             scored = 0   # 真正给出分数的评审数；失败/不可解析不得当成 0 分计入
-            for agent in critics:
-                role = "critique-c%d" % i
+            role = "critique-c%d" % i
+            results = {}
+            # 绑定解析提前到主线程：bind_agent 会把链首同步进 CLI 自家配置（写盘），
+            # 多线程同时调它有写盘竞争。解析结果随线程参数传入，线程内只做调用。
+            bound = [modelhub.bind_agent(a, difficulty) for a in critics]
+
+            def _critique_one(idx, agent):
+                """单评审执行体（线程内只做调用与解析，不改共享结构）。
+
+                异常不吞：记进 results 由主线程按原顺序重抛——串行版的
+                Cancelled/管道异常语义（上抛打断本 run）必须原样保留。"""
+                try:
+                    _critique_one_inner(idx, agent)
+                except BaseException as exc:      # noqa: BLE001（含 Cancelled）
+                    results[idx] = {"error": exc}
+
+            def _critique_one_inner(idx, agent):
                 if agent.get("mode") == "mock":
                     step, log_abs = store.add_step(run_id, role, agent["id"], agent.get("label"))
                     time.sleep(0.15)
                     cj = mocks.critique(agent["id"], rnd, dims, threshold_ch)
-                    scored += 1
                     store.finish_step(run_id, step["n"], "done",
                                       summary="均分 %.1f：%s" % (
                                           sum(cj["scores"].values()) / max(1, len(dims)),
                                           cj["summary"]),
                                       duration_s=0.15)
-                else:
-                    lens = _critic_lens(critics, agent)
-                    res = _run_step(run_id, role, modelhub.bind_agent(agent, difficulty),
-                                    crit_prompt_for(
-                                        text,
-                                        note=("小说第 %d 章" % i) + (
-                                            "｜你的专属评审视角：%s（其他评审会覆盖其余视角，"
-                                            "请深挖你的镜头，但所有维度仍需打分）" % lens)
-                                        if lens else "",
-                                        event_check=event_check) + note_extra,
-                                    workdir, readonly=True, ev=ev,
-                                    resume=sids.get(agent["id"]))
-                    cj = _critique_json(res, dims)
-                    if cj.get("scores"):
-                        scored += 1
-                    # 逐项目标审稿 + 资源账本：解析评审回复里的标记块（借鉴
-                    # AI-Novel-Writer 逐项核对/角色资源账本）。多评审取第一份
-                    # 非空即可，聚合时已在前两处赋值处去重。
-                    evl = _parse_tagged_lines(res.get("text"), "event_check")
-                    if evl and not ev_check_lines[0]:
-                        ev_check_lines[0] = evl
-                    ledger_lines.extend(_parse_tagged_lines(res.get("text"), "ledger"))
+                    results[idx] = {"agent": agent, "cj": cj, "evl": [],
+                                    "ledger": [], "sid": None}
+                    return
+                lens = _critic_lens(critics, agent)
+                res = _run_step(run_id, role, bound[idx],
+                                crit_prompt_for(
+                                    text,
+                                    note=("小说第 %d 章" % i) + (
+                                        "｜你的专属评审视角：%s（其他评审会覆盖其余视角，"
+                                        "请深挖你的镜头，但所有维度仍需打分）" % lens)
+                                    if lens else "",
+                                    event_check=event_check) + note_extra,
+                                workdir, readonly=True, ev=ev,
+                                resume=sids.get(agent["id"]))
+                results[idx] = {
+                    "agent": agent, "cj": _critique_json(res, dims),
+                    # 逐项目标审稿 + 资源账本：标记块先各存各的，join 后按序合并
+                    "evl": _parse_tagged_lines(res.get("text"), "event_check"),
+                    "ledger": _parse_tagged_lines(res.get("text"), "ledger"),
                     # §07 T1.1：记录该评审的会话 id（第 2 轮复用）
-                    csid = _resume_sid(agent, res.get("sid"))
-                    if csid:
-                        sids[agent["id"]] = csid
+                    "sid": _resume_sid(agent, res.get("sid")),
+                }
+
+            threads = []
+            for idx, agent in enumerate(critics):
+                th = threading.Thread(target=_critique_one, args=(idx, agent),
+                                      name="crit-%s-c%d-%d" % (run_id, i, idx), daemon=True)
+                threads.append(th)
+                th.start()
+            for th in threads:
+                th.join(3000)
+            _check_cancel(ev)
+
+            # join 后按原顺序合并（确定性：与串行版结果一致）
+            for idx in range(len(critics)):
+                r = results.get(idx)
+                if r is None:
+                    continue     # 该评审线程超时未回，按「没出分」处理
+                if "error" in r:
+                    raise r["error"]     # 还原串行版的异常上抛语义
+                agent, cj = r["agent"], r["cj"]
+                if cj.get("scores"):
+                    scored += 1
+                if r["evl"] and not ev_check_lines[0]:
+                    ev_check_lines[0] = r["evl"]
+                ledger_lines.extend(r["ledger"])
+                if r["sid"]:
+                    sids[agent["id"]] = r["sid"]
                 cj_map[agent["id"]] = cj
                 issues_all.extend({"chapter": i, **it} for it in (cj.get("issues") or [])[:6])
-                _check_cancel(ev)
 
             # 评审者级 fallback：名单内评审全挂（网关抖动/CLI 故障）时，
             # 从其它已启用真实智能体补位至多 2 个（排除 mock 与已试过的），
@@ -2496,6 +2571,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 chapter_reason = route.get("author", "")
                 last_attempt_impl = impl
                 last_attempt_reason = chapter_reason
+                prev_prompt = None      # 上一次实际下发的提示词
+                prev_timed_out = False  # 上一次是否「超时/停滞」收场
                 for draft_attempt in range(3):
                     if draft_attempt:
                         # 30s / 60s 退避；ev.wait 睡等可被取消即刻唤醒
@@ -2511,11 +2588,20 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         # 30KB 对讯飞必挂）
                         sk2, bible2, _note = _shrink_context_block(sk_block, bible, budget=12000)
                         use_prompt = prompt.replace(sk_block, sk2).replace(bible, bible2)
+                    # 超时重试必须有新变量才值得做（2026-09-22）：提示词与上次逐字节
+                    # 相同、上次又是超时/停滞收场时，重试只是把同一个超时再烧一遍
+                    # （2400s × N）。此时直接跳出交替换将——换 CLI/模型才是新机会。
+                    # 注意保留「缩上下文重试」：提示词真的变小了（缩块生效）就照试，
+                    # 那是针对「提示词过大挂起」的有效降级。
+                    if prev_timed_out and use_prompt == prev_prompt:
+                        break
                     res = _run_step(run_id, "draft-c%d" % i, modelhub.bind_agent(impl, difficulty), use_prompt,
                                     step_wd, readonly=False, ev=ev, timeout=2400,
                                     resume=resume_ctx["session"] if resume_ctx else None,
                                     images=_task_images(task, workdir),
                                     note=("起草重试 %d/2（网关限流退避）" % draft_attempt) if draft_attempt else "")
+                    prev_prompt = use_prompt
+                    prev_timed_out = bool((res.get("raw") or {}).get("timed_out"))
                     good, txt = _chapter_state()
                     if good:
                         break
@@ -2836,9 +2922,23 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     global_issues = []
 
     def run_global_round(agent_list):
-        """一轮全局评审：返回 (出分评审数, 按维累计分)。失败/不可解析不得当成低分计入。"""
+        """一轮全局评审：返回 (出分评审数, 按维累计分)。失败/不可解析不得当成低分计入。
+
+        多评审并发（2026-09-22，同章级评审并发）：各自读同一份全书文本、互不依赖，
+        串行只是把等待时间叠起来。共享结构仍在 join 后按原顺序合并，结果与串行一致。"""
         gmeans_acc, scored = {}, 0
-        for agent in agent_list:
+        results = {}
+        # 绑定解析提前到主线程（线程内不做会写盘的 bind_agent）
+        bound = [modelhub.bind_agent(a, difficulty) for a in agent_list]
+
+        def _global_one(idx, agent):
+            """异常不吞：记进 results 由主线程按原顺序重抛（保留串行语义）。"""
+            try:
+                _global_one_inner(idx, agent)
+            except BaseException as exc:      # noqa: BLE001（含 Cancelled）
+                results[idx] = {"error": exc}
+
+        def _global_one_inner(idx, agent):
             if agent.get("mode") == "mock":
                 step, _ = store.add_step(run_id, "global-critique", agent["id"],
                                          agent.get("label"))
@@ -2847,25 +2947,41 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                       "issues": [], "summary": "（mock）全书结构完整，达到可签约水平"}
                 store.finish_step(run_id, step["n"], "done", summary="均分 8.0：（mock）全书达标",
                                   duration_s=0.15)
+                results[idx] = gj
+                return
+            gtpl = SERIAL_GLOBAL_PROMPT
+            if bible:
+                gtpl = gtpl.replace("## 全书目标", bible + "\n\n## 全书目标", 1)
+            res = _run_step(run_id, "global-critique", bound[idx],
+                            (gtpl.replace("__DIMKEYS__", dimkey)
+                             .replace("__GOAL__", task["goal"])
+                             .replace("__MANUSCRIPT__", full_text[:60000])),
+                            workdir, readonly=True, ev=ev, timeout=2400)
+            results[idx] = _critique_json(res, dims)
+
+        threads = []
+        for idx, agent in enumerate(agent_list):
+            th = threading.Thread(target=_global_one, args=(idx, agent),
+                                  name="gcrit-%s-%d" % (run_id, idx), daemon=True)
+            threads.append(th)
+            th.start()
+        for th in threads:
+            th.join(3000)
+        _check_cancel(ev)
+
+        for idx in range(len(agent_list)):
+            gj = results.get(idx)
+            if gj is None:
+                continue
+            if "error" in gj:
+                raise gj["error"]     # 还原串行版的异常上抛语义
+            if gj.get("scores"):
                 scored += 1
-            else:
-                gtpl = SERIAL_GLOBAL_PROMPT
-                if bible:
-                    gtpl = gtpl.replace("## 全书目标", bible + "\n\n## 全书目标", 1)
-                res = _run_step(run_id, "global-critique", modelhub.bind_agent(agent, difficulty),
-                                (gtpl.replace("__DIMKEYS__", dimkey)
-                                 .replace("__GOAL__", task["goal"])
-                                 .replace("__MANUSCRIPT__", full_text[:60000])),
-                                workdir, readonly=True, ev=ev, timeout=2400)
-                gj = _critique_json(res, dims)
-                if gj.get("scores"):
-                    scored += 1
             global_issues.extend({"chapter": "全书", **it} for it in (gj.get("issues") or [])[:8])
             for d in dims:
                 v = gj.get("scores", {}).get(d)
                 if v is not None:
                     gmeans_acc.setdefault(d, []).append(float(v))
-            _check_cancel(ev)
         return scored, gmeans_acc
 
     gscored, gmeans_acc = run_global_round(critics)
@@ -3359,8 +3475,8 @@ def _run_content_review(run, task, agents, ev, stats, mode):
         if task.get("context"):
             crit_prompt += "\n\n## 原始任务背景与附件参考\n" + task["context"]
         # AI 味确定性检测（借鉴 oh-story 去AI味）：客观参考线随评审下发，
-        # 命中才追加——评审官结合上下文判断是否真问题，脚本不直接扣分。
-        crit_prompt = _inject_detection(crit_prompt, manuscript, task)
+        # 命中才追加——评审官结合上下文判断是否真问题，脚本不直接扣分
+        crit_prompt = aiflavor.inject_into_prompt(crit_prompt, manuscript, task.get("type"))
         for agent in critics:
             role = "critique-r%d" % r
             if agent.get("mode") == "mock":

package/app/core/planner.py

@@ -114,13 +114,16 @@ def _log_usage(source, role, task, res, agent=None, tool="", model="", provider=
     except Exception:
         pass
 
-CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
-并判定任务难度和后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
+CODE_PLAN_PROMPT = """你是技术负责人。请先判定任务难度，再按难度拆解为按顺序执行的子任务，
+并给出后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {"difficulty": "easy 或 hard", "workflow": {"review_required": true, "max_repair_rounds": 0, "allow_switch": false}, "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
-难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
+难度判定：宁易勿难，绝大多数任务都是 easy——常规增删改查/小函数/格式调整/单点 bug 修复/
+配置调整 = easy；只有跨模块改动/架构调整/复杂算法/安全相关才算 hard，拿不准时一律按 easy。
 质量步骤判定：涉及安全、数据迁移、并发、权限、公共 API 或跨模块改动时必须评审；
 有明确自动验收的低风险小改可不做模型评审。max_repair_rounds 取 0-2，只有复杂任务才建议换将。
-子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
+子任务拆分：easy 一律只拆 1 个子任务——一个子任务把目标完整做完并自检通过即收尾，
+禁止拆出独立的核查/联调/收尾子任务；只有 hard 才允许多个子任务（至多 __N__ 个），
+粒度要可独立验证，且最后一个子任务必须包含整体联调/收尾。
 
 ## 先探索再计划（重要，借鉴 OpenSpec explore）
 拆解之前先用你的读文件/搜索工具**实际查看工作目录**，找到目标相关的真实文件与函数，再据此拆解。
@@ -527,7 +530,13 @@ def _norm_subtasks(data):
             if clean:
                 step["files"] = clean
         steps.append(step)
-    return steps or None
+    if not steps:
+        return None
+    # easy 任务执行层钉死单子任务：编排者提示词不服从多拆时，截掉只留首步
+    # （联调/收尾要求仅对 hard 生效，easy 单步自检即收尾）。
+    if _plan_difficulty(data) == "easy":
+        steps = steps[:1]
+    return steps
 
 
 def _plan_difficulty(data):