codebee 0.1.100 → 0.1.102

package/app/core/pipeline.py

@@ -586,6 +586,8 @@ def _external_sandbox_block_reason(agent, workdir, sandbox):
     from . import policy
     root = os.path.realpath(workdir or ".")
     normalized = policy.normalize_sandbox(sandbox, root)
+    if normalized.get("backend") == "docker":
+        return "沙箱拒绝：Docker 目前仅接入内置命令工具，外部 CLI 未验证容器启动，拒绝运行"
     if (agent or {}).get("kind") == "codex":
         if normalized.get("network") is False:
             return "沙箱拒绝：该 CLI 后端未接入网络隔离，拒绝运行网络受限任务"
@@ -912,7 +914,8 @@ def _finish_step_result(run_id, step, res, role, agent, start):
                       followups=res.get("followups"),
                       # 思考过程（内置智能体流式抓取）：落进步骤记录，对话气泡折叠展示
                       thinking=res.get("reasoning") or None,
-                      partial=bool(res.get("partial")))
+                      partial=bool(res.get("partial")),
+                      acp_events=(raw.get("acp_events") or []))
     try:
         checkpoint_status = ("unknown" if raw.get("unknown") else
                              "timeout" if status == "timeout" else
@@ -2591,6 +2594,36 @@ __CRITIQUE__
 - 针对性改进所有 major 问题；保持既定风格与设定。
 - 完成后用 3 句话说明本轮改了什么。"""
 
+# 评审口径单一真源：评审面提示词（单章/全局）与作者面注入块从这里同源提取，
+# 两边永不脱节。此前评审清单/签约专项/全局口径只活在评审面，作者第一遍写完
+# 被打回才知道按什么标准被审（2026-10-10 实案：全章过线仍卡全局 major）。
+# 作者面刻意不下发评分机制本体（1-10 分/阈值/宁严勿宽）——对写作者零价值，
+# 透下去只喂响应试素材；清单条目本身全是质量正向要求，事前下发只有好处。
+REVIEW_CHECKLIST_ITEMS = (
+    "叙述语域与视角统一",
+    "复杂情感落到动作、五感或生理细节",
+    "开篇在前 600 字进入具体冲突",
+    "每章发生真实的局面变化",
+    "无可删的重复铺垫与长段解释",
+)
+GLOBAL_REVIEW_FOCUS = ("主线一致性、人物弧光、开篇吸引力、文风表现、情感表达、"
+                       "情节推进与节奏控制")
+
+
+def author_review_rubric_block(dims, signing_dims):
+    """作者面评审口径块：起草/修订提示词里事前下发「会按什么标准被审」，
+    与评审面同源（REVIEW_CHECKLIST_ITEMS / GLOBAL_REVIEW_FOCUS）。静态文本，
+    同批各章字节一致，不碎前缀缓存。"""
+    lines = [
+        "## 评审口径（本书会按以下标准审稿，写作时对照自查）",
+        "- 评分维度：" + " / ".join(dims) + "。",
+        "- 逐项硬清单：" + "；".join(REVIEW_CHECKLIST_ITEMS) + "。",
+        "- 全书级关注：" + GLOBAL_REVIEW_FOCUS + "。",
+        "- 签约专项维度：" + "、".join(signing_dims) + "。",
+    ]
+    return "\n".join(lines) + "\n"
+
+
 NOVEL_CRITIQUE_PROMPT = """你是严格的评审（不要使用任何工具、不要修改文件，只依据下方稿件内容评审）。
 请输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {
@@ -2599,7 +2632,7 @@ NOVEL_CRITIQUE_PROMPT = """你是严格的评审（不要使用任何工具、
   "summary": "一句话总评"
 }
 每个维度打 1-10 分（可为小数），宁严勿宽。major 问题必须给 quote（系统会逐条校验引文是否真在稿件中——编造的引文会被降档标记）。
-评审必须逐项回答：叙述语域与视角是否统一；复杂情感是否有动作、五感或生理细节；开篇是否在前 600 字进入具体冲突；本章是否发生局面变化；是否存在可删的重复铺垫或长段解释。
+评审逐项核查以下各项是否成立：%s。""" % ("；".join(REVIEW_CHECKLIST_ITEMS)) + """
 
 ## 待评审稿件
 ---
@@ -2885,6 +2918,7 @@ __VOLUME__
 - 本章主要情绪/戏剧变化：__HIGHLIGHT__（按其重要性决定篇幅和表现方式；不强制放大，不为满足标签伪造高潮）
 __LOCKED_CH__
 __STALE_NOTE__
+__REDO_ISSUES__
 - 正文约 __WORDS__ 字，中文，直接开写正文（可含本章标题行）。
 
 ## 前情提要（此前各章结尾摘录，衔接用）
@@ -2899,6 +2933,7 @@ __STYLE__
 ## 签约质量门禁
 __QUALITY_GATE__
 
+__REVIEW_RUBRIC__
 - 写完文件后，最终回复只输出一行：`第 __I__ 章完成（约 __WORDS__ 字）`——不要在回复里复述或解释正文。"""
 
 SERIAL_REVISE_PROMPT = """你是一名网文作者。第 __I__ 章没有通过评审，请修订文件 `__FILE__`（直接改写该文件）。文件必须以 UTF-8 编码保存（PowerShell 显式加 -Encoding UTF8，禁止依赖默认编码）。
@@ -2913,6 +2948,7 @@ __BEATS__
 （本章爽点/情绪爆点：__HIGHLIGHT__）
 __LOCKED_CH__
 
+__REVIEW_RUBRIC__
 ## 本章评审意见
 __CRITIQUE__
 
@@ -2936,7 +2972,7 @@ SERIAL_GLOBAL_PROMPT = """你是独立小说质量评审（不要修改任何文
   "issues": [{"dim": "维度名", "severity": "major|minor", "note": "具体问题（指明哪一章）", "quote": "支撑该问题的稿件原文连续片段（≥8字，逐字摘录不许改写）"}],
   "summary": "一句话总评：所读范围内的文本优势、主要风险与未验证项；不得预测签约结果"
 }
-每个维度打 1-10 分，按统一文本 rubric 与所读证据评估，不以“宁严勿宽”压分。重点关注：主线一致性、人物弧光、开篇吸引力、文风表现、情感表达、情节推进与节奏控制。
+每个维度打 1-10 分，按统一文本 rubric 与所读证据评估，不以“宁严勿宽”压分。重点关注：%s。""" % GLOBAL_REVIEW_FOCUS + """
 若是全书最初的前 3 章，可观察视角人物、故事承诺、开篇兑现和读者理解成本；固定字数点、钩子/爽点密度仅作参考，不是扣分门槛。发现问题须给可定位原文引文，并区分文本事实、解释和建议。
 major 问题必须给 quote（系统会逐条校验引文是否真在稿件中——编造的引文会被降档标记）。
 
@@ -3342,6 +3378,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     # 签约专项维度作为额外硬性检查注入提示词与报告证据。
     dims = task.get("rubric") or DEFAULT_RUBRIC
     signing_dims = novel_quality.rubric_for({"type": "serial_novel"})
+    # 作者面评审口径块（与评审面同源提取）：起草/修订/打磨提示词都带
+    rubric_block = author_review_rubric_block(dims, signing_dims)
     threshold = task.get("threshold", 7.0)
     threshold_ch = threshold - 0.5 if threshold >= 7.5 else threshold   # 单章阈值略放宽 0.5 分
     dimkey = ", ".join('"%s": 0' % d for d in dims)
@@ -3412,6 +3450,9 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     inherit = run.get("inherit") or {}
     done_set = set(inherit.get("done_chapters") or [])
     inh_scores = {c.get("chapter"): c for c in (inherit.get("chapter_scores") or [])}
+    # 未达标重写的原因账（store.retry_task 从 verdict.major_issues 下发）：
+    # 章节级+全局级 major，渲染进对应重写章的起草提示词；达标续跑为空表
+    redo_issues = [x for x in (inherit.get("redo_issues") or []) if isinstance(x, dict)]
     if inherit.get("outline"):
         outline = inherit["outline"]
         # 历史遗留：降级/模板大纲被继承时，真实任务宁可中止重生成，也不按空模板写全书
@@ -3840,6 +3881,26 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             if os.path.exists(os.path.join(workdir, ch_file)):
                 stale_note = ("- 注意：目录里已有一版**未通过评审**的旧稿 `%s`——不要校验沿用、"
                               "不要增量修补，按本章任务直接覆盖重写。" % ch_file)
+            # 上一轮未达标原因（「重写未达标章」链路）：本章被点名的 major 与
+            # 全书级 major 随起草提示词下发——原因只躺在报告里、作者盲写等
+            # 修订拉回，白白多烧一轮评审（2026-10-10 实案）。
+            def _issue_ch(x):
+                try:
+                    return int(x.get("chapter"))
+                except (TypeError, ValueError):
+                    return None
+
+            redo_lines = []
+            mine = [x for x in redo_issues if _issue_ch(x) == i]
+            book_lvl = [x for x in redo_issues if _issue_ch(x) is None]
+            if mine:
+                redo_lines.append("- 本章被上一轮评审点名的问题（重写必须逐条消解）：")
+                redo_lines += _major_lines(mine)
+            if book_lvl:
+                redo_lines.append("- 上一轮全书级 major 问题（本章重写须配合消解，不得相抵）：")
+                redo_lines += _major_lines(book_lvl)
+            redo_note = ("## 上一轮评审未达标原因（必读）\n" + "\n".join(redo_lines) + "\n"
+                         ) if redo_lines else ""
             # stable_order：同一任务 8 个章节的技能块必须字节级一致（§07 T1.2' 前缀缓存）
             # 三块分开留底：起草重试的分层降级（_serial_shrunk_block）要按
             # 「经验库/圣经」各自的身份收缩，折成一整块就只剩 4K 硬截一层了
@@ -3878,6 +3939,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         .replace("__HOOK__", branch_hook or ch.get("hook") or "留下悬念")
                         .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, i))
                         .replace("__STALE_NOTE__", stale_note)
+                        .replace("__REDO_ISSUES__", redo_note)
+                        .replace("__REVIEW_RUBRIC__", rubric_block)
                         .replace("__HIGHLIGHT__", ch.get("highlight") or "按剧情要点自然铺设一处小冲突/小反转")
                         .replace("__STYLE__", style_tpl)
                         .replace("__QUALITY_GATE__", novel_quality.opening_requirements(i, wpc))
@@ -4031,7 +4094,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 if not res["ok"]:
                     # 成品是文件不是退出码：CLI 超时但章稿已完整落盘（终章长文实测
                     # 反复出现——文件写完、收尾声明没等到）就送评审门把关，别整章作废
-                    live = (store.get_run(run_id).get("steps") or [])
+                    live = ((store.get_run(run_id) or {}).get("steps") or [])
                     if live:
                         store.finish_step(run_id, live[-1]["n"], "done",
                                           summary="起草调用超时，但章稿已完整落盘（约 %d 字）——交评审门判质量"
@@ -4290,6 +4353,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                           .replace("__VOLUME__", vol_block_for(i))
                           .replace("__BEATS__", ch.get("beats") or "按大纲推进")
                           .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, i))
+                          .replace("__REVIEW_RUBRIC__", rubric_block)
                           .replace("__HIGHLIGHT__", ch.get("highlight")
                                    or "按剧情要点自然铺设一处小冲突/小反转")
                           .replace("__STYLE__", style_tpl)
