codebee 0.1.18 → 0.1.19

package/app/core/cleanup.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+"""每日垃圾清理：只清 CodeBee 自己产生的可再生数据，绝不碰用户成果。
+
+垃圾来源（实测 data/ 923MB 构成）：
+  - runs/<id>/steps/*.log   运行过程日志，单文件可达 22MB（保留 run.json
+                            与 report.md，运行记录/结果页签不受影响）
+  - publish/shots/          发布过程截图证据
+  - data 根 *.bak*          配置改写工具留下的备份残留
+  - pending/                运行中指挥信箱的过期附件
+  - publish/profiles/       浏览器 profile 迁移残留（新版已搬家目录，
+                            旧位置 688MB 实测；仅当家目录同款平台目录
+                            存在——即迁移已完成——才按废弃清理）
+  - exports/ imports/       备份模块自己的历史产物
+  - data 根 *.log           服务日志按体量截尾，不是按天删
+
+调度挂在 automation._tick（fire_due 自节流：启用 + 当天没清过才真跑）。
+配置在 data/settings.json（cleanup_enabled / cleanup_retention_days），
+状态在 data/cleanup.json（last_run/last_freed/history 供设置页展示）。
+
+发布浏览器 profile（家目录 ~/.codebee/publish_profiles，约 1GB）含平台
+登录态，清了要重新扫码——绝不进每日自动清理，只留手动入口
+（run_cleanup(include_profiles=True)）。
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+from . import paths, settings as settings_mod
+
+DEFAULT_RETENTION_DAYS = 14
+LOG_MAX_BYTES = 5 * 1024 * 1024      # 服务日志超过这个体量才截
+LOG_KEEP_BYTES = 1 * 1024 * 1024     # 截尾保留的末段
+STATE_NAME = "cleanup.json"
+
+
+# ---------------------------------------------------------------- 状态
+
+def _state_path():
+    return Path(paths.DATA_DIR) / STATE_NAME
+
+
+def _load_state():
+    try:
+        d = json.loads(_state_path().read_text(encoding="utf-8"))
+        return d if isinstance(d, dict) else {}
+    except Exception:
+        return {}
+
+
+def _save_state(st):
+    p = _state_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(st, ensure_ascii=False, indent=2), encoding="utf-8")
+    os.replace(str(tmp), str(p))
+
+
+def _profiles_base(home=None):
+    """家目录浏览器 profile 根（与 publish/manager 同款落点）。home 供测试注入。"""
+    if home:
+        return Path(home) / ".codebee" / "publish_profiles"
+    return Path.home() / ".codebee" / "publish_profiles"
+
+
+def _parse_local_dt(s):
+    try:
+        return time.mktime(time.strptime(str(s)[:19], "%Y-%m-%d %H:%M:%S"))
+    except Exception:
+        return None
+
+
+# ---------------------------------------------------------------- 扫描
+
+def _run_ended(run_dir, cutoff_ts):
+    """run 目录整体是否过期：看 run.json 的 ended_at；没有就退回目录 mtime。"""
+    rj = run_dir / "run.json"
+    if rj.is_file():
+        ts = None
+        try:
+            ts = _parse_local_dt(json.loads(rj.read_text(encoding="utf-8"))
+                                 .get("ended_at"))
+        except Exception:
+            ts = None
+        if ts:
+            return ts < cutoff_ts
+    try:
+        return run_dir.stat().st_mtime < cutoff_ts
+    except OSError:
+        return False
+
+
+def _plan_items(retention_days=None, include_profiles=False, home=None, now=None):
+    """扫描各类垃圾，返回条目列表。每条：key/label/note/bytes/count/files，
+    files 元素为 {path, op}，op ∈ delete | rmtree | truncate。"""
+    now = now or time.time()
+    try:
+        days = int(retention_days if retention_days is not None
+                   else settings_mod.load().get("cleanup_retention_days"))
+    except (TypeError, ValueError):
+        days = DEFAULT_RETENTION_DAYS
+    days = max(1, min(365, days))
+    cutoff = now - days * 86400
+    data_dir = Path(paths.DATA_DIR)
+    items = []
+
+    def add(key, label, note, files):
+        size = 0
+        good = []
+        for f in files:
+            try:
+                p = Path(f["path"])
+                if f["op"] == "truncate":
+                    sz = p.stat().st_size - LOG_KEEP_BYTES
+                elif p.is_dir():
+                    sz = sum(x.stat().st_size for x in p.rglob("*") if x.is_file())
+                else:
+                    sz = p.stat().st_size
+            except OSError:
+                continue
+            # truncate 只在有得砍时才留；delete/rmtree 即使 0 字节（空目录）也要清
+            if sz > 0 or f["op"] != "truncate":
+                good.append(f)
+            size += max(0, sz)
+        if good:
+            items.append({"key": key, "label": label, "note": note,
+                          "bytes": size, "count": len(good), "files": good})
+
+    # 1) 过期运行的过程日志（保留 run.json / report.md / 封面）
+    runs_dir = data_dir / "runs"
+    files = []
+    if runs_dir.is_dir():
+        for rd in runs_dir.iterdir():
+            if not rd.is_dir() or not _run_ended(rd, cutoff):
+                continue
+            steps = rd / "steps"
+            if steps.is_dir():
+                files.append({"path": str(steps), "op": "rmtree"})
+    add("runs_old_logs", "运行过程日志",
+        "保留运行记录与结果报告，只删过程中的原始日志", files)
+
+    # 2) 发布截图
+    shots = data_dir / "publish" / "shots"
+    add("publish_shots", "发布截图", "发布过程留档截图，超期即清",
+        [{"path": str(p), "op": "delete"}
+         for p in (shots.iterdir() if shots.is_dir() else [])
+         if p.is_file() and p.stat().st_mtime < cutoff])
+
+    # 3) 配置备份残留 *.bak*
+    add("bak_files", "配置备份残留", "改配置时自动留的 .bak 副本，超期即清",
+        [{"path": str(p), "op": "delete"}
+         for p in data_dir.glob("*.bak*")
+         if p.is_file() and p.stat().st_mtime < cutoff])
+
+    # 4) 过期指挥信箱（运行早已结束，附件永远不会被消费）
+    pend = data_dir / "pending"
+    files = []
+    for p in (pend.iterdir() if pend.is_dir() else []):
+        try:
+            if p.stat().st_mtime >= cutoff:
+                continue
+        except OSError:
+            continue
+        files.append({"path": str(p), "op": "rmtree" if p.is_dir() else "delete"})
+    add("pending_stale", "过期指挥信箱", "已结束任务的运行中留言附件",
+        files)
+
+    # 5) 浏览器 profile 迁移残留：家目录同款平台目录存在（迁移已完成）才清
+    legacy = data_dir / "publish" / "profiles"
+    files = []
+    if legacy.is_dir():
+        for p in legacy.iterdir():
+            if not p.is_dir():
+                continue
+            try:
+                if (_profiles_base(home) / p.name).exists():
+                    files.append({"path": str(p), "op": "rmtree"})
+            except OSError:
+                continue
+    add("legacy_profiles", "旧版浏览器缓存残留",
+        "发布浏览器 profile 已迁往用户主目录，旧位置属废弃残留", files)
+
+    # 6) 历史备份包（导出 zip / 导入前自动备份，超期即清）
+    files = []
+    for d in ("exports", "imports"):
+        base = data_dir / d
+        for p in (base.iterdir() if base.is_dir() else []):
+            try:
+                if p.stat().st_mtime < cutoff:
+                    files.append({"path": str(p),
+                                  "op": "rmtree" if p.is_dir() else "delete"})
+            except OSError:
+                continue
+    add("backups_old", "历史备份包", "导出与导入前自动备份的旧 zip", files)
+
+    # 7) 服务日志截尾（不删文件，砍掉前段）
+    files = [{"path": str(p), "op": "truncate"}
+             for p in data_dir.glob("*.log")
+             if p.is_file() and p.stat().st_size > LOG_MAX_BYTES]
+    add("logs_truncate", "服务日志瘦身", "只保留每个日志的末尾 1MB", files)
+
+    # 8) 手动：发布浏览器缓存（含登录态，清了要重新扫码；绝不自动清）
+    if include_profiles:
+        base = _profiles_base(home)
+        files = [{"path": str(p), "op": "rmtree"}
+                 for p in (base.iterdir() if base.is_dir() else []) if p.is_dir()]
+        add("publish_profiles", "发布浏览器缓存",
+            "含平台登录态，清理后发布时需重新扫码登录", files)
+    return {"retention_days": days, "items": items,
+            "total_bytes": sum(i["bytes"] for i in items)}
+
+
+def plan(retention_days=None, include_profiles=False, home=None):
+    return _plan_items(retention_days=retention_days,
+                       include_profiles=include_profiles, home=home)
+
+
+def status():
+    """设置页一次拉全：配置 + 上次清理状态 + 当前可清理预估。"""
+    cfg = settings_mod.load()
+    return {"config": {"enabled": bool(cfg.get("cleanup_enabled")),
+                       "retention_days": cfg.get("cleanup_retention_days")},
+            "state": _load_state(), "plan": plan()}
+
+
+# ---------------------------------------------------------------- 执行
+
+def _delete_path(p: Path, op):
+    if op == "rmtree":
+        import shutil
+        shutil.rmtree(str(p), ignore_errors=False)
+    elif op == "truncate":
+        with open(str(p), "rb") as f:
+            f.seek(-LOG_KEEP_BYTES, 2)
+            tail = f.read()
+        tmp = p.with_suffix(".tmp-cl")
+        tmp.write_bytes(tail)
+        os.replace(str(tmp), str(p))
+    else:
+        p.unlink()
+
+
+def run_cleanup(retention_days=None, include_profiles=False):
+    """按当前扫描结果执行清理。返回汇总并落状态（供设置页展示）。"""
+    scan = _plan_items(retention_days=retention_days,
+                       include_profiles=include_profiles)
+    freed = 0
+    done = []
+    errors = []
+    for item in scan["items"]:
+        got = 0
+        n = 0
+        for f in item["files"]:
+            try:
+                p = Path(f["path"])
+                if f["op"] == "truncate":
+                    sz = p.stat().st_size - LOG_KEEP_BYTES
+                elif p.is_dir():
+                    sz = sum(x.stat().st_size for x in p.rglob("*") if x.is_file())
+                else:
+                    sz = p.stat().st_size
+                _delete_path(p, f["op"])
+                got += max(0, sz)
+                n += 1
+            except OSError as e:
+                errors.append("%s：%s" % (f["path"], e.strerror or e))
+        if n:
+            done.append({"key": item["key"], "label": item["label"],
+                         "bytes": got, "count": n})
+            freed += got
+    result = {"ts": time.strftime("%Y-%m-%d %H:%M:%S"), "freed": freed,
+              "items": done, "errors": errors[:10],
+              "include_profiles": bool(include_profiles)}
+    st = _load_state()
+    st["last_run"] = result["ts"]
+    st["last_freed"] = freed
+    st["last_result"] = result
+    hist = st.get("history") or []
+    hist.insert(0, {"ts": result["ts"], "freed": freed})
+    st["history"] = hist[:30]
+    _save_state(st)
+    try:
+        from . import store
+        store.bump_state()
+    except Exception:
+        pass
+    return result
+
+
+def fire_due():
+    """automation._tick 每拍调用：启用且当天没清过才真跑，否则零开销返回。"""
+    try:
+        cfg = settings_mod.load()
+    except Exception:
+        return None
+    if not cfg.get("cleanup_enabled"):
+        return None
+    today = time.strftime("%Y-%m-%d")
+    if str(_load_state().get("last_run") or "").startswith(today):
+        return None
+    return run_cleanup()

package/app/core/flows.py

@@ -76,7 +76,7 @@ BUILTIN_FLOWS = [
      "note": "起草 → 多维评审 → 修订循环 → 发布门禁"},
     {"id": "rank_scan", "name": "扫榜选材", "icon": "i-chart", "engine": "direct", "builtin": True,
      "goal_hint": "想写哪个方向（一句话，可留空默认分析总榜热门题材）",
-     "note": "抓取七猫排行榜公开数据 → AI 提炼热门题材/人设/差异化切入点（快档直出报告）"},
+     "note": "抓取七猫+番茄排行榜公开数据 → AI 提炼跨平台热门题材/人设/差异化切入点（快档直出报告）"},
     {"id": "research", "name": "调研报告", "icon": "i-file-search", "engine": "review", "builtin": True,
      "manuscript": "report.md",
      "rubric": ["全面性", "深度", "论据可靠", "可读性", "结论质量"],

package/app/core/jobs.py

@@ -156,6 +156,18 @@ def cancel(run_id):
     ev = CANCELS.get(run_id)
     if ev:
         ev.set()
+        # 强制终止语义：置位事件后立刻把 running 落成 cancelled 终态，
+        # UI 即刻翻牌，不等流水线走到下一个检查点（CLI 子进程树由取消
+        # 事件在 run_process 的 0.4s 轮询里秒杀；内置智能体生成中的 HTTP
+        # 由取消等待方放弃）。expected_status 守卫保证已正常结束的运行
+        # 不被误改；流水线随后照常收尾，终态幂等。
+        try:
+            from . import store
+            store.update_run(run_id, expected_status="running",
+                             status="cancelled", ended_at=_now(),
+                             error="用户主动取消")
+        except Exception:
+            pass
         return True
     # 事件不存在=任务还在队列里没被 worker 拿起：直接落终态（取消事件在
     # worker 起跑时才创建，排队任务点取消会在这里漏掉——起跑后再杀一遍）。
@@ -576,12 +588,13 @@ def _do_mgmt(job, ev):
                           cost_usd=res.get("cost_usd", 0.0), tokens=res.get("tokens", 0))
     else:
         store.finish_step(run_id, step["n"], "failed", summary="未知操作 %s" % op)
-    # 以步骤状态汇总 run 状态
+    # 以步骤状态汇总 run 状态；expected_status 守卫：用户已强制终止的运行
+    # 保持 cancelled，不被步骤汇总改写成 failed（被杀的步骤记的就是非 done）
     run = store.get_run(run_id)
     statuses = [s["status"] for s in (run.get("steps") if run else [])] or ["failed"]
     final = "done" if all(s == "done" for s in statuses) else "failed"
     suffix = "（AI 修复成功）" if ok and len((run.get("steps") if run else [])) > 1 else ""
-    store.update_run(run_id, status=final, ended_at=_now(),
+    store.update_run(run_id, expected_status="running", status=final, ended_at=_now(),
                      summary=("%s %s %s%s" % (entry.get("name"), op,
                                               "完成" if final == "done" else "失败", suffix)))
 
@@ -600,7 +613,9 @@ def _do_selfupgrade(job):
                       summary="升级完成，点「重启」生效" if res["ok"]
                       else ("升级失败: " + res["error"][:300]),
                       exit_code=res.get("exit_code"))
-    store.update_run(run_id, status="done" if res["ok"] else "failed", ended_at=_now(),
+    # expected_status 守卫：用户已强制终止的运行保持 cancelled，不被改写
+    store.update_run(run_id, expected_status="running",
+                     status="done" if res["ok"] else "failed", ended_at=_now(),
                      summary="CodeBee selfupgrade %s" % ("完成" if res["ok"] else "失败"))
 
 
@@ -619,7 +634,10 @@ def _ai_repair(run_id, entry, ev, failed_cmd, orig_log):
     if agent is None or agent.get("mode") != "real":
         return False  # 无真实智能体可用，维持原失败
     try:
-        log_tail = runner.tail_decoded(orig_log.read_bytes(), 2000) if orig_log.exists() else "（无输出）"
+        # 日志尾巴喂进 AI 修复提示词：先洗终端噪声，否则 ANSI 转义/乱码墙会被
+        # 模型当成"日志原文"照抄进修复推理里
+        log_tail = runner.clean_cli_text(
+            runner.tail_decoded(orig_log.read_bytes(), 2000)) if orig_log.exists() else "（无输出）"
     except Exception:
         log_tail = "（日志不可读）"
     import shutil

package/app/core/knowledge.py

@@ -6,8 +6,10 @@
   - 知识（knowledge）记「已知是这样」——领域事实/平台规则/结论/方法论，
     来源=run 产出材料（调研报告/文档）。两者输入源不同，提炼互不双写。
 
-质量闸门：自动提炼的条目一律落 draft（草稿态），人工「转正」后才参与注入——
-垃圾知识进了提示词比没有知识更糟；手动新建即视为已确认（直接 approved）。
+质量闸门：条目默认直接转正（approved）参与注入——用户拍板：人工把关太重，
+提炼提示词里的「只保留有明确复用价值的」约束兜质量。status 字段保留 draft
+枚举向后兼容，手动新建同样直接 approved；migrate_drafts_approved() 在启动时
+把历史草稿一次性转正。
 
 注入纪律（与教训反着来）：教训是全量小注（top-8），知识默认不注入——
 scope 命中且库里有 approved 条目才成块，按与任务目标的相关性取 top，
@@ -299,12 +301,15 @@ def learn_from_run(run_id):
     """运行结束后由编排者从产出材料提炼知识条目（草稿态）。返回写入条数。
 
     知识没有便宜的兜底路径：无编排者/无产出/非真实运行（mock）一律静默跳过，
