codebee 0.1.50 → 0.1.51

package/app/core/router.py

@@ -1,15 +1,18 @@
-# -*- coding: utf-8 -*-
-"""智能路由：能力基线 × 历史胜率 × 角色约束 → 选智能体，并给出可解释的理由。"""
-from __future__ import annotations
-
+# -*- coding: utf-8 -*-
+"""智能路由：能力基线 × 历史胜率 × 角色约束 → 选智能体，并给出可解释的理由。"""
+from __future__ import annotations
+
+import os
+import re
+
 from . import dispatch, history
-
-# 各类智能体的能力基线（0-100）。真实 CLI 里官方双雄最高。
-CAPABILITY = {
-    "codex": 84, "claude": 84, "opencode": 74, "qwen": 72,
-    "aider": 70, "openclaw": 60, "generic": 55, "mock": 10,
-}
-
+
+# 各类智能体的能力基线（0-100）。真实 CLI 里官方双雄最高。
+CAPABILITY = {
+    "codex": 84, "claude": 84, "opencode": 74, "qwen": 72,
+    "aider": 70, "openclaw": 60, "generic": 55, "mock": 10,
+}
+
 MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
 AUTO_CRITIC_LIMIT = 2  # 自动内容评审只取综合分前两名；手工模式仍尊重完整名单
 
@@ -19,35 +22,43 @@ def _task_type(ttype):
     if isinstance(ttype, dict):
         return str(ttype.get("type") or ttype.get("dimension") or "direct")
     return str(ttype or "direct")
-
-
+
+
 def _binding_bonus(agent_id, dispatch_mode=False):
-    """绑定链可用性加分/减分：链上有可用条目 +8，解析为空 -25。2026-09-16 实测：
-    静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，绑定空的 CLI 更是连
-    用户配置的模型都没用上——先按「能不能按配置跑起来」校准。2026-09-17 起
-    空链步骤在 pipeline 直接判失败（不再静默回落本机默认），此处只管排序。"""
-    try:
-        from . import modelhub
+    """绑定链可用性加分/减分：解析出的调用链有备胎（≥2 条）+8；单条 = 单点
+    无降级空间 +0；解析为空 -25。2026-09-16 实测：静态能力基线让配额烧干的
+    codex 永远压过健康备用 CLI，绑定空的 CLI 更是连用户配置的模型都没用上
+    ——先按「能不能按配置跑起来」校准。2026-09-22 续修：单条链（含空链+
+    仅 provider_id 的旧数据）拿过 +8 是信号失真——2026-09-22 智谱余额清零
+    实测「绑定链可用」的 claude/kimi 全是单点，无一家有第二口气。返回
+    (分值, 理由文本)。"""
+    try:
+        from . import modelhub
         pref = modelhub._binding_for(agent_id)
         configured = bool(modelhub._binding_chain(pref) or pref.get("provider_id"))
         if not configured:
-            return 0.0 if dispatch_mode else -25.0
+            return (0.0, "") if dispatch_mode else (-25.0, "，绑定链为空：相关步骤将判失败（-25.0）")
         b = modelhub.resolve_binding(agent_id)
-        return 8.0 if (b and b.get("call_chain")) else -25.0
-    except Exception:
-        return 0.0
-
-
+        n = len((b or {}).get("call_chain") or [])
+        if n >= 2:
+            return 8.0, "，绑定链可用（+8.0）"
+        if n == 1:
+            return 0.0, "，绑定单点无备胎（+0）"
+        return -25.0, "，绑定链为空：相关步骤将判失败（-25.0）"
+    except Exception:
+        return 0.0, ""
+
+
 def _history_bonus(stats, agent_id, ttype):
