codebee 0.1.48 → 0.1.49

package/CHANGELOG.md

@@ -6,6 +6,12 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.49（2026-09-22）
+
+### 🛠 问题修复
+
+- 修复设置 →「钩子」卡片样式坍缩：下拉框漏写闭合标签导致命令框与操作行被吞进内部，整卡挤成一行。
+
 ## v0.1.48（2026-09-22）
 
 ### ✨ 新功能

package/app/core/aiflavor.py

@@ -8,6 +8,8 @@
 """
 from __future__ import annotations
 
+import re
+
 # 译制腔/套话词表（按误导性排序，持续运维）
 AI_PHRASES = (
     "空气仿佛凝固", "眸中闪过一丝", "嘴角勾起一抹", "心中一动",
@@ -81,8 +83,73 @@ def narrative_analyze(text):
     return {"cats": cats, "per_kilo": per_kilo, "alert": alert, "ending_hits": ending_hits}
 
 
-def report_line(text):
-    """生成注入评审提示词的报告行（措辞层 + 叙事架构层）；全部无命中返回空串。"""
+# ---------- 节奏/钩子密度（借鉴 web-novel-pacing-analyzer：连载作品的章级
+# 节奏审计——读者留存看「每章有没有钩子、段落有没有淤积、是不是通篇独白」，
+# 这些是能确定性统计的客观量。与套话检测同路：只给评审官一条参考线，
+# 不直接扣分——短段落多的快节奏文也可能开篇没有冲突词。）
+NARRATIVE_FLOWS = ("novel", "serial_novel", "video_script")
+
+# 冲突/悬念信号词表：开篇用来看「抓不抓人」，章末用来看「留不留钩子」
+HOOK_WORDS = (
+    "突然", "忽然", "竟然", "没想到", "万万没想到", "难道", "究竟", "为什么",
+    "是谁", "怎么回事", "就在这时", "就在此时", "然而", "可是", "却见", "却听",
+    "不对劲", "不对！", "脸色一变", "猛地", "陡然", "下一秒", "醒来", "睁开眼",
+    "电话响", "门被推开", "传来", "砸", "吼", "喊",
+)
+DIALOG_RE = re.compile(r"[「『“\"]")
+OPENING_SCAN_CHARS = 300        # 开篇抓力只看前 300 字（黄金三章 / 短视频黄金 3 秒）
+PACING_TAIL_CHARS = 200         # 章末钩子只看最后 200 字
+PARA_LONG_CHARS = 400           # 单段超过此字数算「信息淤积」
+PARA_AVG_ALERT = 300            # 段均长告警线
+DIALOG_ALERT_RATIO = 0.12       # 含对话段占比低于此值算「通篇叙述独白」
+PACING_MIN_CHARS = 400          # 太短（摘要/片段）不做节奏统计，避免噪声
+
+
+def _paras(text):
+    """切段：空行或单换行都算分隔；丢掉标题行（# 开头）与空白。"""
+    out = []
+    for p in re.split(r"\n\s*\n|\n", text or ""):
+        p = p.strip()
+        if p and not p.startswith("#"):
+            out.append(p)
+    return out
+
+
+def pacing_analyze(text):
+    """统计叙事节奏客观量。返回 {ok, paras, avg_len, longest, dialog_ratio,
+    open_hits, tail_hits, alerts, alert}；文本过短时 ok=False。"""
+    text = text or ""
+    paras = _paras(text)
+    if len(text) < PACING_MIN_CHARS or not paras:
+        return {"ok": False}
+    lens = [len(p) for p in paras]
+    avg = round(sum(lens) * 1.0 / len(lens), 1)
+    longest = max(lens)
+    dialog = sum(1 for p in paras if DIALOG_RE.search(p))
+    ratio = round(dialog * 1.0 / len(paras), 3)
+    opening, tail = text[:OPENING_SCAN_CHARS], text[-PACING_TAIL_CHARS:]
+    open_hits = sum(1 for w in HOOK_WORDS if w in opening)
+    tail_hits = sum(1 for w in HOOK_WORDS if w in tail)
+    alerts = []
+    if avg >= PARA_AVG_ALERT:
+        alerts.append("段落偏长（均 %.0f 字），阅读有淤积感" % avg)
+    if longest >= PARA_LONG_CHARS:
+        alerts.append("存在超长段（最长 %d 字）" % longest)
+    if ratio < DIALOG_ALERT_RATIO:
+        alerts.append("对话段占比偏低（%.0f%%），易成通篇独白" % (ratio * 100))
+    if not tail_hits:
+        alerts.append("章末 200 字无悬念信号，缺钩子")
+    if not open_hits:
+        alerts.append("开篇 300 字无冲突信号，开头偏平")
+    return {"ok": True, "paras": len(paras), "avg_len": avg, "longest": longest,
+            "dialog_ratio": ratio, "open_hits": open_hits, "tail_hits": tail_hits,
+            "alerts": alerts, "alert": bool(alerts)}
+
+
+def report_line(text, kind=None):
+    """生成注入评审提示词的报告行（措辞层 + 叙事架构层 + 节奏层）；
+    全部无命中返回空串。kind 为流程类型：只有叙事类流程才下发节奏检测
+    （邮件/汇报/翻译等非叙事文体统计段落节奏没有意义）。"""
     lines = []
     r = analyze(text)
     if r["hits"]:
@@ -102,4 +169,15 @@ def report_line(text):
                      "请评审情节结构：主题是否被叙述者直接说破、情绪是否只有身体描写、"
                      "结尾是否靠主角想通收束。")
         lines.append(line)
+    if kind in NARRATIVE_FLOWS:
+        pr = pacing_analyze(text)
+        if pr["ok"]:
+            line = ("- [节奏检测] 确定性统计：%d 段（均 %.0f 字 / 最长 %d 字），"
+                    "含对话段 %.0f%%，开篇 300 字冲突信号 %d 处，章末 200 字悬念信号 %d 处。"
+                    % (pr["paras"], pr["avg_len"], pr["longest"],
+                       pr["dialog_ratio"] * 100, pr["open_hits"], pr["tail_hits"]))
+            if pr["alert"]:
+                line += ("提示：%s。连载留存取决于每章的钩子与段落节奏，"
+                         "请评审官结合剧情判断是否真问题。" % "、".join(pr["alerts"]))
+            lines.append(line)
     return "\n".join(lines)

package/app/core/automation.py

@@ -10,8 +10,13 @@ store.create_run → jobs.enqueue）拉起一次真实运行，不自己造运
 任务模型：
   {id, name, prompt, workdir, kind: daily|interval|weekly|once, time: "HH:MM",
    interval_hours, weekday(0-6 周一=0), run_at(once 用, ISO), flow(编排流程 id),
+   mode(编排模式), thinking(思考程度), direct_provider_id/direct_model(仅 direct 流程),
    enabled, created_at, last_run, next_run, run_count, last_status}
 
+运行偏好（mode/thinking/对话模型）与新建任务 Composer 的三颗胶囊同一套取值，
+到点拉起时原样透传给 store.create_task——定时任务不是另一条执行链，用户在这里
+选的编排强度与模型偏好必须与手动建任务完全等价。
+
 重启语义：错过的 once 不补跑（启动恢复时直接停用）；daily/weekly/interval
 重算 next_run 到下一个未来时刻即可，不追赶停机期间错过的周期。
 
@@ -48,17 +53,24 @@ KINDS = ("daily", "interval", "weekly", "once")
 INTERVAL_MIN, INTERVAL_MAX = 1, 720   # interval_hours 合法区间（小时）
 DEFAULT_FLOW = "doc"  # 未指定编排流程时的兜底：review 引擎产出文档，适配巡检/整理类提示词
 
+# 运行偏好取值（必须与 store.create_task 的口径一致，否则到点拉起时被静默改档）
+MODES = ("auto", "fast", "expert", "manual")
+THINKINGS = ("auto", "low", "standard", "high")
+
 _TIME_RE = re.compile(r"\s*(\d{1,2}):(\d{1,2})\s*")
 
 # 字段缺省（加载历史文件/脏数据时兜底；enabled 兜底为 False，绝不意外触发）
 _DEFAULTS = {"id": "", "name": "", "prompt": "", "workdir": "", "kind": "", "time": "",
              "interval_hours": 0, "weekday": -1, "run_at": "", "flow": "",
+             "mode": "auto", "thinking": "standard",
+             "direct_provider_id": "", "direct_model": "",
              "enabled": False, "created_at": "", "last_run": "", "next_run": "",
              "run_count": 0, "last_status": ""}
 
 # 允许通过 update() 修改的字段（id/created_at/run_count 等运行痕迹不可改）
 _UPDATABLE = ("name", "prompt", "workdir", "kind", "time", "interval_hours",
-              "weekday", "run_at", "flow", "enabled")
+              "weekday", "run_at", "flow", "mode", "thinking",
+              "direct_provider_id", "direct_model", "enabled")
 
 
 # ---------------------------------------------------------------- 时间工具
@@ -206,6 +218,37 @@ def _apply_schedule(t, check_flow=True):
         t["flow"] = DEFAULT_FLOW
 
 
