codebee 0.1.54 → 0.1.56

package/CHANGELOG.md

@@ -23,6 +23,19 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 - **首选 KEY 超限自动切备用了**：同厂商多密钥此前只认欠费类文案——首选 KEY 撞上 429 限流（智谱「并发数超过限制」「每分钟Token数已超过上限」、claude 的 rate_limit_error、codex 的 "429 Too Many Requests" 等）只记一笔错误、不进冷却，每个新步骤仍从超限的首选 KEY 重新烧起。现在限流文案与欠费同口径：进冷却 30 分钟、密钥镜像自动切下一把、链展开跳过冷却中的 KEY（到期或「恢复」按钮一键回首选）。顺带补一处漏账：无显式链时「换模型回退」的链条目不带 KEY 标记，这类重试失败此前完全不记 KEY 账。
 
+## v0.1.56（2026-09-23）
+
+- 鉴权错误不再触发换将：密钥失效类错误换哪个 CLI 都一样，直接报错省时间
+- 超时任务提供「恢复」入口；排队任务状态文案更明确
+- 驾驶舱轮询载荷瘦身（大屏常开不再吃带宽）；移动端任务详情操作按钮对齐
+
+## v0.1.55（2026-09-23）
+
+- 知识库可信度分级：引用核验借鉴——知识条目带 confidence 分级，low 直接丢弃，中高按置信度加权注入
+- 编排执行稳定化 + 模型回退修复：调用链失败时的回退路径更稳
+- 定时任务终态徽章补全：done/failed/cancelled 三分支全可见（失败必须一眼看到）
+- 任务驾驶舱视觉改版；禅道 Bug 扫描过滤 + 去重防重录
+
 ## v0.1.54（2026-09-23）
 
 - 任务驾驶舱大屏：/board.html 独立页 + /api/board 聚合端点——模型/厂商分布、实时思考流、排队滚动，中英双语

package/README.md

@@ -21,11 +21,10 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.54）
+### 最新版更新内容（v0.1.56）
 
-- 新增任务驾驶舱大屏（/board.html）：模型/厂商分布、实时思考流、排队滚动
-- 章节原子落盘；日志一键复制；删除/归档乐观清场；卡死调用快速转投
-- run_end 钩子支持「AI 复查后自动提交推送」；蜂巢卡显示当前模型与思考流
+- 鉴权类错误不再无谓换将；超时任务新增「恢复」入口
+- 驾驶舱轮询载荷瘦身；移动端详情操作对齐；排队状态文案更明确
 <!-- relnotes:end -->
 
 ---

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/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:
@@ -333,12 +344,12 @@ def _requeue_await_slot(job, waits_left=None):
             return
         if _restart_drain:
             _close_unstarted(job, "服务正在完成升级重启；本次未排队，请稍后重试",
-                             statuses=("running",))
+                             statuses=("queued", "running"))
         elif waits_left > 0:
             _requeue_await_slot(job, waits_left - 1)
         else:
             _close_unstarted(job, "并发位已满，排队等待超时仍未起跑，请稍后重试",
-                             statuses=("running",))
+                             statuses=("queued", "running"))
 
     with _timer_lock:
         if run_id in _deferred_timers:
@@ -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():

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)
@@ -248,6 +251,11 @@ def block_for(task):
         stale = _is_stale(x.get("as_of"))
         mark = ("（事实截至 %s，可能过期，请自行核实时效）" % x.get("as_of") if stale
                 else ("（事实截至 %s）" % x.get("as_of") if x.get("as_of") else ""))
+        # 置信标注（引用核验续）：medium 不标（默认噪音为零），low 早已
+        # 在学习口丢弃——只有 high 显式加冕，模型据以分配采信权重
+        conf = str(x.get("confidence") or "medium").strip().lower()
+        if conf == "high":
+            mark += "［有据］"
         lines.append("- **%s**%s：%s" % (x["title"], mark, x["body"]))
         used.append(x["id"])
     text = "## 知识库（已确认的领域知识，供参考）\n\n" + "\n".join(lines)
@@ -277,10 +285,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 +396,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

package/app/core/modelhub.py

@@ -681,6 +681,7 @@ def provider_view():
 # 读取点（凭据注入/健康探测/取模型列表）无需感知多 KEY 结构。没配 keys 的老数据
 # 由 _provider_keys 按 api_key 现场合成一条——文件一个字节都不用改。
 _KEY_COOLDOWN_S = 30 * 60      # 欠费类失败后的冷却时长
+_AUTH_COOLDOWN_S = 30 * 60     # 明确认证拒绝后的冷却时长，可在 UI 手动恢复
 MAX_PROVIDER_KEYS = 8          # 单厂商 KEY 上限
 MAX_CHAIN_ATTEMPTS = 8         # 链展开后的尝试上限（模型 × KEY）
 # 欠费/配额/限流类失败：换 KEY 有意义（同厂商另一账号=另一份额度与并发桶），
@@ -699,6 +700,19 @@ def _quota_error(err):
     return any(k in e for k in _QUOTA_HINTS)
 
 