-    s = (stats.get(agent_id) or {}).get(ttype) or {}
-    if not s.get("runs"):
-        return 0.0
-    runs = s["runs"]
-    win_rate = s["wins"] / runs
-    # 胜率为主，经验为辅；败率要扣分且随样本量爬满（前 3 次线性加权，防一次
-    # 偶发失败把智能体埋了）。0/3 全败 = -18：常挂的 CLI 必须排到无历史的新
-    # 面孔之后（2026-09-17 前败率不扣分，0/3 还拿 +6 经验分，比没跑过还高）。
-    loss_penalty = 24.0 * (1.0 - win_rate) * min(1.0, runs / 3.0)
+    s = (stats.get(agent_id) or {}).get(ttype) or {}
+    if not s.get("runs"):
+        return 0.0
+    runs = s["runs"]
+    win_rate = s["wins"] / runs
+    # 胜率为主，经验为辅；败率要扣分且随样本量爬满（前 3 次线性加权，防一次
+    # 偶发失败把智能体埋了）。0/3 全败 = -18：常挂的 CLI 必须排到无历史的新
+    # 面孔之后（2026-09-17 前败率不扣分，0/3 还拿 +6 经验分，比没跑过还高）。
+    loss_penalty = 24.0 * (1.0 - win_rate) * min(1.0, runs / 3.0)
     return round(18.0 * win_rate + min(6.0, runs) - loss_penalty, 1)
 
 
@@ -79,20 +90,15 @@ def _online_bonus(agent, role, ttype):
 
 
 def score(agent, role, ttype, stats=None):
-    """返回 (总分, 理由字符串)。配额惩罚：catalog 里配了
-    quota_tokens_per_hour 的智能体，本小时用量越接近配额分越低
-    （封顶 -45，足以盖过历史加分），满额后仅在没有其他选择时才会被选中。"""
+    """返回 (总分, 理由字符串)。配额惩罚：catalog 里配了
+    quota_tokens_per_hour 的智能体，本小时用量越接近配额分越低
+    （封顶 -45，足以盖过历史加分），满额后仅在没有其他选择时才会被选中。"""
     stats = stats or {}
     ttype = _task_type(ttype)
-    base = CAPABILITY.get(agent.get("kind"), 60)
+    base = CAPABILITY.get(agent.get("kind"), 60)
     use_dispatch = bool(agent.get("_dispatch_task_type") or
                         agent.get("dispatch_enabled"))
-    bb = _binding_bonus(agent.get("id"), dispatch_mode=use_dispatch)
-    btxt = ""
-    if bb > 0:
-        btxt = "，绑定链可用（+%s）" % bb
-    elif bb < 0:
-        btxt = "，绑定链为空：相关步骤将判失败（%s）" % bb
+    bb, btxt = _binding_bonus(agent.get("id"), dispatch_mode=use_dispatch)
     hb = _history_bonus(stats, agent.get("id"), ttype)
     online, online_txt = _online_bonus(agent, role, ttype)
     # 保持公开 score() 的历史绝对分值；运行级候选由 pipeline 标记画像后
@@ -100,41 +106,120 @@ def score(agent, role, ttype, stats=None):
     affinity, affinity_txt = (dispatch.agent_affinity(agent.get("kind"), ttype, role)
                               if use_dispatch else (0.0, "兼容模式"))
     total = base + bb + hb + affinity + online
-    hs = (stats.get(agent.get("id")) or {}).get(ttype)
-    htxt = ("，历史 %d/%d 胜（%s）" % (hs["wins"], hs["runs"], "%+.1f" % hb)) if hs else "，无历史记录"
-    quota_txt = ""
-    quota = int(agent.get("quota_tokens_per_hour") or 0)
-    if quota > 0:
-        try:
-            from . import usage
-            used = usage.agent_tokens_recent(agent.get("id"), hours=1)
-        except Exception:
-            used = 0
-        if used > 0:
-            ratio = min(1.0, used / float(quota))
-            penalty = round(-45.0 * ratio, 1)
-            if penalty:
-                total += penalty
-                quota_txt = "，本小时 %d/%d tokens（%s）" % (used, quota, penalty)
+    hs = (stats.get(agent.get("id")) or {}).get(ttype)
+    htxt = ("，历史 %d/%d 胜（%s）" % (hs["wins"], hs["runs"], "%+.1f" % hb)) if hs else "，无历史记录"
+    quota_txt = ""
+    quota = int(agent.get("quota_tokens_per_hour") or 0)
+    if quota > 0:
+        try:
+            from . import usage
+            used = usage.agent_tokens_recent(agent.get("id"), hours=1)
+        except Exception:
+            used = 0
+        if used > 0:
+            ratio = min(1.0, used / float(quota))
+            penalty = round(-45.0 * ratio, 1)
+            if penalty:
+                total += penalty
+                quota_txt = "，本小时 %d/%d tokens（%s）" % (used, quota, penalty)
     return total, "能力基线 %d，%s%s%s%s%s，总分 %s" % (
         base, affinity_txt, btxt, htxt, online_txt, quota_txt, round(total, 1))
