codebee 0.1.52 → 0.1.54

package/app/core/pipeline.py

@@ -19,7 +19,7 @@ import re
 import threading
 import time
 
-from . import aiflavor, attachments, catalog, dispatch_log, history, hooks, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage, volumes
+from . import aiflavor, attachments, branching, catalog, chaptersafe, dispatch_log, history, hooks, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage, volumes
 from . import builtin_agent
 from . import diagnostics
 from . import paths as paths_mod
@@ -331,7 +331,8 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
     if dead_binding:
         note = ((note + "；") if note else "") + "⚠ " + dead_msg
     step, log_abs = store.add_step(run_id, role, agent["id"],
-                                   agent.get("label", agent["id"]), note=note)
+                                   agent.get("label", agent["id"]), note=note,
+                                   model=agent.get("model") or "")
     start = time.time()
     if dead_binding:
         from .error_codes import ErrorCode
@@ -393,7 +394,8 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
     followups=True 时从回答末尾解析「建议追问」块（直连对话专用协议）：
     剥离出结构化列表落步骤记录，正文保持干净。"""
     _wait_gate(run_id, ev)
-    step, log_abs = store.add_step(run_id, role, "builtin", "CodeBee", note=note)
+    step, log_abs = store.add_step(run_id, role, "builtin", "CodeBee", note=note,
+                                   model=bi.get("model") or "")
     start = time.time()
     agent_pseudo = {"id": "builtin", "label": "CodeBee", "kind": "builtin", "mode": "real",
                     "provider": {"id": bi.get("provider_id") or "",
@@ -940,6 +942,72 @@ def _record_dispatch_completed(run_id, task, result, verify_pass=None, review_pa
         pass
 
 
+def _retry_content_draft_with_cli(run_id, task, agents, impl, difficulty, mode,
+                                  stats, prompt, workdir, step_wd, ev, resume_ctx,
+                                  draft_note, draft_res):
+    """Auto content tasks may try another configured CLI after a draft failure.
+
+    Model/provider failover has already been exhausted inside run_agent. Keep
+    manual execution, user cancellation and resumed sessions pinned to the
+    user's explicit choice.
+    """
+    raw = draft_res.get("raw") or {}
+    if (mode == "manual" or impl.get("mode") != "real" or resume_ctx
+            or raw.get("cancelled") or draft_res.get("error_code") == "CANCELLED"):
+        return draft_res, impl, draft_note
+
+    tried = {impl.get("id")}
+    failures = ["%s：%s" % (impl.get("id") or "CLI",
+                            (draft_res.get("error") or "起草失败")[:180])]
+    dead_upstreams = []
+    first_upstreams = router.agent_upstreams(impl.get("id"))
+    if first_upstreams:
+        dead_upstreams.append(first_upstreams)
+    current = impl
+    last_impl = impl
+    last_result = draft_res
+    last_note = draft_note
+
+    while True:
+        _check_cancel(ev)
+        candidate, reason = router.pick_switch_candidate(
+            agents, "implement", task.get("type") or "novel", stats,
+            exclude=tried, dead_upstreams=dead_upstreams)
+        if candidate is None or candidate.get("id") in tried:
+            break
+        tried.add(candidate.get("id"))
+        if candidate.get("mode") != "real":
+            continue
+
+        why = (last_result.get("error") or "起草失败")[:180]
+        switch_note = ("起草自动换 CLI：%s → %s（%s）；前序失败：%s" % (
+            current.get("id") or "CLI", candidate.get("id") or "CLI",
+            reason or "自动路由", why))
+        attempt_note = (draft_note + "；" if draft_note else "") + switch_note
+        bound = modelhub.bind_agent(candidate, difficulty)
+        last_result = _run_step(
+            run_id, "draft", bound, prompt, step_wd, readonly=False, ev=ev,
+            note=attempt_note, images=_task_images(task, workdir))
+        last_impl = candidate
+        last_note = attempt_note
+        if last_result.get("ok"):
+            return last_result, candidate, attempt_note
+
+        failures.append("%s：%s" % (candidate.get("id") or "CLI",
+                                    (last_result.get("error") or "起草失败")[:180]))
+        if (last_result.get("raw") or {}).get("cancelled"):
+            break
+        ups = router.agent_upstreams(candidate.get("id"))
+        if ups:
+            dead_upstreams.append(ups)
+        current = candidate
+
+    if last_impl is not impl:
+        last_result = dict(last_result)
+        last_result["error"] = "CLI 自动切换均失败：%s" % "；".join(failures[-4:])
+    return last_result, last_impl, last_note
+
+
 def _run_code(run, task, agents, ev, stats, mode):
     run_id = run["id"]
     workdir = task["workdir"]
@@ -2108,8 +2176,9 @@ def _wc(text):
 
 
 def _write_chapter(workdir, i, text):
-    with _chapter_io(workdir, i, "w") as f:
-        f.write(text)
+    # 安全落盘委托（inkos 安全章节工作区借鉴）：tmp+原子改名，写一半
+    # 崩溃不留半章冒充成稿；路径守卫在 chaptersafe（resolve+parents）
+    chaptersafe.atomic_write_chapter(workdir, i, text)
 
 
 def _all_ge(scores, threshold):
@@ -2556,6 +2625,20 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             scope = ("本章 = 大纲第 %d 章" % i) if start == 1 else (
                 "本批为第 %d–%d 章，下列按全书章号列出各章要点" % (start, end))
 
+            # 多线剧情推演（inkos 借鉴 2026-09-23）：serial.branches>=2 时
+            # 写章前一次编排者调用生成 N 条分支节拍、自荐择优，选中分支替换
+            # 本章 BEATS/HOOK（计划级赛马，省 prose 级开销）；失败静默走原大纲。
+            branch_beats = branch_hook = None
+            try:
+                n_branch = max(1, min(3, int(serial.get("branches") or 1)))
+                if n_branch >= 2:
+                    got = branching.plan_branches(
+                        run_id, task, i, task["goal"], outline_txt, prev, n_branch)
+                    if got:
+                        branch_beats, branch_hook = got
+            except Exception:
+                branch_beats = None
+
             def _draft_prompt(vfile):
                 return (SERIAL_CHAPTER_PROMPT
                         .replace("__SKILLS__", sk_block)
@@ -2567,8 +2650,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         .replace("__PREV__", prev)
                         .replace("__LEDGER__", ledger_txt)
                         .replace("__TITLE__", ch["title"])
-                        .replace("__BEATS__", ch["beats"] or "按大纲推进")
-                        .replace("__HOOK__", ch.get("hook") or "留下悬念")
+                        .replace("__BEATS__", branch_beats or ch["beats"] or "按大纲推进")
+                        .replace("__HOOK__", branch_hook or ch.get("hook") or "留下悬念")
                         .replace("__WORDS__", str(wpc)))
 
             n_variants = max(1, min(3, int(serial.get("variants") or 1)))
@@ -3477,6 +3560,27 @@ def _run_content_review(run, task, agents, ev, stats, mode):
                                   ev=ev, note=draft_note,
                                   resume=resume_ctx["session"] if resume_ctx else None,
                                   images=_task_images(task, workdir))
+        if not draft_res["ok"]:
+            draft_res, actual_impl, fallback_note = _retry_content_draft_with_cli(
+                run_id, task, agents, impl, difficulty, mode, stats,
+                _draft_prompt_for(ms_name), workdir, step_wd, ev, resume_ctx,
+                draft_note, draft_res)
+            if actual_impl.get("id") != impl.get("id"):
+                impl = actual_impl
+                draft_note = fallback_note
+                route["author"] = fallback_note
+                if mode != "manual":
+                    critic_pool, route["critics"] = router.pick_critics(
+                        agents, task.get("type") or "novel", stats, impl=impl)
+                    critics = critic_pool[:workflow["reviewers"]]
+                plan = planner.make_novel_plan(_steered_task(run_id, task), impl, critics)
+                store.update_run(run_id, route=route, plan=plan)
+                _record_actual_route(
+                    run_id, task, agents, stats, impl, critics=critics,
+                    implement_reason=route.get("author", ""),
+                    review_reason=route.get("critics", ""))
+            if draft_res.get("raw", {}).get("cancelled"):
+                _check_cancel(ev)
         if not draft_res["ok"]:
             store.update_run(run_id, expected_status="running", status="failed",
                              error="起草失败: %s" % draft_res.get("error"),

package/app/core/runner.py

@@ -28,7 +28,8 @@ from .error_codes import ErrorCode
 # 非 Windows 必须置 0：POSIX 的 Popen 对非零 creationflags 直接抛 ValueError，
 # 置 0 则两边通用（remote.py 同款守卫）。
 CREATE_NO_WINDOW = 0x08000000 if os.name == "nt" else 0
-DEFAULT_TIMEOUT = 1200  # 单步 20 分钟
+DEFAULT_TIMEOUT = 1200  # 单步 20 分钟
+MAX_ATTEMPT_TIMEOUT_S = 60  # 单模型上游最多等 1 分钟，随后换模型/供应商
 
 _BASH_CANDIDATES = [
     r"D:\Git\usr\bin\bash.exe",
@@ -774,8 +775,8 @@ def _codex_fail_msg(stdout):
     2026-09-16 实测：配额/限流只出现在 error 与 turn.failed 事件里，旧解析器
     两者都丢——进程退出码非 0 时错误串里只剩 "Reading prompt from stdin..."，
     _quota_error/_transient_error 判不出可降级，健康后继模型从未被尝试。
-    Reconnecting... 是 CLI 内部重试噪音（可能自愈），不取；turn.failed 是
-    终态优先于裸 error（后者取最后一条兜底）。
+    Reconnecting... 是 CLI 内部重试噪音（可能自愈），不取作终态错误；重复
+    重连由进程看门狗提前中断。turn.failed 优先于裸 error（后者取最后一条兜底）。
     """
     terminal, last_err = "", ""
     for line in (stdout or "").splitlines():
@@ -823,6 +824,10 @@ def _parse_claude_json(stdout):
         int(u.get("cache_creation_input_tokens") or 0)
     usage = {"input": inp, "output": out, "cached": cached, "reasoning": 0,
              "total": inp + out + cached}
+    # 网关实服模型：请求 deepseek-v4.1-flash 却被网关映射成 gemini-3.8-flash
+    # 之类（2026-09-23 夜班实案）——用量统计记错名、失败排查看错病根，都
+    # 靠 result 行的 modelUsage 对出来
+    served = sorted({str(k) for k in ((data.get("modelUsage") or {}) or {})})
     return {
         "text": data.get("result") or "",
         "cost_usd": data.get("total_cost_usd") or 0.0,
@@ -831,6 +836,7 @@ def _parse_claude_json(stdout):
         "is_error": bool(data.get("is_error")),
         # §07 T1.1：claude -p 返回本次会话 id，供 --resume 复用
         "sid": str(data.get("session_id") or ""),
+        "served_models": served,
     }
 
 
@@ -898,6 +904,49 @@ RATE_LIMIT_GRACE_S = 45      # 宽限等待时长：限流窗口通常按分钟
 RATE_LIMIT_GRACE_N = 1       # 每步宽限次数：只兜一次，防限流长拖整轮时间
 
 
+# 上游内容拒答（refusal）：claude CLI 把 refusal stop_reason 渲染成
+# "API Error: <model> can't help with this. Start a new session to continue."
+# 这是网关后面那个模型对本次会话内容的过滤决定，不是任务终态——换一家
+# 异上游候选常常就能跑通。2026-09-23 夜班实案：doc 起草被 gemini 拒答后
+# 判成非瞬态整链早死，链上云知声候选根本没被尝试。
+_REFUSAL = ("can't help with this", "couldn't help with this",
+            'stop_reason":"refusal"', "content policy", "content filtering")
+
+
+def _refusal_error(err):
+    err = (err or "").lower()
+    return any(k in err for k in _REFUSAL)
+
+
+def _attempt_upstream(att):
+    """返回尝试项的上游身份；同一 host 换模型/供应商别名不重复烧超时。"""
+    provider = (att or {}).get("provider") or {}
+    base_url = str(provider.get("base_url") or "").strip()
+    match = re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://([^/?#]+)", base_url)
+    if match:
+        return match.group(1).lower()
+    provider_id = str((att or {}).get("provider_id") or "").strip()
+    return "provider:" + provider_id if provider_id else "unknown"
+
+
+def _claude_drift_note(att_model, parsed):
+    """请求模型 vs 网关实服模型不一致时的注记；一致或无从判断返回空。"""
+    served = (parsed or {}).get("served_models") or []
+    if not served or not att_model or served == [att_model]:
+        return ""
+    return "[模型漂移] 请求 %s，上游实服 %s" % (att_model, ",".join(served))
+
+
+def _log_note(log_path, text):
+    if not log_path or not text:
+        return
+    try:
+        with open(log_path, "a", encoding="utf-8") as fh:
+            fh.write("\n[%s]\n" % text)
+    except OSError:
+        pass
+
+
 def _rate_limited(err):
     err = (err or "").lower()
     return any(k in err for k in _RATE_LIMIT)