+_AUTH_HINTS = ("invalid api key", "invalid_api_key", "api key is invalid",
+               "incorrect api key", "unauthorized", "unauthorised",
+               "authentication failed", "authentication error",
+               "authentication_error", "invalid token", "invalid_token",
+               "http 401", "status code 401")
+
+
+def _auth_error(err):
+    """明确的凭据认证拒绝；不把一般 403/模型权限错误误判成 KEY 错误。"""
+    e = (err or "").lower()
+    return any(k in e for k in _AUTH_HINTS)
+
+
 def _provider_keys(prov, available_only=False, now=None):
     """供应商的 KEY 列表，顺序=调用顺序。返回 [{id,key,label,enabled,cooling,...}]。
 
@@ -826,7 +840,7 @@ def key_op(provider_id, op, key_id="", key="", label="", enabled=None, ids=None)
 
 
 def note_key_error(provider_id, key_id, error=""):
-    """一次 KEY 级失败回写：欠费类进冷却（后续解析自动跳过 → 切备用 KEY）。"""
+    """一次 KEY 级失败回写：欠费或明确认证拒绝进冷却，后续解析切备用 KEY。"""
     import time as _t
     if not provider_id or not key_id:
         return
@@ -842,6 +856,8 @@ def note_key_error(provider_id, key_id, error=""):
         target["last_fail_at"] = _t.time()
         if _quota_error(error):
             target["cool_until"] = _t.time() + _KEY_COOLDOWN_S
+        elif _auth_error(error):
+            target["cool_until"] = _t.time() + _AUTH_COOLDOWN_S
         _sync_api_key(prov)
         _save(data)
 
@@ -2156,11 +2172,14 @@ def _entry_endpoint(prov, allowed):
     """
     proto = prov.get("protocol")
     if proto in allowed:
-        return proto, prov.get("base_url"), prov.get("wire_api", "responses")
+        base = prov.get("base_url")
+        if not _wire_endpoint_compatible(proto, base):
+            return None
+        return proto, base, prov.get("wire_api", "responses")
     caps = prov.get("wire_caps") or {}
     for p in allowed:
         cap = caps.get(p) or {}
-        if cap.get("base"):
+        if cap.get("base") and _wire_endpoint_compatible(p, cap["base"]):
             return p, cap["base"], cap.get("wire_api") or "responses"
     return None
 
@@ -2172,10 +2191,12 @@ def _protocol_candidates(prov):
     调用方逐个试、全失败才报错——不猜一条去发请求。"""
     proto = (prov or {}).get("protocol")
     if proto in _PROTOCOLS:
-        return [(proto, (prov or {}).get("base_url") or "")]
+        base = (prov or {}).get("base_url") or ""
+        return ([(proto, base)] if _wire_endpoint_compatible(proto, base) else [])
     caps = (prov or {}).get("wire_caps") or {}
     return [(p, caps[p]["base"]) for p in _WIRE_PREFERENCE
-            if (caps.get(p) or {}).get("base")]
+            if (caps.get(p) or {}).get("base")
+            and _wire_endpoint_compatible(p, (caps.get(p) or {}).get("base"))]
 
 
 def _ensure_wire_candidates(provider_id, prov, model_name=""):
@@ -2195,6 +2216,26 @@ def _ensure_wire_candidates(provider_id, prov, model_name=""):
     return (_protocol_candidates(prov2) if prov2 else []), (note or "")
 
 
+def _wire_endpoint_compatible(proto, base_url):
+    """Reject an endpoint whose URL path contradicts the selected wire.
+
+    Some providers expose an Anthropic API under a path containing ``anthropic``
+    and may have stale ``wire_caps`` from an earlier probe that recorded that
+    same URL as OpenAI/Responses.  Codex then retries forever because it sends
+    Responses events to the Anthropic route.  A path marker is a conservative
+    local guard; normal shared roots such as ``https://host/v1`` remain valid
+    for both protocols.
+    """
+    if proto != "openai" or not base_url:
+        return True
+    try:
+        import urllib.parse
+        path = (urllib.parse.urlsplit(str(base_url)).path or "").lower()
+    except Exception:
+        return True
+    return re.search(r"(?:^|/)anthropic(?:/|$)", path) is None
+
+
 def bindable_protocols(agent_kind_or_id):
     """该 CLI 可绑定的 wire 协议（与 resolve_binding 的 allowed 一致）。
     供死链告警/失败文案解释「为什么绑不上」：claude 只认 anthropic，
@@ -2851,6 +2892,10 @@ def _wire_base_candidates(base_url, target_proto):
         cands = [base if base.endswith("/v1") else base + "/v1"]
         if not base.endswith("/v1"):
             cands.append(base)
+        # `/api/anthropic` 是 Anthropic 专用入口，不要把它拼成
+        # `/api/anthropic[/v1]/responses` 再误记为 Codex 能力。
+        if not _wire_endpoint_compatible(target_proto, base):
+            cands = []
     else:
         # anthropic 习惯：CLI 在 base 后拼 /v1/messages，base 本身不含 /v1
         cands = [base[:-3] if base.endswith("/v1") else base]