-    宁缺毋滥——教训库的规则兜底搬到这里只会制造垃圾知识。
+    宁缺毋滥——教训库的规则兜底搬到这里只会制造垃圾知识。只有正常跑完（done）
+    的运行才提炼：失败/取消的运行产物是半成品，据此沉淀的知识会污染知识库。
     """
     from . import store
     run = store.get_run(run_id)
     if not run:
         return 0
+    if (run.get("status") or "") != "done":
+        return 0
     task = store.get_task(run.get("task_id")) if run.get("task_id") else None
     if not task:
         return 0
@@ -339,7 +344,7 @@ def learn_from_run(run_id):
                 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="draft"):
+                            as_of=as_of, status="approved"):
                 n += 1
     except Exception:
         return n
@@ -356,6 +361,23 @@ def learn_async(run_id):
     threading.Thread(target=_run, name="kb-learn", daemon=True).start()
 
 
+def migrate_drafts_approved():
+    """一次性迁移：草稿闸门退役（默认直接转正），把历史 draft 全部转正。
+
+    幂等——没有 draft 时零写入。返回转正条数。"""
+    with _LOCK:
+        data = _load()
+        items = data.get("entries") or []
+        dirty = [x for x in items if (x.get("status") or "draft") != "approved"]
+        if not dirty:
+            return 0
+        for x in dirty:
+            x["status"] = "approved"
+            x["updated_at"] = _now()
+        _save(data)
+        return len(dirty)
+
+
 def view():
     """知识库总览（给 UI/API）：条目 + 标签聚合 + 草稿数 + 账龄标记。"""
     entries = list_entries()

package/app/core/manager.py

@@ -859,6 +859,21 @@ def _toml_top_set(text, key, value):
     return eol.join(lines).rstrip("\r\n") + eol, True
 
 
+_TEST_HOST_SUFFIXES = (".test", ".example", ".invalid", ".localhost")
+
+
+def _is_dead_endpoint(base):
+    """明显打不通的测试/保留地址（*.test、*.example、example.com 等）。
+    这类端点落进 config.toml 后 codex 每次请求都撞死墙——2026-09-20
+    orch/p1.test 残留反复劫持全局配置的事故教训：宁可不写，不写必死端点。"""
+    host = (base or "").split("://", 1)[-1].split("/", 1)[0].split("@")[-1]
+    host = host.split(":")[0].lower().rstrip(".")
+    if not host:
+        return True
+    return (host in ("example.com", "example.org", "example.net", "localhost")
+            or host.endswith(_TEST_HOST_SUFFIXES))
+
+
 def _sync_codex_settings(entry, model, cp):
     """codex 专属：把绑定供应商与模型写进 ~/.codex/config.toml
     （[model_providers.orch] 段 + 顶层 model_provider/model）。
