codebee 0.1.63 → 0.1.65

package/app/core/modelhub.py

@@ -2037,6 +2037,35 @@ def _model_image_in(prov, model):
     return False
 
 
+def vision_candidates(prefer_provider_id="", prefer_model=""):
+    """全库搜「能看图」的候选模型，供图类调用自动降级（编排模型不支持看图时
+    自己换将，不甩人工）。返回有序 [(prov, model_name, inferred)]：
+    声明 image_in 的在先；仅名字推断（_auto_image_in）的在后（inferred=True，
+    调用方实测成功后应 set_model_caps 落标记）。编排者供应商排最前，
+    编排模型本身若可看图排整个列表第一。"""
+    out, seen = [], set()
+    provs = [p for p in providers()
+             if isinstance(p, dict) and p.get("enabled", True) and p.get("api_key")]
+    provs.sort(key=lambda p: 0 if p.get("id") == prefer_provider_id else 1)
+    for p in provs:
+        for m in _enabled_models(p):
+            name = str(m.get("name") or "")
+            if not name or (p.get("id"), name) in seen:
+                continue
+            if bool(m.get("image_in")):
+                inferred = False
+            elif _auto_image_in(name):
+                inferred = True
+            else:
+                continue
+            seen.add((p.get("id"), name))
+            out.append((p, name, inferred))
+    if prefer_model:
+        out.sort(key=lambda x: 0 if (x[0].get("id") == prefer_provider_id
+                                     and x[1] == prefer_model) else 1)
+    return out
+
+
 def bind_agent(agent, difficulty="default", task_type="", role=""):
     """按绑定生成应用了供应商/模型覆盖的 agent 副本；无绑定时原样返回。
 
@@ -3096,32 +3125,68 @@ def resolve_orchestrator():
     return prov, model
 
 
-def _chat_cache_path(provider_id, model_name, prompt, max_tokens, reasoning_effort=""):
-    """§07 T2.2：精确匹配响应缓存的落盘路径（只缓存 ok 的幂等调用）。"""
+def _chat_user_content(proto, prompt, images):
+    """images=[(mime, b64)] 时构造多模态 user content；无图返回原样文本。
+
+    openai/anthropic 的 content 变数组块，google 走 parts；形状与
+    builtin_agent 的对话消息一致（图只进 user 消息）。"""
+    if not images:
+        return [{"text": prompt}] if proto == "google" else prompt
+    if proto == "google":
+        parts = [{"text": prompt}]
+        for mime, b64 in images:
+            parts.append({"inline_data": {"mime_type": mime, "data": b64}})
+        return parts
+    blocks = [{"type": "text", "text": prompt}]
+    for mime, b64 in images:
+        if proto == "anthropic":
+            blocks.append({"type": "image",
+                           "source": {"type": "base64", "media_type": mime,
+                                      "data": b64}})
+        else:
+            blocks.append({"type": "image_url",
+                           "image_url": {"url": "data:%s;base64,%s" % (mime, b64)}})
+    return blocks
+
+
+def _chat_cache_path(provider_id, model_name, prompt, max_tokens, reasoning_effort="",
+                     images=None):
+    """§07 T2.2：精确匹配响应缓存的落盘路径（只缓存 ok 的幂等调用）。
+    images 参与键（同 prompt 不同图的响应可能不同）。"""
     import hashlib as _h
+    img_sig = ""
+    if images:
+        try:
+            img_sig = _h.sha256("|".join("%s|%s" % (m, b) for m, b in images)
+                                .encode("utf-8")).hexdigest()[:16]
+        except Exception:
+            img_sig = "err"
     key = "|".join([str(provider_id), str(model_name), str(max_tokens),
-                    str(reasoning_effort or ""), str(prompt)])
+                    str(reasoning_effort or ""), str(prompt), img_sig])
     name = _h.sha256(key.encode("utf-8")).hexdigest()[:24]
     return paths.DATA_DIR / "chat_cache" / (name + ".json")
 
 
 def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_ttl=0,
-         on_delta=None, reasoning_effort=""):
+         on_delta=None, reasoning_effort="", images=None):
     """直连供应商 API 做一次对话（编排者规划 / 连通性测试）。
 
     支持 anthropic / openai / google 三种协议；复用 SSRF 防护。
