codebee 0.1.20 → 0.1.22

package/app/core/knowledge.py

@@ -2,9 +2,9 @@
 """知识库（Knowledge）：运行产出自动整理形成的可复用知识 + 个人知识管理入口。
 
 与经验库（skills.py）的分工边界：
-  - 教训（lessons）记「别这么做」——负面规则，来源=评审暴露的问题（verdict/issues）；
-  - 知识（knowledge）记「已知是这样」——领域事实/平台规则/结论/方法论，
-    来源=run 产出材料（调研报告/文档）。两者输入源不同，提炼互不双写。
+  - 经验（lessons）记「下次怎么做」——流程规范、实践方法和评审暴露的教训；
+  - 知识（knowledge）记「已知是什么」——领域事实、外部规则和可验证结论。
+运行产出中的实践方法会分流进经验库，事实才进入知识库，避免同一方法双写。
 
 质量闸门：条目默认直接转正（approved）参与注入——用户拍板：人工把关太重，
 提炼提示词里的「只保留有明确复用价值的」约束兜质量。status 字段保留 draft
@@ -243,10 +243,13 @@ def _bump_hits(ids):
 # ---------------------------------------------------------------- 自动整理
 
 KNOWLEDGE_PROMPT = """你是编排系统的知识管理员。下面是一次任务的目标与它的产出材料（调研报告/文档等）。
-请从产出中提炼**可长期复用的知识条目**：领域事实、平台规则、结论、方法论。
-注意：只提炼事实性/结论性内容；「下次要避免什么」这类负面教训由另一个复盘流程负责，你不要写。
+请从产出中提炼可长期复用的内容，并明确分成两类：
+- fact：回答「是什么」，只含领域事实、外部规则和可验证结论，进入知识库；
+- practice：回答「怎么做」，含流程、操作方法和正向实践，进入经验库；此类必须填写 category。
+「下次要避免什么」这类负面教训由评审复盘流程负责，不要重复提炼。
 只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"entries": [{"title": "≤20 字的知识标题", "body": "具体结论（≤200 字，自含上下文，脱离本次任务也能看懂）", "tags": ["1-3 个检索标签"], "as_of": "YYYY-MM-DD（事实采集日）"}]}
+{"entries": [{"kind": "fact 或 practice", "title": "≤20 字的标题", "body": "具体内容（≤200 字，自含上下文，脱离本次任务也能看懂）", "category": "practice 的经验分类", "tags": ["1-3 个检索标签"], "as_of": "YYYY-MM-DD（fact 的事实采集日）"}]}
+category 只能从以下枚举选择：__CATEGORIES__。
 最多 3 条，只保留有明确复用价值的；产出里没有值得沉淀的就返回空数组。
 
 ## 任务类型
@@ -298,7 +301,7 @@ def _pick_material(run):
 
 
 def learn_from_run(run_id):
-    """运行结束后由编排者从产出材料提炼知识条目（草稿态）。返回写入条数。
+    """运行结束后从产出提炼事实与实践并分流入库。返回总写入条数。
 
     知识没有便宜的兜底路径：无编排者/无产出/非真实运行（mock）一律静默跳过，
     宁缺毋滥——教训库的规则兜底搬到这里只会制造垃圾知识。只有正常跑完（done）
@@ -326,6 +329,7 @@ def learn_from_run(run_id):
             return 0
         prov, model = orch
         prompt = (KNOWLEDGE_PROMPT
+                  .replace("__CATEGORIES__", "、".join(skills.LESSON_CATEGORIES))
                   .replace("__TYPE__", str(task.get("type")))
                   .replace("__GOAL__", (task.get("goal") or "")[:600])
                   .replace("__MATERIAL__", material))
@@ -339,6 +343,14 @@ def learn_from_run(run_id):
         for x in raw[:3]:
             if not (isinstance(x, dict) and x.get("title") and x.get("body")):
                 continue