@@ -867,6 +882,8 @@ def _sync_codex_settings(entry, model, cp):
     没有 config.toml 里的 provider 段，绑定模型根本无处可用；而 model 单写
     不写 provider 会指到 codex 自带 openai 官方端点上（401）。与编排的
     _codex_provider_args 同构，但落 config 文件。返回错误串或 None。"""
+    if _is_dead_endpoint(cp.get("base_url")):
+        return "供应商端点 %r 是测试/保留地址，拒绝写入 config.toml" % (cp.get("base_url"),)
     path = _config_path(entry)
     if not path:
         return "codex 配置路径无效"
@@ -1459,6 +1476,12 @@ def sync_runtime_config(agent):
                     break
         if entry is None or not (entry.get("config") or {}).get("path"):
             return
+        if entry["id"] in ("codex-cli", "codex"):
+            return   # codex 绝不在运行防线上落盘（2026-09-20 orch 劫持事故）：
+                     # 编排步骤走 runner 的 -c 一次性注入，不依赖 config.toml；
+                     # 在这里写盘会把全局 ~/.codex/config.toml 的 model_provider
+                     # 顶掉（CC Switch / 用户手动选的供应商被劫持）。交互 TUI
+                     # 场景由 launch() 自行同步，且端点防线在 _sync_codex_settings。
         from . import modelhub
         binding = modelhub.resolve_binding(entry["id"]) or {}
         model = (binding.get("model") or "").strip()
@@ -1631,7 +1654,8 @@ def run_mgmt_command(entry, op, cancel_event=None, log_path=None):
         # 2026-09-18 dsh 案）。
         refresh_update_async(entry)
     return {"ok": res["ok"], "exit_code": res["exit_code"], "command": cmd,
-            "error": "" if res["ok"] else (res["stderr"][-800:] or "退出码 %s" % res["exit_code"])}
+            "error": "" if res["ok"] else (runner.clean_cli_text(res["stderr"])[-800:]
+                                           or "退出码 %s" % res["exit_code"])}
 
 
 def refresh_update_async(entry):

package/app/core/market.py

@@ -218,9 +218,19 @@ def install_files(pack_id, name, files, extra=None):
     """通用安装入口：任意 {安装相对路径: 文本内容} 写进用户包目录并记账。
     内置市场包（install）与外部目录插件（market_remote）共用这一条落地通道，
     避让 / 安装标记 / market.json 记账 / 幂等纪律完全一致；extra 追加进记账记录
