codebee 0.1.98 → 0.1.99

package/CHANGELOG.md

@@ -4,7 +4,12 @@ CodeBee 的用户可感知变更记录。发布新版时：最上面加一节，
 `<!-- relnotes:start -->…<!-- relnotes:end -->` 段（那段会被 `npm view` 的
 README 元数据带回，供老版本在「发现新版本」时展示新版更新内容）。
 
-## 未发布
+## v0.1.99（2026-10-09）
+
+- **直连对话「本轮失败 NameError」修复**：内置智能体（CodeBee 直连）每轮起跑数秒即失败，根因是沙箱加固提交把 `sandbox=task.get("sandbox")` 误引入无 task 上下文的内置步骤函数——实参求值即 NameError，Mac/Windows 全平台直连对话不可用。现改为显式传参，任务沙箱策略照常透传生效（回归测试锁定形参与全链）
+- **命令执行沙箱闸策略感知**：沙箱加固曾把内置智能体的 run_command 在 Windows/macOS 一律拒跑（「未接入文件系统隔离后端」）——无后端平台上命令工具全死。现与外部 CLI 闸同口径：默认宽策略照常全信任直跑（2026-09-22 拍板档位），进程内无法兑现的收窄仍拒（禁网需 OS 后端；环境变量白名单在子进程侧实际滤不掉，宁拒不假装）；Linux bubblewrap 全策略强制不变
+- **大屏 KPI 长数值不再裁字**：万位级数值（如「2246.7万」）在 KPI 卡被挤到第二行、遭 overflow 裁切只剩半截；现 KPI 数字禁止换行，并按内容长度三档自动降字号，长数值单行完整显示
+- **经验库设置页文案对齐**：注入范围说明「小说类任务」改「同类任务」，与知识注入按任务类型全量覆盖的实现口径一致
 
 ## v0.1.98（2026-10-09）
 

package/README.md

@@ -25,11 +25,12 @@ Trae Agent、OpenClaw……），提供
 ---
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.98）
+### 最新版更新内容（v0.1.99）
 
-- 修复连载/常规任务被沙箱闸误拒：非 codex 外部 CLI 默认策略放行，仅收窄策略仍拒绝（89—96 批连载起草误拒实案）
-- 蜂巢 3D 场景重做为真 3D 蜜蜂办公室（WebGL）：运行打字颤翅、失败趴桌、蜂王督工，悬停看实时输出
-- uv 缺失自动补装（winget/pip/brew/curl 免 sudo），uv 系安装链 Mac PATH 兜底
+- 修复直连对话每轮起跑即「本轮失败 NameError」：Mac/Windows 全平台直连对话恢复可用
+- 内置智能体命令执行沙箱闸策略感知：默认策略照常直跑，仅收窄策略仍拒绝
+- 大屏 KPI 长数值不再裁字：禁换行 + 按内容长度三档降字号
+- 经验库设置页注入范围文案与全类型实现口径对齐
 <!-- relnotes:end -->
 
 

package/app/core/builtin_agent.py

@@ -98,15 +98,15 @@ def resolve(provider_id="", model="", difficulty="default"):
                 if selected not in enabled_names:
                     return None
             if not selected:
-                selected = (p.get("model_hard") if difficulty == "hard" else
-                            p.get("model_easy") if difficulty == "easy" else
-                            p.get("model") or "").strip()
-            if not selected:
+                # 默认/难度模型键位与 models[] 启停开关不联动：键位指向已停用
+                # 模型时对账启用名单回落，不冒充可用（停用的模型不准用）
                 try:
-                    names = modelhub._enabled_models(p)
+                    selected = modelhub._usable_default_model(
+                        p, (p.get("model_hard") if difficulty == "hard" else
+                            p.get("model_easy") if difficulty == "easy" else
+                            p.get("model")) or "")
                 except Exception:
-                    names = []
-                selected = names[0]["name"] if names else ""
+                    selected = (p.get("model") or "").strip()
             if selected:
                 return {"prov": p, "model": selected,
                         "provider_id": p.get("id") or "",
@@ -125,15 +125,13 @@ def resolve(provider_id="", model="", difficulty="default"):
     for p in modelhub.providers():
         if not p.get("enabled", True) or not p.get("api_key"):
             continue
-        m = ((p.get("model_hard") if difficulty == "hard" else
-              p.get("model_easy") if difficulty == "easy" else
-              p.get("model")) or "").strip()
-        if not m:
-            try:
-                names = modelhub._enabled_models(p)
-            except Exception:
-                names = []
-            m = names[0]["name"] if names else ""
+        try:
+            m = modelhub._usable_default_model(
+                p, (p.get("model_hard") if difficulty == "hard" else
+                    p.get("model_easy") if difficulty == "easy" else
+                    p.get("model")) or "")
+        except Exception:
+            m = (p.get("model") or "").strip()
         if m:
             return {"prov": p, "model": m, "provider_id": p.get("id") or "",
                     "provider_name": p.get("name") or p.get("id") or ""}
@@ -422,7 +420,11 @@ def _tool_run_command(workdir, args, cancel_event=None, deadline=None, sandbox=N
     → cmd /c 或 /bin/sh -c），仓库唯一的 shell 落点，不另起炉灶。全信任档
     （用户拍板 2026-09-22）：无白名单无确认闸，与 codex/claude 全权沙箱同档。
     提权靠模型自己包 Start-Process -Verb RunAs——UAC 必须人点，绕不过也不该绕。
-    输出按字符头尾截断（解码已在 run_process 完成，无残缺多字节问题）。"""
+    输出按字符头尾截断（解码已在 run_process 完成，无残缺多字节问题）。
+    沙箱闸策略感知（与外部 CLI 闸 b267107 同口径）：Linux 有 bwrap 全策略
+    强制；Win/Mac 无 OS 后端，进程内无法兑现的收窄仍拒（禁网、env 白名单
+    ——run_process 的 env 是注入语义滤不掉），默认宽策略保持全信任档直跑，
+    目录闸由 path_allowed 兑现。"""
     cmdline = str(args.get("command") or "").strip()
     if not cmdline:
         return "（命令为空，未执行）"
@@ -432,15 +434,20 @@ def _tool_run_command(workdir, args, cancel_event=None, deadline=None, sandbox=N
     cwd = os.path.abspath(workdir or ".")
     if not policy.path_allowed(cwd, sandbox):
         return "（沙箱拒绝：工作目录不在允许范围内，命令未执行）"
-    # This process runner has no OS-level network/filesystem namespace. Do not
-    # imply network isolation when policy requests it; fail closed instead.
-    if sandbox.get("network") is False:
-        if os.name != "posix" or not shutil.which("bwrap"):
-            return "（沙箱拒绝：当前系统没有可用的网络隔离后端，命令未执行）"
-    # Enforce the declared filesystem boundary at the process boundary too.
-    # bubblewrap is the supported Linux backend. Windows/macOS without an
-    # equivalent backend fail closed rather than pretending cwd is a sandbox.
-    if os.name == "posix" and shutil.which("bwrap"):
+    # Enforce the declared boundary at the process boundary where an OS
+    # backend exists (bubblewrap on Linux). Windows/macOS have no equivalent:
+    # stay policy-aware like the external-CLI gate (b267107) — the narrowings
+    # this in-process runner cannot honor fail closed, while a default wide
+    # policy keeps the user-approved full-trust tier (2026-09-22) instead of
+    # refusing every command.
+    has_bwrap = os.name == "posix" and bool(shutil.which("bwrap"))
+    if sandbox.get("network") is False and not has_bwrap:
+        return "（沙箱拒绝：当前系统没有可用的网络隔离后端，命令未执行）"
+    if sandbox.get("env_allowlist"):
+        # run_process 的 env 是注入语义（合并进完整父环境，供凭据注入），
+        # 不是白名单替换——环境收窄在子进程侧无法兑现，宁拒不假装
+        return "（沙箱拒绝：该任务带环境变量白名单，命令执行无法兑现该策略，未执行）"
+    if has_bwrap:
         argv = ["bwrap", "--die-with-parent", "--new-session", "--tmpfs", "/"]
         # Mount only the runtime needed by ordinary commands. Do not expose the
         # entire host root read-only: read access can still leak user secrets.
@@ -461,18 +468,10 @@ def _tool_run_command(workdir, args, cancel_event=None, deadline=None, sandbox=N
             argv.extend(["--dir", root_path])
             argv.extend(["--bind", root_path, root_path])
         argv.extend(["--chdir", cwd, "--", "/bin/sh", "-lc", cmdline])
-    elif os.name == "posix" and sys.platform == "darwin":
-        return "（沙箱拒绝：当前 macOS 执行器尚未接入文件系统隔离后端，命令未执行）"
-    elif os.name != "posix":
-        return "（沙箱拒绝：当前 Windows 执行器尚未接入文件系统隔离后端，命令未执行）"
     else:
-        return "（沙箱拒绝：未安装 bubblewrap 隔离后端，命令未执行）"
-    env_policy = dict(sandbox)
-    env_policy["env_allowlist"] = list(dict.fromkeys(
-        list(sandbox.get("env_allowlist") or [])
-        + ["PATH", "SYSTEMROOT", "WINDIR", "TEMP", "TMP", "COMSPEC", "HOME", "USERPROFILE"]))
-    r = runner.run_process(argv=argv, cwd=cwd,
-                           env=policy.filter_env(os.environ, env_policy),
+        argv = None   # 全信任档：runner 按平台自包 cmd /c 或 /bin/sh -c
+    r = runner.run_process(argv=argv, shell_cmd=cmdline if argv is None else None,
+                           cwd=cwd, env=None,
                            timeout=min(timeout, CMD_MAX_TIMEOUT),
                            deadline=deadline, cancel_event=cancel_event)
     out = runner.clean_cli_text(

package/app/core/modelhub.py

@@ -2177,6 +2177,20 @@ def _model_bindable(prov, model):
     return True
 
 
+def _usable_default_model(prov, model=""):
+    """默认模型键位（model / model_easy / model_hard / 编排者配置）对账启用名单。
+
+    默认/难度模型是自由文本，与 models[] 的启停开关互不联动——键位指向已
+    停用/已删除的模型时不能冒充可用：回落该厂商启用名单首个；全停用返回
+    空串（调用方按「无默认模型」处理）。空键位本身合法（用网关默认），
+    也返回空。"""
+    model = (model or "").strip()
+    if model and _model_bindable(prov, model):
+        return model
+    names = [m.get("name") for m in _enabled_models(prov) if m.get("name")]
+    return names[0] if names else ""
+
+
 def _model_image_in(prov, model):
     """模型是否声明支持图片输入：models[] 条目 image_in；缺省/查不到=False（纯文本）。"""
     for m in ((prov or {}).get("models") or []):
@@ -2591,7 +2605,7 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
                 if len(entries) >= MAX_CHAIN_ATTEMPTS:
                     break
                 entries.append(_chain_entry_env(
-                    prov, model or prov.get("model") or "",
+                    prov, model or _usable_default_model(prov, prov.get("model")),
                     target=agent_kind_or_id, endpoint=ep, key=kk["key"],
                     key_id=kk.get("id") or "", provider_id=pid))
             if len(entries) >= MAX_CHAIN_ATTEMPTS:
@@ -2662,6 +2676,8 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
     model = prov.get("model_" + tier) or "" if (routing and tier) else ""
     if not model:
         model = prov.get("model") or ""
+    if model and not _model_bindable(prov, model):
+        model = ""   # 默认/难度模型键位指向停用或已删模型：不冒充可用，回落启用名单
     if not model and names:
         model = names[0] if (not routing or difficulty != "easy") else names[-1]
     if not _evaluation_is_usable(pid, model):
@@ -2724,7 +2740,9 @@ def recommend_binding(agent_kind_or_id, difficulty="default", task_type="", role
         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"))]
+            dflt = str(prov.get("model"))
+            if _model_bindable(prov, dflt):   # 默认模型被停用时不再充作唯一候选
+                names = [dflt]
         # 候选阶段不能先截前三个：便宜档往往排在供应商列表后面，easy 任务
         # 需要看到完整启用列表后再按成本与档位评分。最终调用链仍受上限约束。
         for model in names:
@@ -3618,9 +3636,7 @@ def resolve_orchestrator():
     if not prov or not prov.get("enabled", True) or not prov.get("api_key"):
         return None
     model = (cfg.get("model") or "").strip() or prov.get("model") or ""
-    if not model:
-        names = _enabled_models(prov)
-        model = names[0]["name"] if names else ""
+    model = _usable_default_model(prov, model)   # 配置的模型被停用时回落启用名单，不冒充可用
     if not model:
         return None
     if not _evaluation_is_usable(pid, model):

package/app/core/pipeline.py

@@ -628,14 +628,16 @@ def _create_task_from_builtin(payload):
 
 
 def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=None,
-                      followups=False):
+                      followups=False, sandbox=None):
     """内置智能体步骤：直连模型 API + 工具循环（builtin_agent），不经 CLI 进程。
 
     与 _run_step 对齐的三件事：暂停/取消闸门、运行中指令 drain 注入、重复调用
     守门；结果同样经 _finish_step_result 落步骤（output=干净回答）并入用量台账。
     日志只有「迭代/工具」摘要行——对话视图吃 output，日志抽屉看工具轨迹。
     followups=True 时从回答末尾解析「建议追问」块（直连对话专用协议）：
-    剥离出结构化列表落步骤记录，正文保持干净。"""
+    剥离出结构化列表落步骤记录，正文保持干净。
+    sandbox：任务沙箱策略由调用方透传（本函数无 task 上下文），builtin_agent
+    内部 normalize 后在工具执行期强制。"""
     _wait_gate(run_id, ev)
     deadline = _ensure_budget(run_id)
     step, log_abs = store.add_step(run_id, role, "builtin", "CodeBee", note=note,
@@ -689,7 +691,7 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
                             on_reason=_on_reason, on_stream=_on_stream,
                             on_activity=_on_activity,
                             task_creator=_create_task_from_builtin,
-                            sandbox=task.get("sandbox"), checkpoint_run_id=run_id)
+                            sandbox=sandbox, checkpoint_run_id=run_id)
     if followups and res.get("ok"):
         clean, fups = _parse_followups(res.get("text") or "")
         if fups:
@@ -2334,7 +2336,7 @@ def _run_direct(run, task, agents, ev, stats, mode):
         if bi is not None:
             res = _run_builtin_step(run_id, "direct" if first else "chat", bi, prompt,
                                     step_wd, ev=ev, note=note, images=images,
-                                    followups=True)
+                                    followups=True, sandbox=task.get("sandbox"))
         else:
             res = _run_step(run_id, "direct" if first else "chat", impl, prompt, step_wd,
                             readonly=False, ev=ev, note=note,

package/app/core/publish/auto.py

@@ -135,7 +135,9 @@ def pending(task_id, platform):
     """待发章节清单：任务工作目录里的章节文件 − 已发章号，按章号升序。
 
     已发口径连载链合并（含校准所得平台实况），所以任何一个批次任务上发
-    起发布，看到的都是整本书的待发清单。返回 (list, err)；list 项
+    起发布，看到的都是整本书的待发清单。已存草稿的章同样剔除（内容已在
+    平台草稿箱，再跑只会造重复稿；提交发布走平台草稿箱由用户手工完成）。
+    返回 (list, err)；list 项
     {chapter_no, file, size}，file 为工作目录相对路径。章号解析不出的
     文件不进自动发布（防同章多文件误发），API 单章发（manager 直调）
     不受此限。
@@ -154,7 +156,8 @@ def pending(task_id, platform):
             if fs:
                 files = fs           # 任一 run 的成品口径都从任务首跑起，取到即够
                 break
-    done = ledger.published_chapters(task_id, platform)
+    done = ledger.published_chapters(task_id, platform) \
+        | ledger.drafted_chapters(task_id, platform)
     # 分卷标注（2026-10-08 用户需求：待发清单按卷展示）：卷计划解析不出时
     # volume 为空串，前端不分组平铺。
     plan = []
@@ -182,7 +185,12 @@ def pending(task_id, platform):
 
 
 def status(task_id):
-    """前端视图：待发清单 + 护栏状态 + 自动发布进度。"""
+    """前端视图：待发清单 + 护栏状态 + 自动发布进度。
+
+    护栏分两层给前端：guard_ok/guard_reason=完整发布闸（硬护栏+质量闸），
+    管「发布」类按钮；draft_ok/draft_reason=硬护栏（每日上限/连败退避/建书
+    确认），管「存草稿」按钮——草稿不上线，质量闸拦它只会堵死「先落平台
+    再人工把关」的通路；quality_blockers 单独带出去做提示性展示。"""
     from .. import store
     from . import ledger, manager
     ent = ledger.books_for(str(task_id))   # 沿连载链继承：续写批次同书同账
@@ -190,19 +198,25 @@ def status(task_id):
     books = []
     for plat, info in ent.items():
         pend, err = pending(task_id, plat)
-        ok, why = guards(task_id, plat)
+        hard_ok, hard_why = guards(task_id, plat)
         if not _book_ready(info):
-            ok, why = False, "该平台建书结果未确认（缺少作品 ID），请重试创建作品或登记已有作品"
-        elif task:
+            hard_ok, hard_why = False, "该平台建书结果未确认（缺少作品 ID），请重试创建作品或登记已有作品"
+        blockers = []
+        if task and _book_ready(info):
             quality = manager._quality_release_guard(task, plat, action="publish")
             if not quality.get("allowed"):
-                ok, why = False, "质量门禁拦截：%s" % "；".join(
-                    quality.get("blockers") or [])
+                blockers = [str(b) for b in (quality.get("blockers") or [])]
+        ok, why = hard_ok, hard_why
+        if ok and blockers:
+            ok, why = False, "质量门禁拦截：%s" % "；".join(blockers)
         books.append({"platform": plat, "bound": True,
                       "title": info.get("title") or "",
                       "pending": len(pend),
                       "items": pend[:200],
                       "guard_ok": ok, "guard_reason": why,
+                      "draft_ok": hard_ok, "draft_reason": hard_why,
+                      "quality_blockers": blockers,
+                      "drafted": len(ledger.drafted_chapters(task_id, plat)),
                       "calibrated": calibrated(plat)})
     run = _running.get(task_id) or None
     if run:
@@ -236,8 +250,27 @@ def calibrated(platform):
     return (paths.PUBLISH_DIR / ("flows-%s.json" % platform)).is_file()
 
 
+def flow_calibrated(plat, action):
+    """某动作的步骤表是否有真机校准来源（用户校准文件或仓库校准模板里
+    有该动作的表）。内置推测表不算——存草稿虽不上线，批量乱点照样惹
+    风控/攒一箱废稿，无人值守跑之前必须有验证过的步骤表。"""
+    import json as _json
+    from pathlib import Path as _Path
+    from .. import paths as _paths
+    for fp in (_paths.PUBLISH_DIR / ("flows-%s.json" % plat),
+               _Path(__file__).with_name("flows-%s-calibrated.json" % plat)):
+        try:
+            data = _json.loads(fp.read_text(encoding="utf-8"))
+            if isinstance(data, dict) and isinstance(data.get(action), list):
+                return True
+        except Exception:
+            pass
+    return False
+
+
 def publish_pending_async(task_id, platform, auto_submit=False, only=None,
-                          force=False, force_confirmed=False, force_reason=""):
+                          force=False, force_confirmed=False, force_reason="",
+                          as_draft=False):
     """把任务的待发章节按章号顺序发出（后台线程）。返回 (ok, err)。
 
     only=章号清单（批量选择发布）：从待发清单里挑出所选章号，保持章号
@@ -245,12 +278,22 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     auto_submit=True（直发）逐章提交走完全程；False（人工确认）每轮只填
     **一章**就停在 manual_pause——表单填好后提交权在用户，walker 若直接
     填下一章会导航离开未提交的编辑器，把上一章内容丢掉（平台草稿自动
-    保存不可依赖）。用户在浏览器提交后再次发起即发下一章。"""
+    保存不可依赖）。用户在浏览器提交后再次发起即发下一章。
+    as_draft=True（全部发草稿，2026-10-09）：逐章自动填稿并点「存草稿」，
+    不上线、不受质量闸拦、无需人工确认，一章接一章连跑到清空待发清单
+    （章间仍按 PACE_S 防风控节奏）；提交发布由用户到平台草稿箱手工完成，
+    届时质量闸照常把关。与 auto_submit 互斥（草稿模式忽略 auto_submit）。"""
     from .. import store
     from . import ledger, manager
     if platform not in manager.PLATFORMS:
         return False, "未知平台"
-    if auto_submit and not calibrated(platform):
+    if as_draft:
+        auto_submit = False                # 草稿模式没有「提交」语义
+        if not flow_calibrated(platform, "upload_chapter_draft"):
+            return False, ("存草稿模式需要该平台有 upload_chapter_draft 步骤表"
+                           "（仓库校准模板或 data/publish/flows-%s.json）；"
+                           "未校准不许无人值守批量动表单" % platform)
+    elif auto_submit and not calibrated(platform):
         return False, ("自动提交模式需要先校准该平台发布流程：用「探测」按钮 dump "
                        "表单后把真实步骤写进 data/publish/flows-%s.json（缺省选择器"
                        "只是推测，未校准不许无人值守直发）" % platform)
@@ -271,9 +314,13 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
         return False, "该任务尚未在此平台建书，请先「创建作品」"
     if not _book_ready(book):
         return False, "该平台建书结果未确认（缺少作品 ID），请重试创建作品或登记已有作品"
-    quality = manager._quality_release_guard(
-        task, platform, action="publish", force=force,
-        force_confirmed=force_confirmed, force_reason=force_reason)
+    if as_draft:
+        # 草稿不上线：质量闸不适用（同 manager 口径），硬护栏照查
+        quality = {"allowed": True, "status": "draft_only"}
+    else:
+        quality = manager._quality_release_guard(
+            task, platform, action="publish", force=force,
+            force_confirmed=force_confirmed, force_reason=force_reason)
     if not quality.get("allowed"):
         return False, "质量门禁拦截：%s" % "；".join(quality.get("blockers") or [])
     ok, why = guards(task_id, platform)
@@ -298,7 +345,8 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     wd = task.get("workdir") or ""
     st = {"platform": platform, "at": time.strftime("%Y-%m-%d %H:%M:%S"),
           "done": 0, "total": len(pend), "status": "running", "error": "",
-          "auto_submit": bool(auto_submit), "last_chapter": 0}
+          "auto_submit": bool(auto_submit), "as_draft": bool(as_draft),
+          "last_chapter": 0}
     with _LOCK:
         _running[task_id] = st
 
@@ -310,7 +358,7 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                     st["status"] = "error"
                     st["error"] = "第 %d 章前护栏拦截：%s" % (item["chapter_no"], why)
                     return
-                upload_kwargs = {"auto_submit": auto_submit}
+                upload_kwargs = {"auto_submit": auto_submit, "as_draft": as_draft}
                 if force or force_confirmed or force_reason:
                     upload_kwargs.update(force=force,
                                          force_confirmed=force_confirmed,
@@ -324,10 +372,29 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                     return
                 if not _wait_idle(platform):
                     st["status"] = "error"
-                    st["error"] = ("第 %d 章发布等待超时（%.0f 分钟）；若在等人工提交，"
-                                   "请提交后重跑剩余章节" % (item["chapter_no"],
-                                                             IDLE_TIMEOUT_S / 60))
+                    if as_draft:
+                        st["error"] = ("第 %d 章存草稿等待超时（%.0f 分钟），后续"
+                                       "章节未存" % (item["chapter_no"],
+                                                     IDLE_TIMEOUT_S / 60))
+                    else:
+                        st["error"] = ("第 %d 章发布等待超时（%.0f 分钟）；若在等人工提交，"
+                                       "请提交后重跑剩余章节" % (item["chapter_no"],
+                                                                 IDLE_TIMEOUT_S / 60))
                     return
+                if as_draft:
+                    # manager 走完草稿流程（含平台侧验证）才返回；台账落了
+                    # upload_chapter_draft 才算数，防「流程跑完但平台没存上」。
+                    if item["chapter_no"] not in ledger.drafted_chapters(
+                            task_id, platform):
+                        st["status"] = "error"
+                        st["error"] = ("第 %d 章存草稿未确认，后续章节未存（详见"
+                                       "发布台账与截图存证）" % item["chapter_no"])
+                        return
+                    st["done"] += 1
+                    st["last_chapter"] = item["chapter_no"]
+                    if st["done"] < st["total"]:
+                        time.sleep(PACE_S)
+                    continue
                 if not auto_submit:
                     # The manager stopped before the submit step. There is no
                     # remote success receipt until the user clicks submit.
@@ -348,7 +415,11 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                 if st["done"] < st["total"]:
                     time.sleep(PACE_S)
             st["status"] = "done"
-            if not auto_submit:
+            if as_draft:
+                st["message"] = ("已存草稿 %d 章（未发布，不受质量闸拦不代表可直发）；"
+                                 "请到平台章节管理/草稿箱逐章检查后提交发布"
+                                 % st["done"])
+            elif not auto_submit:
                 st["message"] = "第 %d 章已填好，请在浏览器里确认提交，再重新校准" % st["last_chapter"]
         except Exception as e:                 # 线程内绝不能悬挂无终态
             st["status"] = "error"

package/app/core/publish/fanqie.py

@@ -110,6 +110,35 @@ UPLOAD_CHAPTER = [
      "optional": True},
 ]
 
+# 发章存草稿（2026-10-09 全部发草稿）：与 UPLOAD_CHAPTER 同一张填表前段，
+# 终点不同——点编辑器头部「存草稿」直接落草稿箱，不走「下一步→内容检测→
+# 发布提示→提交」发布链。草稿不上线，批量连跑无需人工确认；提交发布由
+# 用户到章节管理/草稿箱手工完成。verify 沿用章节管理页断言（草稿行同样
+# 出现在列表里，标题/章号标记可命中）；若平台改版把草稿挪去独立草稿箱页，
+# 首轮失败的 step 截图会指出来，照 flows-fanqie.json 校准即可。
+UPLOAD_CHAPTER_DRAFT = [
+    {"do": "navigate", "url": "{editor_url}"},
+    {"do": "url_any", "any": ["fanqienovel.com"]},
+    {"do": "wait", "sel": "[contenteditable=true],textarea[class*=content],div[class*=editor]", "timeout": 10},
+    {"do": "volume", "key": "volume_name", "optional": True,
+     "open_sel": "input[type=number],input[class*=serial],div[class*=volume]",
+     "modal_sel": "[class*=volume][class*=modal],[class*=modal][class*=volume]",
+     "item_sel": "[class*=volume] li,[class*=volume-item]",
+     "add_sel": "[class*=add-volume],[class*=volume] button",
+     "confirm_sel": "[class*=confirm]", "settle": 1.5},
+    {"do": "fill", "sel": "input[type=number],input[class*=serial],input[class*=byte]", "key": "chapter_no"},
+    {"do": "fill", "sel": "input[placeholder*='章节'],input[placeholder*='标题']", "key": "chapter_name"},
+    {"do": "wait", "sel": "[contenteditable=true],textarea[class*=content],div[class*=editor]", "timeout": 10},
+    {"do": "fill", "sel": "[contenteditable=true],textarea[class*=content]", "key": "chapter_body"},
+    {"do": "shot", "name": "chapter-filled-draft"},
+    {"do": "submit", "text": "存草稿", "scope": "button", "tries": 15},
+    {"do": "js_click", "text": "存草稿", "scope": "button", "tries": 10,
+     "optional": True, "skip_if_modal": True},
+    {"do": "sleep", "s": 2.5},
+    {"do": "verify", "url": "{chapter_manage_url}",
+     "any": ["第{chapter_no}章", "{chapter_name}"], "settle": 6, "new_tab": True},
+]
+
 # 登录态探测：打开后台首页，URL 被踢到登录页 → 未登录
 CHECK_LOGIN = [
     {"do": "navigate", "url": "{home}"},
@@ -125,6 +154,7 @@ PROBE_FORM = [
 ]
 
 FLOWS = {"create_book": CREATE_BOOK, "upload_chapter": UPLOAD_CHAPTER,
+         "upload_chapter_draft": UPLOAD_CHAPTER_DRAFT,
          "check_login": CHECK_LOGIN, "probe_form": PROBE_FORM}
 
 

package/app/core/publish/flows-fanqie-calibrated.json

@@ -1,5 +1,6 @@
 {
  "_note": "番茄真机校准（2026-09-19 定稿，2026-09-24 加固）：编辑器=/main/writer/<book_id>/publish/ 直达（章节号 input.serial-input 纯数字；标题 div.serial-editor-input-hint input ≥5字/30上限；正文 .ProseMirror ≥1000字；「下一步」保存校验后按钮组右缘箭头展开下拉含「定时发布」）。建书=/main/writer/create 直达表单：radio 签约模式/目标读者（label 真实点击）→ 阅读标签 select（y<430）弹层 arco-anchor 切主分类/主题/角色/情节 + 标签云点击 + 确认 → 内容标签 select（y>430）弹层 情感/人设/世界观 同构 → 名称/主角1/主角2/简介 → 立即创建（submit 步骤：auto_submit=false 时填好即停，留给人工提交） → 跳 book-info/<id>。锚点切换渲染慢（0924 三连败）：弹层打开后 settle，锚点 tries=12。0928 再加固（弹层没开连败案）：签约/读者 radio 点击后断言选中态（expect_checked）；两处标签触发器点完 wait .category-modal 存在替代盲 sleep；real_click_text 落点 elementFromPoint 守卫，找不到目标时报错自带定位范围可见项诊断。2026-10-08 发章三修：values 补 chapter_no/chapter_name 键（此前序号框从未被填、被平台以「章节序号只支持阿拉伯数字」打回）；标题位改填 chapter_name（read_chapter 拆掉「第X章」前缀，序号/标题分开填）；verify 标记改「第{chapter_no}章」或「{chapter_name}」任一命中（用户手工改过标题时按名对版必假失败）。。2026-10-08 批量自动发布·自动分卷：upload_chapter 增加 volume 步骤（values.volume_name 由 manager 按工作目录卷计划解析：分卷.json 优先，其次 大纲/series-outline.md 的「## 第X卷：名」+「依次48、56…章」；平台卷弹窗 = .publish-header-volume-name 开 → .editor-volume-list-item 按去前缀名匹配选中，缺卷走 .editor-volume-footer-add-volume 新建→行内 input 输名→i.tomato-confirm 落名→选中→确定；新建卷名会追加进 values._volumes 由 manager 回写 books.json 缓存）。。2026-10-08 晚：平台发布确认 UI 已改——下一步（保存校验）后弹「发布提示」错别字确认框（取消/提交），不再有「定时发布」下拉组；流程撤 click_arrow/定时发布/发布，改点确认框「提交」（optional：无错别字时可能不弹，直接 verify）。。verify 改 new_tab（开新页签验证、编辑器页签不动）：编辑器页签内导航触发 beforeunload 原生确认，渲染挂起+发布请求被取消——直发章全卡死在验证导航上的实案修法。。1008深夜终版：publish链=submit(下一步,gate)→js_click下一步兜底(skip_if_modal)→js_click仅基础检测(检测方式弹窗,tries60)→sleep5→js_click提交(错别字确认,tries75)→verify new_tab；真实鼠标在 headless/后台页签不触发平台处理器，DOM click 可靠。",
+ "upload_chapter_draft": "2026-10-09 全部发草稿：前段（volume/序号/标题/正文填表）与 upload_chapter 同源选择器；终点改点编辑器头部「存草稿」直接落草稿箱，不走下一步/检测/发布提示发布链。verify 沿用章节管理页断言（草稿行同样在列表里）；若平台把草稿挪去独立草稿箱页，首轮失败截图会指出，届时按此校准。「存草稿」按钮文本未真机实证（校准时浏览器离线），首次批量跑请盯首章截图。",
  "check_login": [
   {
    "do": "navigate",
@@ -111,6 +112,86 @@
    "new_tab": true
   }
  ],
+ "upload_chapter_draft": [
+  {
+   "do": "navigate",
+   "url": "about:blank"
+  },
+  {
+   "do": "navigate",
+   "url": "{editor_url}"
+  },
+  {
+   "do": "url_any",
+   "any": [
+    "fanqienovel.com"
+   ]
+  },
+  {
+   "do": "wait",
+   "sel": ".ProseMirror",
+   "timeout": 20
+  },
+  {
+   "do": "volume",
+   "key": "volume_name",
+   "optional": true,
+   "open_sel": ".publish-header-volume-name",
+   "modal_sel": ".serial-modal.editor-volume",
+   "item_sel": ".editor-volume-list-item",
+   "add_sel": ".editor-volume-footer-add-volume",
+   "input_sel": ".editor-volume-list-item input",
+   "confirm_sel": "i.tomato-confirm",
+   "settle": 1.5
+  },
+  {
+   "do": "fill",
+   "sel": "input.serial-input, input.byte-input",
+   "key": "chapter_no"
+  },
+  {
+   "do": "fill",
+   "sel": "div.serial-editor-input-hint input",
+   "key": "chapter_name"
+  },
+  {
+   "do": "fill",
+   "sel": ".ProseMirror",
+   "key": "chapter_body"
+  },
+  {
+   "do": "shot",
+   "name": "chapter-filled-draft"
+  },
+  {
+   "do": "submit",
+   "text": "存草稿",
+   "scope": "button",
+   "tries": 15
+  },
+  {
+   "do": "js_click",
+   "text": "存草稿",
+   "scope": "button",
+   "tries": 10,
+   "optional": true,
+   "skip_if_modal": true
+  },
+  {
+   "do": "sleep",
+   "s": 2.5
+  },
+  {
+   "do": "verify",
+   "url": "{chapter_manage_url}",
+   "any": [
+    "第{chapter_no}章",
+    "{chapter_name}"
+   ],
+   "settle": 6,
+   "new_tab": true
+  }
+ ],
  "probe_form": [
   {
    "do": "navigate",

package/app/core/publish/flows-qimao-calibrated.json

@@ -1,5 +1,6 @@
 {
  "_note": "七猫真机校准（2026-09-19 凌晨定稿）：建书=book-manage「新建小说」→站点弹层(click_match+确认)→information 表单(fill_label/radio/级联分类/tags 四组各1-3个+确定/主角名平铺/简介)；书名仅允许，：！？中文标点（·被拦）。发章=编辑器填好后「立即发布」落草稿箱（未签约书限制）→草稿行「立即发布」→「更正序号去发布」→「确认发布」三层弹窗→章节待审核。正文下限 1000 字（min_chapter_chars）。book-upload?id=<书id> 直达编辑器。；2026-09-24 加固：二级分类选完 settle 1s 再点「添加标签」（下拉关闭动画吞点击致标签弹层未开、组名切换失败案）；2026-09-24 夜修：平台编辑器「立即发布」变为弹重型确认框（点后页面假死、章节未提交、草稿箱亦空——旧「立即发布落草稿箱」语义过时），改点「存草稿」再走草稿箱三层发布（草稿行立即发布→更正序号→确认发布，22:47 实证成功路径）",
+ "upload_chapter_draft": "2026-10-09 全部发草稿：按 upload_chapter 的「存草稿」段拆出（填标题/正文→click_real 存草稿→draft_url 草稿箱 verify 行在场）。存草稿段是 0924 实证路径的前半段，选择器同源；提交发布（立即发布三层弹窗）留给用户在草稿箱手工完成。",
  "probe_form": [
   {
    "do": "navigate",
@@ -226,6 +227,63 @@
    "settle": 6
   }
  ],
+ "upload_chapter_draft": [
+  {
+   "do": "navigate",
+   "url": "about:blank"
+  },
+  {
+   "do": "navigate",
+   "url": "{editor_url}"
+  },
+  {
+   "do": "url_any",
+   "any": [
+    "qimao.com"
+   ]
+  },
+  {
+   "do": "wait",
+   "sel": "textarea[placeholder*='章节名称']",
+   "timeout": 20
+  },
+  {
+   "do": "fill",
+   "sel": "textarea[placeholder*='章节名称']",
+   "key": "chapter_title"
+  },
+  {
+   "do": "wait",
+   "sel": ".q-contenteditable",
+   "timeout": 12
+  },
+  {
+   "do": "fill",
+   "sel": ".q-contenteditable",
+   "key": "chapter_body"
+  },
+  {
+   "do": "shot",
+   "name": "chapter-filled-draft"
+  },
+  {
+   "do": "click_real",
+   "text": "存草稿",
+   "tries": 25
+  },
+  {
+   "do": "sleep",
+   "s": 2
+  },
+  {
+   "do": "verify",
+   "url": "{draft_url}",
+   "any": [
+    "{chapter_title}"
+   ],
+   "settle": 5
+  }
+ ],
  "check_login": [
   {
    "do": "navigate",

package/app/core/publish/ledger.py

@@ -111,6 +111,28 @@ def published_chapters(task_id, platform):
     return out
 
 
+def drafted_chapters(task_id, platform):
+    """该任务在该平台已成功存草稿的章节号集合（发草稿模式的幂等口径）。
+
+    与 published_chapters 同款连载链合并；不含校准的平台实况（实况口径里
+    没有「草稿」桶，草稿章是否已由用户手工发布以重新校准后的
+    remote_published_nos 为准）。草稿章从待发清单剔除：已在平台存稿的章
+    再跑一遍只会造出重复草稿。"""
+    from .. import store
+    try:
+        ids = set(store.serial_chain_ids(task_id))
+    except Exception:
+        ids = {str(task_id)}
+    out = set()
+    for r in _iter_records(3650):
+        if (r.get("action") == "upload_chapter_draft" and r.get("ok")
+                and r.get("task_id") in ids and r.get("platform") == platform):
+            n = r.get("chapter_no") or 0
+            if n > 0:
+                out.add(int(n))
+    return out
+
+
 def recent(task_id=None, platform=None, limit=50):
     """最近记录（新在前），详情页发布历史用。task_id 给定时按连载链合并。"""
     from .. import store
@@ -338,7 +360,8 @@ def consecutive_failures(platform):
     for r in reversed(list(_iter_records(7))):
         if r.get("platform") != platform:
             continue
-        if r.get("action") not in ("upload_chapter", "create_book"):
+        if r.get("action") not in ("upload_chapter", "create_book",
+                                   "upload_chapter_draft"):
             continue
         t = _rec_time(r)
         if t is None:

package/app/core/publish/manager.py

@@ -872,8 +872,14 @@ def read_chapter(fp):
 
 
 def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
-                         force=False, force_confirmed=False, force_reason=""):
-    """把一章发到平台（或填好待人工确认）。幂等：已成功发布的章号拒绝重发。"""
+                         force=False, force_confirmed=False, force_reason="",
+                         as_draft=False):
+    """把一章发到平台（或填好待人工确认/as_draft 只存草稿）。
+
+    幂等：已成功发布**或已存草稿**的章号拒绝重做——重复发会平台上出双章，
+    重复存草稿会攒一箱重复稿。as_draft=True 走「存草稿」流程表
+    （upload_chapter_draft）：内容落平台草稿箱不上线，不构成发布动作，
+    质量闸不拦（发布时照拦）；存稿动作无需人工确认，适合批量连跑。"""
     from .. import store
     if plat not in PLATFORMS:
         return False, "未知平台"
@@ -894,9 +900,14 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
     ch_no, title, body, err = read_chapter(chapter_file)
     if err:
         return False, err
-    quality = _quality_release_guard(
-        task, plat, action="publish", target_chapter=ch_no or None,
-        force=force, force_confirmed=force_confirmed, force_reason=force_reason)
+    if as_draft:
+        # 草稿不上线：质量闸不适用（evaluate_release action=draft 直通），
+        # 人工复核挪到「平台草稿箱 → 用户逐章检查后提交」那一步。
+        quality = {"allowed": True}
+    else:
+        quality = _quality_release_guard(
+            task, plat, action="publish", target_chapter=ch_no or None,
+            force=force, force_confirmed=force_confirmed, force_reason=force_reason)
     if not quality.get("allowed"):
         return False, "质量门禁拦截：%s" % "；".join(quality.get("blockers") or [])
     n_chars = len(body.replace("\n", "").replace(" ", ""))
@@ -912,10 +923,14 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
     done = ledger.published_chapters(task_id, plat)
     if ch_no and ch_no in done:
         return False, "第 %d 章已成功发布过（台账幂等拦截）；确需重发请手工处理" % ch_no
+    if as_draft and ch_no and ch_no in ledger.drafted_chapters(task_id, plat):
+        return False, ("第 %d 章已存过草稿（台账幂等拦截）；请到平台草稿箱检查后"
+                       "提交发布，确需重存请先在平台删旧稿" % ch_no)
     ok_login, why = _login_guard(plat)
     if not ok_login:
         return False, why
-    _set(plat, status="busy", last_action="upload_chapter", error="")
+    flow_key = "upload_chapter_draft" if as_draft else "upload_chapter"
+    _set(plat, status="busy", last_action=flow_key, error="")
 
     mod = PLATFORMS[plat]
     values = chapter_fill_values(ch_no, title, body,
@@ -934,7 +949,7 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
     operation_id = operations.begin(
         "publish:%s:upload_chapter" % plat,
         {"task_id": task_id, "chapter_no": ch_no, "title": title}, task_id=task_id,
-        metadata={"platform": plat, "action": "upload_chapter"})
+        metadata={"platform": plat, "action": flow_key})
 
     def run():
         try:
@@ -948,14 +963,26 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
             elif not book_ref.get("book_id"):
                 raise RuntimeError("未按作品名找到远端作品，未打开章节编辑器；"
                                    "请检查平台作品名或补填作品 ID")
-            flow.run_flow(page, load_flow(plat, "upload_chapter"), values=values,
+            flow.run_flow(page, load_flow(plat, flow_key), values=values,
                           config=mod.CONFIG, auto_submit=auto_submit,
                           shot=lambda n: page.screenshot(ledger.shot_path(plat, task_id, n)),
                           log=logs.append)
             new_vols = values.get("_volumes")
             if isinstance(new_vols, list) and new_vols != (book_ref.get("volumes") or []):
                 ledger.update_book(task_id, plat, volumes=new_vols)
-            if auto_submit:
+            if as_draft:
+                # 草稿已落平台草稿箱（流程含验证步，走到这=验证过）。发布确认权
+                # 仍在用户：到平台草稿箱逐章检查后手工提交，质量闸在「发布」时
+                # 照常把关。
+                operations.confirm(operation_id, metadata={"platform": plat,
+                                                           "action": "upload_chapter_draft",
+                                                           "chapter_no": ch_no})
+                ledger.record(plat, "upload_chapter_draft", task_id=task_id,
+                              chapter_no=ch_no, book_id=book_ref.get("book_id") or "",
+                              title=title, ok=True, operation_id=operation_id,
+                              operation_status="confirmed",
+                              remote_receipt="platform-draft")
+            elif auto_submit:
                 operations.confirm(operation_id, metadata={"platform": plat,
                                                             "action": "upload_chapter",
                                                             "chapter_no": ch_no})

package/app/core/publish/qimao.py

@@ -60,6 +60,22 @@ UPLOAD_CHAPTER = [
     {"do": "submit", "sel": "button[class*=publish],button[class*=submit]"},
 ]
 
+# 发章存草稿（2026-10-09 全部发草稿）：内置推测表——真机校准表在
+# flows-qimao-calibrated.json（按其 upload_chapter 的「存草稿」段拆出：
+# 填好→存草稿→草稿箱验证行在场即成）。草稿不上线；提交发布由用户在
+# 草稿箱手工点（立即发布→更正序号→确认发布三层弹窗照旧人工走）。
+UPLOAD_CHAPTER_DRAFT = [
+    {"do": "navigate", "url": "{editor_url}"},
+    {"do": "url_any", "any": ["qimao.com"]},
+    {"do": "fill", "sel": "textarea[placeholder*='章节名称']", "key": "chapter_title"},
+    {"do": "wait", "sel": "[contenteditable=true],textarea[class*=content],iframe", "timeout": 10},
+    {"do": "fill", "sel": "[contenteditable=true],textarea[class*=content]", "key": "chapter_body"},
+    {"do": "shot", "name": "chapter-filled-draft"},
+    {"do": "click_real", "text": "存草稿", "tries": 25},
+    {"do": "sleep", "s": 2},
+    {"do": "verify", "url": "{draft_url}", "any": ["{chapter_title}"], "settle": 5},
+]
+
 CHECK_LOGIN = [
     {"do": "navigate", "url": "{home}"},
     {"do": "url_any", "any": ["qimao.com"]},
@@ -73,6 +89,7 @@ PROBE_FORM = [
 ]
 
 FLOWS = {"create_book": CREATE_BOOK, "upload_chapter": UPLOAD_CHAPTER,
+         "upload_chapter_draft": UPLOAD_CHAPTER_DRAFT,
          "check_login": CHECK_LOGIN, "probe_form": PROBE_FORM}
 
 

package/app/core/quality_gate.py

@@ -127,6 +127,13 @@ def evaluate_release(verdict, action="publish", target_chapter=None,
     if action == "continue":
         return {"allowed": True, "status": "continue_only", "forced": False,
                 "blockers": [], "warnings": []}
+    if action == "draft":
+        # 存草稿不是发布：内容不公开展示（读者不可见），正式提交前用户还会
+        # 在平台上逐章过目——质量闸只在「发布/签约」这类上线动作上拦，
+        # 拦草稿只会把「先落平台再人工把关」的通路堵死（2026-10-09 全部
+        # 发草稿需求：质量未达标的 53 章先存草稿，发布仍受本闸约束）。
+        return {"allowed": True, "status": "draft_only", "forced": False,
+                "blockers": [], "warnings": []}
 
     blockers = []
     warnings = []

package/app/main.py

@@ -2263,7 +2263,9 @@ class Handler(BaseHTTPRequestHandler):
         """批量发布全部待发章节（publish/auto.py）。
 
         护栏（每日上限/连败退避/幂等/单飞）在 auto 层，每章发起前复查；
-        auto_submit 默认 false——每章表单填好后停，提交权留给用户。"""
+        auto_submit 默认 false——每章表单填好后停，提交权留给用户。
+        as_draft=true 走「全部发草稿」：逐章存草稿不上线、不受质量闸拦、
+        无需人工确认连跑到清空（2026-10-09）；草稿与直发互斥，草稿优先。"""
         from core import store
         from core.publish import auto as pub_auto
         if not store.get_task(task_id):
@@ -2276,7 +2278,8 @@ class Handler(BaseHTTPRequestHandler):
         force_confirmed = bool(body.get("force_confirmed"))
         force_reason = str(body.get("force_reason") or "").strip()
         only = body.get("chapters")            # 批量选择发布：章号数组（可省=全部待发）
-        kwargs = {"only": only if isinstance(only, list) else None}
+        kwargs = {"only": only if isinstance(only, list) else None,
+                  "as_draft": bool(body.get("as_draft"))}
         if force or force_confirmed or force_reason:
             kwargs.update(force=force, force_confirmed=force_confirmed,
                           force_reason=force_reason)

package/app/ui/app.js

@@ -812,8 +812,14 @@ function onTypeChange() {
 }
 
 function directProviders() {
-  /* 停用厂商不列出（用户拍板 2026-09-21「停用的不弄出来」）；只列启用且有 key 的 */
-  return (S.providers || []).filter((p) => p.enabled !== false && p.api_key);
+  /* 停用厂商不列出（用户拍板 2026-09-21「停用的不弄出来」）；只列启用且有 key 的。
+   * 模型名单已抓取但启用数为零的也不列——「随厂商推荐」没有可落的模型。 */
+  return (S.providers || []).filter((p) => {
+    if (p.enabled === false || !p.api_key) return false;
+    const ms = p.models;
+    if (Array.isArray(ms) && ms.length && !ms.some((m) => m.enabled !== false && !m.hidden)) return false;
+    return true;
+  });
 }
 
 function renderDirectModelPicker() {
@@ -826,7 +832,8 @@ function renderDirectModelPicker() {
   if (prev && provs.some((p) => p.id === prev)) ps.value = prev;
   const p = provs.find((x) => x.id === ps.value);
   const oldModel = ms.value;
-  const names = p ? (p.models || []).filter((m) => !m.hidden)
+  // 只列启用模型（停用/已删除的与后端 resolve 同口径；已选模型被停用时自然回落「随厂商推荐」）
+  const names = p ? (p.models || []).filter((m) => !m.hidden && m.enabled !== false)
     .map((m) => m.name).filter(Boolean) : [];
   ms.innerHTML = '<option value="">' + t("随厂商推荐") + '</option>' + names.map((name) =>
     '<option value="' + esc(name) + '">' + esc(name) + "</option>").join("");
@@ -6166,7 +6173,7 @@ function pbBlock(task, platform) {
     const run = (S.pubAuto && S.pubAuto.running &&
       S.pubAuto.running.platform === platform) ? S.pubAuto.running : null;
     if (run && run.status === "running") {
-      btns += '<span class="pb-book">' + esc(t("自动发布中 ") + run.done + "/" + run.total) + "</span>";
+      btns += '<span class="pb-book">' + esc((run.as_draft ? t("存草稿中 ") : t("自动发布中 ")) + run.done + "/" + run.total) + "</span>";
     } else if (au.pending > 0) {
       // 门禁不再禁用按钮：点了走 pbApiWithQualityOverride 的复审/强制对话，
       // 死按钮只会让用户无路可走（2026-10-08 实案：guard false 全灰点不了）
@@ -6174,6 +6181,12 @@ function pbBlock(task, platform) {
         ' title="' + esc(au.guard_ok ? t("按章号顺序逐章填稿（人工模式每点一次填一章，浏览器里提交后再点发下一章）") : t("护栏提示：") + (au.guard_reason || "")) + '"' +
         ' onclick="pbPublishAll(\'' + esc(task.id) + "', '" + platform + '\')">' +
         t("发布全部待发") + t("（") + au.pending + t("）") + "</button>";
+      // 全部发草稿（2026-10-09）：质量闸拦发布不拦草稿——逐章自动填稿点
+      // 「存草稿」连跑到清空，提交发布由用户到平台草稿箱手工完成
+      btns += ' <button class="ghost" ' + (busy || au.draft_ok === false ? "disabled" : "") +
+        ' title="' + esc(au.draft_ok !== false ? t("逐章自动填稿并点「存草稿」：内容落平台草稿箱不上线，不受质量门禁拦截，无需逐章人工确认；完成后到平台检查并提交发布") : t("护栏提示：") + (au.draft_reason || "")) + '"' +
+        ' onclick="pbDraftAll(\'' + esc(task.id) + "', '" + platform + '\')">' +
+        t("全部存草稿") + t("（") + au.pending + t("）") + "</button>";
     }
     // 批量选择：待发章号 chips 按卷分组（卷计划来自服务端 items[].volume），
     // 「发布所选」人工模式 / 「直发所选」逐章自动提交（护栏照常生效）。
@@ -6222,10 +6235,23 @@ function pbBlock(task, platform) {
           (au.guard_ok ? "" : "；" + t("护栏提示：") + (au.guard_reason || ""))) + '"' +
         ' onclick="pbPublishSelected(\'' + esc(task.id) + "','" + platform + '\',true)">' +
         t("直发所选") + t("（") + sel.size + t("）") + "</button>" +
+        '<button class="ghost" ' + (busy || !sel.size || au.draft_ok === false ? "disabled" : "") +
+        ' title="' + esc(t("所选章节逐章自动存草稿（不上线、不受质量门禁拦截），完成后到平台检查并提交发布") +
+          (au.draft_ok !== false ? "" : "；" + t("护栏提示：") + (au.draft_reason || ""))) + '"' +
+        ' onclick="pbDraftSelected(\'' + esc(task.id) + "','" + platform + '\')">' +
+        t("存草稿所选") + t("（") + sel.size + t("）") + "</button>" +
         "</div></div>";
     }
-    if (au.pending > 0 && !au.guard_ok) {
-      btns += '<div class="pb-err">' + esc(au.guard_reason || t("护栏拦截")) + "</div>";
+    if (au.pending > 0 && au.draft_ok === false) {
+      // 硬护栏（建书未确认/每日上限/连败退避）：存草稿也走不了，红色示警
+      btns += '<div class="pb-err">' + esc(au.draft_reason || au.guard_reason || t("护栏拦截")) + "</div>";
+    } else if (au.pending > 0 && !au.guard_ok && au.quality_blockers && au.quality_blockers.length) {
+      // 纯质量闸拦截：不给死路——提示先存草稿（2026-10-09 全部发草稿通路）
+      btns += '<div class="pb-hint">' + esc(t("质量闸未过：") + au.quality_blockers.join(t("；")) +
+        t("——可先「全部存草稿」落平台（不上线），正式发布前需复审达标或强制放行")) + "</div>";
+    }
+    if (au.drafted > 0) {
+      btns += '<div class="pb-hint">' + esc(t("已存草稿 {0} 章（未发布）：到平台章节管理/草稿箱逐章检查后提交发布", au.drafted)) + "</div>";
     }
     if (run && run.status === "manual_pause") {
       // 人工模式一轮只填一章：等用户在浏览器提交后再发起（连发会导航离开
@@ -6580,6 +6606,38 @@ window.pbPublishAll = async function (taskId, platform) {  const au = (((S.pubAu
   S._pbSig = ""; pbKick();
 };
 
+/* 全部发草稿（2026-10-09）：逐章自动填稿点「存草稿」连跑到清空，不上线、
+ * 不受质量闸拦、无需人工确认；提交发布由用户到平台草稿箱手工完成。 */
+window.pbDraftAll = async function (taskId, platform) {
+  const au = (((S.pubAuto && S.pubAuto.books) || [])
+    .find((b) => b.platform === platform)) || {};
+  if (!au.pending) return;
+  if (!(await uiConfirm(t("将对全部 {0} 章待发稿逐章自动填稿并点「存草稿」：内容落平台草稿箱不上线，不受质量门禁拦截，无需逐章人工确认（章间隔约 1 分钟防风控）。跑完后请到平台章节管理/草稿箱逐章检查，再手工提交发布。继续？", au.pending),
+    { ok: t("开始存草稿") }))) return;
+  try {
+    await api("/api/publish/task/" + encodeURIComponent(taskId) + "/publish-all",
+      { method: "POST", body: JSON.stringify({ platform, as_draft: true }) });
+    toast(t("存草稿已启动：逐章自动填稿并保存草稿，进度见发布台"));
+  } catch (e) { toast(t("存草稿启动失败：") + e.message, true); }
+  S._pbSig = ""; pbKick();
+};
+
+window.pbDraftSelected = async function (taskId, platform) {
+  const key = taskId + ":" + platform;
+  const ent = (S.pbSel || {})[key];
+  const chapters = ent ? [...ent.sel].sort((a, b) => a - b) : [];
+  if (!chapters.length) return;
+  if (!(await uiConfirm(t("将对所选 {0} 章（第 {1} 章—第 {2} 章）逐章自动填稿并点「存草稿」（不上线、不受质量门禁拦截），完成后到平台章节管理/草稿箱检查并提交发布。继续？",
+      chapters.length, chapters[0], chapters[chapters.length - 1]),
+    { ok: t("开始存草稿") }))) return;
+  try {
+    await api("/api/publish/task/" + encodeURIComponent(taskId) + "/publish-all",
+      { method: "POST", body: JSON.stringify({ platform, chapters, as_draft: true }) });
+    toast(t("存草稿已启动：逐章自动填稿并保存草稿，进度见发布台"));
+  } catch (e) { toast(t("存草稿启动失败：") + e.message, true); }
+  S._pbSig = ""; pbKick();
+};
+
 function pbKick() {
   const key = detailSideTaskKey();
   if (!key) return;
@@ -9781,7 +9839,8 @@ function rdModelMenuRender() {
         t("管理模型…") + "</span></span></button></div>";
   } else {
     const p = directProviders().find((x) => x.id === rdMenuProv);
-    const names = p ? (p.models || []).filter((m) => !m.hidden)
+    // 只列启用模型：停用的选了也会被运行时拒（builtin_agent.resolve 对账启用名单）
+    const names = p ? (p.models || []).filter((m) => !m.hidden && m.enabled !== false)
       .map((m) => m.name).filter(Boolean) : [];
     menu.innerHTML =
       '<button type="button" class="type-item" data-back="1"><span class="ti-body"><span class="ti-name">‹ ' +
@@ -10486,6 +10545,14 @@ function apnSyncActive() {
 /* ---------------------------------------------------------- 智能体目录：模型选择 */
 const MAX_ORCH_MODELS = 3;   // 与后端 modelhub.MAX_BIND_MODELS、runner 降级链保持一致
 
+/* 供应商有无可用密钥：keys 结构以「有启用且未冷却」为准；老数据单 KEY 看
+ * api_key 镜像（与后端 _chain_keys / resolve_binding 的「无可用密钥」同口径） */
+function provKeyOk(p) {
+  const ks = (p || {}).keys || [];
+  if (ks.length) return ks.some((k) => k.enabled !== false && !k.cooling);
+  return !!(p || {}).api_key;
+}
+
 /* 供应商 → 已启用模型（按优先级），用于分组下拉与多选面板 */
 function modelGroups() {
   const out = [];
@@ -10496,7 +10563,7 @@ function modelGroups() {
       .sort((a, b) => (a.priority || 0) - (b.priority || 0))
       .map((m) => m.name).filter(Boolean);
     if (ms.length) out.push({ id: p.id, name: p.name, models: ms,
-      protocol: p.protocol || "", caps: p.wire_caps || {} });
+      protocol: p.protocol || "", caps: p.wire_caps || {}, keyOk: provKeyOk(p) });
   }
   return out;
 }
@@ -10556,9 +10623,10 @@ function bindAllowedProtocols(kind) {
 function modelSelectHtml(id, current, kind) {
   const cur = fmtModel(current);
   const allow = bindAllowedProtocols(kind);
+  // 无可用密钥的供应商不进下拉：默认模型配上去解析时也会被跳过（死配置）
   const groups = modelGroups().filter((g) => {
     const p = (S.providers || []).find((x) => x.id === g.id);
-    return provAdaptedProto(p, allow, kind);
+    return g.keyOk !== false && provAdaptedProto(p, allow, kind);
   });
   let opts = '<option value="">' + t("（未设置）") + '</option>';
   if (cur && !groups.some((g) => g.models.includes(cur))) {
@@ -10685,7 +10753,7 @@ function chainProvUsable(p, allow, kind) {
   if (!p || p.enabled === false) return false;
   if (!provAdaptedProto(p, allow, kind)) return false;
   const ks = p.keys || [];
-  if (!ks.length) return true; // 老数据单 KEY（api_key 镜像）：无 keys 结构视为可用
+  if (!ks.length) return !!p.api_key;   // 老数据单 KEY（api_key 镜像）；两者皆无=没配密钥，不推荐
   return ks.some((k) => k.enabled !== false && !k.cooling);
 }
 
@@ -10847,16 +10915,19 @@ function bindPanel(c) {
            ? t("注入该厂商凭据") : t("已适配 · 注入该厂商凭据"))) + '</span></div>' +
       g.models.map((m) => {
         // 本供应商注入本 CLI 实际走的 wire（与后端 _entry_endpoint 同规则）；
-        // 无命中 = 勾了也会被解析层整条跳过，标死防止白配
+        // 无命中 = 勾了也会被解析层整条跳过，标死防止白配。
+        // 无可用密钥同理：勾了也是死条目（解析层「无可用密钥」跳过）
         const wire = provAdaptedProto(g, allow, c.orch_kind);
-        const dead = !wire;
+        const dead = !wire || g.keyOk === false;
         const has = st.chain.some((x) => x.p === g.id && x.m === m);
         return '<label class="oitem' + (dead ? " dim" : "") + '"><input type="checkbox" value="' + esc(m) + '" data-p="' + esc(g.id) + '"' +
           (has ? " checked" : "") + (dead ? " disabled" : "") +
           " onchange=\"bindPick('" + esc(c.id) + "', this, this.checked)\">" + esc(m) +
           (modelHasImage(g.id, m)
             ? ' <span class="tag ok" title="' + esc(t("支持图片输入")) + '">' + t("图") + "</span>" : "") +
-          (dead ? ' <span class="hint warn">' + esc(t("无可用 wire，解析时跳过")) + "</span>" : "") +
+          (dead ? ' <span class="hint warn">' + esc(!wire
+            ? t("无可用 wire，解析时跳过")
+            : t("无可用密钥，解析时跳过")) + "</span>" : "") +
           "</label>";
       }).join("") +
       "</div>").join("") + "</div>";
@@ -11995,7 +12066,8 @@ function renderAuModelPicker(pid, model) {
   ps.value = provs.some((p) => p.id === keepP) ? keepP : "";
   const fillModels = (keepM) => {
     const p = provs.find((x) => x.id === ps.value);
-    const names = p ? (p.models || []).filter((m) => !m.hidden)
+    // 只列启用模型：停用的不允许在定时任务里选（运行时同样会拒）
+    const names = p ? (p.models || []).filter((m) => !m.hidden && m.enabled !== false)
       .map((m) => m.name).filter(Boolean) : [];
     ms.innerHTML = '<option value="">' + t("随厂商推荐") + "</option>" + names.map((name) =>
       '<option value="' + esc(name) + '">' + esc(name) + "</option>").join("");

package/app/ui/board.css

@@ -207,7 +207,11 @@ button { font: inherit; cursor: pointer; }
 }
 .k-lab { font-size: 11px; color: var(--t3); letter-spacing: .8px; }
 .k-row { display: flex; align-items: baseline; justify-content: space-between; gap: 10px; }
-.k-num { font: 700 27px/1 var(--mono); }
+/* k-num 不许换行：卡高 78px 固定 + overflow hidden，换行必裁字（「2246.7万」案）；
+   放不下由 fitKpis() 降档，仍放不下才在末档省略号 */
+.k-num { font: 700 27px/1 var(--mono); white-space: nowrap; }
+.k-num.sm { font-size: 21px; }
+.k-num.xs { font-size: 16px; min-width: 0; overflow: hidden; text-overflow: ellipsis; }
 .k-sub { font: 11px var(--mono); color: var(--t2); white-space: nowrap; }
 .k-run .k-num { color: var(--live-hi); }
 .k-queue .k-num { color: var(--data); }

package/app/ui/board.js

@@ -42,6 +42,20 @@ function parseTs(s) {
   const t = Date.parse(String(s || "").replace(" ", "T"));
   return isNaN(t) ? 0 : t;
 }
+/* 指标条长数值自适应：行宽放不下就逐档降字号（27→21→16px）。
+   判据用 k-row 的 scrollWidth：num/sub 都 nowrap 不收缩，超宽才会外溢。 */
+function fitKpis() {
+  document.querySelectorAll("#kpis .k-row").forEach((row) => {
+    const num = row.querySelector(".k-num");
+    if (!num) return;
+    num.classList.remove("sm", "xs");
+    if (row.scrollWidth <= row.clientWidth + 1) return;
+    num.classList.add("sm");
+    if (row.scrollWidth <= row.clientWidth + 1) return;
+    num.classList.remove("sm");
+    num.classList.add("xs");
+  });
+}
 function esc(s) {
   return String(s == null ? "" : s).replace(/[&<>"']/g,
     (c) => ({"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"}[c]));
@@ -167,6 +181,7 @@ function render(d) {
 
   $("#k-tokens").textContent = fmtTokens(usage.tokens);
   $("#k-use-sub").textContent = fmtCost(usage.cost_usd) + " · " + (Number(usage.calls) || 0) + " " + t("次调用");
+  fitKpis();
 
   // 顶栏态势：整屏只在这里说一次「有没有活」
   const st = $("#hd-state");
@@ -493,6 +508,7 @@ document.addEventListener("keydown", (e) => {
   if (e.key === "T" || e.key === "t") $("#sw-mode").click();
   if (e.key === "S" || e.key === "s") $("#sw-skin").click();
 });
+window.addEventListener("resize", fitKpis);
 
 /* ---------------------------------------------------------------- 时钟与耗时每秒跳 */
 setInterval(() => {

package/app/ui/i18n.js

@@ -824,6 +824,7 @@
     "openai 面仅 chat 形态（codex 只讲 responses）": "openai face is chat-only (codex speaks responses only)",
     "openai 面仅 chat 形态（codex 只讲 responses），解析时跳过": "openai face is chat-only (codex speaks responses only) — skipped when resolving",
     "无可用 wire，解析时跳过": "no usable wire — skipped when resolving",
+    "无可用密钥，解析时跳过": "no usable key — skipped when resolving",
     "该 CLI 只接受特定 wire 协议的供应商，当前没有匹配项——先到「模型接入」页导入对应协议的网关。": "This CLI only accepts providers on a specific wire protocol and none match — import a compatible gateway on the Models page first.",
     "%1 个供应商 wire 协议不匹配已隐藏（降级只在同协议网关间进行）。": "%1 provider(s) hidden due to wire-protocol mismatch — fallback stays within the same protocol.",
     "已适配（%1 wire）": "adapted (%1 wire)",
@@ -1407,7 +1408,7 @@
     "每套皮肤都是一份完整配色，并且各带「日间 / 夜间」两版，明暗切换不会丢皮肤。选中的皮肤立即生效并记在这台设备上（手机与电脑各自独立）。": "Each skin is a complete palette, with day / night variants — switching brightness never loses your skin. The selected skin applies instantly and is remembered on this device (phone and computer are independent).",
     "系统自己的经验沉淀：": "The system's own distilled experience:",
     "这台设备第一次连接，请输入访问令牌": "First connection from this device — enter the access token",
-    "（如七猫签约标准，自动注入小说类任务的规划与评审提示词） 与": " (e.g. the Qimao signing standard, auto-injected into planning & review prompts for novel tasks)",
+    "（如七猫签约标准，自动注入同类任务的规划与评审提示词） 与": " (e.g. the Qimao signing standard, auto-injected into planning & review prompts for matching tasks)",
     "（每次任务结束由编排者复盘本次评审暴露的问题，去重沉淀，下次同类任务自动带上）——越跑越好，无需人工维护。": " (after each task the orchestrator reviews the problems this review exposed, dedupes and distills them, and re-attaches them to the next similar task) — it gets better with every run, no manual upkeep.",
     "条": " entries",
     "（暂无，跑一次任务后自动生成）": " (none yet — generated after the first run)",
@@ -2600,6 +2601,30 @@
     "自动发布失败：": "Auto-publish failed: ",
     "已填好一章，请在浏览器确认提交": "One chapter is filled — please review and submit in the browser",
     "护栏拦截": "Blocked by guardrail",
+    "全部存草稿": "Save all as drafts",
+    "存草稿所选": "Draft selected",
+    "逐章自动填稿并点「存草稿」：内容落平台草稿箱不上线，不受质量门禁拦截，无需逐章人工确认；完成后到平台检查并提交发布": "Fills each chapter and clicks \"Save draft\": content lands in the platform's draft box without going live, bypasses the quality gate, no per-chapter confirmation; review and submit on the platform when done",
+    "所选章节逐章自动存草稿（不上线、不受质量门禁拦截），完成后到平台检查并提交发布": "Saves the selected chapters as drafts one by one (not live, quality gate not applied); review and submit on the platform when done",
+    "存草稿中 ": "Saving drafts ",
+    "已存草稿 {0} 章（未发布）：到平台章节管理/草稿箱逐章检查后提交发布": "{0} chapters saved as drafts (not published): review each in the platform's chapter management/draft box, then submit",
+    "质量闸未过：": "Quality gate not passed: ",
+    "——可先「全部存草稿」落平台（不上线），正式发布前需复审达标或强制放行": " — you can \"Save all as drafts\" first (not live); publishing requires a passing re-review or a forced override",
+    "将对全部 {0} 章待发稿逐章自动填稿并点「存草稿」：内容落平台草稿箱不上线，不受质量门禁拦截，无需逐章人工确认（章间隔约 1 分钟防风控）。跑完后请到平台章节管理/草稿箱逐章检查，再手工提交发布。继续？": "Will fill and save every pending chapter ({0} total) as a draft: content lands in the platform's draft box without going live, quality gate not applied, no per-chapter confirmation (~1 min pacing between chapters). Review each draft on the platform and submit manually when done. Continue?",
+    "将对所选 {0} 章（第 {1} 章—第 {2} 章）逐章自动填稿并点「存草稿」（不上线、不受质量门禁拦截），完成后到平台章节管理/草稿箱检查并提交发布。继续？": "Will fill and save the selected {0} chapters (ch. {1}–ch. {2}) as drafts (not live, quality gate not applied); review and submit on the platform when done. Continue?",
+    "开始存草稿": "Start saving drafts",
+    "存草稿已启动：逐章自动填稿并保存草稿，进度见发布台": "Draft saving started: chapters are filled and saved one by one — watch progress in the publish panel",
+    "存草稿启动失败：": "Failed to start draft saving: ",
+    "发布所选": "Publish selected",
+    "直发所选": "Auto-publish selected",
+    "开始直发": "Start auto-publish",
+    "清空": "Clear",
+    "待发 ": "Pending ",
+    " 章（按卷计划自动分卷）": " chapters (volumes auto-assigned per plan)",
+    "直发已启动，进度见发布台": "Auto-publish started — track progress in the publish panel",
+    "所选章节逐章自动提交（无人值守），护栏每日上限/连败退避照常生效": "Selected chapters submit automatically one by one (unattended); guards (daily cap / failure backoff) stay active",
+    "将对所选 {0} 章（第 {1} 章—第 {2} 章）逐章自动填稿并提交发布，无需人工确认；护栏（每日上限/连续失败暂停）生效。确定直发？": "Will fill and submit the selected {0} chapters (ch. {1}–ch. {2}) one by one automatically, no manual confirmation; guards (daily cap / consecutive-failure pause) stay active. Start auto-publish?",
+    "将按章号顺序逐章填所选 {0} 章（第 {1} 章—第 {2} 章）。人工模式每轮填一章并停在表单页，由你在浏览器里确认提交。分卷会按卷计划自动选/建。继续？": "Will fill the selected {0} chapters (ch. {1}–ch. {2}) in order. Manual mode fills one chapter per round and stops at the form page — you confirm each submission in the browser. Volumes are auto-picked/created per plan. Continue?",
+    "护栏提示：": "Guardrail notice: ",
 
     // —— 报告区 / 状态 / 杂项 ——
     "将于 {0} 自动续跑": "Auto-resumes at {0}",

package/app/ui/index.html

@@ -957,7 +957,7 @@
         <div class="panel wide">
           <div class="panel-head"><h2 data-i18n="经验库">经验库</h2>
             <button class="hhelp" data-help-topic="features" title="这是什么？点开看帮助" data-i18n-title="这是什么？点开看帮助" aria-label="帮助" data-i18n-aria="帮助"><svg class="ico" aria-hidden="true"><use href="#i-help"></use></svg></button></div>
-          <p class="hint"><span data-i18n="系统自己的经验沉淀：">系统自己的经验沉淀：</span><b data-i18n="内置规范包">内置规范包</b><span data-i18n="（如七猫签约标准，自动注入小说类任务的规划与评审提示词） 与">（如七猫签约标准，自动注入小说类任务的规划与评审提示词）
+          <p class="hint"><span data-i18n="系统自己的经验沉淀：">系统自己的经验沉淀：</span><b data-i18n="内置规范包">内置规范包</b><span data-i18n="（如七猫签约标准，自动注入同类任务的规划与评审提示词） 与">（如七猫签约标准，自动注入同类任务的规划与评审提示词）
             与</span><b data-i18n="运行中自动学到的教训">运行中自动学到的教训</b><span data-i18n="（每次任务结束由编排者复盘本次评审暴露的问题，去重沉淀，下次同类任务自动带上）——越跑越好，无需人工维护。">（每次任务结束由编排者复盘本次评审暴露的问题，去重沉淀，下次同类任务自动带上）——越跑越好，无需人工维护。</span></p>
           <h3 data-i18n="内置规范包" class="sec-title">内置规范包</h3>
           <div id="skill-packs" class="cards"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.98",
+  "version": "0.1.99",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {