codebee 0.1.49 → 0.1.51

package/app/core/runner.py

@@ -58,52 +58,91 @@ def find_git_bash():
     return None
 
 
-def resolve_command(command):
+def resolve_command(command):
     """命令名 → 可直接 spawn 的 argv 前缀（.cmd/.bat 垫片必须经 cmd /c）。"""
     path = shutil.which(command) or command
     low = path.lower()
     if low.endswith(".cmd") or low.endswith(".bat"):
         return ["cmd", "/c", path]
-    return [path]
-
-
-def _git_repo_issue(workdir):
-    """返回工作目录 Git 仓库的可读性问题；无 Git 仓库时返回空串。
-
-    Aider 会在启动后自行读取索引。索引包缺失时它通常先写入 .gitignore，
-    再在深层调用中才报错，用户会误以为任务卡住；提前做一次廉价预检能把
-    错误变成可操作的任务失败信息。
-    """
-    if not workdir or not os.path.isdir(workdir):
-        return ""
-    git_dir = os.path.join(workdir, ".git")
-    if not os.path.exists(git_dir):
-        return ""
-    try:
-        probe = subprocess.run(
-            ["git", "-C", workdir, "rev-parse", "--git-dir"],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            text=True, timeout=5, check=False,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return "Git 命令不可用，无法读取仓库；请安装 Git 或改用非 Aider 实现器"
-    if probe.returncode != 0:
-        detail = (probe.stderr or probe.stdout or "仓库元数据不可读").strip()
-        return "Git 仓库不可读：%s；请先执行 git fsck/恢复 .git 对象后重试" % detail[-300:]
-    try:
-        probe = subprocess.run(
-            ["git", "-C", workdir, "status", "--porcelain", "--untracked-files=no"],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            text=True, timeout=8, check=False,
-        )
-    except subprocess.TimeoutExpired:
-        return "Git 仓库检查超时；请先执行 git status/git fsck 修复后重试"
-    except OSError:
-        return "Git 命令不可用，无法读取仓库；请安装 Git 或改用非 Aider 实现器"
-    if probe.returncode != 0:
-        detail = (probe.stderr or probe.stdout or "仓库对象或索引不可读").strip()
-        return "Git 仓库损坏或对象缺失：%s；请先执行 git fsck 并恢复仓库后重试" % detail[-300:]
-    return ""
+    return [path]
+
+
+def _orphan_pack_files(workdir):
+    """列出缺少同名 .idx 的 pack 文件名（无则空列表）。
+
+    Git 本体扫目录时发现 pack 没有对应 .idx，只打一行 warning 就跳过该包，
+    所以 git status/fsck 全都正常；aider 走的 gitpython/gitdb 却按
+    pack-*.pack 逐个打开同名 .idx，缺一次就抛 FileNotFoundError，被它记成
+    「is your git repo corrupted?」——2026-09-22 mo-so 实案：pack-a52e675e
+    .idx 缺失，aider 换将后跑满 14 分钟才失败，报错头还是 prompt toolkit 噪声。
+    """
+    try:
+        probe = subprocess.run(
+            ["git", "-C", workdir, "rev-parse", "--git-path", "objects/pack"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, timeout=5, check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
+    rel = (probe.stdout or "").strip()
+    if probe.returncode != 0 or not rel:
+        return []
+    pack_dir = rel if os.path.isabs(rel) else os.path.join(workdir, rel)
+    try:
+        names = set(os.listdir(pack_dir))
+    except OSError:
+        return []
+    return sorted(n for n in names
+                  if n.startswith("pack-") and n.endswith(".pack")
+                  and (n[:-len(".pack")] + ".idx") not in names)
+
+
+def _git_repo_issue(workdir):
+    """返回工作目录 Git 仓库的可读性问题；无 Git 仓库时返回空串。
+
+    Aider 会在启动后自行读取索引。索引包缺失时它通常先写入 .gitignore，
+    再在深层调用中才报错，用户会误以为任务卡住；提前做一次廉价预检能把
+    错误变成可操作的任务失败信息。
+    """
+    if not workdir or not os.path.isdir(workdir):
+        return ""
+    git_dir = os.path.join(workdir, ".git")
+    if not os.path.exists(git_dir):
+        return ""
+    try:
+        probe = subprocess.run(
+            ["git", "-C", workdir, "rev-parse", "--git-dir"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, timeout=5, check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return "Git 命令不可用，无法读取仓库；请安装 Git 或改用非 Aider 实现器"
+    if probe.returncode != 0:
+        detail = (probe.stderr or probe.stdout or "仓库元数据不可读").strip()
+        return "Git 仓库不可读：%s；请先执行 git fsck/恢复 .git 对象后重试" % detail[-300:]
+    try:
+        probe = subprocess.run(
+            ["git", "-C", workdir, "status", "--porcelain", "--untracked-files=no"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, timeout=8, check=False,
+        )
+    except subprocess.TimeoutExpired:
+        return "Git 仓库检查超时；请先执行 git status/git fsck 修复后重试"
+    except OSError:
+        return "Git 命令不可用，无法读取仓库；请安装 Git 或改用非 Aider 实现器"
+    if probe.returncode != 0:
+        detail = (probe.stderr or probe.stdout or "仓库对象或索引不可读").strip()
+        return "Git 仓库损坏或对象缺失：%s；请先执行 git fsck 并恢复仓库后重试" % detail[-300:]
+    # git status 对「pack 缺 .idx」不敏感（只 warning 跳过该包），必须单独查：
+    # aider 的 gitdb 按 pack-*.pack 逐个开同名 .idx，缺一个就整步失败。
+    orphans = _orphan_pack_files(workdir)
+    if orphans:
+        return ("Git 仓库 pack 索引缺失：%s 没有同名 .idx（git 本体只警告跳过，"
+                "Aider 的 gitdb 会直接报「Unable to list files in git repo」）。"
+                "修复：在 %s 目录对每个 pack 执行 `git index-pack <pack文件>` "
+                "重建索引，或临时改用 Codex/Claude 实现器。"
+                % (", ".join(orphans[:3]), os.path.join(".git", "objects", "pack")))
+    return ""
 
 
 def _npm_shim_bypass(argv):
@@ -115,8 +154,8 @@ def _npm_shim_bypass(argv):
             and str(argv[2]).lower().endswith((".cmd", ".bat")):
         shim = argv[2]
         try:
-            with open(shim, encoding="utf-8", errors="replace") as fh:
-                text = fh.read()
+            with open(shim, encoding="utf-8", errors="replace") as fh:
+                text = fh.read()
         except Exception:
             return argv
         m = re.search(r'%_prog%"\s+"?%dp0%(\\[^"\n]+?\.(?:mjs|js))"?', text)
@@ -187,20 +226,32 @@ def _pipe_reader(stream, chunks, log_fh, stamp=None):
     在长命令（npm 安装等）上等于"进程结束才一次性返回"，日志面板全程空白。
     read1() 只要有数据就返回，日志才能真正边跑边看。
     stamp：共享 [最后输出时刻]，停滞看门狗据此判定进程是否卡死。
+    关闭也归本线程：EOF（或杀树后的异常）后自关。主线程绝不能 close()——
+    close 要抢 BufferedReader 的锁，而锁被还在 read1 等 EOF 的本线程攥着，
+    孙进程漏杀时它攥着管道到自然死，主线程就陪锁到天荒地老（2026-09-22
+    run_command 超时杀 ping 实测：taskkill /T 失手 → close 卡满命令时长）。
     """
-    while True:
-        b = stream.read1(65536)
-        if not b:
-            break
-        chunks.append(b)
-        if stamp is not None:
-            stamp[0] = time.time()
-        if log_fh:
-            try:
-                log_fh.write(b)
-                log_fh.flush()
-            except Exception:
-                pass
+    try:
+        while True:
+            b = stream.read1(65536)
+            if not b:
+                break
+            chunks.append(b)
+            if stamp is not None:
+                stamp[0] = time.time()
+            if log_fh:
+                try:
+                    log_fh.write(b)
+                    log_fh.flush()
+                except Exception:
+                    pass
+    except Exception:
+        pass                   # 杀树瞬间句柄作废：ValueError/OSError 都算正常收场
+    finally:
+        try:
+            stream.close()
+        except Exception:
+            pass
 
 
 def _decode_line(blob):
@@ -400,8 +451,21 @@ def pretty_cli_log(text, max_event_chars=4000):
     --json 模式下 stdout 全是机器事件（thread/turn/item…），智能体真正在说的
     话被埋在转义 JSON 里；这里逐行翻译成【消息】【思考】【命令】，让日志抽屉
     读到的是「蜂在干什么」。解析失败或未识别的事件类型原样保留，不吞内容。
+
+    claude stream-json 同场翻译（2026-09-22 真实案：3.2MB 步骤日志 15828 条
+    thinking_tokens 心跳，每 SSE 分片一条、数值只涨 1~2）：思考心跳按邻近组
+    折成一行；init/api_retry/assistant/result 翻译成可读行——api_retry 是
+    429/断连诊断金矿，逐条保留不折叠。只影响抽屉显示，原始日志与解析不动。
     """
     out = []
+    hb = [0, 0]   # claude 思考心跳邻近组：[条数, 最大估算 tokens]
+    msg_seen = [False]   # 是否已出过【消息】（防 result 再重复一遍正文）
+
+    def _flush_thinking():
+        if hb[0]:
+            out.append("— 思考中（心跳 ×%d 已折叠，估算 ~%d tokens）—" % (hb[0], hb[1]))
+            hb[0] = hb[1] = 0
+
     for ln in (text or "").splitlines():
         s = ln.strip()
         ev = None
@@ -410,10 +474,68 @@ def pretty_cli_log(text, max_event_chars=4000):
                 ev = json.loads(s)
             except Exception:
                 ev = None
+        if isinstance(ev, dict) and ev.get("type") == "system" \
+                and (ev.get("subtype") or "") == "thinking_tokens":
+            try:
+                n = int(ev.get("estimated_tokens") or 0)
+            except Exception:
+                n = 0
+            hb[0] += 1
+            if n > hb[1]:
+                hb[1] = n
+            continue
+        _flush_thinking()
         if not isinstance(ev, dict):
             out.append(ln)
             continue
         typ = ev.get("type") or ""
+        if typ == "system":   # claude 其余系统事件
+            sub = ev.get("subtype") or ""
+            if sub == "init":
+                out.append("— 会话启动（model=%s）—" % (ev.get("model") or "?"))
+            elif sub == "api_retry":
+                out.append("— API 重试 %s/%s（等 %sms）：%s —" % (
+                    ev.get("attempt", "?"), ev.get("max_retries", "?"),
+                    ev.get("retry_delay_ms", "?"), ev.get("error") or "?"))
+            else:
+                out.append(ln)   # 未知 subtype 原样保留，不吞内容
+            continue
+        if typ == "assistant":   # claude 正文/思考/工具调用都在 content 块里
+            for blk in ((ev.get("message") or {}).get("content") or []):
+                if not isinstance(blk, dict):
+                    continue
+                bt = blk.get("type") or ""
+                if bt == "thinking":
+                    th = " ".join(str(blk.get("thinking") or "").split())
+                    if th:
+                        out.append("【思考】" + th[:200])
+                elif bt == "text":
+                    tx = str(blk.get("text") or "")
+                    if tx:
+                        out.append("【消息】" + tx[:max_event_chars])
+                        msg_seen[0] = True
+                elif bt == "tool_use":
+                    out.append("【命令】%s %s" % (
+                        blk.get("name") or "?",
+                        json.dumps(blk.get("input") or "", ensure_ascii=False)[:200]))
+            continue
+        if typ in ("user", "stream_event"):
+            continue   # claude 工具回包/流片段是过程噪音
+        if typ == "result":   # claude 收尾：统计一行；报错带原因
+            u = ev.get("usage") or {}
+            if ev.get("is_error"):
+                out.append("— 完成（报错）：" + str(ev.get("result") or "")[:300] + " —")
+            else:
+                cost = ev.get("total_cost_usd")
+                if not msg_seen[0]:
+                    tx = str(ev.get("result") or "")
+                    if tx:   # 旧单 JSON 模式没有 assistant 事件，正文在这补上
+                        out.append("【消息】" + tx[:max_event_chars])
+                        msg_seen[0] = True
+                out.append("— 完成（tokens 入 %s / 出 %s，%s）—" % (
+                    u.get("input_tokens", "?"), u.get("output_tokens", "?"),
+                    ("$%.2f" % cost) if isinstance(cost, (int, float)) else "?"))
+            continue
         if typ in ("thread.started", "turn.started"):
             continue
         if typ == "turn.completed":
@@ -436,18 +558,18 @@ def pretty_cli_log(text, max_event_chars=4000):
     return "\n".join(out)
 
 
-def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
-                timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None,
-                stall_timeout=0, repeat_abort=None):
+def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
+                timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None,
+                stall_timeout=0, repeat_abort=None):
     """通用子进程执行：并发读管道防死锁；超时/取消杀整棵进程树。
 
     stall_timeout：停滞看门狗（秒，0=关闭）——超过该时长 stdout/stderr 无任何
     新输出即判卡死，提前杀树返回（timed_out=True + stalled=True）。只对输出
-    持续流动的 CLI 开（codex JSONL 事件流）；claude json 到结束才一次性输出，
-    开了会把正常长任务误杀。
-
-    repeat_abort：可选 (marker, count)。同一致命错误达到次数即提前杀树，处理
-    CLI 自身不断打印重连消息、因此永远触发不了静默看门狗的假运行。
+    持续流动的 CLI 开（codex JSONL 事件流）；claude json 到结束才一次性输出，
+    开了会把正常长任务误杀。
+
+    repeat_abort：可选 (marker, count)。同一致命错误达到次数即提前杀树，处理
+    CLI 自身不断打印重连消息、因此永远触发不了静默看门狗的假运行。
 
     返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out, stalled}。
     """
@@ -510,7 +632,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                         pass
             threading.Thread(target=_feed, daemon=True).start()
         start = time.time()
-        cancelled = timed_out = stalled = repeat_aborted = False
+        cancelled = timed_out = stalled = repeat_aborted = False
         while True:
             try:
                 proc.wait(timeout=0.4)
@@ -527,44 +649,46 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 _kill_tree(proc.pid)
                 _drain_streams(proc, t_out, t_err, timeout=5)
                 break
-            if stall_timeout and time.time() - stamp[0] > stall_timeout:
+            if stall_timeout and time.time() - stamp[0] > stall_timeout:
                 # 停滞看门狗：长静默多为卡死（网关挂起/CLI 假死），与其耗满总
                 # 超时不如提前杀——错误按超时归类，走既有的换模型/换将链路
                 stalled = True
                 timed_out = True
                 _kill_tree(proc.pid)
-                _drain_streams(proc, t_out, t_err, timeout=5)
-                break
-            if repeat_abort:
-                try:
-                    marker, limit = repeat_abort
-                    recent = decode_output(b"".join(out_chunks)[-8000:] +
-                                           b"\n" + b"".join(err_chunks)[-8000:])
-                    if marker and recent.count(str(marker)) >= int(limit):
-                        repeat_aborted = True
-                        timed_out = True
-                        _kill_tree(proc.pid)
-                        _drain_streams(proc, t_out, t_err, timeout=5)
-                        break
-                except (TypeError, ValueError):
-                    pass
+                _drain_streams(proc, t_out, t_err, timeout=5)
+                break
+            if repeat_abort:
+                try:
+                    marker, limit = repeat_abort
+                    recent = decode_output(b"".join(out_chunks)[-8000:] +
+                                           b"\n" + b"".join(err_chunks)[-8000:])
+                    if marker and recent.count(str(marker)) >= int(limit):
+                        repeat_aborted = True
+                        timed_out = True
+                        _kill_tree(proc.pid)
+                        _drain_streams(proc, t_out, t_err, timeout=5)
+                        break
+                except (TypeError, ValueError):
+                    pass
         duration = round(time.time() - start, 1)
         t_out.join(timeout=5)
         t_err.join(timeout=5)
         exit_code = proc.returncode
         stdout = decode_output(b"".join(out_chunks))
         stderr = decode_output(b"".join(err_chunks))
-        for stream in (proc.stdin, proc.stdout, proc.stderr):
-            try:
-                if stream:
-                    stream.close()
-            except Exception:
-                pass
-        if cancelled:
-            stderr += "\n[已被用户取消]"
-        elif repeat_aborted:
-            stderr += "\n[同一网络错误重复 %s 次，已提前终止进程树]" % repeat_abort[1]
-        elif stalled:
+        # stdout/stderr 的 close 已归 _pipe_reader 自线程（EOF 后自关）：这里再
+        # close 会抢 read1 手里的锁，孙进程漏杀攥着管道时就死等（见其 docstring）。
+        # stdin 无读线程，_feed 写完自关；这里兜底一次（DEVNULL 时本就无事）。
+        try:
+            if proc.stdin:
+                proc.stdin.close()
+        except Exception:
+            pass
+        if cancelled:
+            stderr += "\n[已被用户取消]"
+        elif repeat_aborted:
+            stderr += "\n[同一网络错误重复 %s 次，已提前终止进程树]" % repeat_abort[1]
+        elif stalled:
             stderr += "\n[输出停滞 %ss，已终止进程树]" % stall_timeout
         elif timed_out:
             stderr += "\n[超时 %ss，已终止进程树]" % timeout
@@ -739,7 +863,12 @@ _TRANSIENT = ("503", "502", "529", "429", "no available channel", "temporarily",
               # 2026-09-20 连载评审实测：codex 网关断流（stream disconnected）
               # 与 opencode 服务端 500（Unexpected server error）都是「重试/换将
               # 就可能活」的瞬态病，旧表判成终态导致整链早死
-              "stream disconnected", "unexpected server error")
+              "stream disconnected", "unexpected server error",
+              # 2026-09-22 mo-so 实案：claude 报 "Can't reach the API server —
+              # check your internet or DNS (ENOTFOUND)"，一家端点解析不到不代表
+              # 跨厂商链上别家也不通，旧表判成终态直接跳去换将别的 CLI
+              "enotfound", "getaddrinfo", "name or service not known",
+              "name resolution")
 
 
 def _transient_error(err):
@@ -747,10 +876,12 @@ def _transient_error(err):
     return any(k in err for k in _TRANSIENT)
 
 
-# 欠费/配额耗尽：换 KEY 与换厂商都该继续（同厂商另一账号往往还能用）。
+# 欠费/配额/限流耗尽：换 KEY 与换厂商都该继续（同厂商另一账号往往还能用）。
 # 与 modelhub._QUOTA_HINTS 同源，这里独立一份避免 core 模块间循环依赖。
 _QUOTA = ("insufficient", "quota", "balance", "credit", "billing", "arrears",
-          "payment required", "402", "欠费", "余额", "额度", "exceeded")
+          "payment required", "402", "欠费", "余额", "额度", "exceeded",
+          "too many requests", "rate limit", "rate_limit", "http 429",
+          "并发", "超过限")
 
 
 def _quota_error(err):
@@ -758,6 +889,64 @@ def _quota_error(err):
     return any(k in err for k in _QUOTA)
 
 
+# 限流（429）专项：与一般瞬态不同，它是「等一个窗口就常能自愈」的病——
+# 2026-09-22 四连败实测：claude ENOTFOUND 换将 codex 后仍与同一上游撞 429，
+# 链上无第三条路时整步立刻判死；而限流窗口通常按分钟计，原地等一个窗口
+# 再试一次，好过把整轮 run 直接烧成 failed（欠费不同源，不适用宽限）。
+_RATE_LIMIT = ("429", "rate limit", "too many requests", "限流")
+RATE_LIMIT_GRACE_S = 45      # 宽限等待时长：限流窗口通常按分钟计，等一个再试
+RATE_LIMIT_GRACE_N = 1       # 每步宽限次数：只兜一次，防限流长拖整轮时间
+
+
+def _rate_limited(err):
+    err = (err or "").lower()
+    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:
+        try:
+            with open(log_path, "a", encoding="utf-8") as fh:
+                fh.write("\n[限流宽限] %s：等待 %ds 后原地重试一次\n"
+                         % (why or "上游限流（429）", seconds))
+        except Exception:
+            pass
+    end = time.time() + seconds
+    while time.time() < end:
+        if cancel_event is not None and cancel_event.is_set():
+            return False
+        time.sleep(min(3, max(0.5, end - time.time())))
+    return cancel_event is None or not cancel_event.is_set()
+
+
 def _report_key(att, out):
     """把这次尝试的结果回写到 KEY 账本：欠费/失败 → 冷却，成功 → 清错误。
 
@@ -825,10 +1014,10 @@ def _resolve_attempts(agent):
     """
     chain = agent.get("call_chain") or []
     if chain:
-        return [{"model": (e.get("model") or "").strip() or None,
-                 "env": dict(e.get("env") or {}),
-                 "provider": e.get("provider") or {},
-                 "from_chain": True,
+        return [{"model": (e.get("model") or "").strip() or None,
+                 "env": dict(e.get("env") or {}),
+                 "provider": e.get("provider") or {},
+                 "from_chain": True,
                  "own_cp": "codex_provider" in e,
                  "codex_provider": e.get("codex_provider"),
                  "provider_id": e.get("provider_id") or "",
@@ -836,12 +1025,12 @@ def _resolve_attempts(agent):
     base_model = agent.get("model")
     fb = [m for m in (agent.get("model_fallbacks") or []) if m and m != base_model]
     models_to_try = ([base_model] if base_model else []) + fb
-    provider = agent.get("provider") or {}
-    return [{"model": m or None, "env": {}, "provider": provider,
-             "from_chain": False, "own_cp": False,
-             "codex_provider": None,
-             "provider_id": provider.get("id") if isinstance(provider, dict) else "",
-             "key_id": ""}
+    provider = agent.get("provider") or {}
+    return [{"model": m or None, "env": {}, "provider": provider,
+             "from_chain": False, "own_cp": False,
+             "codex_provider": None,
+             "provider_id": provider.get("id") if isinstance(provider, dict) else "",
+             "key_id": ""}
             for m in (models_to_try or [None])[:3]]
 
 
@@ -883,9 +1072,9 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
     stdin_text = None
     tmp_files = []
     imgs = [str(p) for p in (images or []) if p]
-    if kind == "codex":
-        cp = agent.get("codex_provider")
-        reasoning = str(agent.get("reasoning_effort") or "").strip().lower()
+    if kind == "codex":
+        cp = agent.get("codex_provider")
+        reasoning = str(agent.get("reasoning_effort") or "").strip().lower()
         if sid:
             # resume 子命令不支持 -s 也不支持 --full-auto（0.154 实测：
             # "unexpected argument '--full-auto'"）——读/写模式都用 -c sandbox_mode
@@ -895,18 +1084,18 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
             if model:
                 argv += ["-m", model]
             argv += ["-c", 'sandbox_mode="%s"' % _codex_sandbox(readonly)]
-            if cp:
-                argv += _codex_provider_args(cp)
+            if cp:
+                argv += _codex_provider_args(cp)
         else:
             argv = resolve_command(agent["command"]) + [
                 "exec", "--skip-git-repo-check", "--json",
                 "-s", _codex_sandbox(readonly)]
             if model:
                 argv += ["-m", model]
-            if cp:
-                argv += _codex_provider_args(cp)
-        if reasoning in ("low", "medium", "high", "xhigh"):
-            argv += ["-c", 'model_reasoning_effort="%s"' % reasoning]
+            if cp:
+                argv += _codex_provider_args(cp)
+        if reasoning in ("low", "medium", "high", "xhigh"):
+            argv += ["-c", 'model_reasoning_effort="%s"' % reasoning]
         # codex exec 与 exec resume 都支持 -i：图片直接附到 prompt（exec resume 的
         # -i 附在恢复后发送的首条消息上，即本次 stdin prompt）
         for p in imgs:
@@ -932,6 +1121,21 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
             # 模型以为环境受限谎报「被策略拦截」躺平（同 codex 沙箱误判案）。
             # 默认跳过全部权限检查（2026-09-17 用户拍板），env 可收回旧行为。
             argv += ["--dangerously-skip-permissions"]
+        # 绑定链 env 落一次性 --settings：claude CLI 里用户 settings.json 的 env
+        # 会覆盖进程 env（2026-09-22 双监听器实测），光靠 run_process 的 env 注入，
+        # 链首供应商会被用户配置顶掉（a.test 毒配置案的放大器）。--settings 的
+        # 优先级高于用户 settings.json（同日实测），临时文件进程结束随 tmp_files 删。
+        ant = {k: v for k, v in (agent.get("env") or {}).items()
+               if k.startswith("ANTHROPIC_")}
+        if ant:
+            try:
+                fd, sp = tempfile.mkstemp(prefix="tutti_claude_settings_", suffix=".json")
+                with os.fdopen(fd, "w", encoding="utf-8") as f:
+                    json.dump({"env": ant}, f)
+                argv += ["--settings", sp]
+                tmp_files.append(sp)
+            except Exception:
+                pass   # 落盘失败退回纯 env 注入（旧路径），不拦运行
         stdin_text = prompt
     elif kind == "opencode":
         argv = resolve_command(agent["command"]) + ["run"]
@@ -954,11 +1158,17 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
         if model:
             argv += ["-m", model]
         stdin_text = prompt
-    elif kind == "aider":
-        argv = resolve_command(agent["command"]) + [
-            "--yes-always", "--no-auto-commits", "--no-check-update",
-            "--no-gitignore", "--no-pretty", "--no-stream",
-            # 网关自定义模型名（glm-5.1 等）litellm 全都不认识，警告页+建议列表
+    elif kind == "aider":
+        argv = resolve_command(agent["command"]) + [
+            "--yes-always", "--no-auto-commits", "--no-check-update",
+            "--no-gitignore", "--no-pretty", "--no-stream",
+            # 无头执行没有 Windows 控制台，aider 建 PromptSession 抛错并打一行
+            # "Can't initialize prompt toolkit: No Windows console found..."
+            # （非致命，但它排在输出最前，UI 失败摘要只取头部 → 真错误被顶掉，
+            # 2026-09-22 mo-so 实案整条失败原因显示成这句噪声）。关掉花式输入
+            # 就不再建 PromptSession，噪声从源头消失。
+            "--no-fancy-input",
+            # 网关自定义模型名（glm-5.1 等）litellm 全都不认识，警告页+建议列表
             # 纯属刷屏（2026-09-20 实测占满步骤日志头部）
             "--no-show-model-warnings", "--message", prompt]
         if model:
@@ -1030,7 +1240,7 @@ def _stall_timeout(env_name, default):
         return default
 
 
-def run_agent(agent, prompt, workdir=None, readonly=True,
+def run_agent(agent, prompt, workdir=None, readonly=True,
               timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None, resume=None,
               images=None, require_tools=False):
     """执行一次智能体调用，返回统一结构
@@ -1053,14 +1263,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     orch_timeout_ms = (agent.get("orch") or {}).get("timeout_ms")
     if orch_timeout_ms:
         timeout = float(orch_timeout_ms) / 1000.0
-    kind = agent.get("kind", "generic")
-    if kind == "aider":
-        repo_issue = _git_repo_issue(workdir)
-        if repo_issue:
-            return {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
-                    "tokens": 0, "usage": None, "error": repo_issue,
-                    "error_code": ErrorCode.VENDOR_ERROR, "raw": None,
-                    "kind": kind, "model": agent.get("model")}
+    kind = agent.get("kind", "generic")
+    if kind == "aider":
+        repo_issue = _git_repo_issue(workdir)
+        if repo_issue:
+            return {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
+                    "tokens": 0, "usage": None, "error": repo_issue,
+                    "error_code": ErrorCode.VENDOR_ERROR, "raw": None,
+                    "kind": kind, "model": agent.get("model")}
     if kind == "codex":
         stall_t = _stall_timeout("TUTTI_CODEX_STALL_TIMEOUT", 600)
     elif kind == "claude":
@@ -1097,6 +1307,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
 
     attempts = _resolve_attempts(agent)
     out = None
+    grace_left = RATE_LIMIT_GRACE_N  # 链尾限流宽限预算：整链撞 429 时原地等一个窗口再试一次
     for ai, att in enumerate(attempts):
         env = dict(base_env)
         env.update(att["env"])
@@ -1118,12 +1329,12 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 att["model"], prompt,
                 images=images if kind == "codex" else None,
                 workdir=workdir)
-            try:
-                repeat_guard = (("Reconnecting... waiting for network", 5)
-                                if kind == "codex" else None)
-                res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
-                                  timeout=timeout, cancel_event=cancel_event, log_path=log_path,
-                                  stall_timeout=stall_t, repeat_abort=repeat_guard)
+            try:
+                repeat_guard = (("Reconnecting... waiting for network", 5)
+                                if kind == "codex" else None)
+                res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
+                                  timeout=timeout, cancel_event=cancel_event, log_path=log_path,
+                                  stall_timeout=stall_t, repeat_abort=repeat_guard)
             finally:
                 # 超长指令临时文件：CLI 进程已结束（管道已收），即刻清场不污染工作目录
                 for tf in tmp_files:
@@ -1131,11 +1342,11 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                         os.remove(tf)
                     except OSError:
                         pass
-            out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
-                   "tokens": 0, "usage": None, "error": "", "error_code": "",
-                   "sid": "", "raw": res, "kind": kind, "model": att["model"],
-                   "provider_id": att.get("provider_id") or "",
-                   "provider": att.get("provider") or {}}
+            out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
+                   "tokens": 0, "usage": None, "error": "", "error_code": "",
+                   "sid": "", "raw": res, "kind": kind, "model": att["model"],
+                   "provider_id": att.get("provider_id") or "",
+                   "provider": att.get("provider") or {}}
             if not res["ok"]:
                 # stderr 与 stdout 都要进错误串：codex 把 "Reading prompt from
                 # stdin..." 打在 stderr，真正的配额/限流错误全在 stdout 的 JSONL
@@ -1159,11 +1370,11 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     parsed_err = _parse_claude_json(res["stdout"] or "")
                     if parsed_err and parsed_err.get("is_error") and parsed_err.get("text"):
                         out["error"] = "claude 返回 is_error: " + parsed_err["text"][:500]
-                if kind == "codex" and att.get("provider_id"):
-                    el = out["error"].lower()
-                    if (("wire_api" in el and "no longer supported" in el)
-                            or "no route matched" in el
-                            or "同一网络错误重复" in out["error"]):
+                if kind == "codex" and att.get("provider_id"):
+                    el = out["error"].lower()
+                    if (("wire_api" in el and "no longer supported" in el)
+                            or "no route matched" in el
+                            or "同一网络错误重复" in out["error"]):
                         # codex 撞 chat-only 供应商（0.154 只讲 responses）：
                         # 自动冷却该供应商 30 分钟，链展开/路由绑定分随之
                         # 自动绕开——不用人工改绑定（2026-09-17 mo-so 实测）
@@ -1186,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":
@@ -1244,6 +1462,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
             break
         _report_key(att, out)
         if out["ok"] or ai == len(attempts) - 1:
+            if (not out["ok"] and grace_left > 0 and _rate_limited(out.get("error"))
+                    and not (cancel_event is not None and cancel_event.is_set())):
+                # 链尾限流宽限：enumerate 活列表——把链尾这条 append 回去，
+                # 下一轮迭代就是「原地重试一次」；再撞限流时预算已耗尽照常判死。
+                grace_left -= 1
+                if _grace_wait(cancel_event, RATE_LIMIT_GRACE_S, log_path=log_path):
+                    attempts.append(att)
+                    continue
             return out
         # 瞬态网络错误 → 换下一条；欠费/配额耗尽同样换（可能是同厂商的备用 KEY，
         # 也可能是另一家厂商）——账单断了死磕同一把 KEY 没有任何意义。