-
-
+
+
 def pick(agents, role, ttype, stats=None, exclude=()):
-    """按分选出最优智能体。返回 (agent, 理由) 或 (None, "")。"""
-    stats = stats or history.agent_stats()
-    best, best_reason = None, ""
-    for a in agents:
-        if a["id"] in exclude:
-            continue
-        total, reason = score(a, role, ttype, stats)
-        if best is None or total > best[0]:
-            best, best_reason = (total, a), reason
-    if best is None:
-        return None, ""
+    """按分选出最优智能体。返回 (agent, 理由) 或 (None, "")。"""
+    stats = stats or history.agent_stats()
+    best, best_reason = None, ""
+    for a in agents:
+        if a["id"] in exclude:
+            continue
+        total, reason = score(a, role, ttype, stats)
+        if best is None or total > best[0]:
+            best, best_reason = (total, a), reason
+    if best is None:
+        return None, ""
     return best[1], best_reason
 
 
+# 空链 CLI 的真实上游在各自本机配置里（注册表里的 provider_id 是 UI 残留，
+# 2026-09-22 实测 qwencode 注册表指 prov-36 本机却指公司网关）。正则探针
+# 只为换将时识别「同上游」，读不到就算未知——未知不参与剔除，宁白试不误杀。
+_LOCAL_ENDPOINT_PROBES = (
+    ("kimi-code", "~/.kimi-code/config.toml", r'baseUrl\s*=\s*"([^"]+)"'),
+    ("claude-code", "~/.claude/settings.json", r'"ANTHROPIC_BASE_URL"\s*:\s*"([^"]+)"'),
+    ("qwencode", "~/.qwen/settings.json", r'"OPENAI_BASE_URL"\s*:\s*"([^"]+)"'),
+    ("opencode", "~/.config/opencode/opencode.json", r'"baseURL"\s*:\s*"([^"]+)"'),
+    ("opencode", "~/.config/opencode/opencode.jsonc", r'"baseURL"\s*:\s*"([^"]+)"'),
+    ("codex-cli", "~/.codex/config.toml", r'base_url\s*=\s*"([^"]+)"'),
+)
+
+
+def _host_of(url):
+    """上游归一：只留 host:port。/api/anthropic 与 /v1 的路径差异不算换上游。"""
+    m = re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://([^/?#]+)", str(url or "").strip())
+    return m.group(1).lower() if m else ""
+
+
+def agent_upstreams(agent_id):
+    """候选实际会用到的上游集合（host:port 归一）。显式链 > CLI 本机配置
+    端点；两者都拿不到返回空集 = 未知。"""
+    ups = set()
+    try:
+        from . import modelhub
+        pref = modelhub._binding_for(agent_id)
+        chain = modelhub._binding_chain(pref)
+        provs = {p.get("id"): p for p in modelhub.providers()}
+        if chain:
+            for item in chain:
+                pid = (item.get("provider_id") or "").strip()
+                h = _host_of((provs.get(pid) or {}).get("base_url"))
+                if h:
+                    ups.add(h)
+    except Exception:
+        pass
+    if not ups:
+        for aid, path, pat in _LOCAL_ENDPOINT_PROBES:
+            if aid != agent_id:
+                continue
+            try:
+                with open(os.path.expanduser(path), "r", encoding="utf-8",
+                          errors="ignore") as fh:
+                    txt = fh.read()
+            except OSError:
+                continue
+            for m in re.finditer(pat, txt):
+                h = _host_of(m.group(1))
+                if h:
+                    ups.add(h)
+    return ups
+
+
+def pick_switch_candidate(agents, role, ttype, stats, exclude=(),
+                          dead_upstreams=()):
+    """换将选将。配额类死亡背景下：与死者同上游的候选依次让位，直到找到
+    异上游/上游未知的候选（2026-09-22 实案：kimi 与 claude 同骑智谱，0.1 分
+    之差把异上游 qwencode 压在下面，换将=换壳不换命）。异上游耗尽后同上游
+    候选捡回分数最高者——聊胜于无。"""
+    exclude = set(exclude)
+    best, reason = pick(agents, role, ttype, stats, exclude=exclude)
+    if best is None or not dead_upstreams:
+        return best, reason
+    deferred = []
+    while best is not None:
+        ups = agent_upstreams(best.get("id"))
+        if not (ups and any(ups & dead for dead in dead_upstreams)):
+            break  # 异上游或上游未知：就用它
+        deferred.append((best, reason))
+        best, reason = pick(agents, role, ttype, stats, exclude=exclude | {
+            x.get("id") for x, _ in deferred})
+    if best is None and deferred:
+        best, reason = deferred[0]  # 异上游全灭：同上游里挑最高的顶上
+    elif deferred:
+        reason = ("%s（%s 与死者同上游，延后让位异上游候选）"
+                  % (reason, deferred[-1][0].get("id")))
+    return best, reason
+
+
 def route_plan(agents, role, task_spec, stats=None, exclude=(), selected=None,
                participants=(), selection_reason=""):
     """生成可审计的候选排序，并可用实际选路覆盖评分预选结果。"""
@@ -177,31 +262,31 @@ def route_plan(agents, role, task_spec, stats=None, exclude=(), selected=None,
             "candidates": rows,
             "fallback": [x["agent_id"] for x in rows
                          if x["agent_id"] not in active_ids]}
-
-
-def pick_reviewer(agents, impl, ttype, stats=None):
-    """评审者：跨厂商是硬规则（Codeband 的对抗式配对）——同族评审有同款盲区，
-    评审者必须来自与实现者不同的 kind；跨族池为空才回退同厂商并如实备注，
-    绝不把回退伪装成跨厂商。"""
-    stats = stats or history.agent_stats()
-    impl_kind = impl.get("kind")
-    real = [a for a in agents if a.get("mode") == "real" and a["id"] != impl["id"]]
-    cross = [a for a in real if a.get("kind") != impl_kind]
-    if cross:
-        best = max(cross, key=lambda a: score(a, "review", ttype, stats)[0])
-        _, reason = score(best, "review", ttype, stats)
-        return best, "跨厂商评审（%s ≠ %s）：%s" % (best.get("kind"), impl_kind, reason)
-    if real:
-        best = max(real, key=lambda a: score(a, "review", ttype, stats)[0])
-        _, reason = score(best, "review", ttype, stats)
-        return best, ("（无跨厂商智能体可用，回退同厂商 %s 评审——建议启用其他厂商的 CLI）"
-                      % impl_kind) + reason
-    mb = next((a for a in agents if a["id"] == "mock-b"), None)
-    if mb and impl.get("mode") != "mock":
-        return mb, "（无第二个真实智能体，用 mock 评审）"
-    return impl, "（自评：仅有实现者一个智能体可用）"
-
-
+
+
+def pick_reviewer(agents, impl, ttype, stats=None):
+    """评审者：跨厂商是硬规则（Codeband 的对抗式配对）——同族评审有同款盲区，
+    评审者必须来自与实现者不同的 kind；跨族池为空才回退同厂商并如实备注，
+    绝不把回退伪装成跨厂商。"""
+    stats = stats or history.agent_stats()
+    impl_kind = impl.get("kind")
+    real = [a for a in agents if a.get("mode") == "real" and a["id"] != impl["id"]]
+    cross = [a for a in real if a.get("kind") != impl_kind]
+    if cross:
+        best = max(cross, key=lambda a: score(a, "review", ttype, stats)[0])
+        _, reason = score(best, "review", ttype, stats)
+        return best, "跨厂商评审（%s ≠ %s）：%s" % (best.get("kind"), impl_kind, reason)
+    if real:
+        best = max(real, key=lambda a: score(a, "review", ttype, stats)[0])
+        _, reason = score(best, "review", ttype, stats)
+        return best, ("（无跨厂商智能体可用，回退同厂商 %s 评审——建议启用其他厂商的 CLI）"
+                      % impl_kind) + reason
+    mb = next((a for a in agents if a["id"] == "mock-b"), None)
+    if mb and impl.get("mode") != "mock":
+        return mb, "（无第二个真实智能体，用 mock 评审）"
+    return impl, "（自评：仅有实现者一个智能体可用）"
+
+
 def pick_critics(agents, ttype, stats=None, impl=None):
     """自动内容评审组选综合分前两名（排除作者本人）。
 
@@ -214,9 +299,9 @@ def pick_critics(agents, ttype, stats=None, impl=None):
         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")
-        return real, note
-    mocks = [a for a in agents if a.get("mode") == "mock"] or agents[:2]
-    return mocks, "（无真实智能体，用内置 mock 演示）"
+        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")
+        return real, note
+    mocks = [a for a in agents if a.get("mode") == "mock"] or agents[:2]
+    return mocks, "（无真实智能体，用内置 mock 演示）"

package/app/core/runner.py

@@ -903,6 +903,33 @@ def _rate_limited(err):
     return any(k in err for k in _RATE_LIMIT)
 
 
+# 审计日志错误行探针：只认强信号，避免把回显提示词里的普通词当错误
+_LOG_ERR_HINT = re.compile(
+    r"(429|402|rate[_ ]?limit|quota|余额|欠费|insufficient|billing|arrears"
+    r"|ENOTFOUND|ECONNREFUSED|failed to run prompt|api_error|overloaded)",
+    re.I)
+
+
+def _augment_error_from_log(out, log_path, limit=300):
+    """stdout/stderr 尾段没有错误信号时，从流式审计日志里补最后一条错误行。
+    真错误有时只走流式管道（kimi 撞 429 时捕获输出只剩启动横幅），不补的
+    话路由层与用户都只看到「退出码 1；stderr/stdout: kimi version 2.0.2」。"""
+    if not log_path or not out.get("error"):
+        return
+    try:
+        with open(log_path, "rb") as fh:
+            fh.seek(0, 2)
+            size = fh.tell()
+            fh.seek(max(0, size - 8192))
+            blob = fh.read().decode("utf-8", "ignore")
+    except OSError:
+        return
+    hits = [ln.strip() for ln in blob.splitlines() if _LOG_ERR_HINT.search(ln)]
+    if not hits:
+        return
+    out["error"] = (out["error"] + "；日志错误行: " + hits[-1][:limit])[-800:]
+
+
 def _grace_wait(cancel_event, seconds, log_path=None, why=""):
     """链尾限流宽限等待：小片睡眠随时响应取消。返回 False=已取消（别再重试）。"""
     if log_path:
@@ -1370,6 +1397,13 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                                 pass
                     except Exception:
                         pass
+                if not (_quota_error(out["error"]) or _transient_error(out["error"])
+                        or _rate_limited(out["error"])):
+                    # 尾段清洗后没有错误信号而流式审计日志里有：补日志错误行。
+                    # 2026-09-22 实测 kimi 撞 429 时 stderr/stdout 只剩启动横幅
+                    # （真错误只走了流式管道），路由层看不到配额关键词，换将
+                    # 判死因全靠猜。
+                    _augment_error_from_log(out, log_path)
                 out["error_code"] = _classify_failure(res, kind=kind)
                 break
             if kind == "codex":

package/app/core/settings.py

@@ -33,9 +33,10 @@ DEFAULTS = {"max_concurrent_jobs": 12, "default_workdir": "", "hooks_token": "",
 # 桌宠形象白名单（与 app/pet.py 的 SKINS 对齐；这里不 import pet 模块，避免
 # core 反向依赖 app 根目录脚本）
 PET_SKINS = ("plush", "robot")
-# 并发保护上限 12：任务有空位即直接启动，满载明确返回忙，不进入等待队列；
-# 同任务单飞守卫在 jobs 层。默认取上限，对齐「默认不排队」的使用预期。
-MIN_WORKERS, MAX_WORKERS = 1, 12
+# 并发保护上限 24：编排任务有空位即直接启动，满载回滚 queued 排队自动补跑，
+# 不秒判失败；同任务单飞守卫在 jobs 层。该上限保护的是本机资源（CLI 子进程
+# 数），与各 API 厂商的限流无关；direct 对话走 jobs 轻量池不占此额度。
+MIN_WORKERS, MAX_WORKERS = 1, 24
 
 
 def builtin_workdir():

package/app/core/skills.py

@@ -300,11 +300,26 @@ def list_lessons(scope=None, only_enabled=False, category=None):
     return items
 
 
+def _title_containment(a, b):
+    """标题近似度：字符 bigram 包含度（交集/较短者）。与 knowledge._title_sim
+    同款度量（追加后缀形态 Jaccard 漏、包含度=1.0），教训/知识去重口径一致。"""
+    ga, gb = _text_bigrams(a), _text_bigrams(b)
+    if not ga or not gb:
+        return 0.0
+    return len(ga & gb) / float(min(len(ga), len(gb)))
+
+
+_LESSON_NEAR_DUP = 0.8   # 同 scope 教训标题包含度 ≥0.8 视为同一条（近似题合并）
+
+
 def upsert_lesson(scope, title, content, source="", category=None, dim=None):
     """写入/合并一条教训：同 scope 同标题视为同一条（seen+1，内容取新的）。
 
     category 为闭集枚举之一（见 LESSON_CATEGORIES）；输入非法时退到 dim 关键词映射，
     仍归不出则落「未分类」。id 仍只按 scope+标题哈希，故老教训再沉淀会合并而非分裂。