-    （如外部插件的来源与版本）。"""
+    （如外部插件的来源与版本）。
+
+    装前静态扫描（借鉴 NVIDIA SkillSpector）：安装内容扫危险模式，风险行写进
+    返回值与记账——提示不拦阻（用户仍可装），但危险必须被看见。"""
     if not files or not any(str(v).strip() for v in files.values()):
         return None, "包内容为空: %s" % pack_id
+    # 装前扫描：全文件合并扫一遍（纯内存静态规则）
+    scan_note = ""
+    try:
+        from . import skill_scan
+        scan_note = skill_scan.scan_summary("\n".join(str(v) for v in files.values()))
+    except Exception:
+        scan_note = ""
     with _LOCK:
         udir = _user_pack_dir()
         reg = _load_registry()
@@ -249,12 +259,14 @@ def install_files(pack_id, name, files, extra=None):
             except OSError as e:
                 return None, "写入用户技能库失败: %s" % e
             record = {"file": target, "files": written, "installed_at": _now()}
+            if scan_note:
+                record["scan"] = scan_note   # 危险模式扫描结果随包记账
             if extra:
                 record.update(extra)
             installed[pack_id] = record
         _save_registry(reg)
     return {"ok": True, "id": pack_id, "name": name, "file": target,
-            "already": already}, None
+            "already": already, "scan": scan_note}, None
 
 
 def remove(pack_id):

