codebee 0.1.47 → 0.1.49

package/app/core/pipeline.py

@@ -19,7 +19,7 @@ import re
 import threading
 import time
 
-from . import aiflavor, attachments, catalog, dispatch_log, history, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage
+from . import aiflavor, attachments, catalog, dispatch_log, history, hooks, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage, volumes
 from . import builtin_agent
 from . import diagnostics
 from . import paths as paths_mod
@@ -1539,6 +1539,14 @@ def _run_direct(run, task, agents, ev, stats, mode):
         # drain 的路径消息永远不消费，只看非空会空转到轮数上限。
         # 比较步骤前后的未消费数即可区分。
         before_n = len(_pending_messages(run_id))
+        # 钩子注入（message_submit / task_start 通道）：一次性消费拼提示词头
+        hook_head = ""
+        try:
+            hook_head = store.pop_run_inject(run_id)
+        except Exception:
+            pass
+        if hook_head:
+            prompt = ("## 项目钩子注入\n" + hook_head + "\n\n" + prompt)
         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,
@@ -1799,6 +1807,13 @@ def _plot_modules(workdir):
             "鼓励化用，不要照抄原句）\n\n" + txt)
 
 
+def _book_volume_plan(task, outline, upto):
+    """本书的卷规划表（卷边界+卷名+卷弧光）。实现见 planner.book_volume_plan
+    ——放在 planner 是因为它要沿 serial.continues 链读历史 run 的卷名，属
+    「大纲/命名」职责；此处保留薄封装便于连载流程阅读。"""
+    return planner.book_volume_plan(task, outline, upto)
+
+
 LEDGER_FILE = os.path.join(".codebee", "resource-ledger.md")
 _LEDGER_MAX_CHARS = 6000   # 账本注入上限：太老的状态让评审官收敛 recent 优先
 
@@ -1913,6 +1928,7 @@ __OUTLINE__
 
 ---
 ## 本章任务（执行这一条即可）
+__VOLUME__
 - 撰写本书第 __I__ 章，把本章正文写入文件 `__FILE__`（直接写入该文件，只写本章）。文件必须以 UTF-8 编码保存：PowerShell 一律显式加 `-Encoding UTF8`（如 `Set-Content -Path __FILE__ -Encoding UTF8`），禁止依赖系统默认编码，否则中文会乱码。
 - 章节标题：__TITLE__
 - 剧情要点：__BEATS__