@@ -930,7 +979,7 @@ def _augment_error_from_log(out, log_path, limit=300):
     out["error"] = (out["error"] + "；日志错误行: " + hits[-1][:limit])[-800:]
 
 
-def _grace_wait(cancel_event, seconds, log_path=None, why=""):
+def _grace_wait(cancel_event, seconds, log_path=None, why=""):
     """链尾限流宽限等待：小片睡眠随时响应取消。返回 False=已取消（别再重试）。"""
     if log_path:
         try:
@@ -939,11 +988,11 @@ def _grace_wait(cancel_event, seconds, log_path=None, why=""):
                          % (why or "上游限流（429）", seconds))
         except Exception:
             pass
-    end = time.time() + seconds
-    while time.time() < end:
-        if cancel_event is not None and cancel_event.is_set():
-            return False
-        time.sleep(min(3, max(0.5, end - time.time())))
+    end = time.monotonic() + seconds
+    while time.monotonic() < end:
+        if cancel_event is not None and cancel_event.is_set():
+            return False
+        time.sleep(min(3, max(0.5, end - time.monotonic())))
     return cancel_event is None or not cancel_event.is_set()
 
 
@@ -1255,14 +1304,17 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     防模型纯口头谎报「环境受限」蒙混过关（2026-09-17 mo-so 实测）。
 
     模型尝试顺序来自 _resolve_attempts：跨厂商链（每条独立 env）或
-    主模型 + 降级备选；瞬态错误才换下一条，取消/超时/解析失败不降级。
+    主模型 + 降级备选；瞬态/配额/超时/上游拒答换下一条，取消与解析
+    失败不降级；同一上游超时两次即跳过该上游剩余模型。
 
