codebee 0.1.52 → 0.1.54

package/CHANGELOG.md

@@ -23,6 +23,22 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 - **首选 KEY 超限自动切备用了**：同厂商多密钥此前只认欠费类文案——首选 KEY 撞上 429 限流（智谱「并发数超过限制」「每分钟Token数已超过上限」、claude 的 rate_limit_error、codex 的 "429 Too Many Requests" 等）只记一笔错误、不进冷却，每个新步骤仍从超限的首选 KEY 重新烧起。现在限流文案与欠费同口径：进冷却 30 分钟、密钥镜像自动切下一把、链展开跳过冷却中的 KEY（到期或「恢复」按钮一键回首选）。顺带补一处漏账：无显式链时「换模型回退」的链条目不带 KEY 标记，这类重试失败此前完全不记 KEY 账。
 
+## v0.1.54（2026-09-23）
+
+- 任务驾驶舱大屏：/board.html 独立页 + /api/board 聚合端点——模型/厂商分布、实时思考流、排队滚动，中英双语
+- 连载章节安全落盘：临时文件 + 原子改名，半截稿不再污染章节文件
+- 日志抽屉一键复制全文（报错 JSON 不再手动圈选）
+- 删除/归档乐观清场：SSE 半死时已删/已归档任务不再挂侧栏
+- 卡死的模型调用快速失败转投，不再耗满超时
+- run_end 钩子新增「完成后 AI 复查并自动提交推送」：AI 复查 diff 判 OK 才 commit+push
+- 蜂巢卡显示当前使用模型 + 运行中思考过程行
+
+## v0.1.53（2026-09-23）
+
+- 换将救活两类「假终态」：上游内容拒答（"can't help with this" 一类 refusal）与真超时，现在都会换绑定链上下一个候选再试——此前拒答直接判死整轮任务（链上异上游候选从未被尝试），超时能不能换全凭输出尾段碰巧带 "timeout" 字样；真实案：夜间知识库整理任务被网关 gemini 拒答后整 run 白烧
+- 同一慢上游连烧止损：链上候选连续两次相同超时即收手（换将=换壳不换命），最坏从 N×单步超时压到 2×；取消显式列为终态绝不降级
+- 网关模型漂移可见：请求 A 模型被网关实际映射成 B 模型时（真实案：请求 deepseek-v4.1-flash 实服 gemini-3.8-flash），失败信息与步骤日志明确标注「请求 X，上游实服 Y」，排查看对病根
+
 ## v0.1.52（2026-09-22）
 
 - 手动指定执行者优先级全面收口：用户点名的 CLI 压过一切自动选择——路由不换将、旁观不抢占、绑定不覆盖；「手动指定执行者」作为一等偏好随任务走

package/README.md

@@ -21,10 +21,11 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.52）
+### 最新版更新内容（v0.1.54）
 
-- 手动指定执行者为一等偏好：用户点名的 CLI 压过自动路由，全程不换将、不被抢占
-- 管理页执行者下拉与新建任务菜单统一；静默挂死看门狗防误杀保留
+- 新增任务驾驶舱大屏（/board.html）：模型/厂商分布、实时思考流、排队滚动
+- 章节原子落盘；日志一键复制；删除/归档乐观清场；卡死调用快速转投
+- run_end 钩子支持「AI 复查后自动提交推送」；蜂巢卡显示当前模型与思考流
 <!-- relnotes:end -->
 
 ---

package/app/core/automation.py