package/app/core/modelhub.py

@@ -835,6 +835,12 @@ def _is_codex_target(target):
     return (target or "").strip().lower() in ("codex-cli", "codex", "codex-code")
 
 
+def _is_aider_target(target):
+    """aider 的绑定键与 orch.kind 同名（catalog id=aider）；兜底前缀匹配防变体。"""
+    t = (target or "").strip().lower()
+    return t == "aider" or t.startswith("aider-")
+
+
 def note_codex_wire_dead(provider_id, minutes=30):
     """codex 撞上 wire 不兼容的供应商 → 供应商级冷却（自动绕开的记账位）。
 
@@ -2037,8 +2043,18 @@ def _chain_entry_env(prov, model, target="", endpoint=None, key="", key_id="",
                       "ANTHROPIC_AUTH_TOKEN": use_key}
         if model:
             out["env"]["ANTHROPIC_MODEL"] = model
+        if _is_aider_target(target):
+            # aider（litellm）不认 AUTH_TOKEN，只认 ANTHROPIC_API_KEY——缺了它
+            # 直接报 LLM Provider NOT provided（2026-09-20 连载评审 aider 全灭根因）。
+            # claude 绝不注入：x-api-key 与 Bearer 两种鉴权头网关挑食，不能混。
+            out["env"]["ANTHROPIC_API_KEY"] = use_key
     else:
         out["env"] = {"ORCH_API_KEY": use_key}
+        if _is_aider_target(target):
+            # litellm 的 openai 通道读这对 env；base 语义与 codex chat wire 一致
+            # （调用方拼 /chat/completions）
+            out["env"]["OPENAI_API_KEY"] = use_key
+            out["env"]["OPENAI_API_BASE"] = base
         wire_api = endpoint[2] if endpoint else prov.get("wire_api", "responses")
         out["codex_provider"] = {
             "name": "orch", "base_url": base,