-    5E：catalog `orch.timeout_ms`（毫秒）优先于 caller 传入的 timeout。
+    5E：catalog `orch.timeout_ms`（毫秒）优先于 caller 传入的 timeout；
+    但单个模型/上游调用硬封顶 60 秒，超时即试链上下一家。
     """
     # 5E：catalog orch.timeout_ms 优先
     orch_timeout_ms = (agent.get("orch") or {}).get("timeout_ms")
-    if orch_timeout_ms:
-        timeout = float(orch_timeout_ms) / 1000.0
+    if orch_timeout_ms:
+        timeout = float(orch_timeout_ms) / 1000.0
+    timeout = min(float(timeout), MAX_ATTEMPT_TIMEOUT_S)
     kind = agent.get("kind", "generic")
     if kind == "aider":
         repo_issue = _git_repo_issue(workdir)
@@ -1308,8 +1360,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     attempts = _resolve_attempts(agent)
     out = None
     grace_left = RATE_LIMIT_GRACE_N  # 链尾限流宽限预算：整链撞 429 时原地等一个窗口再试一次
-    for ai, att in enumerate(attempts):
-        env = dict(base_env)
+    timed_out_upstreams = {}  # 同一上游两次超时后跳过剩余模型
+    skipped_upstreams = set()
+    for ai, att in enumerate(attempts):
+        upstream = _attempt_upstream(att)
+        if upstream in skipped_upstreams:
+            continue
+        model_deadline = att.get("_deadline") or (time.monotonic() + timeout)
+        env = dict(base_env)
         env.update(att["env"])
         if kind == "codex":
             # 网关自定义模型名（如 [opencode]xxx）是合法 API 模型名不能改，但方括号
@@ -1323,25 +1381,32 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
         elif att["from_chain"] and "codex_provider" in eff_agent:
             # 链内条目未注入供应商时不能沿用上一条（可能是另一家厂商）的 -c 覆盖
             del eff_agent["codex_provider"]
-        for attempt in range(2):  # claude 偶发空响应（0 token）自动重试一次
-            argv, stdin_text, prompt_eff, tmp_files = _build_call(
-                eff_agent, kind, sid, readonly,
-                att["model"], prompt,
-                images=images if kind == "codex" else None,
-                workdir=workdir)
-            try:
-                repeat_guard = (("Reconnecting... waiting for network", 5)
-                                if kind == "codex" else None)
-                res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
-                                  timeout=timeout, cancel_event=cancel_event, log_path=log_path,
-                                  stall_timeout=stall_t, repeat_abort=repeat_guard)
-            finally:
-                # 超长指令临时文件：CLI 进程已结束（管道已收），即刻清场不污染工作目录
-                for tf in tmp_files:
-                    try:
-                        os.remove(tf)
-                    except OSError:
-                        pass
+        for attempt in range(2):  # claude 偶发空响应（0 token）自动重试一次
+            remaining = model_deadline - time.monotonic()
+            if remaining <= 0:
+                res = {"ok": False, "exit_code": None, "stdout": "", "stderr": "",
+                       "duration": timeout, "cancelled": False, "timed_out": True,
+                       "stalled": False}
+            else:
+                argv, stdin_text, prompt_eff, tmp_files = _build_call(
+                    eff_agent, kind, sid, readonly,
+                    att["model"], prompt,
+                    images=images if kind == "codex" else None,
+                    workdir=workdir)
+                try:
+                    repeat_guard = (("Reconnecting...", 2)
+                                    if kind == "codex" else None)
+                    res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
+                                      timeout=min(timeout, remaining), cancel_event=cancel_event,
+                                      log_path=log_path, stall_timeout=stall_t,
+                                      repeat_abort=repeat_guard)
+                finally:
+                    # 超长指令临时文件：CLI 进程已结束（管道已收），即刻清场不污染工作目录
+                    for tf in tmp_files:
+                        try:
+                            os.remove(tf)
+                        except OSError:
+                            pass
             out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
                    "tokens": 0, "usage": None, "error": "", "error_code": "",
                    "sid": "", "raw": res, "kind": kind, "model": att["model"],
@@ -1370,6 +1435,10 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     parsed_err = _parse_claude_json(res["stdout"] or "")
                     if parsed_err and parsed_err.get("is_error") and parsed_err.get("text"):
                         out["error"] = "claude 返回 is_error: " + parsed_err["text"][:500]
+                        drift = _claude_drift_note(att.get("model"), parsed_err)
+                        if drift:
+                            out["error"] += "；" + drift
+                            _log_note(log_path, drift)
                 if kind == "codex" and att.get("provider_id"):
                     el = out["error"].lower()
                     if (("wire_api" in el and "no longer supported" in el)
@@ -1442,9 +1511,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 out["tokens"] = parsed["tokens"]
                 out["usage"] = parsed["usage"]
                 out["sid"] = parsed.get("sid") or ""  # §07 T1.1
+                drift = _claude_drift_note(att.get("model"), parsed)
+                if drift:
+                    _log_note(log_path, drift)
                 if parsed["is_error"]:
                     out["ok"] = False
                     out["error"] = "claude 返回 is_error: " + parsed["text"][:500]
+                    if drift:
+                        out["error"] += "；" + drift
                     out["error_code"] = _classify_failure(res, kind="claude", parsed=parsed)
                     break
                 if not out["text"] and attempt == 0:
@@ -1460,21 +1534,44 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 if not out["text"]:
                     out["error_code"] = _classify_failure(res, kind=kind, empty_output=True)
             break
-        _report_key(att, out)
-        if out["ok"] or ai == len(attempts) - 1:
-            if (not out["ok"] and grace_left > 0 and _rate_limited(out.get("error"))
-                    and not (cancel_event is not None and cancel_event.is_set())):
-                # 链尾限流宽限：enumerate 活列表——把链尾这条 append 回去，
-                # 下一轮迭代就是「原地重试一次」；再撞限流时预算已耗尽照常判死。
-                grace_left -= 1
-                if _grace_wait(cancel_event, RATE_LIMIT_GRACE_S, log_path=log_path):
-                    attempts.append(att)
-                    continue
-            return out
-        # 瞬态网络错误 → 换下一条；欠费/配额耗尽同样换（可能是同厂商的备用 KEY，
-        # 也可能是另一家厂商）——账单断了死磕同一把 KEY 没有任何意义。
-        if not (_transient_error(out.get("error")) or _quota_error(out.get("error"))):
-            return out  # 非瞬态（取消/超时/解析失败）不降级
+        _report_key(att, out)
+        if out["ok"] or ai == len(attempts) - 1:
+            remaining = model_deadline - time.monotonic()
+            if (not out["ok"] and grace_left > 0 and _rate_limited(out.get("error"))
+                    and remaining > 2
+                    and not (cancel_event is not None and cancel_event.is_set())):
+                # 链尾限流宽限：enumerate 活列表——把链尾这条 append 回去，
+                # 下一轮迭代就是「原地重试一次」；再撞限流时预算已耗尽照常判死。
+                grace_left -= 1
+                grace_s = min(RATE_LIMIT_GRACE_S, remaining - 1)
+                if _grace_wait(cancel_event, grace_s, log_path=log_path):
+                    retry = dict(att, _deadline=model_deadline)
+                    attempts.append(retry)
+                    continue
+            return out
+        # 换将闸门：什么失败值得烧链上下一个候选。
+        # · 瞬态/配额（文本特征，含 CLI 内部 api_retry 的 429/5xx 字样）照旧；
+        # · 超时：显式可换（看 res 标志位）——慢上游换快候选可能救回。
+        #   2026-09-23 夜班实案：旧逻辑里超时能否换将全赌输出尾部碰巧含有
+        #   "timeout" 字样（当时是步骤里读到的代码 timeout=900 撞的表）。
+        # · 上游内容拒答（refusal）：是那家模型的过滤决定，不是任务终态，
+        #   换异上游候选常常就活；判死则整 run 白烧（同案：gemini 拒答后
+        #   链上云知声候选从未被尝试）。
+        raw = out.get("raw") or {}
+        if (raw.get("cancelled")   # 取消是用户意志，绝不降级（尾段可能带瞬态字样）
+                or not (_transient_error(out.get("error")) or _quota_error(out.get("error"))
+                        or _refusal_error(out.get("error"))
+                        or raw.get("timed_out"))):
+            return out  # 取消/解析失败等真终态不降级
+        # 同一上游的模型连续两次超时就收手——
+        # 链上候选绑同一上游时换将=换壳不换命（2026-09-22 429 集群教训；
+        # 2026-09-23 夜班实案同一慢上游连烧 3×20 分钟全超时零产出），最多
+        # 两个模型预算后转向其他上游。其余瞬态/拒答仍按链长全部尝试：各家病根
+        # 不同，每个候选都值得一次机会。
+        if raw.get("timed_out"):
+            timed_out_upstreams[upstream] = timed_out_upstreams.get(upstream, 0) + 1
+            if timed_out_upstreams[upstream] >= 2:
+                skipped_upstreams.add(upstream)
     return out
 
 

package/app/core/share_page.py

@@ -87,12 +87,15 @@ def render_share_html(run, task, report_text):
 
     steps_rows = ""
     for s in run.get("steps") or []:
+        who = s.get("agent_label") or s.get("agent") or ""
+        if s.get("model"):
+            who += " · " + str(s["model"])
         steps_rows += (
             '<div class="step"><span class="n">%02d</span>'
             '<span class="role">%s</span><span class="who">%s</span>'
             '<span class="sum">%s</span><span class="st %s">%s</span></div>'
             % (s.get("n") or 0, _esc(s.get("role") or ""),
-               _esc(s.get("agent_label") or s.get("agent") or ""),
+               _esc(who),
                _esc((s.get("summary") or "")[:220]), _esc(s.get("status") or ""),
                _esc(s.get("status") or "")))
 

package/app/core/store.py

@@ -223,6 +223,15 @@ def create_task(payload):
                     v = 1
                 if v > 1:
                     s["variants"] = v
+                # 多线剧情推演（inkos 借鉴 2026-09-23）：2-3 = 写章前生成
+                # N 条分支节拍计划择优注入（计划级赛马，省 prose 级开销）；
+                # 越界钳到 3（与 variants 同口径：上限仍可用，1=不启用不落键）
+                try:
+                    br = max(1, min(3, int(serial.get("branches") or 1)))
+                except Exception:
+                    br = 1
+                if br > 1:
+                    s["branches"] = br
                 # 分卷：显式卷表优先（新建任务时用户明确给出的分卷信息），
                 # 其次每卷章数等长切卷。卷边界一律由 volumes 模块从「章号」
                 # 确定性推导——续写批次沿用同一份卷表/每卷章数即自动接上同一卷，
@@ -1528,7 +1537,7 @@ def update_task_params(task_id, patch):
     return True, ""
 
 
-def add_step(run_id, role, agent_id, agent_label, note=""):
+def add_step(run_id, role, agent_id, agent_label, note="", model=""):
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
@@ -1537,6 +1546,9 @@ def add_step(run_id, role, agent_id, agent_label, note=""):
         step = {
             "n": n, "role": role, "agent": agent_id, "agent_label": agent_label,
             "note": note,
+            # 起跑即记解析到的模型：运行中蜂巢卡/步骤列表就能看到「在用哪个模型」，
+            # 不必等 finish_step 用实际结果覆盖（换将成功后以实际为准）
+            "model": str(model or "")[:80],
             "status": "running", "started_at": time.strftime("%H:%M:%S"),
             "ended_at": None, "duration_s": None, "exit_code": None,
             "summary": "", "log": None, "cost_usd": 0.0, "tokens": 0,

package/app/main.py

@@ -30,7 +30,7 @@ if os.environ.get("TUTTI_ISOLATE_HOME", "").strip() == "1":
     os.environ["USERPROFILE"] = _fake_home
     os.environ["HOME"] = _fake_home
 
-from core import automation, catalog, flows, jobs, manager, market, market_remote, preview, registry, remote, settings, store
+from core import automation, board, catalog, flows, jobs, manager, market, market_remote, preview, registry, remote, settings, store
 from core import paths
 from core import health
 import pick_dialog
@@ -235,6 +235,9 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/health":
                 from core import health
                 return self._json(200, health.snapshot())
+            if path == "/api/board":
+                # 任务驾驶舱大屏的轻量聚合（KB 级；别让它去拉 /api/state 全量）
+                return self._json(200, board.payload())
             if path == "/api/connect":
                 # 供设置页「手机连接」弹框生成二维码；远程打开需令牌，天然受保护
                 return self._json(200, {"urls": remote.build_connect_urls(PORT),