@@ -1932,6 +1948,8 @@ SERIAL_REVISE_PROMPT = """你是一名网文作者。第 __I__ 章没有通过
 ## 全书目标
 __GOAL__
 
+## 本卷上下文
+__VOLUME__
 ## 本章评审意见
 __CRITIQUE__
 
@@ -2067,6 +2085,20 @@ def _weakest_chapters(chapter_scores, global_means, threshold, limit=2):
     return cand[:limit]
 
 
+def _inject_detection(tpl, text, task):
+    """把确定性检测行（AI 味/叙事架构/节奏）插进评审提示词。
+
+    命中才插，位置固定为「## 待评审稿件」之前——与技能包/圣经/知识库注入
+    同一位置，保持前缀稳定（§07 T1.2' 前缀缓存）。单稿件评审与连载逐章
+    评审共用本函数：此前连载逐章完全没有这条参考线（旗舰场景漏挂）。
+    """
+    det = aiflavor.report_line(text, task.get("type"))
+    if not det:
+        return tpl
+    block = "## 确定性检测结果（供评审参考）\n%s\n\n" % det
+    return tpl.replace("## 待评审稿件", block + "## 待评审稿件", 1)
+
+
 def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route, resume_ctx, difficulty):
     """连载流水线：大纲 → 逐章起草/评审/修订 → 全局一致性评审 → 合并成书。"""
     import json as _json
@@ -2142,6 +2174,10 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         kb = knowledge.block_for(task)
         if kb:
             tpl = tpl.replace("## 待评审稿件", "%s\n\n## 待评审稿件" % kb, 1)
+        # 确定性检测（AI 味/叙事架构/节奏）此前只挂在单稿件评审上，连载逐章
+        # 评审从未拿到——连载是我们的旗舰场景，逐章节奏与钩子恰恰最需要这条
+        # 参考线。与单稿件一致：命中才追加，只作参考不直接扣分。
+        tpl = _inject_detection(tpl, text, task)
         return tpl.replace("__DIMKEYS__", dimkey).replace(
             "__MANUSCRIPT__", text or "（稿件为空！）")
 
@@ -2201,6 +2237,34 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                                 ("（章末钩子：%s）" % c.get("hook")) if c.get("hook") else "")
         for k, c in enumerate(outline["chapters"]))
 
+    # 分卷规划表（本书级、由章号确定性推导）：覆盖到本批末章即可。写成
+    # 全书顶层字段，UI/报告/发布页直接读，不必重算。
+    vol_plan = _book_volume_plan(task, outline, end)
+    if vol_plan:
+        store.update_run(run_id, volumes=vol_plan)
+
+    def vol_block_for(chapter):
+        """单章的卷上下文：写作时知道自己身处哪一卷、卷内第几章、是否卷末。
+        不分卷返回 ""（提示词零噪音）。"""
+        ent = volumes.find(vol_plan, chapter) if vol_plan else None
+        if not ent:
+            return ""
+        pos, total = volumes.position(vol_plan, chapter)
+        title = ("《%s》" % ent["title"]) if ent.get("title") else "（本卷待命名）"
+        lines = ["- 本卷：第 %d 卷 %s" % (ent["vol"], title)]
+        if total:
+            lines.append("- 本卷位置：第 %d 章 / 共 %d 章" % (pos, total))
+        else:
+            lines.append("- 本卷位置：第 %d 章" % pos)
+        if ent.get("arc"):
+            lines.append("- 本卷弧光（本卷写作须服务这条主线）：%s" % ent["arc"])
+        if total and pos == total:
+            lines.append("- **本章是卷末章**：必须收束本卷主线冲突，写出本卷最高潮，"
+                         "并在结尾留下牵出下一卷的大钩子（卷末是最重要的读者留存点）。")
+        elif total and pos >= max(1, total - 1):
+            lines.append("- 本章临近卷末：开始向本卷高潮收拢，不要再铺新的支线。")
+        return "\n".join(lines) + "\n"
+
     chapter_scores = []          # [{chapter,title,means,passed,rounds,words}]
     issues_all = []
 
@@ -2209,6 +2273,20 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         i = start + k - 1        # 全书章号：文件名/步骤角色/评分记录都按全书编号
         ch = outline["chapters"][k - 1]
         ch_file = "chapter-%02d.md" % i
+        # 分卷上下文：评审时也带着「这是第几卷第几章、是不是卷末」——
+        # 卷末章要按卷弧度收束，不符的章节不该靠全书评分才发现。
+        _vpos, _vtotal = volumes.position(vol_plan, i) if vol_plan else (0, 0)
+        vol_review_block = ""
+        if vol_plan and _vpos:
+            _vent = volumes.find(vol_plan, i)
+            _vt = ("《%s》" % _vent["title"]) if (_vent and _vent.get("title")) else ""
+            vol_review_block = (
+                "本卷上下文：第 %d 卷%s，本章是卷内第 %d%s 章。%s\n"
+                % (_vent["vol"], _vt, _vpos,
+                   ("/%d" % _vtotal) if _vtotal else "",
+                   "**卷末章**：须核对本卷主线是否收束、高潮是否到位、卷末钩子是否立住。"
+                   if (_vtotal and _vpos == _vtotal)
+                   else "核对本章是否服务于本卷主线弧光。"))
         # 逐项目标审稿（借鉴 AI-Novel-Writer）：本章大纲要点随评审下发，评审
         # 以 <event_check> 回逐项判定；资源账本（借鉴角色资源账本）以 <ledger>
         # 回本章道具/伤情/承诺/伏笔增量，评审达标后追加账本文件供下章注入。
@@ -2220,8 +2298,9 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             "「铺垫了但没发生」不算已完成；未完成的项必须反映到对应维度评分。\n"
             "另在 <event_check> 块之后输出 <ledger> 块（没有新变化就整个省略）："
             "逐行列出本章新出现或状态变化的 道具/伤情/承诺/伏笔，格式："
-            "类型|名称|现状（一句话）。\n\n"
-            % (ch.get("beats") or "按大纲推进", ch.get("hook") or "留下悬念"))
+            "类型|名称|现状（一句话）。\n%s\n"
+            % (ch.get("beats") or "按大纲推进", ch.get("hook") or "留下悬念",
+               vol_review_block))
         ev_check_lines = [[]]     # 每章重置：第一份非空评审的逐项判定
         ledger_lines = []         # 本章全部评审的账本增量并集
         ledger_txt = _read_ledger(workdir)   # 截至上一章的资源账本（起草注入）
@@ -2384,6 +2463,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 return (SERIAL_CHAPTER_PROMPT
                         .replace("__SKILLS__", sk_block)
                         .replace("__SCOPE__", scope)
+                        .replace("__VOLUME__", vol_block_for(i))
                         .replace("__I__", str(i)).replace("__FILE__", vfile)
                         .replace("__GOAL__", task["goal"])
                         .replace("__OUTLINE__", outline_txt)
@@ -2632,6 +2712,11 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             cs = dict(inh_scores[i])
             cs.setdefault("chapter", i)
             cs["reused"] = True
+            _vent = volumes.find(vol_plan, i) if vol_plan else None
+            if _vent:
+                cs["vol"] = _vent["vol"]
+                if _vent.get("title"):
+                    cs["vol_title"] = _vent["title"]
             chapter_scores.append(cs)
             store.update_run(run_id, chapter_scores=chapter_scores)
             continue
@@ -2695,6 +2780,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 prompt = (SERIAL_REVISE_PROMPT
                           .replace("__I__", str(i)).replace("__FILE__", ch_file)
                           .replace("__GOAL__", task["goal"])
+                          .replace("__VOLUME__", vol_block_for(i))
                           .replace("__CRITIQUE__", "\n".join(crit_lines))
                           .replace("__WORDS__", str(wpc)))
                 prompt = attachments.append_task_context(prompt, task)
@@ -2710,6 +2796,11 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                   "passed": bool(means) and all(v >= threshold_ch for v in means.values()),
                   "rounds": rounds_used,
                   "words": _wc(_read_chapter(workdir, i))}
+        _vent = volumes.find(vol_plan, i) if vol_plan else None
+        if _vent:
+            cs_new["vol"] = _vent["vol"]                     # 章节卡按卷分组用
+            if _vent.get("title"):
+                cs_new["vol_title"] = _vent["title"]
         if ev_check_lines[0]:
             cs_new["event_check"] = ev_check_lines[0][:8]   # 逐项目标审稿结果
         chapter_scores.append(cs_new)
@@ -2838,6 +2929,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 prompt = (SERIAL_REVISE_PROMPT
                           .replace("__I__", str(i)).replace("__FILE__", "chapter-%02d.md" % i)
                           .replace("__GOAL__", task["goal"])
+                          .replace("__VOLUME__", vol_block_for(i))
                           .replace("__CRITIQUE__", crit)
                           .replace("__WORDS__", str(wpc)))
                 prompt = attachments.append_task_context(prompt, task)
@@ -2918,14 +3010,29 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     ms_name = _ms_name(task.get("manuscript"))
     book_title = outline.get("book_title") or task["title"]
     parts = ["# %s" % book_title, ""]
+    # 分卷标题：卷首章之前插「第 X 卷 《卷名》」分隔（全书 1..end 都插，续写
+    # 批次合并时上一批的卷标题也一并补上，不会只在首批出现）
+    vol_heads = {}
+    if vol_plan:
+        for _ent in vol_plan:
+            if _ent["first"] <= end:
+                vol_heads[_ent["first"]] = _ent
     for i in range(1, end + 1):     # 合并全书：续写时包含上一批已写好的章
+        head = vol_heads.get(i)
+        if head:
+            vol_title = ("第 %d 卷 《%s》" % (head["vol"], head["title"])) \
+                if head.get("title") else ("第 %d 卷" % head["vol"])
+            parts.append("## %s" % vol_title)
+            parts.append("")
         parts.append(_read_chapter(workdir, i).strip())
         parts.append("")
     with _ms_io(workdir, ms_name, "w") as f:
         f.write("\n".join(parts))
     total_words = _wc("\n".join(parts))
     store.finish_step(run_id, step["n"], "done",
-                      summary="已合并 %d 章为 %s（约 %d 字）" % (n, ms_name, total_words),
+                      summary="已合并 %d 章为 %s（约 %d 字%s）" % (
+                          n, ms_name, total_words,
+                          "，分 %d 卷" % len(vol_heads) if vol_heads else ""),
                       duration_s=0.1)
 
     chapters_pass = all(c["passed"] for c in chapter_scores)
@@ -2940,11 +3047,19 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         "chapter_scores": chapter_scores, "global_scores": global_means,
         "global_pass": global_pass, "route": route,
     }
+    if vol_plan:
+        verdict["volumes"] = vol_plan
     scope_txt = ("续写第 %d–%d 章，衔接前文 %d 章" % (start, end, start - 1)) if start > 1 \
         else ("共 %d 章" % n)
     lines = ["# 连载小说评审报告：%s" % task["title"], "",
              "- 书名：%s（%s / 约 %d 字，合并为 `%s`）" % (
                  book_title, scope_txt, total_words, ms_name),
+             "- 分卷：%s" % ("；".join(
+                 ("第 %d 卷《%s》第 %d–%d 章" % (v["vol"], v.get("title") or "未命名",
+                                                v["first"],
+                                                v["last"] if v["last"] is not None else end))
+                 for v in vol_heads.values()) if vol_heads
+                 else ("未分卷（可设置「每卷章数」，或在目标里写明卷结构）")),
              "- 结论：**%s**（各章门禁 %s / 全局评审 %s）" % (
                  "✅ 达到发布标准" if publishable else "❌ 未达标",
                  "通过" if chapters_pass else "未通过",
@@ -3244,10 +3359,8 @@ def _run_content_review(run, task, agents, ev, stats, mode):
         if task.get("context"):
             crit_prompt += "\n\n## 原始任务背景与附件参考\n" + task["context"]
         # AI 味确定性检测（借鉴 oh-story 去AI味）：客观参考线随评审下发，
-        # 命中才追加——评审官结合上下文判断是否真问题，脚本不直接扣分
-        _aiflavor_line = aiflavor.report_line(manuscript)
-        if _aiflavor_line:
-            crit_prompt += "\n\n## 确定性检测结果（供评审参考）\n" + _aiflavor_line
+        # 命中才追加——评审官结合上下文判断是否真问题，脚本不直接扣分。
+        crit_prompt = _inject_detection(crit_prompt, manuscript, task)
         for agent in critics:
             role = "critique-r%d" % r
             if agent.get("mode") == "mock":
@@ -3698,6 +3811,20 @@ def execute_run(run_id):
     })
     mode = task.get("mode") or ("manual" if task.get("implementer") else "auto")
     store.update_run(run_id, mode=mode)
+    # 任务生命周期钩子（task_start，2026-09-22）：stdout 注入文本并入任务上下文
+    # ——context 在全引擎提示词都有 __CONTEXT__ 占位，一处并入全覆盖
+    try:
+        hook_txt = hooks.run_event("task_start",
+                                   ctx={"title": task.get("title") or "",
+                                        "type": task.get("type") or "",
+                                        "mode": mode, "goal": task.get("goal") or ""},
+                                   task_id=task.get("id") or "", run_id=run_id)
+        if hook_txt:
+            task["context"] = ((task.get("context") or "") + "\n\n" +
+                               t("## 项目钩子注入（task_start）\n") + hook_txt).strip()
+            store.update_run(run_id, hook_inject=hook_txt[:400])
+    except Exception:
+        pass   # 外部钩子故障绝不挡主流程
     # engine 决定流水线：code=实现/验证/评审/修复；review=起草/多维评审/修订/门禁；
     # direct=单 CLI 直达（无拆解/评审，信箱续轮即对话）
     engine = task.get("engine") or ("code" if task["type"] == "code" else "review")

package/app/core/planner.py

@@ -12,7 +12,7 @@ import os
 import re
 import time
 
-from . import knowledge, modelhub, runner, skills, usage
+from . import knowledge, modelhub, runner, skills, usage, volumes
 
 MAX_SUBTASKS = 4
 DEFAULT_OUTLINE_TIMEOUT = 900   # 8 章大纲 + 经验包注入是重生成任务，300s 实测不够
@@ -155,12 +155,13 @@ SERIAL_OUTLINE_PROMPT = """你是网文主编，熟悉签约平台（番茄/七
 __SKILLS__
 请为下面的小说目标设计一份连载大纲：共 __N__ 章，每章约 __W__ 字。
 只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"book_title": "书名", "chapters": [{"title": "章节标题", "beats": "本章剧情要点（50-120字：事件/冲突/推进）", "hook": "章末钩子（一句话）"}]}
+{"book_title": "书名", "chapters": [{"title": "章节标题", "beats": "本章剧情要点（50-120字：事件/冲突/推进）", "hook": "章末钩子（一句话）"}]__VOLUMES_KEY__}
 硬性要求：
 - 第 1-3 章是黄金三章：第 1 章开篇即冲突+人设立住，第 3 章末留大钩子；
 - 每章有明确冲突与剧情推进，禁止水字数的日常流水账；
 - 结局必须闭环（完本感），主角有成长弧光；
 - 题材健康，无违规内容，符合平台签约调性。
+__VOLUMES__
 
 ## 小说目标
 __GOAL__
@@ -173,12 +174,13 @@ SERIAL_CONTINUE_OUTLINE_PROMPT = """你是网文主编，熟悉签约平台（
 __SKILLS__
 这是一部长篇连载的续写：全书已完成前 __DONE__ 章，现在请规划第 __START__–__END__ 章
 （本批共 __N__ 章，每章约 __W__ 字）。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"book_title": "书名（与前文保持一致）", "chapters": [{"title": "章节标题", "beats": "本章剧情要点（50-120字：事件/冲突/推进）", "hook": "章末钩子（一句话）"}]}
+{"book_title": "书名（与前文保持一致）", "chapters": [{"title": "章节标题", "beats": "本章剧情要点（50-120字：事件/冲突/推进）", "hook": "章末钩子（一句话）"}]__VOLUMES_KEY__}
 硬性要求：
 - 第 1 章直接衔接前文（见下方前情），不得跳线、不得重启设定、不得复述前文；
 - 主线沿既有脉络推进，新冲突尽量从已埋伏笔中生长，人物性格与前文一致；
 - 每章有明确冲突与剧情推进，禁止水字数的日常流水账；
 - 题材健康，无违规内容，符合平台签约调性。
+__VOLUMES__
 
 ## 前情大纲（已完成章节，章号为全书章号）
 __PREV_OUTLINE__
@@ -192,8 +194,23 @@ __GOAL__
 ## 背景与上下文
 __CONTEXT__"""
 