+    近似题合并（与知识库同款防膨胀）：自动复盘每次 done 运行都跑，「节奏拖沓」与
+    「节奏拖沓问题」会各占一条；同 scope 标题包含度 ≥0.8 也视为同一条，合并语义
+    与精确同题一致。<4 字符短题只认精确（bigram 噪声大）。
     """
     title = str(title or "").strip()[:60]
     content = str(content or "").strip()[:1200]
@@ -315,18 +330,27 @@ def upsert_lesson(scope, title, content, source="", category=None, dim=None):
     with _LOCK:
         data = _load()
         items = data.setdefault("lessons", [])
-        for it in items:
-            if it.get("id") == lid:
-                it["content"] = content
-                it["seen"] = int(it.get("seen") or 1) + 1
-                it["updated_at"] = _now()
-                # 合并时不降级已有分类：除非本次归到了明确类别，或该条原本没有分类
-                if cat != LESSON_UNCATEGORIZED or not it.get("category"):
-                    it["category"] = cat
-                if source:
-                    it["source"] = source
-                _save(data)
-                return it
+        hit = next((x for x in items if x.get("id") == lid), None)
+        if hit is None and len(title) >= 4:
+            for x in items:
+                if x.get("scope") != scope:
+                    continue
+                xt = str(x.get("title") or "")
+                if len(xt) >= 4 and _title_containment(title, xt) >= _LESSON_NEAR_DUP:
+                    hit = x
+                    break
+        if hit is not None:
+            it = hit
+            it["content"] = content
+            it["seen"] = int(it.get("seen") or 1) + 1
+            it["updated_at"] = _now()
+            # 合并时不降级已有分类：除非本次归到了明确类别，或该条原本没有分类
+            if cat != LESSON_UNCATEGORIZED or not it.get("category"):
+                it["category"] = cat
+            if source:
+                it["source"] = source
+            _save(data)
+            return it
         it = {"id": lid, "scope": scope, "title": title, "content": content,
               "source": source, "hits": 0, "seen": 1, "enabled": True,
               "category": cat,