+            kind = str(x.get("kind") or "fact").strip().lower()
+            if kind == "practice":
+                if skills.upsert_lesson(task.get("type") or "*", x["title"],
+                                        x["body"], source=run_id,
+                                        category=x.get("category"),
+                                        dim="%s %s" % (x["title"], x["body"])):
+                    n += 1
+                continue
             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]

package/app/core/manager.py

@@ -31,11 +31,18 @@ _LOCK = threading.RLock()
 _STATE = {"detected": {}, "versions": {}, "detect_ts": 0.0, "detect_ev": None}
 
 # 能自动写入默认模型的 config.format（其余格式只能手动编辑）
-_WRITABLE_FORMATS = ("toml-line", "toml-section", "json", "json-path", "jsonc",
-                     "yaml-line")
-
-
-def _expand(p):
+_WRITABLE_FORMATS = ("toml-line", "toml-section", "json", "json-path", "jsonc",
+                     "yaml-line")
+
+
+def _read_text(path, preserve_newlines=False):
+    """读取文本并及时关闭句柄；改写配置前可保留原始换行符。"""
+    newline = "" if preserve_newlines else None
+    with open(path, encoding="utf-8", errors="replace", newline=newline) as fh:
+        return fh.read()
+
+
+def _expand(p):
     return os.path.abspath(os.path.expanduser(os.path.expandvars(p)))
 
 
@@ -475,7 +482,7 @@ def read_model(entry):
     if not path or not os.path.isfile(path) or not cfg.get("format"):
         return None
     try:
-        text = open(path, encoding="utf-8", errors="replace").read()
+        text = _read_text(path)
     except Exception:
         return None
     if cfg["format"] == "toml-line":
@@ -547,7 +554,7 @@ def write_model(entry, model):
             # mimo（mimocode.jsonc）有注释，整体重解析会丢注释——复用
             # _jsonc_set 做就地片段改写（只动目标键，其余原样保留）
             keys = (cfg.get("model_key") or "model").split(".")
-            text = open(path, encoding="utf-8", errors="replace", newline="").read()
+            text = _read_text(path, preserve_newlines=True)
             new_text, ok = _jsonc_set(text, tuple(keys),
                                       json.dumps(model, ensure_ascii=False))
             if not ok:
@@ -555,7 +562,7 @@ def write_model(entry, model):
                         "error": "jsonc 结构异常，未能就地写入 %s（已避免覆盖）" % path}
             Path(path).write_bytes(new_text.encode("utf-8"))
         elif fmt == "toml-line":
-            text = open(path, encoding="utf-8", errors="replace").read()
+            text = _read_text(path)
             new_line = 'model = "%s"' % model
             if re.search(r'(?m)^\s*model\s*=\s*"[^"]*"', text):
                 text = re.sub(r'(?m)^\s*model\s*=\s*"[^"]*"', new_line, text)
@@ -563,19 +570,19 @@ def write_model(entry, model):
                 text = text.rstrip("\n") + "\n" + new_line + "\n"
             Path(path).write_bytes(text.encode("utf-8"))
         elif fmt == "toml-section":
-            text = open(path, encoding="utf-8", errors="replace", newline="").read()
+            text = _read_text(path, preserve_newlines=True)
             text = _toml_write_value(text, *_dotted_key(cfg), value=model)
             Path(path).write_bytes(text.encode("utf-8"))
         elif fmt == "yaml-line":
             # newline="" 关掉通用换行转换：文本层面看不出 \r\n 就会被静默改写成 LF，
             # 用户的 Windows 配置不该因为写个模型名而整篇换行符被替换
-            text = open(path, encoding="utf-8", errors="replace", newline="").read()
+            text = _read_text(path, preserve_newlines=True)
             text = _yaml_write_value(text, *_yaml_model_path(cfg), value=model)
             Path(path).write_bytes(text.encode("utf-8"))
         elif fmt == "json-path":
             # openclaw（agents.defaults.model.primary）：默认模型藏在嵌套对象里，
             # 且 openclaw 对未知顶层键直接拒绝启动——绝不能写顶层 "model"
-            text = open(path, encoding="utf-8", errors="replace", newline="").read()
+            text = _read_text(path, preserve_newlines=True)
             try:
                 data = json.loads(text) if text.strip() else {}
             except Exception:
@@ -597,7 +604,7 @@ def write_model(entry, model):
                 json.dumps(data, ensure_ascii=False, indent=2).encode("utf-8"))
         else:
             try:
-                data = json.loads(open(path, encoding="utf-8", errors="replace").read())
+                data = json.loads(_read_text(path))
             except FileNotFoundError:
                 return {"ok": False,
                         "error": "配置文件尚未生成（%s 首次运行后才有），暂无法写入" % path}
@@ -655,7 +662,7 @@ def _launch_log_path(entry):
 def _best_url(log_path, port):
     """从启动日志提取该端口的信任 URL（含 token 优先）。无日志/未匹配返回 None。"""
     try:
-        text = open(str(log_path), encoding="utf-8", errors="replace").read()
+        text = _read_text(str(log_path))
     except Exception:
         return None
     urls = re.findall(r"https?://[^\s\"'<>]+", text)
@@ -755,7 +762,7 @@ def _sync_dsh_settings(entry, model, base_url):
         return "dsh 配置路径越出用户主目录，已拒绝"
     try:
         if os.path.isfile(path):
-            text = open(path, encoding="utf-8", errors="replace", newline="").read()
+            text = _read_text(path, preserve_newlines=True)
         else:
             Path(path).parent.mkdir(parents=True, exist_ok=True)
             text = ""
@@ -778,7 +785,7 @@ def _dsh_selfcheck_model(entry):
     if not path or not os.path.isfile(path):
         return None, ""
     try:
-        text = open(path, encoding="utf-8", errors="replace", newline="").read()
+        text = _read_text(path, preserve_newlines=True)
     except Exception:
         return None, ""
     cur = _yaml_read_value(text, "agent-default-model", "model")
@@ -802,7 +809,7 @@ def _dsh_key_present():
         return True
     try:
         envfile = os.path.join(os.path.expanduser("~"), ".dsh", ".env")
-        return "DEEPSEEK_API_KEY" in open(envfile, encoding="utf-8", errors="replace").read()
+        return "DEEPSEEK_API_KEY" in _read_text(envfile)
     except Exception:
         return False
 
@@ -908,7 +915,7 @@ def _sync_codex_settings(entry, model, cp):
              ("wire_api", q(cp.get("wire_api", "responses")))]
     try:
         if os.path.isfile(path):
-            text = open(path, encoding="utf-8", errors="replace", newline="").read()
+            text = _read_text(path, preserve_newlines=True)
         else:
             Path(path).parent.mkdir(parents=True, exist_ok=True)
             text = ""
@@ -1115,7 +1122,7 @@ def _sync_settings_env(path, updates, remove_keys=()):
     不覆盖；改动前 .bak。返回错误串或 None。path 必须已过主目录围栏校验。"""
     try:
         if os.path.isfile(path):
-            text = open(path, encoding="utf-8", errors="replace").read()
+            text = _read_text(path)
             try:
                 data = json.loads(text)
             except Exception:
@@ -1235,7 +1242,7 @@ def _sync_opencode_settings(entry, model, prov):
                 errs.append("路径越出主目录：%s" % path)
                 continue
             if os.path.isfile(path):
-                text = open(path, encoding="utf-8", errors="replace", newline="").read()
+                text = _read_text(path, preserve_newlines=True)
             else:
                 Path(path).parent.mkdir(parents=True, exist_ok=True)
                 text = ""
@@ -1326,7 +1333,7 @@ def _sync_kimi_settings(entry, model, prov):
             Path(path).parent.mkdir(parents=True, exist_ok=True)
             text = ""
             if os.path.isfile(path):
-                text = open(path, encoding="utf-8", errors="replace", newline="").read()
+                text = _read_text(path, preserve_newlines=True)
                 shutil.copyfile(path, path + ".bak")
             # 移除旧托管块与旧顶层键（防重复/防键落进别的表）
             text = _re.sub(r"# >>> CodeBee managed.*?# <<< CodeBee managed <<<\n?",
@@ -1403,7 +1410,7 @@ def _sync_agent_injection(entry, binding):
     if entry["id"] in _NO_CHANNEL_HINT:
         if binding.get("env"):
             return "已按绑定注入 env，但该 CLI 未必认 CodeBee 的凭据通道，打开后若要求登录请在其界面内登录"
-        return "未绑定可用供应商：打开后需在其自带界面登录；要打开即用请到「CLI 绑定」页绑定"
+        return "未指定可用供应商：打开后使用 CLI 自带登录；需要固定注入请到「模型调度（可选）」页指定"
     return None
 
 
@@ -1523,7 +1530,7 @@ def launch(entry, open_browser=True):
     notes = _sync_launch_model(entry, binding)
     if is_dsh and not (binding.get("env") or {}) and not _dsh_key_present():
         notes.append("未发现 dsh 密钥：打开后可能需在 dsh 内登录配置；"
-                     "要打开即用，请到「CLI 绑定」页给 DeepSeek Harness 绑定 openai 协议供应商")
+                     "要打开即用，请到「模型调度（可选）」页给 DeepSeek Harness 指定 openai 协议供应商")
     name = entry.get("name", entry["id"])
     kind = (launch.get("kind") or "console").lower()
     extra = ("；".join(notes)) if notes else ""
@@ -1630,7 +1637,7 @@ def _open_when_ready(port, url, log_path, timeout=30):
 # ---------------------------------------------------------------- 安装/升级
 
 def run_mgmt_command(entry, op, cancel_event=None, log_path=None):
-    """执行 install/upgrade/uninstall 命令（在任务队列里跑，日志实时落盘）。"""
+    """执行 install/upgrade/uninstall 命令（由任务执行器异步运行，日志实时落盘）。"""
     if op == "uninstall":
         cmd = catalog.uninstall_command(entry)
         if not cmd:

package/app/core/market_remote.py

@@ -30,9 +30,10 @@ import subprocess
 import tarfile
 import tempfile
 import time
-import urllib.error
-import urllib.request
-import zipfile
+import urllib.error
+import urllib.request
+import urllib.parse
+import zipfile
 from pathlib import Path
 from urllib.parse import urlparse
 
@@ -93,7 +94,8 @@ _CAP_DOWNLOAD = 80 * 1024 * 1024
 _CAP_UNPACKED = 120 * 1024 * 1024
 _CAP_FILES = 500
 _CAP_FILE_TEXT = 512 * 1024
-_CAP_TOTAL_TEXT = 4 * 1024 * 1024
+_CAP_TOTAL_TEXT = 4 * 1024 * 1024
+_MAX_REDIRECTS = 3
 
 
 def _cache_dir():
@@ -130,18 +132,52 @@ def assert_public_url(url):
     return host, port
 
 
-def _fetch(url, cap=_CAP_MANIFEST):
+def _fetch(url, cap=_CAP_MANIFEST):
     """带体量上限的 https GET；返回 bytes。
 
     两段式网络策略：先走默认通道（Windows 上 urllib 会读注册表系统代理，
     依赖代理上网的环境靠它），失败再自动直连重试一次（实测本机代理对部分
     CDN 文件返回 404/篡改，直连正常；反过来需要代理的网络第一段就成功）。
     体量超限属确定性错误，不重试。"""
-    assert_public_url(url)
-    req = urllib.request.Request(url, headers={
-        "User-Agent": "CodeBee-Market/1.0",
-        "Accept": "*/*",
-    })
+    assert_public_url(url)
+
+    class _NoRedirect(urllib.request.HTTPRedirectHandler):
+        def redirect_request(self, req, fp, code, msg, headers, newurl):
+            return None
+
+    def _close_quietly(resp):
+        try:
+            resp.close()
+        except Exception:
+            pass
+
+    def _open(opener, target):
+        """逐跳 GET；重定向目标在发起下一跳前重新过 SSRF 网关。"""
+        current = target
+        for hop in range(_MAX_REDIRECTS + 1):
+            assert_public_url(current)
+            req = urllib.request.Request(current, headers={
+                "User-Agent": "CodeBee-Market/1.0",
+                "Accept": "*/*",
+            })
+            try:
+                resp = opener.open(req, timeout=30)
+                code = getattr(resp, "status", getattr(resp, "code", 200))
+            except urllib.error.HTTPError as e:
+                code, resp = e.code, e
+            if code not in (301, 302, 303, 307, 308):
+                if isinstance(resp, urllib.error.HTTPError):
+                    raise resp
+                return resp
+            location = resp.headers.get("Location")
+            if not location:
+                _close_quietly(resp)
+                raise ValueError("重定向缺少 Location: %s" % current)
+            _close_quietly(resp)
+            current = urllib.parse.urljoin(current, location)
+            if hop >= _MAX_REDIRECTS:
+                raise ValueError("重定向次数超过上限: %s" % target)
+        raise ValueError("重定向失败: %s" % target)
 
     def _read(open_fn):
         with open_fn() as resp:
@@ -156,15 +192,17 @@ def _fetch(url, cap=_CAP_MANIFEST):
                 chunks.append(chunk)
         return b"".join(chunks)
 
-    try:
-        return _read(lambda: urllib.request.urlopen(
-            req, timeout=30, context=tlsctx.context()))   # 默认 opener：含系统代理
-    except (urllib.error.HTTPError, urllib.error.URLError):
-        # 直连重试：ProxyHandler({}) 显式清空代理
-        opener = urllib.request.build_opener(
-            urllib.request.ProxyHandler({}),
-            urllib.request.HTTPSHandler(context=tlsctx.context()))
-        return _read(lambda: opener.open(req, timeout=30))
+    try:
+        # 默认 opener 仍读取系统代理，但显式禁用自动重定向。
+        opener = urllib.request.build_opener(
+            _NoRedirect(), urllib.request.HTTPSHandler(context=tlsctx.context()))
+        return _read(lambda: _open(opener, url))
+    except (urllib.error.HTTPError, urllib.error.URLError):
+        # 直连重试：ProxyHandler({}) 显式清空代理；每一跳仍经过 SSRF 校验。
+        opener = urllib.request.build_opener(
+            _NoRedirect(), urllib.request.ProxyHandler({}),
+            urllib.request.HTTPSHandler(context=tlsctx.context()))
+        return _read(lambda: _open(opener, url))
 
 
 # ---------------------------------------------------------------- 清单解析
@@ -772,16 +810,22 @@ def _gh_fetch_files(entry, tmp):
     raise ValueError("jsdelivr 拉取失败: %s/%s（%s）" % (owner, repo, last_err))
 
 
-def _download_git(entry, tmp):
+def _download_git(entry, tmp):
     """git 浅克隆取子目录（Anthropic 生态的 git-subdir 来源）。"""
     if shutil.which("git") is None:
         raise ValueError("本机没有 git，无法安装 git-subdir 来源的插件")
-    inst = entry["install"]
+    inst = entry["install"]
+    # 非 GitHub 来源没有 codeload/jsdelivr 的安全收口，必须在 clone 前
+    # 复用同一公网 HTTPS 网关，避免 git 自己跟随重定向或访问内网。
+    assert_public_url(inst.get("url") or "")
     dst = tmp / "git"
     sub = str(inst.get("path") or "").replace("\\", "/")
     if sub.startswith("/") or ":" in sub or ".." in _rel_parts(sub):
         raise ValueError("插件子目录路径可疑: %s" % inst.get("path"))
-    cmd = ["git", "clone", "--depth", "1", "--single-branch", "--quiet"]
+    # git 会自行跟随 HTTP 重定向，而重定向目标无法再经过 assert_public_url；
+    # ��装来源宁可明确失败，也不能让 clone 跳进内网。
+    cmd = ["git", "-c", "http.followRedirects=false", "clone",
+           "--depth", "1", "--single-branch", "--quiet"]
     if inst.get("ref"):
         cmd += ["--branch", inst["ref"]]
     cmd += [inst["url"], str(dst)]

package/app/core/modelhub.py

@@ -1066,6 +1066,20 @@ def _binding_chain(b):
     return [{"provider_id": pid, "model": n} for n in names]
 
 
+def _binding_for(agent_kind_or_id):
+    """取 CLI 绑定，仅允许两组历史别名互通。
+
+    旧写法把所有非 codex 标识都回落到 claude-code，导致 opencode/qwen 等
+    未配置时误继承 Claude 的显式绑定并触发死链闸门。
+    """
+    key = str(agent_kind_or_id or "")
+    all_bindings = bindings()
+    if key in all_bindings:
+        return all_bindings[key] or {}
+    alias = {"codex": "codex-cli", "claude": "claude-code"}.get(key)
+    return (all_bindings.get(alias) or {}) if alias else {}
+
+
 def set_binding(agent_id, provider_id=None, model=None, models=None,
                 difficulty_routing=None, chain=None):
     """写一条 CLI 绑定。chain=[{provider_id, model}] 是跨厂商模型链（唯一真源），
@@ -1973,7 +1987,7 @@ def _model_image_in(prov, model):
     return False
 
 
-def bind_agent(agent, difficulty="default"):
+def bind_agent(agent, difficulty="default", task_type="", role=""):
     """按绑定生成应用了供应商/模型覆盖的 agent 副本；无绑定时原样返回。
 
     binding_configured：该 CLI 是否配过绑定链（配没配与解析结果分开带出——
@@ -1987,13 +2001,21 @@ def bind_agent(agent, difficulty="default"):
         manager.sync_runtime_config(agent)
     except Exception:
         pass
+    task_type = task_type or agent.get("_dispatch_task_type") or ""
+    role = role or agent.get("_dispatch_role") or ""
     rid = agent.get("id")
-    b = bindings().get(rid) or bindings().get(
-        "codex-cli" if rid == "codex" else "claude-code") or {}
-    configured = bool(_binding_chain(b))
+    b = _binding_for(rid)
+    # provider_id 即使没有显式模型链也代表用户锁定了供应商；空 bindings
+    # 才是“完全交给系统推荐”的默认模式。
+    configured = bool(_binding_chain(b) or b.get("provider_id"))
     r = resolve_binding(rid, difficulty) or resolve_binding(agent.get("kind"), difficulty)
+    binding_mode = "explicit" if configured else "auto"
+    if not r and not configured:
+        r = recommend_binding(rid, difficulty, task_type=task_type, role=role)
+        binding_mode = "auto" if r else "cli_default"
     a = dict(agent)
     a["binding_configured"] = configured
+    a["binding_mode"] = binding_mode
     if not r:
         return a
     merged = dict(agent.get("env") or {})
@@ -2007,6 +2029,26 @@ def bind_agent(agent, difficulty="default"):
         a["codex_provider"] = r["codex_provider"]
     if r.get("call_chain"):
         a["call_chain"] = r["call_chain"]
+    # 统一级联入口：代码、写作、调研等所有流程都复用同一套模型链排序。
+    # 默认关闭，保留用户手工链顺序；开启后仅 easy 任务按成本/档位优先。
+    routing_enabled = bool((b or {}).get("difficulty_routing"))
+    if difficulty in ("easy", "hard"):
+        try:
+            from .settings_schema import get as ss_get, register_default_namespaces
+            register_default_namespaces()
+            cascade_enabled = bool(ss_get("cascade", "enabled"))
+            if (routing_enabled or cascade_enabled) and a.get("call_chain"):
+                from . import capability
+                data = _load()
+                from . import dispatch
+                entries, decisions = dispatch.rank_model_entries(
+                    a.get("call_chain") or [],
+                    {p.get("id"): p for p in data.get("providers") or []},
+                    data.get("pricing") or {}, difficulty, task_type, role)
+                a["call_chain"] = entries
+                a["dispatch_decisions"] = decisions
+        except Exception:
+            pass
     return a
 
 
@@ -2131,7 +2173,7 @@ def binding_dead_msg(cli_id):
         protos = ()
     hint = ("该 CLI 仅接受 %s 协议的已启用供应商；" % "、".join(protos)) if protos else ""
     return ("绑定链全部失效（链上供应商已停用/删除/无密钥，或模型已停用），"
-            "本步判失败、不回落 CLI 本机默认——%s请在「CLI 绑定」页为该 CLI 绑定已启用的供应商" % hint)
+            "本步判失败、不回落 CLI 本机默认——%s请在「模型调度（可选）」页为该 CLI 指定已启用的供应商" % hint)
 
 
 def resolve_binding(agent_kind_or_id, difficulty="default"):
@@ -2142,8 +2184,7 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
     → 整体回落 CLI 默认（None）。纯链条目（无供应商）不注入 env，只传 -m。
     难度路由只在无显式链时生效。
     """
-    b = bindings().get(agent_kind_or_id) or bindings().get(
-        "codex-cli" if agent_kind_or_id == "codex" else "claude-code") or {}
+    b = _binding_for(agent_kind_or_id)
     chain = _binding_chain(b)
     provs = {p.get("id"): p for p in providers()}
     routing = bool(b.get("difficulty_routing"))
@@ -2198,6 +2239,16 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
                 break
         if not entries:
             return None
+        # 显式难度路由开启时，解析层就是唯一排序真源；关闭时保持手工链顺序。
+        if routing and tier in ("easy", "hard"):
+            try:
+                from . import dispatch
+                data = _load()
+                entries, _decisions = dispatch.rank_model_entries(
+                    entries, {p.get("id"): p for p in data.get("providers") or []},
+                    data.get("pricing") or {}, tier, "", "")
+            except Exception:
+                pass
         head = entries[0]
         out = {"model": head["model"], "env": head["env"], "provider": head.get("provider"),
                # model_fallbacks 是「换模型」的列表（runner 无链时的回退用）：
@@ -2253,6 +2304,89 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
     return out
 
 
+def recommend_binding(agent_kind_or_id, difficulty="default", task_type="", role=""):
+    """按当前可用供应商临时生成推荐链，不写入用户 bindings。
+
+    这是默认调度路径：只有没有显式 provider_id/chain 时才由 bind_agent 调用。
+    推荐结果仍经过 CLI 协议、供应商启停、密钥、健康状态和模型启停过滤，
+    再按任务类型、难度、档位和价格排序。没有可用供应商时返回 None，调用方
+    继续使用 CLI 自带登录态与默认模型。
+    """
+    allowed = bindable_protocols(agent_kind_or_id)
+    try:
+        from . import health
+        down_set = health.down_names()
+    except Exception:
+        down_set = set()
+    data = _load()
+    provs = {p.get("id"): p for p in data.get("providers") or []}
+    candidates = []
+    for prov in data.get("providers") or []:
+        pid = (prov.get("id") or "").strip()
+        if not pid or not prov.get("enabled", True) or not prov.get("api_key"):
+            continue
+        if prov.get("name") in down_set:
+            continue
+        ep = _entry_endpoint(prov, allowed)
+        if not ep:
+            continue
+        if _is_codex_target(agent_kind_or_id) and (ep[2] == "chat" or codex_wire_blocked(prov)):
+            continue
+        names = [m.get("name") for m in _enabled_models(prov)
+                 if isinstance(m, dict) and m.get("name")]
+        if not names and prov.get("model"):
+            names = [str(prov.get("model"))]
+        # 候选阶段不能先截前三个：便宜档往往排在供应商列表后面，easy 任务
+        # 需要看到完整启用列表后再按成本与档位评分。最终调用链仍受上限约束。
+        for model in names:
+            candidates.append({"provider_id": pid, "model": model})
+    if not candidates:
+        return None
+    from . import dispatch
+    ranked, decisions = dispatch.rank_model_entries(
+        candidates, provs, data.get("pricing") or {}, difficulty,
+        task_type=task_type, role=role, force=True)
+    entries, entry_decisions = [], []
+    decision_by_model = {
+        (d.get("provider_id") or "", d.get("model") or ""): d
+        for d in decisions}
+    for item in ranked[:MAX_CHAIN_ATTEMPTS]:
+        prov = provs.get(item.get("provider_id"))
+        if not prov:
+            continue
+        ep = _entry_endpoint(prov, allowed)
+        if not ep:
+            continue
+        pid = item.get("provider_id") or ""
+        # 与显式绑定完全同口径：同一模型按可用 KEY 展开，runner 才能在首 KEY
+        # 欠费/失效时记账冷却并尝试下一把。最终尝试数仍受硬上限约束。
+        for kk in _chain_keys(prov):
+            entries.append(_chain_entry_env(
+                prov, item.get("model") or "", target=agent_kind_or_id,
+                endpoint=ep, key=kk["key"], key_id=kk.get("id") or "",
+                provider_id=pid))
+            entry_decisions.append(decision_by_model.get(
+                (pid, item.get("model") or ""), {}))
+            if len(entries) >= MAX_CHAIN_ATTEMPTS:
+                break
+        if len(entries) >= MAX_CHAIN_ATTEMPTS:
+            break
+    if not entries:
+        return None
+    head = entries[0]
+    out = {"model": head["model"], "env": head["env"],
+           "provider": head.get("provider"),
+           "model_fallbacks": list(dict.fromkeys(
+               e["model"] for e in entries[1:]
+               if e.get("model") and e["model"] != head["model"])),
+           "call_chain": [dict(e) for e in entries],
+           "dispatch_decisions": entry_decisions,
+           "binding_mode": "auto"}
+    if head.get("codex_provider"):
+        out["codex_provider"] = head["codex_provider"]
+    return out
+
+
 def launch_pick(agent_id, protocols):
     """「一键打开」专属选链：绑定链里第一个「已启用+有密钥+协议匹配」的供应商。
 
@@ -2294,13 +2428,13 @@ def launch_pick(agent_id, protocols):
         mismatch = True
     if disabled:
         return None, ("绑定链里的 %s 已停用或无密钥：打开后需在其自带界面登录；"
-                      "要打开即用请在「CLI 绑定」页启用"
+                      "要打开即用请在「模型调度（可选）」页启用"
                       % "、".join(dict.fromkeys(disabled)))
     if mismatch:
         return None, ("当前绑定的供应商协议与该 CLI 不匹配：打开后需在其自带界面登录；"
-                      "要打开即用请在「CLI 绑定」页换绑可注入协议的供应商")
-    return None, ("未绑定供应商：打开后需在其自带界面登录；"
-                  "要打开即用请到「CLI 绑定」页绑定")
+                      "要打开即用请在「模型调度（可选）」页改为可注入协议的供应商")
+    return None, ("未指定供应商：打开后使用该 CLI 自带的登录与配置；"
+                  "需要固定注入时请到「模型调度（可选）」页指定")
 
 
 def migrate_orch_models():