+def _flow_engine(flow_id):
+    """流程引擎名（查不到返回空串）。"""
+    from . import flows as flows_mod
+    f = flows_mod.get_flow(str(flow_id or "").strip())
+    return (f or {}).get("engine") or ""
+
+
+def _apply_run_prefs(t):
+    """校验并归一运行偏好（编排模式/思考程度/对话模型），就地改写 t。必须在
+    _apply_schedule 之后调用——只有那里才把 flow 归一成最终值。
+
+    mode/thinking 非法值一律收敛到默认（auto/standard），不抛异常：这两个是
+    「偏好」不是「配置」，脏值不该把保存卡死。对话模型只在流程引擎为 direct
+    时有意义：非 direct 流程一律清空，避免换流程后残留的模型绑定在下一次
+    触发时静默生效（用户看不到却在生效的配置，比没有更糟）。direct 流程下
+    「有模型没厂商」则明确报错——猜一个厂商等于把模型请求打到别家。
+    """
+    mode = str(t.get("mode") or "").strip().lower()
+    t["mode"] = mode if mode in MODES else "auto"
+    thinking = str(t.get("thinking") or "").strip().lower()
+    t["thinking"] = thinking if thinking in THINKINGS else "standard"
+    pid = str(t.get("direct_provider_id") or "").strip()[:80]
+    model = str(t.get("direct_model") or "").strip()[:160]
+    if _flow_engine(t.get("flow")) != "direct":
+        t["direct_provider_id"], t["direct_model"] = "", ""
+        return
+    if model and not pid:
+        raise ValueError("指定对话模型时必须同时选择厂商")
+    t["direct_provider_id"], t["direct_model"] = pid, model
+
+
 # ---------------------------------------------------------------- 持久化
 
 def _list_locked():
@@ -298,7 +341,15 @@ def _launch_run(t):
                "title": ("%s %s" % (t.get("name") or "定时任务",
                                     time.strftime("%m-%d %H:%M"))).strip()[:40],
                "goal": t.get("prompt") or "",
-               "workdir": (t.get("workdir") or "").strip()}
+               "workdir": (t.get("workdir") or "").strip(),
+               # 运行偏好与 Composer 同一套字段：create_task 里已支持，透传即可
+               "mode": t.get("mode") or "auto",
+               "thinking": t.get("thinking") or "standard"}
+    # direct 流程才有对话模型；非 direct 流程这两个键连传都不传（避免碰 store
+    # 里「有模型没厂商就报错」的校验，也避免给别的引擎塞无意义字段）
+    if t.get("direct_provider_id"):
+        payload["direct_provider_id"] = t["direct_provider_id"]
+        payload["direct_model"] = t.get("direct_model") or ""
     task = None
     run = None
     try:
@@ -470,6 +521,7 @@ def create(payload):
     t["kind"] = payload.get("kind") or "daily"
     _validate_core(t)
     _apply_schedule(t)
+    _apply_run_prefs(t)     # 依赖 _apply_schedule 归一后的 flow 判引擎
     t["next_run"] = compute_next_run(t)
     with _LOCK:
         _TASKS[t["id"]] = t
@@ -492,6 +544,7 @@ def update(tid, patch):
                 merged[k] = patch[k]
         _validate_core(merged, check_workdir=("workdir" in patch))
         _apply_schedule(merged, check_flow=("flow" in patch))
+        _apply_run_prefs(merged)   # 改了 flow 就重判：非 direct 流程清掉残留模型
         merged["next_run"] = compute_next_run(merged)
         _TASKS[tid] = merged
         _save_locked()

package/app/core/pipeline.py

@@ -1807,45 +1807,11 @@ def _plot_modules(workdir):
             "鼓励化用，不要照抄原句）\n\n" + txt)
 
 
-def _chain_volume_names(task):
-    """沿 serial.continues 链收集各批次大纲里的卷名/卷弧光（旧 → 新，后者覆盖）。
-    续写批次合并成书时要给全书（含此前各批）的卷都写上标题，那些卷的命名记在
-    更早的批次任务上，本批 run 的 outline 里没有。失败静默返回 {}。"""
-    from . import store as _store
-    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 章。
-    不分卷返回 []；调用方据此决定是否插卷标题/卷末约束。"""
-    serial = task.get("serial") or {}
-    per = volumes.norm_per(serial.get("volume_chapters"))
-    plan = volumes.build_plan(serial.get("volumes"), per, 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)
+    """本书的卷规划表（卷边界+卷名+卷弧光）。实现见 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")
@@ -2119,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
@@ -2194,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 "（稿件为空！）")
 
@@ -3375,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":

package/app/core/planner.py

@@ -298,6 +298,51 @@ def _prev_serial_story(task):
     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):
     """连载大纲：编排者 API 优先 → 作者 CLI → 模板。返回 {book_title, chapters:[{title,beats,hook}]}。
 

package/app/core/store.py

@@ -218,11 +218,10 @@ def create_task(payload):
                 # 不会因分批而错位。
                 vol_spec = volumes.norm_spec(serial.get("volumes"))
                 if not vol_spec:
-                    # 表单没填卷表时，从目标/上下文文字里识别用户手写的
-                    # 「第一卷 少年初入江湖 第1-20章」式分卷信息（保守识别，
-                    # 认不出就返回空，绝不会把普通文字误判成分卷）。
-                    vol_spec = volumes.parse_spec_text(goal) \
-                        or volumes.parse_spec_text(serial.get("volumes_text")) \
+                    # 否则从文字里识别：表单「指定卷结构」框 > 任务目标 > 上下文。
+                    # 保守识别——认不出返回空，绝不把普通文字误判成分卷。
+                    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

package/app/core/volumes.py

@@ -169,8 +169,10 @@ def parse_spec_text(text):
     「第一卷 少年初入江湖 第1-20章；卷二 风云再起 21-40章」）。
 
     保守策略：必须出现 ≥1 个卷标记（第X卷/卷X/第X部/第X篇）才认为用户在
-    分卷，且除末卷外每个卷段都要有章号范围或章数（末卷可省 = 开放到书末）。
-    识别不到就返回 []，绝不猜——误判会把普通文字里的「第一卷」当成分卷要求。
+    分卷；且**每个卷段都必须带边界**（章号范围 / 章数 / 「N章起」开放标记）。
+    缺边界的段一律判为「不是分卷信息」——「第一卷要吸引人」这类句子里的
+    「第一卷」是修辞不是结构，绝不能据此把全书切成一个卷。正常写法都带边界
+    （「第一卷 少年初入江湖 20章」「第1-20章」「21章起」），因此不受影响。
 
     切段方式：按**卷标记出现位置**切（而非按行/分号），这样「卷一 甲 20章，
     卷二 乙 25章」这种同一行多卷也能正确拆开。"""
@@ -191,7 +193,7 @@ def parse_spec_text(text):
         end = marks[i + 1].start() if i + 1 < len(marks) else len(text)
         segs.append((text[m.start():end], key))
     out = []
-    for idx, (seg, _num) in enumerate(segs):
+    for seg, _num in segs:
         m = _VOL_RE.match(seg)     # seg 以卷标记起头，相对位置 0
         if not m:
             continue
@@ -208,8 +210,8 @@ def parse_spec_text(text):
             m2 = _COUNT_RE.search(body) or _COUNT_RE.search(seg[:m.start()])
             chapters = _to_int(m2.group(1)) if m2 else None
             start, end = None, None
-        if idx < len(segs) - 1 and not (chapters or (start and end)):
-            # 非末卷却没有边界：整段解析不可信，放弃（避免半数卷无边界的错切）
+        if not (chapters or (start and end) or (op and start)):
+            # 该卷段没有可用的边界：整段判为不是分卷信息（见 docstring）
             return []
         out.append({"title": _clean_title(seg, m), "start": start,
                     "end": end, "chapters": chapters})

package/app/ui/app.js

@@ -10,7 +10,7 @@ function codebeeDocumentTitle(lang) {
 document.title = codebeeDocumentTitle((localStorage.getItem("orch.lang") || "zh").toLowerCase());
 
 const $ = (id) => document.getElementById(id);
-const S = { state: null, catalog: null, catSig: "", providers: null, bindings: null, modelsSig: "", bindSig: "", tab: "tasks", detailRunId: null, pollTimer: null, showArchived: false, /* 会话内开关：每次加载默认隐藏已归档、图标不选中（不持久化，见 btn-side-arch） */ selProvs: {}, selModels: {}, selRuns: {}, bindSel: {}, catalogChecking: false, updateCheckAt: 0, control: null, sseLive: false, es: null, flows: null, orch: null, skills: null, orchSig: "", settings: null, sessionAgents: new Set(), atts: [], gitInfo: null, gitWb: null, gitWbKey: "", gitWbAt: 0, gitWbBusy: false, creatingTask: false, inspKey: null, inspData: null, inspSig: "", inspAt: 0, inspTab: "git", inspAutoSig: "", rdTab: null, rdTabSig: "", rdTabPin: false, _rdCtx: {}, lastPrefs: null, prefsApplied: false };
+const S = { state: null, catalog: null, catSig: "", providers: null, bindings: null, modelsSig: "", bindSig: "", tab: "tasks", mainPage: "", /* 主栏正显示的全局页（"" = 新建任务表单）；左栏是任务树还是设置导航看 body.settings-mode */ detailRunId: null, pollTimer: null, showArchived: false, /* 会话内开关：每次加载默认隐藏已归档、图标不选中（不持久化，见 btn-side-arch） */ selProvs: {}, selModels: {}, selRuns: {}, bindSel: {}, catalogChecking: false, updateCheckAt: 0, control: null, sseLive: false, es: null, flows: null, orch: null, skills: null, orchSig: "", settings: null, sessionAgents: new Set(), atts: [], gitInfo: null, gitWb: null, gitWbKey: "", gitWbAt: 0, gitWbBusy: false, creatingTask: false, inspKey: null, inspData: null, inspSig: "", inspAt: 0, inspTab: "git", inspAutoSig: "", rdTab: null, rdTabSig: "", rdTabPin: false, _rdCtx: {}, lastPrefs: null, prefsApplied: false };
 
 /* ---------------------------------------------------------- 任务类型（流程） */
 async function loadFlows() {
@@ -301,7 +301,8 @@ function onTypeChange() {
   const bibleCreate = $("bible-create-field");
   const isSerialReview = isReview && !!(flow && flow.serial);
   if (bibleCreate) bibleCreate.classList.toggle("hidden", !isSerialReview);
-  const clearSerialFields = () => ["f-chapters", "f-words-per-ch", "f-variants", "f-bible"].forEach((id) => {
+  const clearSerialFields = () => ["f-chapters", "f-words-per-ch", "f-variants", "f-bible",
+    "f-vol-chapters", "f-vol-spec"].forEach((id) => {
     const el = $(id);
     if (el) el.value = "";
   });
@@ -330,6 +331,12 @@ function onTypeChange() {
     if (flow.serial) {
       if (!$("f-chapters").value) $("f-chapters").value = lp.chapters || flow.serial.chapters || "";
       if (!$("f-words-per-ch").value) $("f-words-per-ch").value = lp.words_per_chapter || flow.serial.words_per_chapter || "";
+      // 分卷开箱即用：没填过就预填一个常见每卷章数（用户可改；清空 = 不分卷）。
+      // 卷边界由后端按全书章号推导，续写批次自动接上同一卷。
+      if (!$("f-vol-chapters").value && !$("f-vol-spec").value) {
+        $("f-vol-chapters").value = (lp.volume_chapters != null && lp.volume_chapters !== "")
+          ? lp.volume_chapters : (flow.serial.volume_chapters || 20);
+      }
     } else clearSerialFields();
   } else {
     // 隐藏控件仍保留 DOM 值；换流程时清理，避免章节/圣经状态污染下一次提交。
@@ -2465,6 +2472,12 @@ async function createTask() {
         words_per_chapter: parseInt($("f-words-per-ch").value, 10) || 2500,
         variants: Math.max(1, Math.min(3, parseInt($("f-variants").value, 10) || 1)),
       };
+      // 分卷：显式卷结构文本优先（后端解析成卷表），否则用每卷章数。
+      // 两个都留空 = 不分卷（后端收到 0/缺字段即不分卷）。
+      const volSpec = ($("f-vol-spec") || {}).value ? $("f-vol-spec").value.trim() : "";
+      const volPer = parseInt(($("f-vol-chapters") || {}).value, 10);
+      if (volSpec) payload.serial.volumes_text = volSpec;
+      else if (volPer >= 2) payload.serial.volume_chapters = volPer;
     } else if (flow.serial) {
       // 显式 null 覆盖 serial_novel 的流程默认，空章节就是单稿件。
       payload.serial = null;
@@ -3139,6 +3152,16 @@ function newFromTask(id) {
     $("f-chapters").value = tk.serial ? tk.serial.chapters : "";
     $("f-words-per-ch").value = tk.serial ? tk.serial.words_per_chapter : "";
     $("f-variants").value = tk.serial && tk.serial.variants ? tk.serial.variants : "";
+    // 分卷：还原每卷章数；指定卷结构还原成可读文本（卷名 + 章数/章号范围）
+    $("f-vol-chapters").value = tk.serial && tk.serial.volume_chapters ? tk.serial.volume_chapters : "";
+    $("f-vol-spec").value = tk.serial && Array.isArray(tk.serial.volumes)
+      ? tk.serial.volumes.map((v) => {
+          const ttl = (v && v.title) || "未命名";
+          if (v && v.start && v.end) return ttl + " 第" + v.start + "-" + v.end + "章";
+          if (v && v.chapters) return ttl + " " + v.chapters + "章";
+          return ttl;
+        }).join("；")
+      : "";
     const want = new Set(tk.critics || []);
     $("f-critics").querySelectorAll("input").forEach((i) => { i.checked = want.has(i.value); });
     // 同目录同稿件名再开一篇会覆盖旧产出——提醒但不阻止（有意重写也合理）
@@ -3644,7 +3667,7 @@ function showDetailInMain() {
 function jumpToRun(id) {
   S.focusStep = 0;
   S.focusDone = false;
-  if (document.body.classList.contains("settings-mode")) switchTab("runs");
+  if (document.body.classList.contains("settings-mode")) switchTab("runs", "settings");   // 已在设置里：留在设置侧栏
   else showDetailInMain();
   openRun(id);
 }
@@ -3992,12 +4015,17 @@ function closeRun() {
   detailSideReset();
   $("run-detail").classList.add("hidden");
   renderChatNav();   // 解除 main.chat-fill（对话为主的固定高度），恢复外层滚动
-  if (document.body.classList.contains("settings-mode")) {
+  if (document.body.classList.contains("settings-mode") || S.mainPage === "runs") {
+    // 回运行列表：设置导航里点进来的，或主栏本就停在运行记录页（快捷导航/概览的入口）
     document.querySelector("#sub-runs .panel:first-child").classList.remove("hidden");
+  } else if (S.mainPage) {
+    // 主栏停在别的快捷导航页（概览/自动化）：返回点开详情前那一页，左栏任务树不动
+    switchTab(S.mainPage, "main");
   } else {
     // 从主视图（侧栏点任务行）进来的详情：返回直接回任务页，不露出运行列表
     document.querySelectorAll("#page-settings .subpage").forEach((d) => d.classList.toggle("hidden", d.id !== "sub-tasks"));
     document.querySelectorAll(".set-item").forEach((b) => b.classList.toggle("active", b.dataset.sub === "tasks"));
+    document.querySelectorAll(".qitem").forEach((b) => b.classList.remove("active"));
     const title = $("page-title");
     if (title) title.textContent = tabTitle("tasks");
   }
@@ -4726,8 +4754,11 @@ window.pbUploadChapter = async function (taskId, platform) {
   if (!box.classList.contains("hidden")) { box.classList.add("hidden"); return; }
   box.classList.remove("hidden");
   box.innerHTML = '<div class="pb-loading">' + esc(t("正在列出章节文件…")) + "</div>";
-  let wd = "";
-  try { const tk = ((S.state || {}).tasks || []).find((x) => x.id === taskId); wd = (tk && tk.workdir) || ""; } catch (e) { /* 兜底空 */ }
+  let wd = "", pubTask = null;
+  try {
+    pubTask = ((S.state || {}).tasks || []).find((x) => x.id === taskId);
+    wd = (pubTask && pubTask.workdir) || "";
+  } catch (e) { /* 兜底空 */ }
   if (!wd) { box.innerHTML = '<div class="pb-err">' + esc(t("找不到任务工作目录")) + "</div>"; return; }
   let files = [];
   try {
@@ -4740,11 +4771,33 @@ window.pbUploadChapter = async function (taskId, platform) {
   }
   if (!files.length) { box.innerHTML = '<div class="pb-err">' + esc(t("工作目录里没有 .md 章稿")) + "</div>"; return; }
   files.sort((a, b) => (a.name > b.name ? 1 : -1));
-  box.innerHTML = '<div class="pb-hint">' + esc(t("选一章发送（表单填好后停，人工确认提交）；已成功发过的章会被台账拦下：")) + "</div>" +
-    files.map((f) =>
-      '<button class="ghost pb-ch-item" onclick="pbSendChapter(\'' + esc(taskId) + "', '" + platform +
-      '\',\'' + esc(f.name) + '\')" title="' + esc(f.name) + '">' + esc(f.name.split("/").pop()) + "</button>"
-    ).join("");
+  const item = (f) =>
+    '<button class="ghost pb-ch-item" onclick="pbSendChapter(\'' + esc(taskId) + "', '" + platform +
+    '\',\'' + esc(f.name) + '\')" title="' + esc(f.name) + '">' + esc(f.name.split("/").pop()) + "</button>";
+  const hint = '<div class="pb-hint">' + esc(t("选一章发送（表单填好后停，人工确认提交）；已成功发过的章会被台账拦下：")) + "</div>";
+  // 最高章号：让卷规划表铺到最后一章（否则超出显式卷表的章节会掉进「其他」）
+  let maxCh = 0;
+  files.forEach((f) => {
+    const n = chapterNumOf(f.name);
+    if (n > maxCh) maxCh = n;
+  });
+  const plan = volumePlanOf(pubTask, maxCh);
+  if (!plan.length) { box.innerHTML = hint + files.map(item).join(""); return; }
+  // 分卷：按卷分组列出可发章节（章号取自 chapter-NN.md）。未落入卷的文件归「其他」。
+  const groups = plan.map((v) => ({ v: v, files: [] }));
+  const rest = [];
+  files.forEach((f) => {
+    const n = chapterNumOf(f.name);
+    if (!n) { rest.push(f); return; }
+    const g = groups.find((x) => n >= x.v.first && (x.v.last == null || n <= x.v.last));
+    if (g) g.files.push(f); else rest.push(f);
+  });
+  box.innerHTML = hint + groups.filter((g) => g.files.length).map((g) => {
+    const label = t("第") + " " + g.v.vol + " " + t("卷") + (g.v.title ? " 《" + g.v.title + "》" : "");
+    return '<div class="pb-vol"><div class="pb-vol-head">' + esc(label) + "</div>" +
+      g.files.map(item).join("") + "</div>";
+  }).join("") + (rest.length ? '<div class="pb-vol"><div class="pb-vol-head">' +
+    esc(t("其他文件")) + "</div>" + rest.map(item).join("") + "</div>" : "");
 };
 
 window.pbSendChapter = async function (taskId, platform, relName) {
@@ -5232,7 +5285,7 @@ window.toggleInspector = function () {
   openInspector(key);
 };
 
-/* 检查器只属于「列表快捷预览」上下文：设置子页、新建表单、运行/任务详情一律收起。
+/* 检查器只属于「列表快捷预览」上下文：设置子页、快捷导航页、新建表单、运行/任务详情一律收起。
  * 详情页已铺开全部信息（蜂巢/步骤/成果/版本/圣经/指挥），检查器留着只会同屏
  * 出现两份标题/成品/Git——让它让位，但不丢选中，回到列表上下文自动滑回 */
 function syncInspectorVis() {
@@ -5244,11 +5297,12 @@ function syncInspectorVis() {
   // 主视图下正在看「要完成什么？」新建表单：不是任务上下文，不自动滑出。
   // （本函数只在模式切换时调用，不在轮询里——用户在表单页手动点树里的任务，
   //   openInspector 直接开，不会被这里关掉）
-  const onComposer = !document.body.classList.contains("settings-mode") &&
+  const onComposer = !S.mainPage && !document.body.classList.contains("settings-mode") &&
     !$("sub-tasks").classList.contains("hidden");
   // 主栏正开着运行/任务详情：详情页是全功能视图，检查器同屏只会重复
   const onDetail = !$("run-detail").classList.contains("hidden");
-  if (document.body.classList.contains("settings-mode") || onComposer || onDetail ||
+  // 主栏停在快捷导航页（概览/运行记录/自动化）：同设置子页，检查器让位不抢版面
+  if (document.body.classList.contains("settings-mode") || S.mainPage || onComposer || onDetail ||
       !S.inspKey || runsGone) {
     document.body.classList.remove("inspector-open");
     insp.classList.add("hidden");
@@ -5854,36 +5908,117 @@ function stepsMatch(runs, current) {
     (r.steps || []).some((s) => s.log === current.rel));
 }
 
+/* 从章稿文件名取全书章号：chapter-07.md → 7；非章稿（或解析不出）返回 0。
+ * 只认「chapter-数字.md」这一约定（与后端 _CH_FILE_RE 一致）。 */
+function chapterNumOf(name) {
+  const base = String(name || "").split("/").pop();
+  if (!/^chapter-\d{1,4}\.md$/i.test(base)) return 0;
+  const digits = base.slice("chapter-".length, -3);
+  const n = parseInt(digits, 10);
+  return n > 0 ? n : 0;
+}
+
+/* 分卷规划表（前端只读副本）：把任务的 serial 分卷配置还原成
+ * [{vol, title, first, last}]，供发布页按卷分组列章。后端 volumes.py 是唯一
+ * 真源（写作与成书都走它）；这里只做「列清单」这一用途的最小推导，取不到
+ * 分卷配置时返回 []（调用方退化为平铺列表）。
+ *   serial.volumes        显式卷表：[{title, chapters|start/end}]（优先）
+ *   serial.volume_chapters 每卷章数：等长切卷（兜底）
+ * last=null 表示开放到书末。 */
+function volumePlanOf(task, upto) {
+  const s = (task || {}).serial || {};
+  const spec = Array.isArray(s.volumes) ? s.volumes : [];
+  let per = parseInt(s.volume_chapters, 10);
+  if (!(per >= 2)) per = 0;
+  if (!spec.length && !per) return [];
+  const plan = [];
+  let prevLast = 0;
+  const push = (title, first, last) => plan.push({ vol: plan.length + 1, title: title || "", first: first, last: last });
+  for (const it of spec) {
+    if (!it) continue;
+    const first = (it.start > 0) ? it.start : prevLast + 1;
+    let last = null;
+    if (it.end > 0) last = it.end;
+    else if (it.chapters > 0) last = first + it.chapters - 1;
+    if (last != null && last < first) last = first;
+    push(it.title, first, last);
+    if (last == null) return plan;     // 开放卷：后面不再有卷
+    prevLast = last;
+  }
+  // 显式卷表用尽后按每卷章数（或末卷长度）续卷，保证覆盖到 upto（与后端
+  // volumes.build_plan 同规则）——否则第 21 章起会掉进「其他文件」分组。
+  const fb = per || (plan.length && plan[plan.length - 1].last != null
+    ? plan[plan.length - 1].last - plan[plan.length - 1].first + 1 : 0);
+  if (fb > 0) {
+    let cursor = prevLast + 1;
+    const limit = (upto > 0) ? upto : (plan.length ? prevLast : fb);
+    while (cursor <= limit && plan.length < 200) {
+      push("", cursor, cursor + fb - 1);
+      cursor += fb;
+    }
+  }
+  return plan;
+}
+
+
 /* 连载章节评审卡：每章均分/是否达标/字数 + 逐项目标审稿结果（event_check，
  * 借鉴 AI-Novel-Writer：大纲要点逐项判定+正文证据）。非连载 run 无
- * chapter_scores 保持隐藏。 */
+ * chapter_scores 保持隐藏。
+ * 分卷：章节卡按卷分组显示（卷名来自 run.volumes / chapter_scores[].vol_title），
+ * 不分卷时退化为原来的平铺列表，视觉零变化。 */
 function renderChapterScores(run) {
   const box = $("rd-chapters");
   if (!box) return;
   const cs = run && run.chapter_scores;
   if (!Array.isArray(cs) || !cs.length) { box.classList.add("hidden"); return; }
   box.classList.remove("hidden");
-  box.innerHTML = '<h3 class="sec-title">' + t("章节评审") +
-    '<span class="tag">' + cs.filter((c) => c.passed).length + "/" + cs.length + " " + t("达标") + "</span></h3>" +
-    cs.map((c) => {
-      const means = c.means || {};
-      const dims = Object.keys(means).map((d) =>
-        '<span class="ch-dim' + (means[d] >= 7 ? "" : " low") + '">' + esc(d) + " " + means[d] + "</span>").join("");
-      const ev = (c.event_check || []).map((line) => {
-        const ok = /已完成/.test(line), bad = /未完成/.test(line);
-        return '<div class="ch-ev' + (ok ? " ok" : bad ? " bad" : "") + '">' + esc(line) + "</div>";
-      }).join("");
-      return '<div class="ch-row' + (c.passed ? "" : " fail") + '">' +
-        '<div class="ch-head"><b>' + esc(t("第") + " " + c.chapter + " " + t("章")) + '</b>' +
-        '<span class="ch-title">' + esc(c.title || "") + "</span>" +
-        '<span class="tag">' + (c.passed ? t("达标") : t("未达标")) + "</span>" +
-        (c.reused ? '<span class="tag">' + t("沿用") + "</span>" : "") +
-        '<span class="ch-meta">' + Number(c.words || 0) + t(" 字") +
-        (c.rounds > 1 ? " · " + c.rounds + t(" 轮") : "") + "</span></div>" +
-        (dims ? '<div class="ch-dims">' + dims + "</div>" : "") +
-        (ev ? '<div class="ch-evs"><span class="hint">' + t("逐项目标核对：") + "</span>" + ev + "</div>" : "") +
-        "</div>";
+  // 卷名表：优先 run.volumes（全书卷规划），退到章节自带的 vol_title
+  const volTitles = {};
+  (run.volumes || []).forEach((v) => { volTitles[v.vol] = v.title || ""; });
+  cs.forEach((c) => {
+    if (c.vol && c.vol_title && !volTitles[c.vol]) volTitles[c.vol] = c.vol_title;
+  });
+  const rowHtml = (c) => {
+    const means = c.means || {};
+    const dims = Object.keys(means).map((d) =>
+      '<span class="ch-dim' + (means[d] >= 7 ? "" : " low") + '">' + esc(d) + " " + means[d] + "</span>").join("");
+    const ev = (c.event_check || []).map((line) => {
+      const ok = /已完成/.test(line), bad = /未完成/.test(line);
+      return '<div class="ch-ev' + (ok ? " ok" : bad ? " bad" : "") + '">' + esc(line) + "</div>";
     }).join("");
+    return '<div class="ch-row' + (c.passed ? "" : " fail") + '">' +
+      '<div class="ch-head"><b>' + esc(t("第") + " " + c.chapter + " " + t("章")) + '</b>' +
+      '<span class="ch-title">' + esc(c.title || "") + "</span>" +
+      '<span class="tag">' + (c.passed ? t("达标") : t("未达标")) + "</span>" +
+      (c.reused ? '<span class="tag">' + t("沿用") + "</span>" : "") +
+      '<span class="ch-meta">' + Number(c.words || 0) + t(" 字") +
+      (c.rounds > 1 ? " · " + c.rounds + t(" 轮") : "") + "</span></div>" +
+      (dims ? '<div class="ch-dims">' + dims + "</div>" : "") +
+      (ev ? '<div class="ch-evs"><span class="hint">' + t("逐项目标核对：") + "</span>" + ev + "</div>" : "") +
+      "</div>";
+  };
+  const head = '<h3 class="sec-title">' + t("章节评审") +
+    '<span class="tag">' + cs.filter((c) => c.passed).length + "/" + cs.length + " " + t("达标") + "</span></h3>";
+  const hasVol = cs.some((c) => c.vol);
+  if (!hasVol) { box.innerHTML = head + cs.map(rowHtml).join(""); return; }
+  // 按卷分组（章号顺序，卷内保持原序）
+  const groups = [];
+  cs.forEach((c) => {
+    const v = c.vol || 0;
+    let g = groups.find((x) => x.vol === v);
+    if (!g) { g = { vol: v, rows: [] }; groups.push(g); }
+    g.rows.push(c);
+  });
+  box.innerHTML = head + groups.map((g) => {
+    const title = volTitles[g.vol] || "";
+    const nPass = g.rows.filter((c) => c.passed).length;
+    const label = g.vol ? (t("第") + " " + g.vol + " " + t("卷") + (title ? " 《" + title + "》" : "")) : t("未分卷");
+    return '<div class="ch-vol"><div class="ch-vol-head"><b>' + esc(label) + "</b>" +
+      '<span class="tag">' + nPass + "/" + g.rows.length + " " + t("达标") + "</span>" +
+      '<span class="ch-meta">' + t("第 ") + g.rows[0].chapter + "–" +
+      g.rows[g.rows.length - 1].chapter + t(" 章") + "</span></div>" +
+      g.rows.map(rowHtml).join("") + "</div>";
+  }).join("");
 }
 
 function renderPlan(run) {
@@ -8355,6 +8490,7 @@ function flowForm(fid) {
     '<div class="field"><label>' + t("连载章节数（留空 = 单稿件）") + '</label><input id="fl-chapters" type="number" min="2" max="20" value="' + (f && f.serial ? f.serial.chapters : "") + '" placeholder="' + t("例：8") + '"></div>' +
     '<div class="field"><label>' + t("每章约字数") + '</label><input id="fl-words-per-ch" type="number" min="500" max="8000" step="100" value="' + (f && f.serial ? f.serial.words_per_chapter : "") + '" placeholder="' + t("例：2500") + '"></div>' +
     '<div class="field"><label>' + t("同章赛马稿件数") + '</label><input id="fl-variants" type="number" min="1" max="3" step="1" value="' + (f && f.serial ? (f.serial.variants || 1) : 1) + '" placeholder="' + t("1 = 关闭") + '"></div>' +
+    '<div class="field"><label>' + t("分卷：每卷章数（留空 = 不分卷）") + '</label><input id="fl-vol-chapters" type="number" min="2" max="200" step="1" value="' + (f && f.serial && f.serial.volume_chapters ? f.serial.volume_chapters : "") + '" placeholder="' + t("例：20") + '"></div>' +
     "</div>" +
     '<div class="field"><label>' + t("起草提示词（可选，占位符 __FILE__ __GOAL__ __CONTEXT__ __SKILLS__）") + '</label><textarea id="fl-draft" rows="3" placeholder="' + t("留空 = 内置通用模板") + '">' + esc(f && f.draft_prompt ? f.draft_prompt : "") + "</textarea></div>" +
     '<div class="field"><label>' + t("评审提示词（可选，占位符 __DIMKEYS__ __MANUSCRIPT__）") + '</label><textarea id="fl-critique" rows="3" placeholder="' + t("留空 = 内置通用模板") + '">' + esc(f && f.critique_prompt ? f.critique_prompt : "") + "</textarea></div>" +
@@ -8394,11 +8530,15 @@ async function saveFlow() {
     const rb = $("fl-rubric").value.split(/[,，、]/).map((s) => s.trim()).filter(Boolean);
     if (rb.length) payload.rubric = rb;
     const ch = parseInt($("fl-chapters").value, 10);
-    if (ch >= 2) payload.serial = {
-      chapters: ch,
-      words_per_chapter: parseInt($("fl-words-per-ch").value, 10) || 2500,
-      variants: Math.max(1, Math.min(3, parseInt($("fl-variants").value, 10) || 1)),
-    };
+    if (ch >= 2) {
+      payload.serial = {
+        chapters: ch,
+        words_per_chapter: parseInt($("fl-words-per-ch").value, 10) || 2500,
+        variants: Math.max(1, Math.min(3, parseInt($("fl-variants").value, 10) || 1)),
+      };
+      const vp = parseInt(($("fl-vol-chapters") || {}).value, 10);
+      if (vp >= 2) payload.serial.volume_chapters = vp;   // 流程默认分卷（任务级可覆盖）
+    }
     const dp = $("fl-draft").value.trim();
     if (dp) payload.draft_prompt = dp;
     const cp = $("fl-critique").value.trim();
@@ -8695,6 +8835,26 @@ function autoStatusTag(tsk) {
   return "";
 }
 
+/* 运行偏好标签：只显示「偏离默认」的那些（编排默认 auto、思考默认 standard），
+ * 否则每张卡都挂两颗没有信息量的胶囊，反而盖住真正要看的节奏与流程 */
+function autoPrefTags(tsk) {
+  const MODE = { auto: "自动", fast: "快速", expert: "专家", manual: "手动" };
+  const TH = { auto: "自动", low: "快速", standard: "标准", high: "深度" };
+  const out = [];
+  if (tsk.mode && tsk.mode !== "auto" && MODE[tsk.mode]) {
+    out.push(t("编排模式") + "：" + t(MODE[tsk.mode]));
+  }
+  if (tsk.thinking && tsk.thinking !== "standard" && TH[tsk.thinking]) {
+    out.push(t("思考程度") + "：" + t(TH[tsk.thinking]));
+  }
+  if (tsk.direct_provider_id) {
+    const p = directProviders().find((x) => x.id === tsk.direct_provider_id);
+    out.push(t("对话模型") + "：" + (p ? (p.name || p.id) : tsk.direct_provider_id) +
+      "/" + (tsk.direct_model || t("随厂商推荐")));
+  }
+  return out.map((s) => '<span class="tag">' + esc(s) + "</span>").join("");
+}
+
 function autoCardHtml(tsk) {
   const flow = tsk.flow ? flowById(tsk.flow) : null;
   return '<div class="card' + (tsk.enabled ? "" : " off") + '"><div class="head">' +
@@ -8704,7 +8864,8 @@ function autoCardHtml(tsk) {
     ' onchange="autoToggle(\'' + esc(tsk.id) + '\', this.checked)"><span>' + (tsk.enabled ? t("启用中") : t("已停用")) + "</span></label>" +
     "</div>" +
     '<div class="auto-kind">' + esc(autoKindText(tsk)) +
-    (flow ? '<span class="tag">' + t("流程：") + esc(t(flow.name)) + "</span>" : "") + "</div>" +
+    (flow ? '<span class="tag">' + t("流程：") + esc(t(flow.name)) + "</span>" : "") +
+    autoPrefTags(tsk) + "</div>" +
     '<div class="auto-prompt">' + esc(tsk.prompt) + "</div>" +
     '<div class="auto-meta">' +
     (tsk.enabled && tsk.next_run ? "<span>" + t("下次运行 ") + esc(tsk.next_run) + "</span>" : "") +
@@ -8747,6 +8908,8 @@ async function autoForm(task, tpl) {
   const f = task || {};
   const kind = f.kind || (tpl && tpl.suggested_kind) || "daily";
   const curFlow = f.flow || (tpl && tpl.suggested_flow) || "";
+  const mode = f.mode || "auto";
+  const thinking = f.thinking || "standard";
   const wdOpts = AUTO_WD.map((w, i) =>
     '<option value="' + i + '"' + (Number(f.weekday) === i || (!task && tpl && tpl.suggested_weekday === i) ? " selected" : "") + ">" + t(w) + "</option>").join("");
   const runAt = f.run_at ? String(f.run_at).replace(" ", "T").slice(0, 16) : "";
@@ -8770,6 +8933,18 @@ async function autoForm(task, tpl) {
         '<option value="' + esc(fl.id) + '"' + (fl.id === curFlow ? " selected" : "") + ">" + esc(t(fl.name)) + "</option>").join("") +
       "</select></div>" +
     "</div>" +
+    /* 运行偏好：与新建任务 Composer 的三颗胶囊同一套取值（编排模式/思考程度/
+       对话模型），到点拉起的运行与手动建的任务完全等价 */
+    '<div class="grid-2">' +
+    '<div class="field"><label>' + t("编排模式") + "</label>" +
+      autoPillHtml("au-mode", AUTO_MODES, mode) + "</div>" +
+    '<div class="field"><label>' + t("思考程度") + "</label>" +
+      autoPillHtml("au-thinking", AUTO_THINKINGS, thinking) + "</div>" +
+    "</div>" +
+    '<div id="au-model-field" class="field hidden"><label>' + t("对话模型（可选）") + '</label><div class="grid-2">' +
+      '<select id="au-direct-provider" aria-label="' + t("对话厂商") + '"></select>' +
+      '<select id="au-direct-model-name" aria-label="' + t("对话模型") + '"></select>' +
+      '</div><p class="hint">' + t("只对「直接执行」类流程生效；留「自动推荐」时按系统路由挑模型。") + "</p></div>" +
     '<div class="grid-2">' +
     '<div class="field au-fld" data-k="time"><label>' + t("时间") + '</label><input id="au-time" type="time" value="' +
       esc(f.time || (tpl && tpl.suggested_time) || "09:00") + '"></div>' +
@@ -8789,6 +8964,71 @@ async function autoForm(task, tpl) {
     kindSel.addEventListener("change", autoFormSyncKind);
     autoFormSyncKind();
   }
+  ["au-mode", "au-thinking"].forEach((id) => {
+    const sel = $(id);
+    if (sel) sel.addEventListener("change", () => syncCmpSelFace(id));
+    syncCmpSelFace(id);   // 弹框是动态插入的：选项文字要在这里同步一次
+  });
+  renderAuModelPicker(f.direct_provider_id || "", f.direct_model || "");
+  const flowSel = $("au-flow");
+  if (flowSel) {
+    flowSel.addEventListener("change", autoFormSyncFlow);
+    autoFormSyncFlow();
+  }
+}
+
+/* 运行偏好取值（真源 = automation.py 的 MODES/THINKINGS，选项文案与 Composer 共用） */
+const AUTO_MODES = [
+  { v: "auto", label: "自动（推荐）：按任务类型与风险动态决定步骤" },
+  { v: "fast", label: "快速：少步骤优先，先做确定性验收" },
+  { v: "expert", label: "专家：完整规划、多评审、失败修复与换将" },
+  { v: "manual", label: "手动：自行指定实现者与评审组" },
+];
+const AUTO_THINKINGS = [
+  { v: "standard", label: "标准：平衡质量与速度" },
+  { v: "auto", label: "自动：随任务难度调整" },
+  { v: "low", label: "快速：少推理、优先响应" },
+  { v: "high", label: "深度：更多推理与检查" },
+];
+
+/* 偏好胶囊：外观与 Composer 同款（透明原生 select 铺满整颗，短名由
+ * syncCmpSelFace 从选中 option 文本截取——语言切换后短名跟着换） */
+function autoPillHtml(id, opts, cur) {
+  return '<span class="cmp-sel"><select id="' + id + '" class="cmp-sel-native" aria-label="' +
+    esc(id === "au-mode" ? t("编排模式") : t("思考程度")) + '">' +
+    opts.map((o) => '<option value="' + o.v + '"' + (o.v === cur ? " selected" : "") +
+      ' data-i18n="' + esc(o.label) + '">' + esc(t(o.label)) + "</option>").join("") +
+    '</select><span class="cmp-sel-face" id="' + id + '-face"></span>' +
+    '<svg class="ico chev" aria-hidden="true"><use href="#i-chevron-r"></use></svg></span>';
+}
+
+/* 对话模型（仅 direct 流程）：复用 Composer 的厂商/模型数据源与重建规则 */
+function renderAuModelPicker(pid, model) {
+  const ps = $("au-direct-provider"), ms = $("au-direct-model-name");
+  if (!ps || !ms) return;
+  const provs = directProviders();
+  const keepP = pid != null ? pid : ps.value;
+  ps.innerHTML = '<option value="">' + t("自动推荐") + "</option>" + provs.map((p) =>
+    '<option value="' + esc(p.id) + '">' + esc(p.name || p.id) + "</option>").join("");
+  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)
+      .map((m) => m.name).filter(Boolean) : [];
+    ms.innerHTML = '<option value="">' + t("随厂商推荐") + "</option>" + names.map((name) =>
+      '<option value="' + esc(name) + '">' + esc(name) + "</option>").join("");
+    ms.value = names.includes(keepM) ? keepM : "";
+  };
+  fillModels(model != null ? model : ms.value);
+  // 换厂商 = 旧模型名多半不在新厂商名录里：回「随厂商推荐」，不留悬空值
+  ps.onchange = () => fillModels("");
+}
+
+/* 流程 → 对话模型字段显隐：只有 direct 引擎流程用得上（其余流程模型由系统路由） */
+function autoFormSyncFlow() {
+  const flow = flowById(($("au-flow") || {}).value);
+  const box = $("au-model-field");
+  if (box) box.classList.toggle("hidden", !(flow && flow.engine === "direct"));
 }
 
 /* 类型 → 字段联动：daily/weekly→时间；weekly→星期几；interval→N 小时；once→未来时间 */
@@ -8813,6 +9053,17 @@ async function saveAutoForm(id) {
   if (!prompt) { toast(t("请填写执行内容"), true); return; }
   const kind = $("au-kind").value;
   const payload = { name, prompt, workdir: ($("au-workdir").value || "").trim(), kind, flow: $("au-flow").value };
+  // 运行偏好：与 Composer 同名字段，后端 _apply_run_prefs 再归一一次
+  payload.mode = $("au-mode") ? $("au-mode").value : "";
+  payload.thinking = $("au-thinking") ? $("au-thinking").value : "";
+  if (!$("au-model-field") || !$("au-model-field").classList.contains("hidden")) {
+    payload.direct_provider_id = $("au-direct-provider") ? $("au-direct-provider").value : "";
+    payload.direct_model = $("au-direct-model-name") ? $("au-direct-model-name").value : "";
+    if (payload.direct_model && !payload.direct_provider_id) {
+      toast(t("选择对话模型前请先选厂商"), true);
+      return;
+    }
+  }
   if (kind === "daily" || kind === "weekly") payload.time = $("au-time").value;
   if (kind === "weekly") payload.weekday = parseInt($("au-weekday").value, 10);
   if (kind === "interval") payload.interval_hours = parseInt($("au-interval").value, 10) || 0;
@@ -9158,26 +9409,26 @@ function renderHooks() {
   if (!box) return;
   const list = S.hooks || [];
   if (empty) empty.classList.toggle("hidden", list.length > 0);
+  const evLabel = { task_start: t("任务开始"), message_submit: t("消息送达"), run_end: t("运行结束") };
   box.innerHTML = list.map((h, i) => {
-    const evName = { task_start: t("任务开始"), message_submit: t("消息送达"), run_end: t("运行结束") }[h.event] || h.event;
     return '<div class="card hook-card" data-i="' + i + '">' +
-      '<div class="hook-head">' +
-      '<input class="hook-name" value="' + esc(h.name || "") + '" placeholder="' + esc(t("名称")) + '" data-hf="name">' +
+      '<div class="hook-row">' +
+      '<input class="hook-name" value="' + esc(h.name || "") + '" placeholder="' + esc(t("钩子名称")) + '" data-hf="name">' +
       '<select class="hook-event" data-hf="event">' +
       ["task_start", "message_submit", "run_end"].map((ev) =>
         '<option value="' + ev + '"' + (h.event === ev ? " selected" : "") + ">" +
-        esc({ task_start: t("任务开始"), message_submit: t("消息送达"), run_end: t("运行结束") }[ev]) + "</option>").join("") +
+        esc(evLabel[ev]) + "</option>").join("") +
       "</select>" +
-      '<label class="switch" title="' + esc(t("启用")) + '"><input type="checkbox" data-hf="enabled"' +
-      (h.enabled ? " checked" : "") + '><span></span></label>' +
-      '<button type="button" class="ghost small" onclick="removeHook(' + i + ')">' + t("删除") + "</button>" +
       "</div>" +
       '<input class="hook-cmd mono" value="' + esc(h.cmd || "") + '" placeholder="' +
-      esc(t('命令，例：python E:\\proj\\hook.py --event {event}')) + '" data-hf="cmd">' +
-      '<div class="hook-foot">' +
-      '<span class="hint">' + esc(t("超时（秒）")) + '</span><input class="hook-timeout" type="number" min="1" max="120" value="' +
-      Number(h.timeout_s || 10) + '" data-hf="timeout_s">' +
+      esc(t('命令：python D:\\proj\\hook.py（stdin 收 JSON，stdout 回 {"inject":"文本"}）')) + '" data-hf="cmd">' +
+      '<div class="hook-row hook-foot">' +
+      '<label class="switch" title="' + esc(t("启用")) + '"><input type="checkbox" data-hf="enabled"' +
+      (h.enabled ? " checked" : "") + '><span></span><em>' + esc(t("启用")) + '</em></label>' +
+      '<span class="hook-foot-lab">' + esc(t("超时（秒）")) + '</span>' +
+      '<input class="hook-timeout" type="number" min="1" max="120" value="' + Number(h.timeout_s || 10) + '" data-hf="timeout_s">' +
       '<button type="button" class="ghost small" data-hook-test="' + i + '">' + t("测试") + "</button>" +
+      '<button type="button" class="ghost small" onclick="removeHook(' + i + ')">' + t("删除") + "</button>" +
       '<span class="hint hook-test-out"></span>' +
       "</div></div>";
   }).join("");
@@ -10458,12 +10709,28 @@ async function suStartupCheck() {
 
 /* ---------------------------------------------------------- 页签 & 初始化 */
 const TAB_TITLES = { overview: "概览", tasks: "任务", runs: "运行记录", automation: "自动化", zentao: "禅道 Bug 自动修复", __wxdigest: "群摘要", usage: "用量统计", agents: "本机智能体", models: "模型接入", bindings: "模型调度（可选）", skills: "经验库", knowledge: "知识库", market: "插件市场", orch: "编排设置", data: "数据与备份", appearance: "皮肤", about: "关于与更新" };
-const SET_TABS = new Set(Object.keys(TAB_TITLES));   // 设置导航里的子页（__phone 是弹框，不算）
+const SET_TABS = new Set(Object.keys(TAB_TITLES));   // 全部设置子页（__phone 是弹框，不算）
 
 function tabTitle(name) {
   return t(TAB_TITLES[name]) || t("设置");
 }
 
+/* 左栏两套导航各管哪些页，一律从 index.html 现读——HTML 改了 JS 自动跟上，
+ * 不再各存一份常量、两处漂移：
+ *   .side-quick    快捷导航（概览/运行记录/自动化）→ main 形态：只换主栏内容，左栏任务树不动
+ *   .side-settings 设置导航                        → settings 形态：左栏整体换成设置导航
+ * 同一个页只应挂在其中一边（重复挂就是两处入口）。 */
+function mainPageSubs() {
+  const s = new Set();
+  document.querySelectorAll(".side-quick .qitem").forEach((b) => { if (b.dataset.page) s.add(b.dataset.page); });
+  return s;
+}
+function settingsNavSubs() {
+  const s = new Set();
+  document.querySelectorAll(".side-settings .set-item").forEach((b) => { if (b.dataset.sub) s.add(b.dataset.sub); });
+  return s;
+}
+
 
 
 /* ---------------------------------------------------------- 用量统计 */
@@ -11553,16 +11820,23 @@ function collapseDrawerIfMobile() {
   if (window.innerWidth < 900) document.body.classList.add("side-collapsed");
 }
 
-function switchTab(name) {
+/* 切页：主栏换成目标子页。shell 决定左栏形态——"main" 保持任务树、"settings" 换成
+ * 设置导航，缺省按目标页归哪套导航自动选（见 mainPageSubs/settingsNavSubs）。 */
+function switchTab(name, shell) {
   if (name === "__phone") { openPhoneConnect(); return; }  // 手机连接是弹框，不切页
   if (name === "__guide") { welcomeOpen(); return; }       // 帮助中心是弹层，不切页（设置导航「软件」组）
-  // 导航收进「设置」：进设置后左栏整体换成设置导航，内容铺满
+  // 形态由目标页决定：快捷导航页（概览/运行记录/自动化）走 main——只换主栏内容、
+  // 左栏任务树原地不动；其余页进设置导航。调用方可用 shell 显式覆盖（如已在设置里
+  // 点运行详情，仍要留在设置侧栏）。用户主动进设置时左栏一定会换成设置导航。
+  const inMain = (shell || (mainPageSubs().has(name) ? "main" : "settings")) === "main";
   S.tab = name;
-  if (SET_TABS.has(name)) localStorage.setItem("orch.setTab", name);
-  document.body.classList.add("settings-mode");
-  document.body.classList.remove("files-mode");   // 文件浏览页与设置导航互斥，别叠在左栏
+  S.mainPage = inMain ? name : "";   // 主栏停在哪个全局页；closeRun 靠它回到点开详情前那一页
+  if (settingsNavSubs().has(name)) localStorage.setItem("orch.setTab", name);
+  document.body.classList.toggle("settings-mode", !inMain);
+  document.body.classList.remove("files-mode");   // 文件浏览页与两套导航都互斥，别叠在左栏
   document.querySelectorAll(".page").forEach((p) => p.classList.toggle("hidden", p.id !== "page-settings"));
-  document.querySelectorAll(".set-item").forEach((b) => b.classList.toggle("active", b.dataset.sub === name));
+  document.querySelectorAll(".set-item").forEach((b) => b.classList.toggle("active", !inMain && b.dataset.sub === name));
+  document.querySelectorAll(".qitem").forEach((b) => b.classList.toggle("active", inMain && b.dataset.page === name));
   document.querySelectorAll("#page-settings .subpage").forEach((d) => d.classList.toggle("hidden", d.id !== "sub-" + name));
   const title = $("page-title");
   if (title) title.textContent = tabTitle(name);
@@ -11587,13 +11861,15 @@ function switchTab(name) {
   syncInspectorVis();    // 检查器只属于任务上下文：进设置子页自动收起
 }
 
-/* 退出设置：左栏恢复任务树，内容回到任务页 */
+/* 退出设置/回到新建任务表单：左栏恢复任务树，主栏回到任务页 */
 function exitSettings() {
   S.tab = "tasks";
+  S.mainPage = "";   // 主栏回到表单：不再是快捷导航页
   stopAutoPoll();   // 离开设置视图：自动化页轮询一并停掉
   document.querySelectorAll(".page").forEach((p) => p.classList.toggle("hidden", p.id !== "page-settings"));
   document.querySelectorAll("#page-settings .subpage").forEach((d) => d.classList.toggle("hidden", d.id !== "sub-tasks"));
   document.querySelectorAll(".set-item").forEach((b) => b.classList.toggle("active", b.dataset.sub === "tasks"));
+  document.querySelectorAll(".qitem").forEach((b) => b.classList.remove("active"));
   document.body.classList.remove("settings-mode");
   document.body.classList.remove("files-mode");
   cmpGreeting();   // 回到任务页：问候语刷新
@@ -11603,10 +11879,12 @@ function exitSettings() {
   syncInspectorVis();    // 回到新建表单：不是任务上下文，检查器收起（点运行详情才会滑回）
 }
 
-/* 侧栏底部齿轮：直接进设置（左栏换成设置导航，不再弹菜单）。回到上次看的那页，默认编排设置 */
+/* 侧栏底部齿轮：直接进设置（左栏换成设置导航，不再弹菜单）。回到上次看的那页，默认编排设置。
+ * 只认设置导航里真实存在的子页——概览/运行记录/自动化已升为快捷导航，落回它们会停在
+ * 一个没有导航项高亮的设置页。 */
 function enterSettings() {
   const saved = localStorage.getItem("orch.setTab") || "";
-  switchTab(SET_TABS.has(saved) ? saved : "orch");
+  switchTab(settingsNavSubs().has(saved) ? saved : "orch", "settings");
 }
 
 window.openRun = openRun;
@@ -11955,10 +12233,11 @@ document.addEventListener("DOMContentLoaded", () => {
     if (e.target.closest("button, summary, .stask")) collapseDrawerIfMobile();
   });
   $("btn-new-task").addEventListener("click", exitSettings);
-  // 主侧栏快捷入口：直达概览 / 自动化 / 插件市场（switchTab 自己会切设置模式并挂载页面）
-  $("btn-q-overview").addEventListener("click", () => switchTab("overview"));
-  $("btn-q-automation").addEventListener("click", () => switchTab("automation"));
-  $("btn-q-market").addEventListener("click", () => switchTab("market"));
+  // 侧栏快捷导航：主栏换成目标页，左栏任务树不动（shell="main"）。
+  // 页面清单以 index.html .side-quick 的 data-page 为准，这里逐项绑 id。
+  $("btn-q-overview").addEventListener("click", () => switchTab("overview", "main"));
+  $("btn-q-runs").addEventListener("click", () => switchTab("runs", "main"));
+  $("btn-q-automation").addEventListener("click", () => switchTab("automation", "main"));
   bindCtxMenus();
   bindInspector();
   if (window.innerWidth < 900) document.body.classList.add("side-collapsed");

package/app/ui/i18n.js

@@ -46,6 +46,16 @@
     "推荐任务类型": "Recommended task type",
     "切换类型": "Switch type",
     "这个需求更适合「{0}」流程，能使用对应的规划与质量门禁。是否切换后执行？": "This request fits the {0} workflow, which provides matching planning and quality gates. Switch before running?",
+    // 自动化卡片上的偏好标签（短名与胶囊面同步取用）
+    "自动": "Auto",
+    "快速": "Fast",
+    "专家": "Expert",
+    "自动推荐": "Auto-recommended",
+    "编排模式：": "Orchestration mode: ",
+    "思考程度：": "Reasoning effort: ",
+    "对话模型：": "Chat model: ",
+    "只对「直接执行」类流程生效；留「自动推荐」时按系统路由挑模型。": "Applies only to the Direct execution workflow; leave it on Auto-recommended to let routing pick the model.",
+    "选择对话模型前请先选厂商": "Choose a provider before picking a chat model",
 
     // —— 引擎/角色 ——
 
@@ -758,6 +768,16 @@
     "评审维度（逗号分隔，可自定义）": "Review dimensions (comma-separated; custom OK)",
     "连载模式：章节数（空 = 单稿件一次成文）": "Serial: chapters (blank = single draft)",
     "每章约字数": "Approx. words per chapter",
+    // —— 分卷（卷结构：大纲规划 / 写作注入 / 成书分割 / UI 分组）——
+    "分卷：每卷章数（空 = 不分卷）": "Volumes: chapters per volume (blank = no volumes)",
+    "分卷：指定卷结构（可选，优先于每卷章数）": "Volumes: explicit structure (optional; overrides chapters per volume)",
+    "例：20（卷边界按全书章号自动推导）": "e.g. 20 (boundaries derived from book-wide chapter numbers)",
+    "例：第一卷 少年初入江湖 20章；第二卷 风云再起 16章": "e.g. Vol 1 The Young Wanderer 20 ch; Vol 2 Storm Rising 16 ch",
+    "每卷一行或分号分隔：卷名 + 章数（或第1-20章）。也可以在任务目标里直接这样写，会自动识别": "One per line or separated by semicolons: volume name + chapter count (or ch.1-20). You can also write this in the task goal — it is detected automatically.",
+    "分卷：每卷章数（留空 = 不分卷）": "Volumes: chapters per volume (blank = no volumes)",
+    "卷": "Vol",
+    "未分卷": "No volumes",
+    "其他文件": "Other files",
     "实现者": "Implementer",
     "评审组": "Reviewers",
     "管理": "Manage",
@@ -2516,7 +2536,9 @@
     });
     // 编排 pill 短名取自 option 文本，重译后要跟着换语言
     if (typeof window.syncCmpSelFace === "function") {
-      ["f-mode", "f-thinking"].forEach((id) => window.syncCmpSelFace(id));
+      // au-* 是自动化弹框里的偏好胶囊：弹框未开时这两个 id 不在 DOM 里，
+      // syncCmpSelFace 对缺失元素直接返回，无需额外守卫
+      ["f-mode", "f-thinking", "au-mode", "au-thinking"].forEach((id) => window.syncCmpSelFace(id));
     }
     if (typeof window.cmpDirectBtnSync === "function") {
       window.cmpDirectBtnSync();   // 「自动推荐/推荐」等词也要换语言

package/app/ui/index.html

@@ -114,19 +114,22 @@
         <span class="ss-label" data-i18n="搜索">搜索</span>
         <span class="kbd" aria-hidden="true">Ctrl K</span>
       </button>
+      <!-- 快捷导航：只放最常用的全局页（data-page 是页面 id 真源）。
+           点它们只换主栏内容，左栏任务树原地不动（app.js switchTab 的 main 形态）；
+           对应入口已从下面设置导航移除，同一页不再两处重复。 -->
       <div class="side-quick">
-        <button class="qitem" id="btn-q-overview" title="概览" data-i18n-title="概览">
+        <button class="qitem" id="btn-q-overview" data-page="overview" title="概览" data-i18n-title="概览">
           <svg class="ico" aria-hidden="true"><use href="#i-gauge"></use></svg>
           <span data-i18n="概览">概览</span>
         </button>
-        <button class="qitem" id="btn-q-automation" title="自动化" data-i18n-title="自动化">
+        <button class="qitem" id="btn-q-runs" data-page="runs" title="运行记录" data-i18n-title="运行记录">
+          <svg class="ico" aria-hidden="true"><use href="#i-history"></use></svg>
+          <span data-i18n="运行记录">运行记录</span>
+        </button>
+        <button class="qitem" id="btn-q-automation" data-page="automation" title="自动化" data-i18n-title="自动化">
           <svg class="ico" aria-hidden="true"><use href="#i-calendar-days"></use></svg>
           <span data-i18n="自动化">自动化</span>
         </button>
-        <button class="qitem" id="btn-q-market" title="插件市场" data-i18n-title="插件市场">
-          <svg class="ico" aria-hidden="true"><use href="#i-blocks"></use></svg>
-          <span data-i18n="插件市场">插件市场</span>
-        </button>
       </div>
       <div class="side-section tasks">
         <div class="side-label-row">
@@ -178,12 +181,9 @@
       <button id="btn-set-back" class="set-back" data-i18n="返回 CodeBee">
         <svg class="ico" aria-hidden="true"><use href="#i-arrow-left"></use></svg>返回 CodeBee
       </button>
-      <div data-i18n="工作台" class="set-group">工作台</div>
-      <button class="set-item" data-sub="overview" data-i18n="概览"><svg class="ico" aria-hidden="true"><use href="#i-gauge"></use></svg>概览</button>
+      <!-- 概览 / 运行记录 / 自动化已升为左栏快捷导航（见 .side-quick），此处不再重复挂条目 -->
       <div data-i18n="编排" class="set-group">编排</div>
       <button class="set-item active" data-sub="tasks" data-i18n="任务"><svg class="ico" aria-hidden="true"><use href="#i-tasks"></use></svg>任务</button>
-      <button class="set-item" data-sub="runs" data-i18n="运行记录"><svg class="ico" aria-hidden="true"><use href="#i-history"></use></svg>运行记录</button>
-      <button class="set-item" data-sub="automation" data-i18n="自动化"><svg class="ico" aria-hidden="true"><use href="#i-calendar-days"></use></svg>自动化</button>
       <button class="set-item" data-sub="hooks" data-i18n="钩子"><svg class="ico" aria-hidden="true"><use href="#i-link"></use></svg>钩子</button>
       <button class="set-item" data-sub="__wxdigest" data-i18n="微信群聊汇报"><svg class="ico" aria-hidden="true"><use href="#i-bee"></use></svg>微信群聊汇报</button>
       <button class="set-item" data-sub="zentao" data-i18n="禅道"><svg class="ico" aria-hidden="true"><use href="#i-search"></use></svg>禅道</button>
@@ -436,7 +436,9 @@
                   <div class="field"><label data-i18n="连载模式：章节数（空 = 单稿件一次成文）">连载模式：章节数（空 = 单稿件一次成文）</label><input id="f-chapters" type="number" min="2" max="20" placeholder="例：8（逐章起草+评审+修订）" data-i18n-ph="例：8（逐章起草+评审+修订）"></div>
                   <div class="field"><label data-i18n="每章约字数">每章约字数</label><input id="f-words-per-ch" type="number" min="500" max="8000" step="100" placeholder="例：2500" data-i18n-ph="例：2500"></div>
                   <div class="field"><label data-i18n="同章赛马稿件数">同章赛马稿件数</label><input id="f-variants" type="number" min="1" max="3" step="1" placeholder="1 = 关闭（2-3 每章多稿择优，更贵）" data-i18n-ph="1 = 关闭（2-3 每章多稿择优，更贵）"></div>
+                  <div class="field"><label data-i18n="分卷：每卷章数（空 = 不分卷）">分卷：每卷章数（空 = 不分卷）</label><input id="f-vol-chapters" type="number" min="2" max="200" step="1" placeholder="例：20（卷边界按全书章号自动推导）" data-i18n-ph="例：20（卷边界按全书章号自动推导）"></div>
                 </div>
+                <div class="field" id="f-vol-spec-field"><label data-i18n="分卷：指定卷结构（可选，优先于每卷章数）">分卷：指定卷结构（可选，优先于每卷章数）</label><input id="f-vol-spec" placeholder="例：第一卷 少年初入江湖 20章；第二卷 风云再起 16章" data-i18n-ph="例：第一卷 少年初入江湖 20章；第二卷 风云再起 16章" data-i18n-title="每卷一行或分号分隔：卷名 + 章数（或第1-20章）。也可以在任务目标里直接这样写，会自动识别" title="每卷一行或分号分隔：卷名 + 章数（或第1-20章）。也可以在任务目标里直接这样写，会自动识别"></div>
               </div>
 
               <div id="f-manual-only" class="hidden">

package/app/ui/style.css

@@ -5715,13 +5715,17 @@ button.request-busy > * { opacity: .18; }
 
 /* 钩子管理卡片（设置 → 钩子，2026-09-22）：名称/事件/开关一行，命令整行，
  * 底部超时+测试。mono 字体命令输入便于读路径 */
-.hook-card .hook-head { display: flex; align-items: center; gap: 10px; }
-.hook-card .hook-head .hook-name { flex: 1 1 140px; min-width: 0; }
-.hook-card .hook-head .hook-event { flex: none; }
-.hook-card .hook-cmd { width: 100%; margin-top: 10px; font-family: var(--mono); font-size: 12px; }
-.hook-card .hook-foot { display: flex; align-items: center; gap: 8px; margin-top: 10px; }
-.hook-card .hook-timeout { width: 64px; }
-.hook-card .hook-test-out { flex: 1 1 auto; min-width: 0; overflow: hidden;
+.hook-card { display: flex; flex-direction: column; gap: 10px; }
+.hook-card .hook-row { display: flex; align-items: center; gap: 10px; }
+.hook-card .hook-name { flex: 1 1 auto; min-width: 180px; }
+.hook-card .hook-event { flex: none; width: 150px; }
+.hook-card .hook-cmd { width: 100%; box-sizing: border-box; font-family: var(--mono); font-size: 12px; }
+.hook-card .hook-foot { flex-wrap: wrap; }
+.hook-card .hook-foot .switch { display: inline-flex; align-items: center; gap: 6px; }
+.hook-card .hook-foot .switch em { font-style: normal; font-size: 12.5px; color: var(--muted); }
+.hook-card .hook-foot-lab { font-size: 12.5px; color: var(--muted); }
+.hook-card .hook-timeout { width: 64px; flex: none; }
+.hook-card .hook-test-out { flex: 1 1 160px; min-width: 0; overflow: hidden;
   text-overflow: ellipsis; white-space: nowrap; }
 .hook-card .switch { display: inline-flex; align-items: center; cursor: pointer; }
 .hook-card .switch input { appearance: none; width: 34px; height: 19px; border-radius: 999px;
@@ -5868,3 +5872,16 @@ button.request-busy > * { opacity: .18; }
   .kpi.has-spark .kpi-s { padding-right: 0; }
 }
 
+
+/* 分卷：章节评审卡按卷分组（.ch-vol 卷头 + 卷内容器）。卷头是一条细分隔线
+ * 加卷名/卷内达标数/章号区间；不分卷时完全不渲染，视觉与分卷前一致。 */
+.ch-vol { margin: 10px 0 14px; }
+.ch-vol-head { display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
+  padding: 4px 2px 6px; border-bottom: 1px solid var(--border, rgba(128,128,128,.22)); }
+.ch-vol-head b { font-size: 13px; letter-spacing: .01em; }
+.ch-vol > .ch-row { margin: 6px 0 0 10px; }
+
+/* 分卷：发布页章节清单按卷分组（.pb-vol 卷头 + 其下章节按钮）。 */
+.pb-vol { margin: 8px 0 12px; }
+.pb-vol-head { font-size: 12.5px; color: var(--muted); padding: 2px 2px 6px;
+  border-bottom: 1px solid var(--border, rgba(128,128,128,.22)); margin-bottom: 6px; }

package/package.json

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