+# 分卷指令块：插进大纲提示词。卷边界（哪几章属于哪一卷）已由全书章号确定，
+# 是本书的不变量——模型只负责起卷名、写卷弧光，不得改动边界。不分卷时整块为空。
+_VOLUMES_BLOCK = """
+## 分卷结构（必须遵守）
+本书按下列卷组织（**卷边界已按全书章号确定，是本书的不变量：不要改动章号区间、
+不要新增或合并卷**）：
+__VOL_PLAN__
 
-def _norm_chapters(data, n):
+请为**本批写作涉及的卷**补全卷名与卷弧光（已给卷名的必须原样沿用，一个字都不要改）：
+- 卷名：4-12 字；已给的（如《卷一 少年初入江湖》）照抄，未给的由你命名。
+- 卷弧光：本卷的主线冲突、人物成长、卷末必须达到的高潮或转折（50-150 字）。
+- 各卷弧光要能串成全书主线：前卷埋的钩子在后卷回收，卷末是本卷最高潮。
+JSON 增加 "volumes" 字段，键为卷号字符串：
+"volumes": {"1": {"title": "卷一 少年初入江湖", "arc": "…"}, "2": {"title": "…", "arc": "…"}}"""
+
+
+def _norm_chapters(data, n, vol_per=0, vol_start=1, vol_plan=None):
     """规范化连载大纲输出；不合规返回 None。"""
     if not isinstance(data, dict):
         return None
