codebee 0.1.53 → 0.1.55

package/CHANGELOG.md

@@ -23,6 +23,23 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 - **首选 KEY 超限自动切备用了**：同厂商多密钥此前只认欠费类文案——首选 KEY 撞上 429 限流（智谱「并发数超过限制」「每分钟Token数已超过上限」、claude 的 rate_limit_error、codex 的 "429 Too Many Requests" 等）只记一笔错误、不进冷却，每个新步骤仍从超限的首选 KEY 重新烧起。现在限流文案与欠费同口径：进冷却 30 分钟、密钥镜像自动切下一把、链展开跳过冷却中的 KEY（到期或「恢复」按钮一键回首选）。顺带补一处漏账：无显式链时「换模型回退」的链条目不带 KEY 标记，这类重试失败此前完全不记 KEY 账。
 
+## v0.1.55（2026-09-23）
+
+- 知识库可信度分级：引用核验借鉴——知识条目带 confidence 分级，low 直接丢弃，中高按置信度加权注入
+- 编排执行稳定化 + 模型回退修复：调用链失败时的回退路径更稳
+- 定时任务终态徽章补全：done/failed/cancelled 三分支全可见（失败必须一眼看到）
+- 任务驾驶舱视觉改版；禅道 Bug 扫描过滤 + 去重防重录
+
+## 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 白烧

package/README.md

@@ -21,11 +21,10 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.53）
+### 最新版更新内容（v0.1.55）
 
-- 换将救活两类「假终态」：上游内容拒答（refusal）与真超时都会换链上下一个候选再试，不再整轮白烧
-- 同一慢上游连烧止损：连续两次相同超时即收手；取消绝不降级
-- 网关模型漂移可见：请求与实际服务的模型不一致时，失败信息明确标注
+- 知识库可信度分级：low 直接丢弃，注入按置信度加权
+- 编排执行稳定化 + 模型回退修复；定时任务终态徽章补全
 <!-- relnotes:end -->
 
 ---

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/builtin_agent.py

@@ -347,7 +347,7 @@ def _tool_write_file(workdir, args):
     return "已写入 %s（%d 字符，UTF-8）" % (rel, len(content))
 
 
-def _tool_run_command(workdir, args, cancel_event=None):
+def _tool_run_command(workdir, args, cancel_event=None, deadline=None):
     """本机执行一条 shell 命令，返回 (退出码, 合并输出)。
 
     薄适配层：执行/杀树/取消/解码全部复用 runner.run_process（shell_cmd 分支
@@ -364,7 +364,7 @@ def _tool_run_command(workdir, args, cancel_event=None):
         timeout = CMD_DEFAULT_TIMEOUT
     r = runner.run_process(shell_cmd=cmdline, cwd=os.path.abspath(workdir or "."),
                            timeout=max(5, min(timeout, CMD_MAX_TIMEOUT)),
-                           cancel_event=cancel_event)
+                           deadline=deadline, cancel_event=cancel_event)
     out = runner.clean_cli_text(
         (r.get("stdout") or "") + (("\n" + r["stderr"]) if r.get("stderr") else ""))
     limit = CMD_OUT_HEAD + CMD_OUT_TAIL
@@ -405,13 +405,13 @@ _TOOL_IMPL = {"list_files": _tool_list_files, "read_file": _tool_read_file,
               "write_file": _tool_write_file, "run_command": _tool_run_command}
 
 
-def _exec_tool(workdir, name, args, cancel_event=None):
+def _exec_tool(workdir, name, args, cancel_event=None, deadline=None):
     fn = _TOOL_IMPL.get(name or "")
     if fn is None:
         return "（未知工具: %s）" % name
     try:
         if name == "run_command":
-            return fn(workdir, args or {}, cancel_event=cancel_event)
+            return fn(workdir, args or {}, cancel_event=cancel_event, deadline=deadline)
         return fn(workdir, args or {})
     except Exception as e:
         return "工具执行失败: %s" % (e)
@@ -443,7 +443,20 @@ def _post_json(url, headers, body, allow_private, timeout):
     return modelhub._post_json_http(url, headers, body, allow_private, timeout=timeout)
 
 
-def _post_interruptible(url, headers, body, allow_private, timeout, cancel_event):
+def _call_with_optional_deadline(fn, args, kwargs, deadline):
+    """Keep older test/integration transport shims source-compatible."""
+    if deadline is None:
+        return fn(*args, **kwargs)
+    try:
+        return fn(*args, **kwargs, deadline=deadline)
+    except TypeError as exc:
+        if "unexpected keyword argument 'deadline'" not in str(exc):
+            raise
+        return fn(*args, **kwargs)
+
+
+def _post_interruptible(url, headers, body, allow_private, timeout, cancel_event,
+                        deadline=None):
     """可打断的模型调用：cancel_event 置位即刻放弃等待返回。
 
     单次生成最长可跑满 timeout，取消不能陪跑到自然结束——HTTP 交给守护