+    images=[(mime, b64)] 时随 user 消息传图（三协议形状见 _chat_user_content；
+    图只在非流式路径验证过，流式 on_delta 与图并用未验证）。
     返回 {ok, text, tokens, usage, error}；usage 为细分 {input, output, cached, reasoning, total}。
-    cache_ttl>0 启用精确匹配响应缓存（key=供应商+模型+prompt+max_tokens，只缓存
-    ok 结果）——仅限幂等调用（连通性测试等）；创作类调用不要开，否则同一 prompt
+    cache_ttl>0 启用精确匹配响应缓存（key=供应商+模型+prompt+max_tokens+图签名，
+    只缓存 ok 结果）——仅限幂等调用（连通性测试等）；创作类调用不要开，否则同一 prompt
     的二次请求会屏蔽模型的新输出。
     on_delta 给定时走 SSE 流式：每收到一段增量文本回调一次。编排者直连调用
     不经 run_process、原本生成全程日志只有一行标题，靠它把「正在吐字」实时
     写进步骤日志（planner._log_streamer 节流落盘）。
     """
+    images = [(str(m), str(b)) for m, b in (images or [])] or None
     if cache_ttl > 0:
         try:
             cache_path = _chat_cache_path(provider_id, model_name, prompt, max_tokens,
-                                          reasoning_effort)
+                                          reasoning_effort, images)
             if cache_path.is_file():
                 age = time.time() - cache_path.stat().st_mtime
                 if age <= cache_ttl:
@@ -3157,7 +3222,7 @@ def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_tt
             else:
                 url = base + "/v1beta/models/%s:generateContent" % model_name
             headers = {"x-goog-api-key": use_key}
-            body = {"contents": [{"parts": [{"text": prompt}]}],
+            body = {"contents": [{"parts": _chat_user_content(proto, prompt, images)}],
                     "generationConfig": {"maxOutputTokens": max_tokens}}
         else:
             path = "/messages" if proto == "anthropic" else "/chat/completions"
@@ -3167,7 +3232,8 @@ def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_tt
             else:
                 headers = {"Authorization": "Bearer " + use_key}
             body = {"model": model_name, "max_tokens": max_tokens,
-                    "messages": [{"role": "user", "content": prompt}]}
+                    "messages": [{"role": "user",
+                                  "content": _chat_user_content(proto, prompt, images)}]}
             effort = str(reasoning_effort or "").strip().lower()
             if proto == "openai" and effort in ("low", "medium", "high"):
                 body["reasoning_effort"] = effort
@@ -3255,7 +3321,7 @@ def chat(provider_id, model_name, prompt, max_tokens=2048, timeout=120, cache_tt
     if cache_ttl > 0:
         try:
             cache_path = _chat_cache_path(provider_id, model_name, prompt, max_tokens,
-                                          reasoning_effort)
+                                          reasoning_effort, images)
             cache_path.parent.mkdir(parents=True, exist_ok=True)
             tmp = cache_path.with_suffix(".tmp")
             import json as _json

package/app/core/pipeline.py

@@ -1060,7 +1060,9 @@ def _retry_content_draft_with_cli(run_id, task, agents, impl, difficulty, mode,
     failures = ["%s：%s" % (impl.get("id") or "CLI",
                             (draft_res.get("error") or "起草失败")[:180])]
     dead_upstreams = []
-    first_upstreams = router.agent_upstreams(impl.get("id"))
+    first_upstreams = router.agent_upstreams(
+        impl.get("id"), difficulty=difficulty,
+        task_type=task.get("type") or "novel", role="implement")
     if first_upstreams:
         dead_upstreams.append(first_upstreams)
     current = impl
@@ -1072,7 +1074,7 @@ def _retry_content_draft_with_cli(run_id, task, agents, impl, difficulty, mode,
         _check_cancel(ev)
         candidate, reason = router.pick_switch_candidate(
             agents, "implement", task.get("type") or "novel", stats,
-            exclude=tried, dead_upstreams=dead_upstreams)
+            exclude=tried, dead_upstreams=dead_upstreams, difficulty=difficulty)
         if candidate is None or candidate.get("id") in tried:
             break
         tried.add(candidate.get("id"))
@@ -1097,7 +1099,9 @@ def _retry_content_draft_with_cli(run_id, task, agents, impl, difficulty, mode,
                                     (last_result.get("error") or "起草失败")[:180]))
         if (last_result.get("raw") or {}).get("cancelled"):
             break
-        ups = router.agent_upstreams(candidate.get("id"))
+        ups = router.agent_upstreams(
+            candidate.get("id"), difficulty=difficulty,
+            task_type=task.get("type") or "novel", role="implement")
         if ups:
             dead_upstreams.append(ups)
         current = candidate
@@ -1309,8 +1313,11 @@ def _run_code(run, task, agents, ev, stats, mode):
             # 原实现者若死于配额，其上游（网关/账号）也一并判入死池——否则第一棒
             # 换将不知道同网关候选已死，评审者重选更会把「与死者同上游」的候选
             # 继续当活口，评审撞同一条失效网关白烧一轮后误报「评审器故障」。
-            if runner._quota_error(res.get("error") or ""):
-                ups0 = router.agent_upstreams(impl_agent["id"])
+            if (runner._quota_error(res.get("error") or "")
+                    or runner._permission_error(res.get("error") or "")):
+                ups0 = router.agent_upstreams(
+                    impl_agent["id"], difficulty=difficulty,
+                    task_type="code", role="implement")
                 if ups0:
                     dead_ups.append(ups0)
             prev_id = impl_agent["id"]
@@ -1318,7 +1325,8 @@ def _run_code(run, task, agents, ev, stats, mode):
             while True:
                 other, other_reason = router.pick_switch_candidate(
                     agents, "implement", "code", stats,
-                    exclude=tried, dead_upstreams=dead_ups)
+                    exclude=tried, dead_upstreams=dead_ups,
+                    difficulty=difficulty)
                 if other is None or other.get("mode") != "real":
                     other = None
                     break
@@ -1348,8 +1356,11 @@ def _run_code(run, task, agents, ev, stats, mode):
                 tried.add(other["id"])
                 dead_ids.add(other["id"])
                 prev_id = other["id"]
-                if runner._quota_error(res.get("error") or ""):
-                    ups = router.agent_upstreams(other["id"])
+                if (runner._quota_error(res.get("error") or "")
+                        or runner._permission_error(res.get("error") or "")):
+                    ups = router.agent_upstreams(
+                        other["id"], difficulty=difficulty,
+                        task_type="code", role="implement")
                     if ups:
                         dead_ups.append(ups)
                 else:
@@ -1541,13 +1552,27 @@ def _run_code(run, task, agents, ev, stats, mode):
         _write_project_memory(task, workdir, _mem_lines)
     except Exception:
         pass
+    # Stop gate（planning-with-files）：收工时活计划若有未勾选项，摘要与 verdict
+    # 如实点名——「计划没走完就报完成」属于静默降级（赛马/异常路径不回写勾选时
+    # 此前无任何可见信号）。只保可见不改判：勾选是文件事实，质量判据仍是评审。
+    try:
+        gate_total, gate_left = plan_stopgate(workdir)
+    except Exception:
+        gate_total, gate_left = 0, []
+    gate_note = ""
+    if gate_left:
+        verdict["plan_gate"] = "活计划 %d 项中 %d 项未勾选完成：%s" % (
+            gate_total, len(gate_left),
+            "、".join("#%d[%s]%s" % (n, mk, t) for n, mk, t in gate_left[:3]))
+        gate_note = "；⚠ 活计划 %d/%d 项完成" % (gate_total - len(gate_left), gate_total)
     store.update_run(run_id, expected_status="running", status="done", verdict=verdict,
-                     summary="代码任务%s（验证%s / 评审%s%s）" % (
+                     summary="代码任务%s（验证%s / 评审%s%s%s）" % (
                          "通过" if overall_pass else "未通过",
                          "通过" if verify_pass else "未通过",
                          (("通过" if review_json.get("pass") else "未通过")
                           if workflow["review_required"] else "按策略省略"),
-                         "，%d 轮修复" % (len(repairs) - 1) if len(repairs) > 1 else ""),
+                         "，%d 轮修复" % (len(repairs) - 1) if len(repairs) > 1 else "",
+                         gate_note),
                      ended_at=_now())
 
 
@@ -4145,6 +4170,31 @@ def _write_task_plan(task, workdir, plan):
 _PLAN_MARK = {"done": "x", "fail": "!", "run": ">"}
 
 
+def plan_stopgate(workdir):
+    """Stop gate（planning-with-files 第四件）：收工前校验活计划勾选完整性。
+    返回 (总项数, [(序号, 标记, 标题)])；计划文件缺失/异常 → (0, [])（无计划不拦）。
+    未完成 = 勾选框不是 [x]（含 [ ] 未跑、[!] 失败、[>] 中断在跑）。"""
+    try:
+        from pathlib import Path as _P
+        import re as _re
+        root = _P(workdir).resolve()
+        target = (root / ".codebee" / "task_plan.md").resolve()
+        if root not in target.parents or not target.is_file():
+            return 0, []
+        pat = _re.compile(r"^(\d+)\. \[([ x!>])\] ")
+        total, unfinished = 0, []
+        for ln in target.read_text("utf-8").splitlines():
+            m = pat.match(ln)
+            if not m:
+                continue
+            total += 1
+            if m.group(2) != "x":
+                unfinished.append((int(m.group(1)), m.group(2), ln[m.end():][:60]))
+        return total, unfinished
+    except Exception:
+        return 0, []
+
+
 def mark_task_plan(workdir, index, status):
     """活计划回写：把 .codebee/task_plan.md 第 index 项（1 基）的勾选框
     翻成 [x]（完成）/[!]（失败）/[>]（进行中）。planning-with-files 的断点