@@ -215,12 +232,20 @@ def _norm_chapters(data, n):
     while len(out) < n:             # 缺的章补模板位
         out.append({"title": "第 %d 章" % (len(out) + 1), "beats": "按全书目标推进剧情",
                     "hook": ""})
-    return {"book_title": str(data.get("book_title") or "").strip()[:40], "chapters": out[:n]}
+    res = {"book_title": str(data.get("book_title") or "").strip()[:40], "chapters": out[:n]}
+    # 分卷：只收本批真正用到的卷的卷名/卷弧光（模型可能多写或乱写卷号，一律按
+    # 本批章号范围过滤）。卷边界不在这里——它由 volumes.build_plan 从章号推导。
+    if vol_plan:
+        named = volumes.norm_volumes(data.get("volumes"), vol_per, vol_start, n)
+        if named:
+            res["volumes"] = named
+    return res
 
 
 def _prev_serial_story(task):
     """续写大纲的前情素材：沿 serial.continues 链收集已完成各章大纲（标全书章号）
-    + 最新一章结尾（衔接锚点）+ 既有书名。返回 (前情文本, 已完成章数, 书名, 最新章结尾)。"""
+    + 最新一章结尾（衔接锚点）+ 既有书名 + 既有卷名。
+    返回 (前情文本, 已完成章数, 书名, 最新章结尾, 卷名表)。"""
     from . import store  # 惰性导入：store 不依赖 planner，避免测试环境导入顺序问题
     chain, seen, cur = [], set(), task
     while len(chain) < 10:
@@ -231,7 +256,7 @@ def _prev_serial_story(task):
         seen.add(prev["id"])
         chain.append(prev)
         cur = prev
-    lines, book_title = [], ""
+    lines, book_title, volnames = [], "", {}
     for prev in reversed(chain):            # 旧 → 新，前情按章号顺序铺开
         try:
             ps = int((prev.get("serial") or {}).get("start_chapter") or 1)
@@ -246,6 +271,7 @@ def _prev_serial_story(task):
         if not outline:
             continue
         book_title = book_title or str(outline.get("book_title") or "")
+        volnames.update(outline.get("volumes") or {})
         for k, c in enumerate(outline["chapters"]):
             lines.append("第 %d 章《%s》：%s" % (ps + k, c.get("title", ""),
                                                str(c.get("beats") or "")[:120]))
@@ -269,7 +295,52 @@ def _prev_serial_story(task):
                     tail = b.decode("utf-8", "replace")[-500:].strip()
     except OSError:
         pass
-    return "\n".join(lines), max(best_i, 0), book_title, tail
+    return "\n".join(lines), max(best_i, 0), book_title, tail, volnames
+
+
+def _chain_volume_names(task):
+    """沿 serial.continues 链收集各批次大纲里的卷名/卷弧光（旧 → 新，后者覆盖）。
+    续写批次合并成书时要给全书（含此前各批）的卷都写上标题，那些卷的命名记在
+    更早的批次任务上，本批 run 的 outline 里没有。失败静默返回 {}。"""
+    from . import store  # 惰性导入：与 _prev_serial_story 同一理由
+    names, seen, cur = {}, set(), task
+    chain = []
+    while cur and len(chain) < 20:
+        tid = str(cur.get("id") or "")
+        if not tid or tid in seen:
+            break
+        seen.add(tid)
+        chain.append(cur)
+        nxt = str((cur.get("serial") or {}).get("continues") or "")
+        cur = store.get_task(nxt) if nxt else None
+    for t in reversed(chain):        # 旧 → 新：新批次的命名覆盖旧批次
+        try:
+            for r in store.task_runs(t["id"]):
+                o = r.get("outline") or {}
+                if isinstance(o.get("volumes"), dict):
+                    names.update(o["volumes"])
+        except Exception:
+            continue
+    return names
+
+
+def book_volume_plan(task, outline, upto):
+    """本书的卷规划表：显式卷表/每卷章数（serial）→ 规划表 → 合并卷名
+    （本批大纲 + 沿链更早批次）→ 保证覆盖到第 upto 章。
+
+    卷边界由 volumes.build_plan 从章号确定性推导，因此同一份卷配置在任何
+    批次都给出同一张表（续写不会重切卷）；模型/用户只提供卷名与卷弧光。
+    不分卷返回 []——调用方据此决定是否插卷标题、卷末约束。"""
+    serial = task.get("serial") or {}
+    plan = volumes.build_plan(serial.get("volumes"),
+                              volumes.norm_per(serial.get("volume_chapters")),
+                              upto=upto)
+    if not plan:
+        return []
+    named = dict(_chain_volume_names(task))
+    if isinstance(outline, dict):
+        named.update(outline.get("volumes") or {})
+    return volumes.merge_titles(plan, named)
 
 
 def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path=None):
@@ -289,15 +360,36 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
     if kb_block:
         sk_block = (sk_block + "\n\n" + kb_block) if sk_block else kb_block
     prev_title = ""
+    # 分卷规划表：显式卷表 → 每卷章数，皆无则不分卷（整块提示词为空）。
+    # 卷边界由章号确定性推导，本批写不到的高章号也要铺出来（upto=start+n-1）。
+    vol_per = volumes.norm_per(serial.get("volume_chapters"))
+    vol_plan = volumes.build_plan(serial.get("volumes"), vol_per,
+                                  upto=start + n - 1)
+    prev_volnames = {}
     if start > 1:
-        prev_lines, done, prev_title, prev_tail = _prev_serial_story(task)
+        prev_lines, done, prev_title, prev_tail, prev_volnames = _prev_serial_story(task)
         done = max(done, start - 1)
+        # 前批已命名的卷名回填进规划表：续写批次沿用同一卷名，不会给同一卷改名
+        if vol_plan:
+            vol_plan = volumes.merge_titles(vol_plan, prev_volnames)
+    else:
+        prev_lines = prev_tail = ""
+    if vol_plan:
+        vol_block = (_VOLUMES_BLOCK
+                     .replace("__VOL_PLAN__", volumes.fmt_plan(vol_plan,
+                                                               upto=start + n - 1)))
+        vol_key = ', "volumes": {"<卷号>": {"title": "<卷名>", "arc": "<卷弧光>"}}'
+    else:
+        vol_block, vol_key = "", ""
+    if start > 1:
         prompt = (SERIAL_CONTINUE_OUTLINE_PROMPT
                   .replace("__SKILLS__", sk_block)
                   .replace("__DONE__", str(done))
                   .replace("__START__", str(start))
                   .replace("__END__", str(start + n - 1))
                   .replace("__N__", str(n)).replace("__W__", str(wpc))
+                  .replace("__VOLUMES_KEY__", vol_key)
+                  .replace("__VOLUMES__", vol_block)
                   .replace("__PREV_OUTLINE__", prev_lines or "（无大纲记录，请依据下方最新一章结尾与小说目标衔接）")
                   .replace("__PREV_TAIL__", prev_tail or "（无）")
                   .replace("__GOAL__", task["goal"])
@@ -305,8 +397,25 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
     else:
         prompt = (SERIAL_OUTLINE_PROMPT.replace("__SKILLS__", sk_block)
                   .replace("__N__", str(n)).replace("__W__", str(wpc))
+                  .replace("__VOLUMES_KEY__", vol_key)
+                  .replace("__VOLUMES__", vol_block)
                   .replace("__GOAL__", task["goal"])
                   .replace("__CONTEXT__", task.get("context") or "（无）"))
+
+    def _norm(data):
+        """规范化大纲 + 收卷名。卷边界不采信模型，只采信它给的卷名/卷弧光。"""
+        o = _norm_chapters(data, n, vol_per=vol_per, vol_start=start,
+                           vol_plan=vol_plan)
+        if o and vol_plan and not o.get("volumes"):
+            # 模型没给卷名时，用规划表里已有的（用户给的/前批命名的）兜底，
+            # 保证成书卷标题不空
+            have = {str(e["vol"]): {"title": e.get("title") or "",
+                                    "arc": e.get("arc") or ""}
+                    for e in vol_plan if (e.get("title") or e.get("arc"))}
+            if have:
+                o["volumes"] = have
+        return o
+
     # 续写批次打上全书章号标记；书名缺省时沿用前文
     def _mark(o):
         if o and start > 1:
@@ -347,7 +456,7 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
                             % (_attempt, (res.get("error") or "未知错误")[:300]))
             orch_errors.append(str(res.get("error") or "返回内容无法解析为大纲"))
             data = runner.extract_json(res.get("text") or "") if res["ok"] else None
-            outline = _norm_chapters(data, n)
+            outline = _norm(data)
             if outline:
                 outline["source"] = "编排者(%s)" % label
                 return _mark(outline)
@@ -367,7 +476,7 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
         if not res["ok"]:
             _append_log(log_path, "作者 CLI 失败：%s" % (res.get("error") or "")[:300])
             reason_tail = (res.get("error") or reason_tail)[:200]
-        outline = _norm_chapters(runner.extract_json(res.get("text") or ""), n)
+        outline = _norm(runner.extract_json(res.get("text") or ""))
         if outline:
             outline["source"] = "llm(%s)" % author_agent["id"]
             return _mark(outline)
@@ -380,6 +489,13 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
     chapters = [{"title": "第 %d 章" % (start + i), "beats": "按全书目标推进剧情，保持冲突与钩子",
                  "hook": ""} for i in range(n)]
     out = {"book_title": prev_title, "chapters": chapters, "source": "template"}
+    if vol_plan:
+        # 分卷是结构性的、与情节无关：兜底模板也给卷名（用户给的/前批命名的），
+        # 这样成书卷标题与章-卷归属在降级情况下依然成立。
+        have = {str(e["vol"]): {"title": e.get("title") or "", "arc": e.get("arc") or ""}
+                for e in vol_plan if (e.get("title") or e.get("arc"))}
+        if have:
+            out["volumes"] = have
     if author_agent and author_agent.get("mode") != "mock":
         out["degraded"] = True
         out["degraded_reason"] = "编排者/作者模型均未返回可用大纲（%s）" % reason_tail

package/app/core/store.py

@@ -18,7 +18,7 @@ import threading
 import time
 from pathlib import Path
 
-from . import paths, runner
+from . import paths, runner, volumes
 
 LOCK = threading.RLock()
 _TASKS = {}
@@ -212,6 +212,22 @@ def create_task(payload):
                     v = 1
                 if v > 1:
                     s["variants"] = v
+                # 分卷：显式卷表优先（新建任务时用户明确给出的分卷信息），
+                # 其次每卷章数等长切卷。卷边界一律由 volumes 模块从「章号」
+                # 确定性推导——续写批次沿用同一份卷表/每卷章数即自动接上同一卷，
+                # 不会因分批而错位。
+                vol_spec = volumes.norm_spec(serial.get("volumes"))
+                if not vol_spec:
+                    # 否则从文字里识别：表单「指定卷结构」框 > 任务目标 > 上下文。
+                    # 保守识别——认不出返回空，绝不把普通文字误判成分卷。
+                    vol_spec = volumes.parse_spec_text(serial.get("volumes_text")) \
+                        or volumes.parse_spec_text(goal) \
+                        or volumes.parse_spec_text(task.get("context") or "")
+                if vol_spec:
+                    s["volumes"] = vol_spec
+                vper = volumes.norm_per(serial.get("volume_chapters"))
+                if vper:
+                    s["volume_chapters"] = vper
                 task["serial"] = s
     critics = payload.get("critics")
     if isinstance(critics, list) and critics:
@@ -708,6 +724,19 @@ def update_run(run_id, expected_status=None, **fields):
             if task:
                 task["status"] = st
                 _save_json(paths.TASKS_DIR / (tid + ".json"), task)
+        if st in ("done", "failed", "cancelled"):
+            # run_end 钩子（2026-09-22）：终态即触发，后台跑副作用型脚本
+            # （回写知识库等）；失败/超时静默，绝不拖慢收尾路径
+            try:
+                import threading
+                from . import hooks
+                threading.Thread(
+                    target=hooks.run_event, args=("run_end",), daemon=True,
+                    kwargs={"task_id": run.get("task_id") or "", "run_id": run_id,
+                            "ctx": {"status": st, "title": run.get("title") or "",
+                                    "error": str(run.get("error") or "")[:300]}}).start()
+            except Exception:
+                pass
         return run
 
 
@@ -1371,6 +1400,11 @@ def continue_task(task_id, chapters=None):
     }
     if serial.get("variants"):   # 赛马配置随链条沿用
         payload["serial"]["variants"] = serial["variants"]
+    # 分卷配置随链条沿用：卷边界必须跨批次稳定，否则同一卷会被续写批次重切
+    if serial.get("volumes"):
+        payload["serial"]["volumes"] = serial["volumes"]
+    if serial.get("volume_chapters"):
+        payload["serial"]["volume_chapters"] = serial["volume_chapters"]
     for key in ("draft_prompt", "critique_prompt"):  # 自定义提示词覆盖一并沿用
         if task.get(key):
             payload[key] = task[key]
@@ -1534,6 +1568,38 @@ def _ensure_messages(run):
     return run["messages"]
 
 
+def append_run_inject(run_id, text):
+    """追加钩子注入文本到 run.hook_inject（message_submit 钩子通道）。
+    直连轮间组装提示词时消费一次并清零。返回 bool。"""
+    text = str(text or "").strip()
+    if not text:
+        return False
+    with LOCK:
+        run = _RUNS.get(run_id)
+        if not run:
+            return False
+        old = str(run.get("hook_inject") or "")
+        run["hook_inject"] = (old + ("\n\n" if old and text else "") + text)[:4000]
+        _save_json(paths.RUNS_DIR / run_id / "run.json", run)
+        return True
+
+
+def pop_run_inject(run_id):
+    """取出并清空 hook_inject（直连轮间提示词头一次性消费）。"""
+    with LOCK:
+        run = _RUNS.get(run_id)
+        if not run:
+            return ""
+        txt = str(run.get("hook_inject") or "")
+        if txt and "hook_inject" in run:
+            run["hook_inject"] = ""
+            try:
+                _save_json(paths.RUNS_DIR / run_id / "run.json", run)
+            except Exception:
+                pass
+        return txt
+
+
 def add_message(run_id, text, sender="本机", attachments=None):
     """往运行信箱追加一条用户指令。attachments 为已落盘到 workdir 的
     附件相对路径清单（由 main.py 提交后传入）。返回消息 dict 或 None。"""