@@ -459,11 +472,13 @@ def _post_interruptible(url, headers, body, allow_private, timeout, cancel_event
 
     th = threading.Thread(target=_go, daemon=True)
     th.start()
-    if cancel_event is None:
-        th.join(timeout + 10)
-    else:
-        while th.is_alive() and not cancel_event.wait(0.5):
-            pass
+    wait_until = deadline if deadline is not None else time.monotonic() + timeout + 10
+    while th.is_alive():
+        if cancel_event is not None and cancel_event.is_set():
+            break
+        if time.monotonic() >= wait_until:
+            return 0, None, ("任务总时限已到" if deadline is not None else "响应超时")
+        th.join(0.5)
     if cancel_event is not None and cancel_event.is_set():
         return 0, None, "已取消"
     return box.get("r") or (0, None, "无响应")
@@ -641,7 +656,8 @@ def _calls_from_acc(acc):
 
 
 def _post_sse_stream(url, headers, body, allow_private, timeout, proto,
-                     on_reason=None, on_text=None, on_tick=None, cancel_event=None):
+                     on_reason=None, on_text=None, on_tick=None, cancel_event=None,
+                     deadline=None):
     """流式（SSE）模型调用 → dict(status/text/reasoning/calls/usage/error/events)。
 
     与 _post_interruptible 同款的可打断语义：读取放守护线程，cancel_event 置位
@@ -717,11 +733,13 @@ def _post_sse_stream(url, headers, body, allow_private, timeout, proto,
 
     th = threading.Thread(target=_go, daemon=True)
     th.start()
-    if cancel_event is None:
-        th.join(timeout + 10)
-    else:
-        while th.is_alive() and not cancel_event.wait(0.5):
-            pass
+    wait_until = deadline if deadline is not None else time.monotonic() + timeout + 10
+    while th.is_alive():
+        if cancel_event is not None and cancel_event.is_set():
+            break
+        if time.monotonic() >= wait_until:
+            break
+        th.join(0.5)
     with lock:
         out = {"status": box["status"], "text": acc["text"],
                "reasoning": acc["reasoning"], "usage": dict(acc["usage"]),
@@ -731,7 +749,9 @@ def _post_sse_stream(url, headers, body, allow_private, timeout, proto,
         out["error"], out["status"] = "已取消", 0
         return out
     if th.is_alive():
-        out["error"], out["status"] = "响应超时", 0
+        out["error"], out["status"] = ("任务总时限已到" if deadline is not None
+                                         else "响应超时"), 0
+        out["deadline_exceeded"] = deadline is not None
     return out
 
 
@@ -903,7 +923,7 @@ def _norm_usage(usage):
 
 
 def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=None,
-        on_reason=None, on_stream=None, on_activity=None, stream=True):
+        on_reason=None, on_stream=None, on_activity=None, stream=True, deadline=None):
     """跑一次内置智能体（内部自带工具循环直到给出最终回答）。
 
     bi: resolve() 的返回；prompt: 本轮完整输入（目标/续轮块由 pipeline 拼）；
@@ -943,6 +963,14 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
     escalated = False       # 本轮 run 是否已提额（只提一次，防无限翻倍）
     empty_streak = 0        # 连续零正文轮数（拿到正文/工具即清零）
 
+    def _deadline_fail():
+        return {"ok": False, "text": "", "usage": dict(total_usage),
+                "error": "任务总时限已到", "model": model,
+                "provider_name": bi["provider_name"],
+                "provider_id": bi["provider_id"], "iterations": iters,
+                "cost_usd": 0.0, "reasoning": "\n\n".join(r for r in reasons if r)[:THINK_MAX_CHARS],
+                "raw": {"timed_out": True, "deadline_exceeded": True}}
+
     def _fire(cb, *cb_args):
         if cb is None:
             return
@@ -968,6 +996,8 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
                 "reasoning": "\n\n".join(r for r in reasons if r)[:THINK_MAX_CHARS]}
 
     for it in range(1, MAX_TOOL_ITERS + 1):
+        if deadline is not None and time.monotonic() >= deadline:
+            return _deadline_fail()
         if cancel_event is not None and cancel_event.is_set():
             return _fail("已取消")
         reasons.append("")   # 每轮迭代各占一段思考（跨轮拼接时分段，join 时滤空段）
@@ -981,6 +1011,10 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
                     got = False        # 本 KEY 拿到了响应（区别于 HTTP 失败换下家）
                     stripped = False   # thinking 对象被网关 400 拒后已摘除重发
                     while True:
+                        if deadline is not None and time.monotonic() >= deadline:
+                            return _deadline_fail()
+                        req_timeout = min(float(timeout), max(0.1, deadline - time.monotonic())) \
+                            if deadline is not None else timeout
                         url, headers, body = _build_request(
                             proto, pbase, kk["key"], model, system, msgs,
                             tools_ok, max_tokens=max_tokens)
@@ -1011,10 +1045,13 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
                         text, calls, usage = "", [], {}
                         streamed = False
                         if sbody is not None:
-                            part = _post_sse_stream(
-                                url, headers, sbody, allow_private, timeout, proto,
-                                on_reason=_take_reason, on_text=on_stream,
-                                cancel_event=cancel_event)
+                            part = _call_with_optional_deadline(
+                                _post_sse_stream,
+                                (url, headers, sbody, allow_private, req_timeout, proto),
+                                {"on_reason": _take_reason, "on_text": on_stream,
+                                 "cancel_event": cancel_event}, deadline)
+                            if part.get("deadline_exceeded"):
+                                return _deadline_fail()
                             if part["error"] == "已取消":
                                 return _fail("已取消")
                             if not part["error"] and part["events"]:
@@ -1032,9 +1069,12 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
                                 # 供应商稳妥；非流式也失败才走下面的记账/换链。
                                 last_err = part["error"]
                         if not streamed:
-                            status, data, err = _post_interruptible(url, headers, body,
-                                                                    allow_private, timeout,
-                                                                    cancel_event)
+                            status, data, err = _call_with_optional_deadline(
+                                _post_interruptible,
+                                (url, headers, body, allow_private, req_timeout, cancel_event),
+                                {}, deadline)
+                            if err == "任务总时限已到":
+                                return _deadline_fail()
                             if cancel_event is not None and cancel_event.is_set():
                                 # 取消先于一切记账：健康 KEY 不能因被放弃的请求背上冷却
                                 return _fail("已取消")