@@ -65,7 +65,7 @@ _DEFAULTS = {"id": "", "name": "", "prompt": "", "workdir": "", "kind": "", "tim
              "mode": "auto", "thinking": "standard",
              "direct_provider_id": "", "direct_model": "",
              "enabled": False, "created_at": "", "last_run": "", "next_run": "",
-             "run_count": 0, "last_status": ""}
+             "run_count": 0, "last_status": "", "last_run_id": ""}
 
 # 允许通过 update() 修改的字段（id/created_at/run_count 等运行痕迹不可改）
 _UPDATABLE = ("name", "prompt", "workdir", "kind", "time", "interval_hours",
@@ -386,8 +386,9 @@ def _fire(snapshot, now):
     """触发一个到期任务：拉起运行并推进 last_run/next_run/run_count/last_status。
     once 触发完自动停用。拉起失败只记 error，next_run 照常推进（下个周期重试）。"""
     status = "started"
+    run_id = ""
     try:
-        _launch_run(snapshot)
+        run_id = _launch_run(snapshot) or ""
     except Exception as e:
         log.warning("automation: 定时触发 %s 失败: %r", snapshot.get("id"), e)
         status = "error"
@@ -398,6 +399,8 @@ def _fire(snapshot, now):
         cur["last_run"] = _fmt_dt(now)
         cur["run_count"] = int(cur.get("run_count") or 0) + 1
         cur["last_status"] = status
+        if run_id:
+            cur["last_run_id"] = run_id
         if cur.get("kind") == "once":
             cur["enabled"] = False
             cur["next_run"] = ""
@@ -408,6 +411,49 @@ def _fire(snapshot, now):
 
 # ---------------------------------------------------------------- 调度线程
 
+def _default_run_status(rid):
+    """按 run_id 查运行状态（终态回写用）；查不到返回 None。"""
+    from . import store
+    try:
+        r = store.get_run(rid)
+    except Exception:
+        return None
+    return (r or {}).get("status") or None
+
+
+# 测试可替换的查态钩子
+_RUN_STATUS = _default_run_status
+
+_RUN_TERMINAL = ("done", "failed", "cancelled")
+
+
+def _reconcile_statuses():
+    """把 last_status 停在 started 的任务对账到真实运行终态。此前触发后永不
+    回写，任务卡片永远显示「运行中」（2026-09-23 实案：三个任务全部如此）。
+    store 查不到或还没到终态就保持原样，下一轮 tick 再看。"""
+    with _LOCK:
+        pending = {tid: t.get("last_run_id") for tid, t in _TASKS.items()
+                   if t.get("last_run_id") and t.get("last_status") == "started"}
+    if not pending:
+        return
+    settled = {}
+    for tid, rid in pending.items():
+        st = _RUN_STATUS(rid)
+        if st in _RUN_TERMINAL:
+            settled[tid] = st
+    if not settled:
+        return
+    with _LOCK:
+        dirty = False
+        for tid, st in settled.items():
+            t = _TASKS.get(tid)
+            if (t and t.get("last_run_id") == pending[tid]
+                    and t.get("last_status") == "started"):
+                t["last_status"] = st
+                dirty = True
+        if dirty:
+            _save_locked()
+
 def _tick():
     """扫描一遍到期任务并逐个触发。单任务异常只跳过该条，绝不上抛。"""
     now = datetime.now()
@@ -429,6 +475,11 @@ def _tick():
             _fire(dict(t), now)
         except Exception:
             log.exception("automation: tick 处理任务 %s 异常，已跳过", tid)
+    # 运行终态对账：last_status 停在 started 的任务查一次真实终态（见函数注）。
+    try:
+        _reconcile_statuses()
+    except Exception:
+        log.debug("automation: 运行终态对账跳过", exc_info=True)
     # 定时发布联动（P2.5）：任务级 auto_publish 标记到点触发批量发布。
     # 发布逻辑全在 publish/auto（护栏/幂等/单飞），这里只当调度宿主。
     try:
@@ -581,10 +632,11 @@ def run_now(tid):
     now = datetime.now()
     run_id = ""
     status = "started"
+    run_id = ""
     try:
         with _LOCK:
             snapshot = dict(_TASKS[tid])
-        run_id = _launch_run(snapshot)
+        run_id = _launch_run(snapshot) or ""
     except Exception as e:
         log.warning("automation: 手动触发 %s 失败: %r", tid, e)
         status = "error"
@@ -601,6 +653,8 @@ def run_now(tid):
             t["last_run"] = _fmt_dt(now)
         t["run_count"] = int(t.get("run_count") or 0) + 1
         t["last_status"] = status
+        if run_id:
+            t["last_run_id"] = run_id
         _save_locked()
         return dict(t), run_id
 

package/app/core/board.py

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+"""任务驾驶舱（/board 大屏）的轻量聚合数据源。
+
+大屏 4 秒轮询：不能拉 /api/state 全量（MB 级），也不能每次全量扫 usage
+台账（summary 全历史读入），所以这里只取大屏要看的字段，并把 usage 聚合
+缓存 8 秒。只读 store/usage/jobs/health，不落新盘。
+"""
+from __future__ import annotations
+
+import time
+
+_CACHE = {"ts": 0.0, "data": None}
+_TTL = 8.0
+
+_TAIL_MAX = 150          # 跑马灯尾行截断
+_TAIL_LINES = 6          # 实时流窗口行数
+_TAIL_LINE_CHARS = 56    # 实时流单行截断（卡内 11px 等宽不换行的安全宽度）
+_RECENT_LIMIT = 10       # 最近完成/失败条数
+_RUN_WINDOW = 300        # 今日计数扫描的运行窗口（id 字典序=时间序）
+
+
+def payload():
+    now = time.time()
+    if _CACHE["data"] is not None and now - _CACHE["ts"] < _TTL:
+        return _CACHE["data"]
+    data = _build()
+    _CACHE["ts"] = now
+    _CACHE["data"] = data
+    return data
+
+
+def _tail(step):
+    """步骤实时流（正文优先，其次思考）的最后一行，给大屏跑马灯。"""
+    for key in ("stream", "thinking"):
+        v = step.get(key)
+        if isinstance(v, str) and v.strip():
+            lines = [ln.strip() for ln in v.strip().splitlines() if ln.strip()]
+            if lines:
+                return lines[-1][:_TAIL_MAX]
+    return ""
+
+
+def _live_block(step):
+    """步骤实时流窗口：尾部多行（正文优先，其次思考），供大屏看它在想什么。
+
+    返回 (来源标签 code, 文本)；标签是 code（output/thinking），由前端 i18n
+    翻译——大屏要做多语言，后端不下发中文。都没有返回 ("", "")。
+    """
+    for key, code in (("stream", "output"), ("thinking", "thinking")):
+        v = step.get(key)
+        if not (isinstance(v, str) and v.strip()):
+            continue
+        lines = [ln.strip()[:_TAIL_LINE_CHARS] for ln in v.strip().splitlines()]
+        lines = [ln for ln in lines if ln]
+        if lines:
+            return code, "\n".join(lines[-_TAIL_LINES:])
+    return "", ""
+
+
+def _model_provider_map():
+    """模型名 → 厂商名（enabled 优先，同模型多厂商取 priority 最靠前的）。"""
+    try:
+        from . import modelhub
+        rows = modelhub.models_view()
+    except Exception:
+        return {}
+    best = {}
+    for r in rows:
+        name = r.get("name")
+        if not name or not r.get("enabled", False):
+            continue
+        pri = r.get("priority", 0)
+        cur = best.get(name)
+        if cur is None or pri < cur[0]:
+            best[name] = (pri, r.get("provider_name") or r.get("provider_id") or "")
+    return {k: v[1] for k, v in best.items()}
+
+
+def _parse_ts(s):
+    try:
+        return time.mktime(time.strptime(str(s), "%Y-%m-%d %H:%M:%S"))
+    except (ValueError, TypeError):
+        return 0.0
+
+
+def _duration_s(run):
+    """运行耗时（秒）：ended-started，缺 started 用 created 兜底。"""
+    end = _parse_ts(run.get("ended_at"))
+    start = _parse_ts(run.get("started_at")) or _parse_ts(run.get("created_at"))
+    if end > 0 and start > 0 and end >= start:
+        return int(end - start)
+    return None
+
+
+def _step_view(steps, prov_map):
+    """进度概要：完成数 + 当前运行中步骤（含模型/厂商/实时流）。"""
+    done = sum(1 for s in steps if s.get("status") == "done")
+    cur = next((s for s in steps if s.get("status") == "running"), None)
+    cur_v = None
+    if cur:
+        live_label, live_text = _live_block(cur)
+        model = str(cur.get("model") or "")[:60]
+        cur_v = {"n": cur.get("n"), "role": cur.get("role") or "",
+                 "agent": cur.get("agent_label") or cur.get("agent") or "",
+                 "summary": (cur.get("summary") or "")[:80],
+                 "tail": _tail(cur),
+                 "model": model, "provider": prov_map.get(model, "") if model else "",
+                 "live_label": live_label, "live_text": live_text}
+    return done, len(steps), cur_v
+
+
+def _build():
+    from . import flows, health, jobs, store, usage
+
+    flow_map = {}
+    try:
+        for f in flows.list_flows():
+            flow_map[f.get("id")] = f
+    except Exception:
+        pass
+
+    prov_map = _model_provider_map()
+    today = time.strftime("%Y-%m-%d")
+    tasks = store.list_tasks(200, archived=False)
+    latest = store.latest_run_by_task()
+
+    running, queued = [], []
+    for t in tasks:
+        tid = t.get("id")
+        run = latest.get(tid)
+        status = t.get("status")
+        if status == "running" and run and run.get("status") == "running":
+            done, total, cur = _step_view(run.get("steps") or [], prov_map)
+            running.append({
+                "task_id": tid, "run_id": run.get("id"),
+                "title": t.get("title") or "", "goal": (t.get("goal") or "")[:120],
+                "type": t.get("type") or "",
+                "type_name": (flow_map.get(t.get("type")) or {}).get("name") or (t.get("type") or ""),
+                "status": status,
+                "started_at": run.get("started_at") or run.get("created_at") or "",
+                "steps_done": done, "steps_total": total,
+                "current": cur,
+                "run_tokens": run.get("tokens") or 0,
+                "run_cost_usd": round(float(run.get("cost_usd") or 0.0), 4),
+                "estimate_s": run.get("estimated_duration_s"),
+            })
+        elif status == "queued":
+            queued.append({
+                "task_id": tid, "run_id": (run or {}).get("id"),
+                "title": t.get("title") or "",
+                "type_name": (flow_map.get(t.get("type")) or {}).get("name") or (t.get("type") or ""),
+                "created_at": (run or {}).get("created_at") or "",
+            })
+    running.sort(key=lambda c: _parse_ts(c["started_at"]))
+    queued.sort(key=lambda c: _parse_ts(c["created_at"]))
+
+    runs = store.list_runs(_RUN_WINDOW)
+    today_done = today_failed = 0
+    recent = []
+    for r in runs:
+        st = r.get("status")
+        ended = str(r.get("ended_at") or "")
+        if st in ("done", "failed", "cancelled") and ended.startswith(today):
+            if st == "done":
+                today_done += 1
+            elif st == "failed":
+                today_failed += 1
+        if len(recent) < _RECENT_LIMIT and st in ("done", "failed", "cancelled") and ended:
+            recent.append({
+                "run_id": r.get("id"), "task_id": r.get("task_id"),
+                "title": r.get("title") or "", "status": st,
+                "ended_at": ended, "duration_s": _duration_s(r),
+                "error": (r.get("error") or "")[:80],
+            })
+
+    trend, models, usage_today = [], [], {"tokens": 0, "calls": 0, "cost_usd": 0.0}
+    try:
+        s = usage.summary(days=7)
+        trend = [{"day": d.get("day"), "tokens": d.get("tokens") or 0}
+                 for d in (s.get("by_day") or [])]
+        for row in (s.get("by_model") or [])[:5]:
+            if not row.get("tokens"):
+                continue
+            models.append({"model": row.get("key") or "?",
+                           "tokens": row.get("tokens") or 0,
+                           "calls": row.get("calls") or 0})
+        for d in s.get("by_day") or []:
+            if str(d.get("day")) == today:
+                usage_today = {"tokens": d.get("tokens") or 0,
+                               "calls": d.get("calls") or 0,
+                               "cost_usd": round(float(d.get("cost_usd") or 0.0), 3)}
+                break
+    except Exception:
+        pass
+
+    return {
+        "now": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "today": today,
+        "running": running,
+        "queued": queued,
+        "today_done": today_done,
+        "today_failed": today_failed,
+        "recent": recent,
+        "trend": trend,
+        "models": models,
+        "usage_today": usage_today,
+        "pool": jobs.workers_info(),
+        "health": health.snapshot().get("providers") or [],
+    }

package/app/core/branching.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""多线剧情推演（inkos 借鉴 2026-09-23）：写章前一次调用生成 2-3 条分支
+节拍计划，自带推荐择优，选中分支注入本章 BEATS；全部分支追加审计文件
+.codebee/branch-plans.md 供回看。计划级赛马——比 prose 级 Best-of-N 省
+一个数量级的 token。"""
+from __future__ import annotations
+
+import logging
+import os
+
+log = logging.getLogger(__name__)
+
+BRANCH_PLAN_PROMPT = """你是网文剧情策划。基于全书设定与上一章结尾，为下一章生成 __N__ 条**彼此方向不同**的剧情分支计划。
+
+要求：
+- 每条分支给出：本章节拍（50-120 字：事件/冲突/推进）+ 章末钩子（一句话）+ 一句取舍理由（为什么选/不选它）
+- 分支之间要有真实的方向差异（不同冲突来源/不同人物决定/不同信息揭示），不是同一件事换措辞
+- 你是策划也是评委：综合大纲意图、前情、人物动机，推荐其中最有力的一条
+
+只输出一个 ```json 代码块：
+{"branches": [{"beats": "…", "hook": "…", "why": "…"}, …], "pick": 0}
+pick = 推荐分支的下标（0 起）。
+
+## 全书目标
+__GOAL__
+
+## 大纲上下文（本章前后）
+__OUTLINE__
+
+## 上一章结尾
+__PREV__
+"""
+
+
+def plan_branches(run_id, task, i, goal, outline_txt, prev, n, *, log_path=None):
+    """生成并择优一条分支计划。返回 (beats, hook) 或 None（失败/未启用走原大纲）。
+
+    编排者一次调用产 N 条+自荐 pick；失败静默回落原大纲节拍（推演是增强
+    不是闸门）。全部分支连同 pick 追加 .codebee/branch-plans.md 审计。"""
+    if n < 2:
+        return None
+    from . import modelhub, runner
+    if n < 2:
+        return None
+    orch = modelhub.resolve_orchestrator()
+    if not orch:
+        return None
+    prov, model = orch
+    prompt = (BRANCH_PLAN_PROMPT
+              .replace("__N__", str(n))
+              .replace("__GOAL__", goal[:600])
+              .replace("__OUTLINE__", outline_txt[:3000])
+              .replace("__PREV__", (prev or "（开篇）")[-1200:]))
+    res = modelhub.chat(prov["id"], model, prompt, max_tokens=4000, timeout=300)
+    if not res.get("ok"):
+        return None
+    data = runner.extract_json(res.get("text") or "")
+    branches = (data or {}).get("branches") if isinstance(data, dict) else None
+    if not isinstance(branches, list):
+        return None
+    usable = [b for b in branches
+              if isinstance(b, dict) and str(b.get("beats") or "").strip()]
+    if len(usable) < 2:
+        return None
+    try:
+        pick = int(data.get("pick") or 0)
+    except (TypeError, ValueError):
+        pick = 0
+    pick = max(0, min(pick, len(usable) - 1))
+    chosen = usable[pick]
+    try:
+        from . import store as _store
+        wd = _store.run_workdir(run_id) or ""
+    except Exception:
+        wd = ""
+    _append_audit(wd, i, usable, pick)
+    return (str(chosen["beats"]).strip()[:300],
+            str(chosen.get("hook") or "").strip()[:80] or None)
+
+
+def _append_audit(workdir, chapter, branches, pick):
+    """全部分支追加 .codebee/branch-plans.md（失败静默——审计是增强）。"""
+    if not workdir:
+        return
+    try:
+        p = os.path.abspath(os.path.join(str(workdir), ".codebee",
+                                         "branch-plans.md"))
+        root = os.path.abspath(str(workdir))
+        if root not in p.split(os.sep)[:-len([".codebee", "branch-plans.md"])]:
+            if not p.startswith(root + os.sep):
+                return
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "a", encoding="utf-8") as f:
+            if f.tell() == 0:
+                f.write("# 多线剧情推演（每章分支计划与择优，供回看）\n\n")
+            f.write("## 第 %d 章\n" % chapter)
+            for k, b in enumerate(branches):
+                mark = "✅ " if k == pick else ""
+                f.write("- %s%s（钩子：%s）——%s\n" % (
+                    mark, str(b.get("beats") or "")[:160],
+                    str(b.get("hook") or "")[:60],
+                    str(b.get("why") or "")[:120]))
+            f.write("\n")
+    except Exception:
+        pass

package/app/core/chaptersafe.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
+
+写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
+判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
+失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
+（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def atomic_write_chapter(workdir, i, text):
+    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
+    root = Path(workdir).resolve()
+    p = (root / ("chapter-%02d.md" % int(i))).resolve()
+    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
+    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
+    # 一并拒绝：workdir 必须是已存在的目录）
+    if root not in p.parents or not root.is_dir():
+        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
+    tmp = Path(str(p) + ".tmp")
+    try:
+        tmp.write_text(str(text), encoding="utf-8", errors="replace")
+        tmp.replace(p)
+    except BaseException:
+        try:
+            tmp.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+    return p

package/app/core/jobs.py

@@ -949,7 +949,7 @@ def _ai_repair(run_id, entry, ev, failed_cmd, orig_log):
               .replace("__OS__", _repair_os_label())
               .replace("__ALLOW__", " / ".join(p.strip() for p in _repair_allow())))
     step, log_abs = store.add_step(run_id, "ai-repair", agent["id"], agent.get("label"),
-                                   note="自动诊断修复")
+                                   note="自动诊断修复", model=agent.get("model") or "")
     res = runner.run_agent(agent, prompt, readonly=True, timeout=300,
                            cancel_event=ev, log_path=str(log_abs))
     try: