codebee 0.1.72 → 0.1.74

package/app/core/paihang.py

@@ -116,7 +116,10 @@ def fetch_rank_items(limit=40):
 
 
 def rank_scan_prompt(goal):
-    """组装扫榜选材分析提示词。四源全空返回 None（调用方回落直连提示词）。"""
+    """组装扫榜选材分析提示词。四源全空返回 None（调用方回落直连提示词）。
+
+    报告契约含逐条 A-E 跨平台证据分级（借鉴 career-ops 的分级报告交付形态）：
+    分级只认素材实际出现情况——抑制单源孤证被模型放大成「大热题材」。"""
     blocks, seen = [], set()
     for label, fname in _SOURCES:
         items = [t for t in globals()[fname](30) if t not in seen]
@@ -131,8 +134,12 @@ def rank_scan_prompt(goal):
         "## 榜单元素材\n%s\n\n"
         "## 用户想写的方向\n%s\n\n"
         "## 你的产出（Markdown 报告）\n"
+        "报告第一行给图例（一行）：「证据分级：A=三平台及以上重合，B=两平台重合，"
+        "C=单平台多次出现，D=单平台仅一次，E=素材无直接证据、系推断」。\n"
         "1. **热门题材 Top3**：各自的共同特征与上榜代表书目（跨平台重合的题材单独点出——多平台都热说明是真风口）\n"
         "2. **高频人设/套路总结**：3-5 条，点名反复出现的元素\n"
         "3. **差异化切入建议**：2-3 个，结合用户方向给出「题材+人设」组合与一句话理由\n"
+        "以上每一项结论末尾标注【证据X】（X 为 A-E 之一）。分级只看素材里真实出现的"
+        "情况：组合条目按其组成元素的较低档取值，拿不准就降一档、不升级。\n"
         "直接输出分析报告，不要复述素材清单，不要输出与报告无关的内容。"
         % (material, goal or "（用户未指定方向，按大盘热门分析）"))

package/app/core/pipeline.py

@@ -2862,6 +2862,27 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
 
     refresh_actual_route(impl)
     workdir = task["workdir"]
+    # Long-form state is a deterministic input to every chapter.  Bootstrap
+    # legacy serial tasks once, then refuse to write over manually edited
+    # derived views until the author reconciles the source JSON.
+    from . import story_tracking
+    try:
+        tracking_state = story_tracking.load(workdir)
+        if tracking_state is None:
+            story_tracking.init(workdir, task.get("id"), task.get("title"),
+                                premise=task.get("goal") or "")
+        tracking_check = story_tracking.check(workdir)
+    except Exception as exc:
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error="故事追踪状态不可用，请先修复：%s" % str(exc)[:500],
+                         ended_at=_now())
+        return
+    if not tracking_check.get("ok"):
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error="故事追踪状态存在漂移，请先修复：%s" %
+                               "；".join(tracking_check.get("errors") or [])[:500],
+                         ended_at=_now())
+        return
     # 续会话步骤的 CLI 启动目录（稿件读写仍用 workdir）
     step_wd = _resume_workdir(resume_ctx, workdir) if resume_ctx else workdir
     serial = task.get("serial") or {}
@@ -3840,6 +3861,26 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         chapter_scores.append(cs_new)
         # 每章即时持久化：长篇中断/超时后可断点续跑，不丢已完成章的分数
         store.update_run(run_id, chapter_scores=chapter_scores)
+        # Structured story state is committed alongside the chapter.  The
+        # pipeline remains compatible with legacy workdirs: a tracking failure
+        # is reported in the run evidence but never deletes a valid chapter.
+        try:
+            from . import story_tracking
+            story_tracking.commit_chapter(
+                workdir, i, outline_txt, _read_chapter(workdir, i),
+                facts=[str(x.get("note") or "") for x in issues_all
+                       if isinstance(x, dict) and x.get("chapter") == i and x.get("note")],
+                foreshadowing=[{"id": "F-%04d-%02d" % (i, n + 1),
+                                "text": str(line)[:400], "status": "active",
+                                "planted_chapter": i}
+                               for n, line in enumerate(ledger_lines[:20])],
+                next_promises=[ch.get("hook") or ch.get("highlight") or ""],
+            )
+        except Exception as exc:
+            try:
+                store.update_run(run_id, story_tracking_warning=str(exc)[:300])
+            except Exception:
+                pass
         # 资源账本（借鉴角色资源账本）：评审提出的道具/伤情/承诺/伏笔增量
         # 追加到 .codebee/resource-ledger.md，下一章起草时注入，防跨章穿帮。
         # 失败静默——账本是增强不是硬依赖。

package/app/core/planner.py

@@ -256,6 +256,8 @@ __SKILLS__
 只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {"book_title": "书名", "style_anchor": "全书文风锚（80字内，具体可执行：叙述视角与人称、句长基调、语域、对白风格、禁用表达）", "chapters": [{"title": "章节标题", "beats": "本章剧情要点（50-120字：事件/冲突/推进）", "hook": "章末钩子（一句话）", "highlight": "本章爽点/情绪爆点（一句话：谁在哪里完成什么反转或释放什么情绪）"}]__VOLUMES_KEY__}
 硬性要求：
+- book_title 4-15 字，必须考虑平台书名全站唯一（撞名建不了书）：避开「我的XX藏不住」
+  「开局XX」等高频套路组合，书名里带本书独有的专名（人名/金手指/设定词），独有专名越多越不易撞名；
 - 第 1-3 章是黄金三章：第 1 章前 100 字出现主角、前 200 字出现异常或欲望、前 600 字进入具体困境，
   第 3 章末留大钩子；不要用世界观或环境描写拖延切入；
 - 每章都写清“主角主动选择 → 阻碍 → 局面变化 → 章末钩子”，禁止水字数的日常流水账和硬旁白推剧情；

package/app/core/plugins.py

@@ -9,6 +9,7 @@ bundles are never executed by this module.
 """
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import re
@@ -523,3 +524,36 @@ def active_mcp_servers():
             continue
     return [x for x in out if isinstance(x, dict) and x.get("command")]
 
+
+def merged_servers_text(user_text):
+    """用户显式 MCP 清单（JSON 文本）+ 已启用插件的声明 → 合成后的 JSON 文本。
+
+    插件服务器名加 ``plg_`` 前缀+短哈希隔离，防与用户配置撞名；用户清单
+    非法或非数组时原样返回，坏插件绝不连累用户显式配置的服务器。
+    逻辑原先长在 main() 启动闭包里、测试够不着（ae9bcb8 半交付时两个
+    用例即因此恒错），2026-09-30 随 /api/plugins 路由补齐一并下沉。"""
+    raw = str(user_text or "")
+    try:
+        configured = json.loads(raw) if raw.strip() else []
+    except (ValueError, TypeError):
+        return raw
+    if not isinstance(configured, list):
+        return raw
+    try:
+        plugin_servers = active_mcp_servers()
+    except Exception:
+        plugin_servers = []
+    for item in plugin_servers or []:
+        if not isinstance(item, dict):
+            continue
+        plugin_id = str(item.pop("plugin_id", "plugin"))
+        server_name = str(item.get("name") or "server")
+        digest = hashlib.sha256(
+            (plugin_id + ":" + server_name).encode("utf-8")).hexdigest()[:6]
+        safe = re.sub(r"[^a-z0-9_-]", "-", plugin_id.lower())
+        item["name"] = ("plg_" + safe[:11] + "_" + digest)[:24]
+        if not any(x.get("name") == item["name"] for x in configured
+                   if isinstance(x, dict)):
+            configured.append(item)
+    return json.dumps(configured, ensure_ascii=False)
+

package/app/core/presence.py

@@ -0,0 +1,77 @@
+"""Small local agent presence registry for the operator dashboard."""
+from __future__ import annotations
+
+import json
+import threading
+import time
+
+from . import paths
+
+_LOCK = threading.RLock()
+_FILE = paths.DATA_DIR / "agent_presence.json"
+_STALE_S = 180
+
+
+def _load():
+    try:
+        value = json.loads(_FILE.read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else {}
+    except Exception:
+        return {}
+
+
+def _save(value):
+    _FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = _FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(_FILE)
+
+
+def heartbeat(agent_id, label="", capabilities=None, task_id="", status="idle", metadata=None):
+    aid = str(agent_id or "").strip()[:100]
+    if not aid:
+        raise ValueError("agent_id 必填")
+    if capabilities is not None and not isinstance(capabilities, list):
+        raise ValueError("capabilities 必须是列表")
+    if status is not None and not isinstance(status, str):
+        raise ValueError("status 必须是文本")
+    now = time.time()
+    with _LOCK:
+        data = _load()
+        safe_meta = metadata if isinstance(metadata, dict) else {}
+        # Presence is a hot, user-controlled endpoint; keep the durable
+        # registry bounded even when an agent sends oversized diagnostics.
+        safe_meta = {str(k)[:80]: str(v)[:500] for k, v in list(safe_meta.items())[:30]}
+        data[aid] = {"agent_id": aid, "label": str(label or aid)[:120],
+                     "capabilities": [str(x)[:80] for x in (capabilities or [])][:30],
+                     "task_id": str(task_id or "")[:100], "status": str(status or "idle")[:30],
+                     "metadata": safe_meta,
+                     "last_seen": now}
+        _save(data)
+        return data[aid]
+
+
+def list_agents():
+    now = time.time()
+    with _LOCK:
+        rows = []
+        for row in _load().values():
+            item = dict(row)
+            try:
+                last_seen = float(item.get("last_seen") or 0)
+            except (TypeError, ValueError):
+                last_seen = 0.0
+            age = max(0, now - last_seen)
+            item["age_s"] = int(age)
+            item["online"] = age <= _STALE_S
+            rows.append(item)
+        return sorted(rows, key=lambda x: (not x["online"], x.get("label") or ""))
+
+
+def remove(agent_id):
+    with _LOCK:
+        data = _load()
+        existed = str(agent_id or "") in data
+        data.pop(str(agent_id or ""), None)
+        _save(data)
+        return existed

package/app/core/publish/auto.py

@@ -186,6 +186,11 @@ def publish_pending_async(task_id, platform, auto_submit=False, force=False,
     task = store.get_task(task_id)
     if not task:
         return False, "任务不存在"
+    from .. import contracts
+    contract = contracts.get(task_id)
+    if ((contract and contract.get("approval_required")) or task.get("approval_required")) \
+            and not contracts.release_allowed(task_id):
+        return False, "任务需要先完成审批，才能发布产物"
     book = ledger.book_for(task_id, platform)
     if not book:
         return False, "该任务尚未在此平台建书，请先「创建作品」"
@@ -359,6 +364,12 @@ def due_tasks(now=None):
         ap = task.get("auto_publish")
         if not isinstance(ap, dict) or not ap.get("enabled"):
             continue
+        if ap.get("auto_submit"):
+            from .. import contracts
+            contract = contracts.get(task["id"])
+            if ((contract and contract.get("approval_required")) or
+                    task.get("approval_required")) and not contracts.release_allowed(task["id"]):
+                continue
         if str(ap.get("time") or "") <= hhmm_now and fired.get(task["id"]) != today:
             plat = ap.get("platform")
             if plat and _book_ready(ledger.book_for(task["id"], plat)):

package/app/core/publish/flow.py

@@ -32,6 +32,47 @@ class FlowError(Exception):
     """流程失败：message 面向用户（含步骤序号与截图路径线索）。"""
 
 
+class TitleDupError(FlowError):
+    """平台拒绝书名：重名（全平台书名唯一）。message 带平台提示原文。
+
+    与普通流程失败分开成独立类型：manager 建书要按它触发「对账复用 →
+    自动换名重试」，普通失败不能换名（换了也建不成）。"""
+
+    def __init__(self, hint):
+        super().__init__("平台拒绝书名（已存在同名作品）：%s" % hint)
+        self.hint = hint
+
+
+# 重名提示识别词（番茄/七猫建书页校验文案口径：「书名已存在」「该名称已被
+# 使用」等）。核心词「已存在/已被使用/已被注册/重名」足够特异——建书页上
+# 出现这些词几乎必然指向书名撞车；不加宽泛的「重复」，防误伤其它字段校验。
+DUP_HINT_WORDS = ("已存在", "已被使用", "已被注册", "重名", "已被占用")
+
+
+def _dup_probe_js():
+    # 抓页面上可见提示里命中重名关键词的那条（toast/表单校验/弹窗）。
+    # 选择器与 _page_error_text_js 同源；只回命中词的那条，空串=页面没喊重名。
+    return ("(words)=>{const sels='.arco-message,.arco-notification,"
+            "[class*=message],[class*=toast],[class*=error],[class*=alert],"
+            "[class*=tip],[class*=tooltip],[class*=valid]';"
+            "for(const e of document.querySelectorAll(sels)){"
+            "const r=e.getBoundingClientRect();"
+            "if(r.width<=0||r.height<=0)continue;"
+            "const x=(e.innerText||'').trim();"
+            "if(!x||x.length>160)continue;"
+            "for(const w of words){if(x.includes(w))return x;}}"
+            "return '';}")
+
+
+def dup_hint(page, timeout=5):
+    """读页面上的重名提示文本；无/读失败返回空串。预检与事后探测共用。"""
+    try:
+        v = page.call(_dup_probe_js(), list(DUP_HINT_WORDS), timeout=timeout)
+        return v.strip() if isinstance(v, str) else ""
+    except Exception:
+        return ""
+
+
 def _click_match_js():
     # 点同时包含所有关键词的最小可见元素（长度最小者=最内层卡片）
     return ("(keys,maxLen)=>{"
@@ -212,11 +253,14 @@ def _tags_select_grouped(page, note, i, pairs):
 
 
 def run_flow(page, steps, values=None, config=None, auto_submit=False,
-             shot=None, log=None):
+             shot=None, log=None, dup_check=False):
     """跑一个流程。values：fill 取值字典；config：平台 URL 等占位符来源。
 
     shot(name) → 截图落盘函数（manager 注入，路径含任务/平台维度）；
-    log(line)  → 步骤日志函数（进发布记录的 log 字段）。返回执行到的步数。"""
+    log(line)  → 步骤日志函数（进发布记录的 log 字段）。返回执行到的步数。
+    dup_check  → 提交前探测页面重名提示（建书专用）：平台实时校验喊「已
+    存在」时点提交必然被拒、流程只会误报「未登录或改版」——在点击前抛
+    TitleDupError 让上层走换名重试，别白点（2026-09-30 马甲案）。"""
     values = values or {}
     config = config or {}
     log = log or (lambda s: None)
@@ -440,7 +484,7 @@ def run_flow(page, steps, values=None, config=None, auto_submit=False,
                         if sections:
                             break
                         time.sleep(1.0)
-                if sections:
+                if sections and isinstance(sections, list):
                     missing = {g for g, _ in pairs} - {s["g"] for s in sections}
                     if missing:
                         # 弹层是分组结构但组名对不上=平台目录/组名改了——
@@ -495,6 +539,13 @@ def run_flow(page, steps, values=None, config=None, auto_submit=False,
                     if shot:
                         shot("ready-manual-submit")
                     return i + 1
+                if dup_check:
+                    # 事前预检：填表阶段平台实时校验（fill 派发过 change 事件，
+                    # blur/输入即触发）喊了重名就别点了，点了也必被拒
+                    hint = dup_hint(page)
+                    if hint:
+                        _fail_shot(shot, "step%d-title-dup" % i)
+                        raise TitleDupError(hint)
                 if st.get("text"):                    # 按按钮文本提交
                     text = str(st["text"])
                     note(i, "提交「%s」（真实鼠标事件）" % text)

package/app/core/publish/manager.py

@@ -382,6 +382,108 @@ def probe_form_async(plat):
 
 
 # ---------------------------------------------------------------- 动作：建书
+_ALT_COUNT = 3       # 撞名后自动换名最多试 3 个候选
+_ALT_TIMEOUT = 90    # 候选书名一次轻调用的墙钟（发布线程内，不能久等）
+_TITLE_MAX = 15      # 两平台书名统一截 15 字（bookmeta._norm 同口径）
+
+
+def _mech_titles(base):
+    """机械变体兜底（模型不可用时的最后手段）：最小改动、不重构词——
+    同音字（了→啦）、去「我的」前缀、加「纪事」尾。丑但能建成书，
+    烧在发布线程里的几万字稿费比书名门面贵得多。"""
+    out, seen = [], {base}
+    for v in (base.replace("了", "啦", 1),
+              base[2:] if base.startswith("我的") else "",
+              (base + "纪事") if len(base) <= 13 else ""):
+        v = str(v or "").strip()[:_TITLE_MAX]
+        if len(v) >= 4 and v not in seen:
+            out.append(v)
+            seen.add(v)
+    return out
+
+
+def _alt_titles(plat, data, task, logs):
+    """撞名候选队列：编排者基于原名+简介一次轻调用重出书名，失败静默
+    降级机械变体——候选生成绝不能阻断建书主流程。"""
+    base = str(data.get("book_name") or "").strip()
+    if not base:
+        return []
+    out = []
+    try:
+        from .. import modelhub, planner, runner
+        orch = modelhub.resolve_orchestrator()
+        if orch:
+            prov, model = orch
+            prompt = (
+                "你是网文编辑。原书名《%s》在平台重名被拒，请为同一本书重起"
+                " %d 个新书名：每个 15 字内；保持原题材气质与钩子感；避开原名"
+                "的核心词组合与「我的XX藏不住」式高频套路组合；书名里带一个本"
+                "书独有的专名（人名/金手指/设定词）最不易再撞。只输出一个 "
+                "```json 字符串数组，如 [\"书名1\",\"书名2\"]，不要输出其它内容。"
+                "\n\n## 简介（截选）\n%s"
+                % (base, _ALT_COUNT + 2, str(data.get("summary") or "")[:300]))
+            res = modelhub.chat(prov["id"], model, prompt,
+                                max_tokens=600, timeout=_ALT_TIMEOUT)
+            planner._log_usage("publish", "create_book", task or {"id": ""}, res,
+                               model=model,
+                               provider=prov.get("name", prov.get("id", "")),
+                               provider_id=prov.get("id", ""))
+            if res["ok"]:
+                arr = runner.extract_json(res.get("text") or "")
+                if isinstance(arr, dict):
+                    arr = arr.get("titles") or arr.get("candidates") or []
+                if isinstance(arr, list):
+                    for x in arr:
+                        t = str(x or "").strip().replace("\n", " ")[:_TITLE_MAX]
+                        if len(t) >= 2 and t != base and t not in out:
+                            out.append(t)
+            if out:
+                logs.append("候选书名（编排者 %s）：%s"
+                            % (model, "、".join(out[:5])))
+    except Exception as e:
+        logs.append("候选书名生成降级（%s）" % str(e)[:100])
+    for v in _mech_titles(base):
+        if v not in out:
+            out.append(v)
+    return out[:_ALT_COUNT + 2]
+
+
+def _sync_renamed_book(task_id, plat, task, data, new_name, logs):
+    """建书撞名自动换名后的全链路同步。
+
+    只换建书表单里的字、bookmeta/大纲/归档还留旧名的话：下轮发章按旧书名
+    对账、用户点「重生成作品信息」又把旧名改回去——马甲案同款错位复发。
+    这里把 bookmeta data、归档 Markdown、最新批次大纲的 book_title 统一到
+    新名（台账 title 由调用方 save_book 落）。任一环节失败只记日志，
+    不拦建书成功主流程。"""
+    try:
+        from pathlib import Path as _Path
+        from .. import bookmeta as _bm
+        from .. import store as _store
+        data["book_name"] = new_name
+        cur = _store.get_task(task_id)
+        prev = ((cur or {}).get("book_meta") or {}).get(plat) or {}
+        if isinstance(prev.get("data"), dict):
+            payload = dict(prev)
+            payload["data"] = dict(prev["data"], book_name=new_name)
+            _store.set_book_meta(task_id, plat, payload)
+            fp = _Path(task.get("workdir") or "") / _bm.PLATFORMS[plat]["file"]
+            if str(fp.parent) and fp.parent.is_dir():
+                fp.write_text(_bm.render_markdown(cur, plat, payload["data"]),
+                              encoding="utf-8")
+            logs.append("作品信息与归档已同步新书名《%s》" % new_name)
+        # 大纲书名：续写链继承与「一键重生成」素材都读最新批次大纲，
+        # 不同步会让下次重生成把书名改回旧名
+        for r in _store.task_runs(task_id):
+            o = r.get("outline")
+            if isinstance(o, dict) and o.get("chapters") and o.get("book_title"):
+                _store.update_run(r["id"], outline=dict(o, book_title=new_name))
+                logs.append("大纲书名已同步为《%s》" % new_name)
+                break
+    except Exception as e:
+        logs.append("书名同步部分失败（不拦建书）：%s" % str(e)[:120])
+
+
 def _create_preflight(plat, data):
     """建书前置闸：平台表单对必填字段有硬校验（番茄简介 50-500 字），过不了
     校验时页面不跳转、流程只能误报「未登录或改版」——开浏览器之前先拦下，
@@ -462,33 +564,101 @@ def create_book_async(task_id, plat, auto_submit=False, force=False,
         metadata={"platform": plat, "action": "create_book"})
 
     def run():
+        final_name = book_name
         try:
             b, page = _open_page(plat)
-            values = mod.values_create_book(data)
-            steps = _with_tag_steps(load_flow(plat, "create_book"),
-                                    mod.tag_groups(data), values, mod)
-            flow.run_flow(page, steps, values=values, config=mod.CONFIG,
-                          auto_submit=auto_submit,
-                          shot=lambda n: page.screenshot(ledger.shot_path(plat, task_id, n)),
-                          log=logs.append)
-            # book_id：创建成功后平台跳书籍详情/编辑器，从 URL 提取
-            # （番茄 book-info/<id>；七猫 information?id=<id>）。url_any 过了
-            # 但页面还在跳转链上时再等几轮；提取落空把最终 URL 记进日志，
-            # 别再静默登记空 id（发章只能兜底找书，直达编辑器就废了）。
+            # 书名全平台唯一（2026-09-30 马甲案）：撞名是建书常见死法，撞了
+            # 原样报「疑似未建成」会白烧几万字稿费。试名队列=原名+自动候选
+            # （编排者重出→机械变体兜底）；同名书恰在本账号下时对账复用不换
+            # 名。人工提交模式（auto_submit=false）不自动换名——用户在页面
+            # 上自己点提交，撞名他自己看得见。
+            names = [book_name]
+            cands_ready = False
             book_id = ""
-            try:
-                for _try in range(6):
-                    m_url = re.search(r"book-info/(\d+)|information\?id=(\d+)",
-                                      str(page.url() or ""))
-                    if m_url:
-                        book_id = m_url.group(1) or m_url.group(2)
+            i = 0
+            while i < len(names) and i < 1 + _ALT_COUNT + 2:
+                name = names[i]
+                i += 1
+                final_name = name
+                if i > 1:
+                    logs.append("第 %d 次尝试，书名《%s》" % (i, name))
+                values = mod.values_create_book(dict(data, book_name=name))
+                steps = _with_tag_steps(load_flow(plat, "create_book"),
+                                        mod.tag_groups(data), values, mod)
+                try:
+                    flow.run_flow(page, steps, values=values, config=mod.CONFIG,
+                                  auto_submit=auto_submit, dup_check=auto_submit,
+                                  shot=lambda n: page.screenshot(
+                                      ledger.shot_path(plat, task_id, n)),
+                                  log=logs.append)
+                except flow.TitleDupError as e:
+                    # 事前预检命中：平台实时校验已喊重名，点提交必被拒
+                    logs.append(str(e))
+                    bid = _resolve_book_id(plat, page, {"title": name})
+                    if bid:
+                        book_id, final_name = bid, name
+                        logs.append("同名书就在本账号下，已复用 book_id=%s" % bid)
                         break
-                    time.sleep(0.8)
-                if not book_id:
-                    logs.append("book_id 提取落空，最终页面：%s"
-                                % str(page.url() or "")[:120])
-            except Exception:
-                pass
+                    if not cands_ready:
+                        names = names + _alt_titles(plat, data, task, logs)
+                        cands_ready = True
+                    if i >= len(names):
+                        break               # 候选没准备出来（模型+机械全空）
+                    continue
+                # book_id：创建成功后平台跳书籍详情/编辑器，从 URL 提取
+                # （番茄 book-info/<id>；七猫 information?id=<id>）。url_any 过了
+                # 但页面还在跳转链上时再等几轮；提取落空把最终 URL 记进日志，
+                # 别再静默登记空 id（发章只能兜底找书，直达编辑器就废了）。
+                try:
+                    for _try in range(6):
+                        m_url = re.search(r"book-info/(\d+)|information\?id=(\d+)",
+                                          str(page.url() or ""))
+                        if m_url:
+                            book_id = m_url.group(1) or m_url.group(2)
+                            break
+                        time.sleep(0.8)
+                    if not book_id:
+                        logs.append("book_id 提取落空，最终页面：%s"
+                                    % str(page.url() or "")[:120])
+                except Exception:
+                    pass
+                if book_id:
+                    break
+                if not auto_submit:
+                    # 人工提交模式：按书名对账兜底即止，不自动换名
+                    bid = _resolve_book_id(plat, page, {"title": name})
+                    if bid:
+                        book_id = bid
+                        logs.append("book_id 提取落空，已按书名在平台对账找回 %s" % bid)
+                    break
+                # 自动提交被平台静默拒绝（不跳转）时，toast 常喊重名——抓
+                # 回来判定，别落进「疑似未建成」的糊涂账
+                hint = ""
+                for _try in range(3):
+                    hint = flow.dup_hint(page)
+                    if hint:
+                        break
+                    time.sleep(1.0)
+                if hint:
+                    logs.append("页面提示：%s" % hint[:120])
+                    bid = _resolve_book_id(plat, page, {"title": name})
+                    if bid:
+                        book_id, final_name = bid, name
+                        logs.append("同名书就在本账号下，已复用 book_id=%s" % bid)
+                        break
+                    if not cands_ready:
+                        names = names + _alt_titles(plat, data, task, logs)
+                        cands_ready = True
+                    continue
+                # 非撞名失败：按书名对账兜底（原有逻辑），找不回就明说未建成
+                bid = _resolve_book_id(plat, page, {"title": name})
+                if bid:
+                    book_id = bid
+                    logs.append("book_id 提取落空，已按书名在平台对账找回 %s" % bid)
+                break
+            if book_id and final_name != book_name:
+                # 换名成功（或复用同名旧书）：书名全链路同步到新名
+                _sync_renamed_book(task_id, plat, task, data, final_name, logs)
             operation_status = "confirmed" if book_id else "unknown"
             if book_id:
                 operations.confirm(operation_id, remote_receipt=book_id,
@@ -496,18 +666,23 @@ def create_book_async(task_id, plat, auto_submit=False, force=False,
             else:
                 operations.mark_unknown(
                     operation_id,
-                    "建书流程完成但未取得远端 book_id，请先在平台核对后再重试",
+                    "建书流程走完，但平台作品列表按书名未找到《%s》，书很可能未建成；"
+                    "请到平台作品管理确认，若已存在可人工登记" % final_name,
                     metadata={"platform": plat, "action": "create_book"})
-            ledger.record(plat, "create_book", task_id=task_id, title=book_name,
+            ledger.record(plat, "create_book", task_id=task_id, title=final_name,
                           book_id=book_id, ok=bool(book_id),
                           error=((("" if book_id else
-                                   "建书结果未知：未取得远端 book_id；请先对账\n")
+                                   "建书流程走完但未取得 book_id，且平台按书名未找到"
+                                   "《%s》，疑似未建成\n" % final_name)
                                   + "\n".join(logs))[:2000] or None),
                           shot=str(ledger.shot_path(plat, task_id, "")),
                           operation_id=operation_id, operation_status=operation_status,
                           remote_receipt=book_id)
-            ledger.save_book(task_id, plat, {"book_id": book_id, "title": book_name,
-                                             "source": "create"})
+            if book_id:
+                # 未取得 id 不落台账：空条目会让界面亮「已建书」、校准盲跑，
+                # 而发章/下次建书各自有按书名对账的兜底，空条目只剩害处。
+                ledger.save_book(task_id, plat, {"book_id": book_id, "title": final_name,
+                                                 "source": "create"})
             _set(plat, status="connected", error="")
         except Exception as e:
             operations.finish_exception(operation_id, e)
@@ -856,6 +1031,18 @@ def sync_published(task_id, plat, manual=False):
             page = b.first_page(create=True)
     except Exception as e:
         return False, "浏览器未连接，点「连接平台」后再校准"
+    if not str(book.get("book_id") or "").strip():
+        # book_id 空的登记（人工登记/未验证建书结果）别拿去拼 URL 盲跑：
+        # 空 id 会落到作品列表页，数章节必然 0 行，报一句误导人的「可能改版」。
+        # 先按书名对账，找回补账再校准；找不回就明说书可能没建成。
+        bid = _resolve_book_id(plat, page, book)
+        if bid:
+            book = dict(book, book_id=bid)
+            ledger.save_book(task_id, plat, book)   # 合并语义：保留 remote_*
+        else:
+            return False, ("平台作品列表按书名未找到《%s》，这本书可能尚未建成；"
+                           "请到平台作品管理确认，若已存在可人工登记"
+                           % (book.get("title") or ""))
     try:
         page.navigate(mod.chapter_manage_url(book), timeout=40)
         time.sleep(4.0)                         # SPA 表格慢渲染

package/app/core/publish/qimao.py

@@ -125,6 +125,36 @@ def chapter_manage_url(book):
     return CONFIG["book_manage"]
 
 
+def resolve_book_id(page, book):
+    """登记缺 book_id 时按书名在作品管理页找回：点书名卡进详情，从 URL 提取。
+
+    与番茄同款对账通道（fanqie.resolve_book_id）；找不回返回空串不拦死。"""
+    import re
+    import time
+    from . import flow as _flow
+    title = str((book or {}).get("title") or "").strip()
+    if not title:
+        return ""
+    try:
+        page.navigate(CONFIG["book_manage"], timeout=30)
+    except Exception:
+        return ""
+    r = None
+    for _try in range(6):                   # 列表慢渲染
+        r = page.call(_flow._click_match_js(), [title], 300)
+        if (r or {}).get("ok"):
+            break
+        time.sleep(1.0)
+    if not (r or {}).get("ok"):
+        return ""
+    time.sleep(2.5)                         # 跳转收尾
+    m = re.search(r"manage\?id=(\d+)|draft\?id=(\d+)|information\?id=(\d+)",
+                  str(page.url() or ""))
+    if not m:
+        return ""
+    return m.group(1) or m.group(2) or m.group(3) or ""
+
+
 def draft_url(book):
     """草稿箱页（发章真发布链中转站）。"""
     bid = str((book or {}).get("book_id") or "")