@@ -1080,7 +1120,8 @@ def run(bi, prompt, workdir, timeout=180, cancel_event=None, log=None, images=No
                         _fire(on_activity, "请求工具: " + "、".join(c["name"] for c in calls))
                         results = []
                         for c in calls:
-                            out = _exec_tool(workdir, c["name"], c["args"], cancel_event)
+                            out = _exec_tool(workdir, c["name"], c["args"], cancel_event,
+                                             deadline=deadline)
                             if log:
                                 brief = out if len(out) <= 120 else out[:120] + "…"
                                 log("[工具] %s → %s" % (c["name"], brief.replace("\n", " ⏎ ")))

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

@@ -19,6 +19,7 @@ from __future__ import annotations
 import queue
 import sys
 import threading
+import time
 import traceback
 
 # 仅保留给旧测试/诊断代码观察；生产 enqueue 永远不向这里写入。
@@ -323,6 +324,16 @@ def _requeue_await_slot(job, waits_left=None):
         # 带着全新重试额度重新入队，封顶永远打不中）。仍满载则续下一拍。
         with _timer_lock:
             _deferred_timers.pop(run_id, None)
+        try:
+            from . import store
+            run = store.get_run(run_id) or {}
+            deadline_at = run.get("deadline_at")
+            if deadline_at is not None and float(deadline_at) <= time.time():
+                store.update_run(run_id, expected_status="queued", status="timeout",
+                                 ended_at=_now(), error="任务总时限已到（排队等待期间）")
+                return
+        except (TypeError, ValueError, AttributeError):
+            pass
         try:
             started = _try_start_once(job)
         except DuplicateJobError:
@@ -774,11 +785,19 @@ def requeue_pending(limit=10, max_age_s=None):
 
 def workers_info():
     with _pool_lock:
-        return {"target": _target, "alive": _alive,
+        info = {"target": _target, "alive": _alive,
                 "chat_alive": _chat_alive, "chat_pool": CHAT_POOL,
-                "queued": 0,
                 "available": 0 if _restart_drain else max(0, _target - _alive),
                 "mode": "restart-drain" if _restart_drain else "direct"}
+    # queued runs are deliberately persisted rather than held in _QUEUE. Report
+    # the same source the board renders so capacity waits are observable.
+    try:
+        from . import store
+        info["queued"] = sum(1 for run in store.list_runs(None)
+                             if run.get("status") == "queued")
+    except Exception:
+        info["queued"] = 0
+    return info
 
 
 def _drain_test_queue():
@@ -949,7 +968,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:

package/app/core/knowledge.py

@@ -97,7 +97,7 @@ _NEAR_DUP_SIM = 0.8    # 同 scope 标题包含度 ≥0.8 视为同一条（近
 
 
 def upsert_entry(scope, title, body, tags=None, source="", source_file="",
-                 as_of=None, status="draft"):
+                 as_of=None, status="draft", confidence=None):
     """写入/合并一条知识。同 scope 同标题视为同一条（指纹去重）：
     - 已有条目是 approved 且新条是 draft：不覆盖正文（人工确认过的内容优先），
       新内容记入 revisions 作为修订候选，seen+1；
@@ -145,6 +145,8 @@ def upsert_entry(scope, title, body, tags=None, source="", source_file="",
             it["tags"] = (it.get("tags") or [])[:8]
             if as_of:
                 it["as_of"] = str(as_of)[:10]
+            if confidence:   # 合并时也可提升/回落置信度（high 覆盖 medium 合理）
+                it["confidence"] = confidence
             if source:
                 it["source"] = source
             if source_file:
@@ -156,6 +158,7 @@ def upsert_entry(scope, title, body, tags=None, source="", source_file="",
               "tags": tags, "status": status, "enabled": True,
               "source": source, "source_file": source_file,
               "as_of": str(as_of or _now()[:10])[:10],
+              "confidence": confidence or "medium",
               "revisions": [], "hits": 0, "seen": 1,
               "created_at": _now(), "updated_at": _now(), "kind": "knowledge"}
         items.append(it)
@@ -277,10 +280,17 @@ KNOWLEDGE_PROMPT = """你是编排系统的知识管理员。下面是一次任
 - fact：回答「是什么」，只含领域事实、外部规则和可验证结论，进入知识库；
 - practice：回答「怎么做」，含流程、操作方法和正向实践，进入经验库；此类必须填写 category。
 「下次要避免什么」这类负面教训由评审复盘流程负责，不要重复提炼。
+
+**可信度分级（引用核验借鉴）**：每条 fact 必须给出 confidence：
+- "high"：产出材料中有明确来源/数据支撑（引用了来源、给了数字口径）；
+- "medium"：材料内部自洽但未标来源（模型整理所得）；
+- "low"：你不确定、可能过时或与材料其他部分矛盾——这类宁可不要，直接丢弃。
+fact 缺 confidence 视为 medium。
+
 只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"entries": [{"kind": "fact 或 practice", "title": "≤20 字的标题", "body": "具体内容（≤200 字，自含上下文，脱离本次任务也能看懂）", "category": "practice 的经验分类", "tags": ["1-3 个检索标签"], "as_of": "YYYY-MM-DD（fact 的事实采集日）"}]}
+{"entries": [{"kind": "fact 或 practice", "title": "≤20 字的标题", "body": "具体内容（≤200 字，自含上下文，脱离本次任务也能看懂）", "category": "practice 的经验分类", "tags": ["1-3 个检索标签"], "as_of": "YYYY-MM-DD（fact 的事实采集日）", "confidence": "high/medium/low（fact 必填）"}]}
 category 只能从以下枚举选择：__CATEGORIES__。
-最多 3 条，只保留有明确复用价值的；产出里没有值得沉淀的就返回空数组。
+最多 3 条，只保留有明确复用价值的；low 置信的直接丢弃；产出里没有值得沉淀的就返回空数组。
 
 ## 任务类型
 __TYPE__
@@ -381,12 +391,19 @@ def learn_from_run(run_id):
                                         dim="%s %s" % (x["title"], x["body"])):
                     n += 1
                 continue
+            # 可信度分级（引用核验借鉴）：low 直接丢弃（宁缺毋滥），
+            # 其余归一 high/medium 并随条目落盘；缺失视为 medium
+            conf = str(x.get("confidence") or "medium").strip().lower()
+            if conf not in ("high", "medium"):
+                if conf == "low":
+                    continue
+                conf = "medium"
             as_of = str(x.get("as_of") or "").strip()
             if not re.match(r"^\d{4}-\d{2}-\d{2}$", as_of):
                 as_of = _now()[:10]
             if upsert_entry(task.get("type") or "*", x["title"], x["body"],
                             tags=x.get("tags"), source=run_id,
-                            as_of=as_of, status="approved"):
+                            as_of=as_of, status="approved", confidence=conf):
                 n += 1
     except Exception:
         return n