@@ -4445,6 +4509,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                              .replace("__VOLUME__", vol_block_for(j))
                              .replace("__BEATS__", _wch.get("beats") or "按大纲推进")
                              .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, j))
+                             .replace("__REVIEW_RUBRIC__", rubric_block)
                              .replace("__HIGHLIGHT__", _wch.get("highlight")
                                       or "按剧情要点自然铺设一处小冲突/小反转")
                              .replace("__STYLE__", style_tpl)
@@ -4656,6 +4721,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                           .replace("__VOLUME__", vol_block_for(i))
                           .replace("__BEATS__", ch.get("beats") or "按大纲推进")
                           .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, i))
+                          .replace("__REVIEW_RUBRIC__", rubric_block)
                           .replace("__HIGHLIGHT__", ch.get("highlight")
                                    or "按剧情要点自然铺设一处小冲突/小反转")
                           .replace("__CRITIQUE__", crit)
@@ -5940,8 +6006,23 @@ def execute_run(run_id):
                          status="cancelled", ended_at=_now())
     except Exception as e:
         import traceback
+        # 崩溃现场随错误行下发（2026-10-10 Mac 实案：连载连烧两轮自动续跑都
+        # 死于 AttributeError("'NoneType' object has no attribute 'get'")，
+        # 错误行只有一行 repr 无从定位；traceback 全文虽落 run 目录 error.log，
+        # 但 UI 上看不见）。尾帧 = 文件:行号:函数名，一行说清死在哪；同因止损
+        # 的错误签名因此按崩溃位置区分——同位置才算同因，代码升级后行号漂移
+        # 自动能多试一轮（新代码可能已修复），次数上限仍兜底。
+        _tb_tail = ""
+        try:
+            _frames = traceback.extract_tb(e.__traceback__)
+            if _frames:
+                _f = _frames[-1]
+                _tb_tail = "（崩溃于 %s:%s %s）" % (
+                    os.path.basename(_f.filename), _f.lineno, _f.name)
+        except Exception:
+            pass
         store.update_run(run_id, expected_status="running", status="failed",
-                         error=repr(e)[:500], ended_at=_now())
+                         error=(repr(e)[:380] + _tb_tail)[:500], ended_at=_now())
         try:
             err_path = store.run_dir(run_id) / "error.log"
             if _inside(str(store.run_dir(run_id).parent), str(err_path)):

package/app/core/plugins.py

@@ -371,14 +371,21 @@ def install(plugin_id, roots=None):
                     "skill_count": len(old.get("skill_pack_ids") or [])}, None
         source = Path(desc["dir"]).resolve()
         target = (_install_root() / plugin_id).resolve()
+        market_id = "plugin-" + plugin_id
+        # 回滚标记必须在 try 之前就绑定：_copy_plugin/load_manifest 在记账前
+        # 抛错时 except 要靠它决定是否清 market 包，未初始化会把人话错误
+        # 炸成 UnboundLocalError→500，还会跳过残留目录清理让重装永远撞车。
+        market_written = False
         try:
             target.relative_to(_install_root().resolve())
+            if target.exists() and target != source:
+                # 有登记记录的已装插件在上面 already 分支就返回了；走到这里
+                # 还存在目标目录只可能是上次安装中途失败的残缺副本，清掉重装。
+                shutil.rmtree(target, ignore_errors=True)
             _copy_plugin(source, target)
             installed_desc = load_manifest(target)
             files = _skill_files(installed_desc)
-            market_id = "plugin-" + plugin_id
             skill_result = None
-            market_written = False
             if files:
                 skill_result, err = market.install_files(
                     market_id, installed_desc["display_name"], files,

package/app/core/policy.py

@@ -50,9 +50,18 @@ def normalize_sandbox(spec=None, workdir=None):
     else:
         # Invalid policy input must never silently widen network access.
         network = False
+    backend = str(spec.get("backend") or "native").strip().lower()
+    if backend not in ("native", "docker"):
+        raise ValueError("沙箱 backend 必须是 native 或 docker")
+    image = str(spec.get("docker_image") or "").strip()[:240]
+    if backend == "docker":
+        import re
+        if not image or not re.match(r"^[A-Za-z0-9][A-Za-z0-9._/:@-]*$", image):
+            raise ValueError("Docker 镜像名无效")
     return {"allowed_roots": [str(x) for x in roots], "env_allowlist": env,
             "network": network, "timeout_s": timeout,
             "max_output_bytes": output,
+            "backend": backend, "docker_image": image,
             "disabled_tools": normalize_disabled_tools(spec.get("disabled_tools"))}
 
 

package/app/core/publish/auto.py

@@ -24,6 +24,7 @@ import time
 PACE_S = 45                  # 章间间隔（防风控节奏），测试里可置 0
 IDLE_POLL_S = 2              # 等 manager busy 结束的轮询步长
 IDLE_TIMEOUT_S = 420         # 单章最长等待（含浏览器操作与人工确认窗口）
+TRANSIENT_RETRY_S = 5        # 连接类瞬断的重试前静默（等浏览器缓过来）
 
 _CAP_DEFAULT = 10
 _STREAK_DEFAULT = 3
@@ -95,6 +96,36 @@ def _fail_window_text():
     return ("%g 小时" % h) if h < 24 else ("%g 天" % (h / 24))
 
 
+# 连接类瞬断标记（2026-10-10 存草稿实案：45 章 fill 时「连接被关闭」整链
+# 停摆）——命中即对该章重试一次再弃，不因浏览器抖动废掉整批
+_TRANSIENT_MARKS = ("连接断开", "连接被关闭", "10053", "10054", "等响应超时",
+                    "已中止", "目标已关闭")
+# 幂等拒起标记（manager 层台账/实况对账的拒绝话术）——命中即跳过该章，
+# 不是失败
+_IDEMPOTENT_MARKS = ("已成功发布过", "已存过草稿")
+
+
+def _is_transient(err):
+    e = str(err or "")
+    return any(m in e for m in _TRANSIENT_MARKS)
+
+
+def _is_idempotent_reject(err):
+    e = str(err or "")
+    return any(m in e for m in _IDEMPOTENT_MARKS)
+
+
+def other_batch_running(task_id):
+    """除本任务外是否还有别的自动发布/存草稿批次在跑。命中返回对方
+    task_id，否则空串——草稿链与之互斥（共用平台浏览器会互踩页签，
+    2026-10-10 实案：连载发章占着浏览器，草稿流 fill 被掐断连接）。"""
+    with _LOCK:
+        for tid, ent in _running.items():
+            if tid != str(task_id) and ent.get("status") == "running":
+                return str(tid)
+    return ""
+
+
 # ---------------------------------------------------------------- 待发枚举
 # 文档目录里的编号文件不是章节稿：章纲/大纲按章编号（第85章-xxx.md、
 # vol-1-ch-16.md），全按章号算会把待发清单撑出一堆「假章」——批量选择
@@ -282,7 +313,10 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     as_draft=True（全部发草稿，2026-10-09）：逐章自动填稿并点「存草稿」，
     不上线、不受质量闸拦、无需人工确认，一章接一章连跑到清空待发清单
     （章间仍按 PACE_S 防风控节奏）；提交发布由用户到平台草稿箱手工完成，
-    届时质量闸照常把关。与 auto_submit 互斥（草稿模式忽略 auto_submit）。"""
+    届时质量闸照常把关。与 auto_submit 互斥（草稿模式忽略 auto_submit）。
+    草稿链三条专属护栏（2026-10-10 假成功案）：起跑前先 attach-only 对账
+    平台实况并重算待发（已发布/已存稿剔除，对不了账就拒起）；跑批期间
+    检测到另一批自动发布即让位停止（平台浏览器互斥）。"""
     from .. import store
     from . import ledger, manager
     if platform not in manager.PLATFORMS:
@@ -301,6 +335,11 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
         cur = _running.get(task_id) or {}
         if cur.get("status") == "running":
             return False, "该任务已有自动发布进行中，请等本轮结束"
+    if as_draft:
+        other = other_batch_running(task_id)
+        if other:
+            return False, ("检测到另一批自动发布/存草稿进行中（任务 %s）——两边"
+                           "共用平台浏览器会互踩，请等它跑完再存草稿" % other)
     task = store.get_task(task_id)
     if not task:
         return False, "任务不存在"
@@ -329,6 +368,7 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     pend, err = pending(task_id, platform)
     if err:
         return False, err
+    want = None
     if only is not None:
         try:
             want = {int(n) for n in (only or []) if n}
@@ -346,13 +386,49 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     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), "as_draft": bool(as_draft),
-          "last_chapter": 0}
+          "last_chapter": 0, "skipped": 0, "notes": []}
     with _LOCK:
         _running[task_id] = st
 
     def run():
         try:
-            for item in pend:
+            items = pend
+            if as_draft:
+                # 起草前对账（2026-10-10 假成功案）：台账只记得自己发的章，
+                # 手工补交的只有平台知道——attach-only 刷一次校准再重算待发，
+                # 已发布/已存稿章就地剔除，不去撞序号重复。对不了账（浏览器
+                # 未连接/忙）整个拒起：存草稿本来就需要平台浏览器，宁等空窗
+                # 不盲跑；平台没配章节计数时跳过对账维持旧路径。
+                ok_r, why_r = manager.sync_published(task_id, platform,
+                                                     manual=False)
+                if not ok_r and "未配置章节计数" not in str(why_r or ""):
+                    st["status"] = "error"
+                    st["error"] = ("存草稿前对账失败：%s。为防把已发布章重复存稿，"
+                                   "本次未起草；请连接平台浏览器并等它空闲后重试"
+                                   % why_r)
+                    return
+                fresh, _ = pending(task_id, platform)
+                if want is not None:
+                    fresh = [p for p in fresh if p["chapter_no"] in want]
+                if not fresh:
+                    st["status"] = "done"
+                    st["message"] = ("对账后没有可存草稿的章节（所选均已发布或"
+                                     "已存稿）；确需重存请先在平台删旧稿")
+                    return
+                if len(fresh) != st["total"]:
+                    st["notes"].append("对账剔除 %d 章已发布/已存稿，实存 %d 章"
+                                       % (st["total"] - len(fresh), len(fresh)))
+                st["total"] = len(fresh)
+                items = fresh
+            for item in items:
+                if as_draft:
+                    other = other_batch_running(task_id)
+                    if other:
+                        st["status"] = "error"
+                        st["error"] = ("检测到另一批自动发布已启动（任务 %s），"
+                                       "存草稿让位停止；已存 %d 章落平台草稿箱，"
+                                       "等对方跑完再续" % (other, st["done"]))
+                        return
                 g_ok, why = guards(task_id, platform)   # 每章前复查（中途也能拦）
                 if not g_ok:
                     st["status"] = "error"
@@ -366,6 +442,22 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                 ok2, err2 = manager.upload_chapter_async(
                     task_id, platform, str(Path(wd) / item["file"]),
                     **upload_kwargs)
+                if not ok2 and as_draft and _is_idempotent_reject(err2):
+                    # 幂等拒起＝这章已发布/已存过稿：跳过，不是失败——
+                    # 整链不该因「没活干」停摆
+                    st["skipped"] += 1
+                    st["notes"].append("第 %d 章跳过：%s"
+                                       % (item["chapter_no"], str(err2)[:60]))
+                    continue
+                if not ok2 and as_draft and _is_transient(err2):
+                    # 连接类瞬断（连载流互踩/浏览器抖动）：重试一次再弃
+                    st["notes"].append("第 %d 章连接中断，%d 秒后重试一次"
+                                       % (item["chapter_no"],
+                                          TRANSIENT_RETRY_S))
+                    time.sleep(TRANSIENT_RETRY_S)
+                    ok2, err2 = manager.upload_chapter_async(
+                        task_id, platform, str(Path(wd) / item["file"]),
+                        **upload_kwargs)
                 if not ok2:
                     st["status"] = "error"
                     st["error"] = "第 %d 章发起失败：%s" % (item["chapter_no"], err2)
@@ -387,12 +479,15 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                     if item["chapter_no"] not in ledger.drafted_chapters(
                             task_id, platform):
                         st["status"] = "error"
-                        st["error"] = ("第 %d 章存草稿未确认，后续章节未存（详见"
-                                       "发布台账与截图存证）" % item["chapter_no"])
+                        st["error"] = ("第 %d 章存草稿未确认（台账未落草稿账），"
+                                       "后续章节未存；截图存证见发布台账，若实际"
+                                       "已保存成功，把页面反馈文案照截图校准进"
+                                       "流程表 expect_text 步骤"
+                                       % item["chapter_no"])
                         return
                     st["done"] += 1
                     st["last_chapter"] = item["chapter_no"]
-                    if st["done"] < st["total"]:
+                    if st["done"] + st["skipped"] < st["total"]:
                         time.sleep(PACE_S)
                     continue
                 if not auto_submit:
@@ -416,9 +511,11 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                     time.sleep(PACE_S)
             st["status"] = "done"
             if as_draft:
-                st["message"] = ("已存草稿 %d 章（未发布，不受质量闸拦不代表可直发）；"
-                                 "请到平台章节管理/草稿箱逐章检查后提交发布"
-                                 % st["done"])
+                st["message"] = ("已存草稿 %d 章%s（未发布，不受质量闸拦不代表可"
+                                 "直发）；请到平台章节管理/草稿箱逐章检查后提交"
+                                 "发布"
+                                 % (st["done"], ("、跳过 %d 章" % st["skipped"])
+                                    if st["skipped"] else ""))
             elif not auto_submit:
                 st["message"] = "第 %d 章已填好，请在浏览器里确认提交，再重新校准" % st["last_chapter"]
         except Exception as e:                 # 线程内绝不能悬挂无终态

package/app/core/publish/fanqie.py

@@ -110,12 +110,17 @@ UPLOAD_CHAPTER = [
      "optional": True},
 ]
 
-# 发章存草稿（2026-10-09 全部发草稿）：与 UPLOAD_CHAPTER 同一张填表前段，
-# 终点不同——点编辑器头部「存草稿」直接落草稿箱，不走「下一步→内容检测→
-# 发布提示→提交」发布链。草稿不上线，批量连跑无需人工确认；提交发布由
-# 用户到章节管理/草稿箱手工完成。verify 沿用章节管理页断言（草稿行同样
-# 出现在列表里，标题/章号标记可命中）；若平台改版把草稿挪去独立草稿箱页，
-# 首轮失败的 step 截图会指出来，照 flows-fanqie.json 校准即可。
+# 发章存草稿（2026-10-09 全部发草稿；2026-10-10 假成功案重构）：
+# 与 UPLOAD_CHAPTER 同一张填表前段，终点不同——点编辑器头部「存草稿」直接
+# 落草稿箱，不走「下一步→内容检测→发布提示→提交」发布链。三点教训入表：
+# 1) submit 带 always=true：草稿流程跑在 auto_submit=false 语义下，而这里的
+#    「存草稿」点击本身就是保存动作——被人工闸吞掉时 manager 把「填好未存」
+#    记成成功（44 章假成功实案）。
+# 2) expect_text 等编辑器页保存反馈为主凭据（标记文案以真机校准为准，失败
+#    自动落 fail 截图）；「已保存」这类自动保存字样刻意不入标记——编辑器
+#    自动保存不可依赖，不能当本次点击的证据。
+# 3) verify 仍走章节管理页兜底（新章草稿行同样在列表里）；对「已发布章重复
+#    起草」它必然假通过——该情形由起草前对账（auto 层）剔除，不靠本表。
 UPLOAD_CHAPTER_DRAFT = [
     {"do": "navigate", "url": "{editor_url}"},
     {"do": "url_any", "any": ["fanqienovel.com"]},
@@ -131,10 +136,11 @@ UPLOAD_CHAPTER_DRAFT = [
     {"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": "submit", "text": "存草稿", "scope": "button", "tries": 15, "always": True},
+    {"do": "sleep", "s": 1.2},
+    {"do": "shot", "name": "chapter-draft-clicked"},
+    {"do": "expect_text",
+     "any": ["保存成功", "存草稿成功", "草稿已保存", "已存草稿"], "timeout": 12},
     {"do": "verify", "url": "{chapter_manage_url}",
      "any": ["第{chapter_no}章", "{chapter_name}"], "settle": 6, "new_tab": True},
 ]

package/app/core/publish/flow.py

@@ -558,7 +558,10 @@ def run_flow(page, steps, values=None, config=None, auto_submit=False,
                 if log:
                     log("PROBE " + json.dumps(info, ensure_ascii=False)[:4000])
             elif act == "submit":
-                if not auto_submit:
+                # always=true 的提交步（草稿流的「存草稿」）本身就是保存动作，
+                # 不吃 auto_submit 人工闸——被闸吞掉时流程停在「填好未存」，
+                # manager 却照记成功（2026-10-10 44 章假成功实案）
+                if not auto_submit and not st.get("always"):
                     note(i, "已填好未提交——请人工检查后提交（auto_submit=false）")
                     if shot:
                         shot("ready-manual-submit")
@@ -686,6 +689,31 @@ def run_flow(page, steps, values=None, config=None, auto_submit=False,
                 finally:
                     if new_tab:
                         vpage.close_tab()
+            elif act == "expect_text":
+                # 页面反馈等待（草稿保存凭据，2026-10-10）：轮询页面文本直到
+                # 出现任一成功标记（toast/状态字样）——verify 的章节管理页对
+                # 「已发布章重复起草」必然假通过，编辑器保存反馈才是本次动作
+                # 自己的证据。超时即失败：宁可带 fail 截图拦下，不可把「没
+                # 存上」记成成功。标记文案以真机校准为准。
+                marks = [str(m) for m in (st.get("any") or [])]
+                if not marks:
+                    continue
+                deadline = time.time() + float(st.get("timeout") or 12)
+                hit = ""
+                while time.time() < deadline:
+                    body_txt = str(page.call(
+                        "()=>(document.body.innerText||'')", timeout=15) or "")
+                    hit = next((m for m in marks if m in body_txt), "")
+                    if hit:
+                        break
+                    time.sleep(0.8)
+                if not hit:
+                    raise FlowError("未见保存成功反馈（等了 %ds，标记：%s）——"
+                                    "若截图里实际已保存成功，请把真实反馈文案"
+                                    "校准进流程表"
+                                    % (int(float(st.get("timeout") or 12)),
+                                       "、".join(marks)[:60]))
+                note(i, "反馈命中「%s」" % hit)
             elif act == "volume":
                 # 发章带卷（2026-10-08 批量自动发布·自动分卷）：确保目标卷
                 # 在平台上存在（缺则走「新建分卷」）。平台新章按卷自动归类、

package/app/core/publish/manager.py

@@ -897,6 +897,14 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
     book_ref = dict(book)
     if _st(plat).get("status") == "busy":
         return False, "该平台有操作正在进行中"
+    if as_draft:
+        # 草稿与别的自动发布批次互斥（2026-10-10 实案：连载发章占着浏览器，
+        # 草稿流 fill 被掐断连接）——单章草稿同样不让起
+        from . import auto as _auto
+        other = _auto.other_batch_running(task_id)
+        if other:
+            return False, ("检测到另一批自动发布进行中（任务 %s），平台浏览器会"
+                           "被互踩；等它跑完再存草稿" % other)
     ch_no, title, body, err = read_chapter(chapter_file)
     if err:
         return False, err

package/app/core/sandbox_runtime.py

@@ -0,0 +1,95 @@
+"""Optional process sandbox launchers.
+
+The default CodeBee install has no container dependency. Docker is an explicit
+opt-in backend selected by a task policy and a configured image; this module
+only builds argv and never silently falls back to a weaker backend.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+from pathlib import Path
+
+
+class SandboxUnavailable(RuntimeError):
+    pass
+
+
+def requested_backend(sandbox):
+    value = str((sandbox or {}).get("backend") or "native").strip().lower()
+    return value or "native"
+
+
+def docker_argv(command, *, sandbox, workdir, image=None, extra_args=(),
+                container_workdir=None,
+                container_command=("/bin/sh", "-lc")):
+    """Build a restricted ``docker run`` argv for a command or stdio server."""
+    if requested_backend(sandbox) != "docker":
+        raise SandboxUnavailable("Docker 后端未被任务策略启用")
+    docker = shutil.which("docker")
+    if not docker:
+        raise SandboxUnavailable("当前系统没有可用的 Docker CLI")
+    root = Path(workdir or ".").expanduser().resolve(strict=True)
+    image = str(image or (sandbox or {}).get("docker_image") or "").strip()
+    if not image or len(image) > 240 or not re.match(r"^[A-Za-z0-9][A-Za-z0-9._/:@-]*$", image):
+        raise SandboxUnavailable("Docker 后端必须配置可信镜像")
+    roots = []
+    for value in (sandbox or {}).get("allowed_roots") or [str(root)]:
+        candidate = Path(value).expanduser().resolve(strict=True)
+        # Docker currently mounts exactly one root. Require the task workspace
+        # itself; narrower roots need a separately resolved container cwd and
+        # must never accidentally broaden into an ancestor mount.
+        if candidate != root:
+            raise SandboxUnavailable("Docker 目前只支持挂载任务工作目录")
+        if candidate not in roots:
+            roots.append(candidate)
+    if not roots:
+        raise SandboxUnavailable("Docker 后端没有允许目录")
+    selected_root = next((candidate for candidate in roots
+                          if candidate == root or candidate in root.parents
+                          or root in candidate.parents), None)
+    if selected_root is None:
+        raise SandboxUnavailable("当前工作目录不在 Docker 允许目录内")
+    if len(roots) != 1:
+        raise SandboxUnavailable("Docker 暂只支持一个明确的允许目录")
+    argv = [docker, "run", "--rm", "--init", "--read-only",
+            "--security-opt", "no-new-privileges", "--cap-drop=ALL",
+            "--ipc=none", "--pids-limit", "256", "--memory", "2g", "--cpus", "2",
+            "--tmpfs", "/tmp:rw,noexec,nosuid,size=64m"]
+    if hasattr(os, "getuid") and hasattr(os, "getgid"):
+        argv += ["--user", "%d:%d" % (os.getuid(), os.getgid())]
+    else:
+        argv += ["--user", "65534:65534"]
+    argv += ["--network", "none" if not bool((sandbox or {}).get("network", True)) else "bridge"]
+    for name in (sandbox or {}).get("env_allowlist") or []:
+        name = str(name)
+        if name and name in os.environ:
+            # Value is supplied through the filtered Docker client environment;
+            # never place credentials in argv, where process/log inspection sees them.
+            argv += ["--env", name]
+    for candidate in roots:
+        if "," in str(candidate):
+            raise SandboxUnavailable("Docker 允许目录包含不支持的逗号")
+        argv += ["--mount", "type=bind,src=%s,dst=/workspace" % str(candidate)]
+    if container_workdir is None:
+        rel_workdir = root.relative_to(selected_root).as_posix()
+        container_workdir = "/workspace" + ("/" + rel_workdir if rel_workdir != "." else "")
+    if not str(container_workdir).startswith("/") or ".." in Path(container_workdir).parts:
+        raise SandboxUnavailable("Docker 容器工作目录无效")
+    argv += ["--workdir", str(container_workdir), *list(extra_args), image]
+    if isinstance(command, (list, tuple)):
+        argv += [str(x) for x in command]
+    else:
+        argv += list(container_command) + [str(command)]
+    return argv
+
+
+def docker_env(sandbox):
+    """Docker receives only explicitly allowed host environment values."""
+    out = {"PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+           "HOME": "/tmp", "TMPDIR": "/tmp"}
+    for name in (sandbox or {}).get("env_allowlist") or []:
+        if name in os.environ:
+            out[str(name)] = os.environ[str(name)]
+    return out