@@ -4211,7 +4261,7 @@ def execute_run(run_id):
     if initial_status not in ("queued", "running"):
         return
     if store.update_run(run_id, expected_status=initial_status, status="running",
-                        started_at=_now()) is None:
+                        started_at=_now(), resume_enqueue_at="", warnings=[]) is None:
         return
     if task is None:
         store.update_run(run_id, expected_status="running", status="failed",

package/app/core/router.py

@@ -2,8 +2,9 @@
 """智能路由：能力基线 × 历史胜率 × 角色约束 → 选智能体，并给出可解释的理由。"""
 from __future__ import annotations
 
-import os
-import re
+import os
+import re
+import json
 
 from . import dispatch, history
 
@@ -144,14 +145,16 @@ def pick(agents, role, ttype, stats=None, exclude=()):
 # 空链 CLI 的真实上游在各自本机配置里（注册表里的 provider_id 是 UI 残留，
 # 2026-09-22 实测 qwencode 注册表指 prov-36 本机却指公司网关）。正则探针
 # 只为换将时识别「同上游」，读不到就算未知——未知不参与剔除，宁白试不误杀。
-_LOCAL_ENDPOINT_PROBES = (
+_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*"([^"]+)"'),
-)
+)
+
+_PI_SETTINGS_PATH = "~/.pi/agent/settings.json"
 
 
 def _host_of(url):
@@ -160,27 +163,59 @@ def _host_of(url):
     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
+def agent_upstreams(agent_id, difficulty="default", task_type="", role=""):
+    """候选实际会用到的上游集合（host:port 归一）。显式链 > CLI 本机配置
+    端点；无显式绑定时按运行期自动推荐链判断；都拿不到返回空集 = 未知。"""
+    ups = set()
+    try:
+        from . import modelhub
+        pref = modelhub._binding_for(agent_id)
+        provs = {p.get("id"): p for p in modelhub.providers()}
+
+        def _add_chain(chain):
+            for item in chain or ():
+                pid = (item.get("provider_id") or "").strip()
+                provider = item.get("provider") or provs.get(pid) or {}
+                h = _host_of(provider.get("base_url"))
+                if h:
+                    ups.add(h)
+
+        configured = bool(modelhub._binding_chain(pref) or pref.get("provider_id"))
+        # 保留原始显式链中的 endpoint，即使某条已禁用/失效；同一个死上游仍
+        # 不值得在另一个 CLI 上立刻再撞一次。
+        if configured:
+            chain = modelhub._binding_chain(pref)
+            _add_chain(chain)
+            resolved = modelhub.resolve_binding(agent_id, difficulty) or {}
+            _add_chain(resolved.get("call_chain"))
+        else:
+            # bind_agent 在空绑定时会自动推荐供应商链。换将选路必须观察同一
+            # 生效链，否则“空绑定”的多个 CLI 可能被排成不同候选却共用一个 403 网关。
+            recommended = modelhub.recommend_binding(
+                agent_id, difficulty, task_type=task_type, role=role) or {}
+            _add_chain(recommended.get("call_chain"))
+    except Exception:
+        pass
+    if not ups:
+        if agent_id == "pi":
+            # Pi 将 endpoint 放在 providers.<defaultProvider>.baseUrl，不能只扫
+            # 所有 baseUrl（那会把未选中的 provider 也误算成当前上游）。
+            try:
+                with open(os.path.expanduser(_PI_SETTINGS_PATH), "r",
+                          encoding="utf-8") as fh:
+                    cfg = json.load(fh)
+                selected = (cfg.get("providers") or {}).get(
+                    cfg.get("defaultProvider") or "") or {}
+                h = _host_of(selected.get("baseUrl") or selected.get("baseURL") or
+                             selected.get("base_url"))
+                if h:
+                    ups.add(h)
+            except (OSError, ValueError, TypeError):
+                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:
@@ -194,8 +229,8 @@ def agent_upstreams(agent_id):
     return ups
 
 
-def pick_switch_candidate(agents, role, ttype, stats, exclude=(),
-                          dead_upstreams=()):
+def pick_switch_candidate(agents, role, ttype, stats, exclude=(),
+                          dead_upstreams=(), difficulty="default"):
     """换将选将。配额类死亡背景下：与死者同上游的候选依次让位，直到找到
     异上游/上游未知的候选（2026-09-22 实案：kimi 与 claude 同骑智谱，0.1 分
     之差把异上游 qwencode 压在下面，换将=换壳不换命）。异上游耗尽后同上游
@@ -204,9 +239,10 @@ def pick_switch_candidate(agents, role, ttype, stats, 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"))
+    deferred = []
+    while best is not None:
+        ups = agent_upstreams(best.get("id"), difficulty=difficulty,
+                              task_type=ttype, role=role)
         if not (ups and any(ups & dead for dead in dead_upstreams)):
             break  # 异上游或上游未知：就用它
         deferred.append((best, reason))

package/app/core/runner.py

@@ -981,7 +981,7 @@ def _model_flag(kind, model):
     return ["--model", model]  # claude / opencode / aider
 
 
-    _TRANSIENT = ("503", "502", "529", "429", "no available channel", "temporarily",
+_TRANSIENT_DEFAULT = ("503", "502", "529", "429", "no available channel", "temporarily",
               "unavailable", "overloaded", "rate limit", "timeout", "timed out",
               "输出停滞",
               # 2026-09-15 连载验收实测：网关故障形态远不止 HTTP 5xx——
@@ -1007,10 +1007,15 @@ def _model_flag(kind, model):
               "enotfound", "getaddrinfo", "name or service not known",
               "name resolution")
 
+# 保留兼容别名：旧 worker 热重载时可能短暂丢失模块级变量，判断函数不能因此
+# 把一次普通上游故障升级成 NameError。
+_TRANSIENT = _TRANSIENT_DEFAULT
 
-def _transient_error(err):
+
+def _transient_error(err, _default_markers=_TRANSIENT_DEFAULT):
     err = (err or "").lower()
-    return any(k in err for k in _TRANSIENT)
+    markers = globals().get("_TRANSIENT") or _default_markers
+    return any(k in err for k in markers)
 
 
 # 欠费/配额/限流耗尽：换 KEY 与换厂商都该继续（同厂商另一账号往往还能用）。
@@ -1038,6 +1043,17 @@ def _auth_error(err):
     return any(k in err for k in _AUTH)
 
 
+_FORBIDDEN_HINTS = ("forbidden", "request not allowed", "permission denied",
+                    "access denied")
+
+
+def _permission_error(err):
+    """识别明确的 HTTP 403 权限拒绝；它是上游故障，不等同于无效 API Key。"""
+    err = (err or "").lower()
+    return bool(re.search(r"(?<!\d)403(?!\d)", err) and
+                any(marker in err for marker in _FORBIDDEN_HINTS))
+
+
 def _attempt_credential(att):
     """绑定链中凭据的非敏感身份；不把密钥值写入日志或尝试记录。"""
     return (str((att or {}).get("provider_id") or ""),
@@ -1616,6 +1632,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     grace_left = RATE_LIMIT_GRACE_N  # 链尾限流宽限预算：整链撞 429 时原地等一个窗口再试一次
     timed_out_upstreams = {}  # 同一上游两次超时后跳过剩余模型
     skipped_upstreams = set()
+    forbidden_upstreams = set()
     auth_failed_credentials = set()
     for ai, att in enumerate(attempts):
         credential = _attempt_credential(att)
@@ -1633,7 +1650,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 out["attempts"] = list(attempt_history)
             continue
         upstream = _attempt_upstream(att)
-        if upstream in skipped_upstreams:
+        if upstream in skipped_upstreams or upstream in forbidden_upstreams:
             continue
         # 有任务 deadline 时，所有候选共享同一个截止时刻；否则每个候选
         # 使用 catalog 配置或 caller 提供的单模型时限。
@@ -1758,7 +1775,8 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     except Exception:
                         pass
                 if not (_quota_error(out["error"]) or _transient_error(out["error"])
-                        or _rate_limited(out["error"])):
+                        or _rate_limited(out["error"])
+                        or _permission_error(out["error"])):
                     # 尾段清洗后没有错误信号而流式审计日志里有：补日志错误行。
                     # 2026-09-22 实测 kimi 撞 429 时 stderr/stdout 只剩启动横幅
                     # （真错误只走了流式管道），路由层看不到配额关键词，换将
@@ -1862,6 +1880,15 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                        for candidate in attempts[ai + 1:]):
                 return out
             continue
+        if _permission_error(out.get("error")):
+            # 403 通常是该网关/上游拒绝当前请求；同一 host 换模型只会重撞，
+            # 但不同 host 的候选仍可能有权限，应继续尝试异上游链项。
+            if upstream != "unknown":
+                forbidden_upstreams.add(upstream)
+            if not any(_attempt_upstream(candidate) not in forbidden_upstreams
+                       for candidate in attempts[ai + 1:]):
+                return out
+            continue
         # 换将闸门：什么失败值得烧链上下一个候选。
         # · 瞬态/配额（文本特征，含 CLI 内部 api_retry 的 429/5xx 字样）照旧；
         # · 超时：显式可换（看 res 标志位）——慢上游换快候选可能救回。
@@ -1874,6 +1901,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
         if (raw.get("cancelled")   # 取消是用户意志，绝不降级（尾段可能带瞬态字样）
                 or not (_transient_error(out.get("error")) or _quota_error(out.get("error"))
                         or _refusal_error(out.get("error"))
+                        or _permission_error(out.get("error"))
                         or raw.get("timed_out"))):
             return out  # 取消/解析失败等真终态不降级
         # 同一上游的模型连续两次超时就收手——

package/app/core/store.py

@@ -18,7 +18,7 @@ import threading
 import time
 from pathlib import Path
 
-from . import paths, runner, volumes
+from . import artifacts, paths, runner, volumes
 
 LOCK = threading.RLock()
 _TASKS = {}
@@ -746,7 +746,7 @@ def task_side(task_id):
     total_steps = sum(len(r.get("steps") or []) for r in runs)
     # 成品口径闸：任务一步都没跑出来过（如历次都在检出前失败）→ 工作目录里的
     # 文件变动全是并行活动的噪音，不算这个任务的成品
-    wd, arts = run_artifacts(latest["id"], limit=50) if (latest and total_steps > 0) else ("", [])
+    wd, arts = run_artifacts(latest["id"], limit=50, cache=True) if (latest and total_steps > 0) else ("", [])
     return {
         "task": {k: task.get(k) for k in ("id", "title", "status", "workdir", "git_state",
                                           "git_rev")},
@@ -966,41 +966,6 @@ def run_workdir(run_id):
     return str(task.get("workdir") or "") if task else ""
 
 
-_SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".idea", ".vscode"}
-
-# 构建产物/依赖缓存目录：里面的文件是工具链再生成的，不是任务成品
-_BUILD_DIRS = {
-    "target", "build", "dist", "out", "bin", "obj",           # 通用构建输出
-    "surefire", "failsafe-reports", "test-output", "reports",  # 测试/报告输出
-    ".next", ".nuxt", ".output", ".gradle", ".gradle-home",    # 前端/Gradle
-    "__MACOSX",
-}
-
-# CLI 自身的历史/评审中间件不属于用户成果。它们通常落在工作目录根部，
-# 只按隐藏目录过滤会漏掉 Aider 的 .aider.* 与流程生成的 *_review.json。
-_PROCESS_ARTIFACT_NAMES = {
-    ".aider.chat.history.md", ".aider.input.history", ".aider.input.history.md",
-    ".aider.tags.cache.v4", ".aider.tags.cache.v3", ".aider.conf.yml",
-}
-_PROCESS_ARTIFACT_SUFFIXES = ("_review.json", ".review.json")
-_PROCESS_ARTIFACT_PREFIXES = ("tutti_prompt_", "_tutti_prompt_")
-
-
-def _is_process_artifact(rel_name):
-    """判断工作目录文件是否为 CLI/评审过程产物，而非可交付成果。"""
-    name = str(rel_name or "").replace("\\", "/")
-    base = name.rsplit("/", 1)[-1].lower()
-    if base in _PROCESS_ARTIFACT_NAMES:
-        return True
-    if base.startswith(".") and base.startswith(".aider"):
-        return True
-    if base.endswith(_PROCESS_ARTIFACT_SUFFIXES):
-        return True
-    if base.startswith(_PROCESS_ARTIFACT_PREFIXES):
-        return True
-    return False
-
-
 def task_first_start(task_id, fallback=""):
     """该任务最早一次运行的开始时间（含回退：任务创建时间 → 指定回退值）。"""
     stamps = []
@@ -1019,13 +984,15 @@ def task_first_start(task_id, fallback=""):
     return best
 
 
-def run_artifacts(run_id, limit=200):
+def run_artifacts(run_id, limit=200, cache=False):
     """列一次运行的「成品文件」：工作目录里自该任务首次运行以来新产生/修改的文件。
 
     断点续跑会拆成多条 run，只按本 run 过滤会漏掉早期章节；这里以「任务首跑」
     为起点。返回 (workdir, files)；files 按 mtime 新→旧，name 为工作目录内
-    相对路径，已跳过 .git / 隐藏目录 / node_modules / target 等构建产物目录，
-    最多 limit 个。
+    相对路径，已跳过 .git / 隐藏目录 / node_modules / target 等构建产物目录。
+    cache=True 供 UI 轮询热路径（详情/侧栏/状态快照）复用短 TTL 缓存与在飞
+    合并；发布/预览/知识库等正确性敏感方保持默认，永远现扫。
+    剪枝遍历与过滤实现在 artifacts.py（几万文件目录从秒级降到百毫秒级）。
     """
     wd = run_workdir(run_id)
     if not wd:
@@ -1040,36 +1007,12 @@ def run_artifacts(run_id, limit=200):
     root = Path(wd)
     if not root.is_dir():
         return wd, []
-    files = []
-    try:
-        for p in root.rglob("*"):
-            if not p.is_file():
-                continue
-            if any(part in _SKIP_DIRS for part in p.parts):
-                continue
-            if any(part in _BUILD_DIRS for part in p.parts[:-1]):
-                continue
-            # 隐藏目录一律是工具过程文件（.mimocode/.zcode/.claude/.codex…），
-            # 不是成品；按前缀通排，免得每来一个新 agent CLI 就补一次白名单
-            if any(part.startswith(".") for part in p.parts[:-1]):
-                continue
-            try:
-                st = p.stat()
-            except OSError:
-                continue
-            if st.st_mtime < t0:
-                continue
-            rel_name = str(p.relative_to(root)).replace("\\", "/")
-            if _is_process_artifact(rel_name):
-                continue
-            files.append({"name": rel_name,
-                          "size": st.st_size, "mtime": int(st.st_mtime)})
-            if len(files) >= 800:  # 防超大目录拖垮接口；截断后再排序取最新
-                break
-    except OSError:
-        pass
-    files.sort(key=lambda f: -f["mtime"])
-    return wd, files[:limit]
+    running = False
+    if cache:
+        task = get_task(run.get("task_id") or "") if run.get("task_id") else None
+        running = bool(task) and task.get("status") in ("queued", "running")
+    return wd, artifacts.scan(str(root), t0, limit=limit,
+                              running=running, cache=cache)
 
 
 def task_step_count(task_id):