@oh-story/dsh 0.1.9 → 0.1.10

package/lib/oh-story/skills/story-long-write/scripts/build_writer_prompt.py

@@ -2,7 +2,12 @@
 """build_writer_prompt.py — 确定性组装 narrative-writer 的 spawn prompt 骨架。
 
 用法:
-    python build_writer_prompt.py --project <书目录> --chapter N [--out <文件>]
+    python build_writer_prompt.py --project <书目录> --chapter N [--out [<文件>]]
+
+`--out` 不带路径时留档到本章工作目录 `<书目录>/.story/work/第NNN章/writer_prompt.md`。
+分组 segment、prompt 留档和逐章事务 JSON 都只放这个书内工作目录——不写系统 /tmp
+（多本书/多会话同章号会互相覆盖，Windows 也没有 /tmp），也不写进 正文/（会被当成章节）。
+`storyctl.py chapter commit` 成功后自动删除该章工作目录。
 
 跑在「写前准备」第一步。stdout 分两区，`===` 分隔线以上是 prompt 正文
 （主会话照抄，空槽以外一字不改），以下是核对报告（不进 prompt）。
@@ -10,8 +15,9 @@
 职责边界:
 - 脚本做确定性部分：固定首行、定位、标题行字面量、细纲指针、文风全文路径与裁决、
   上一章结尾、降档判定与情绪/节奏槽、固定块指针。
+- 脚本代查作者记忆（prose_style + story_design）并填好 author_preferences。
 - 主会话填八槽：执行安排 / 本章意图 / 参考技法 / 本节速记 / 涉及角色 / genre_prose_card /
-  必读设定 / author_preferences。降档不成立时情绪与节奏槽也归主会话。
+  必读设定 / style_resolution。降档不成立时情绪与节奏槽也归主会话。
   材料槽对应原流程步骤 3「写前准备」的四项输出（本节速记 / 情绪目标 / 涉及角色 /
   参考技法）加上题材卡、设定补漏与作者偏好——都是判断，脚本做不了。
 - 续写状态卡校验后由主会话筛选，在「本节速记」槽内写入本章需要的状态。
@@ -23,7 +29,9 @@ Exit: 0 = 骨架已输出；2 = 输入缺失或无效。
 
 import argparse
 import io
+import json
 import re
+import subprocess
 import sys
 from pathlib import Path
 from outline_view import parse as parse_volume
@@ -31,6 +39,13 @@ from outline_view import parse as parse_volume
 TAIL_CHARS = 400          # 上一章结尾注入的目标字符数（按整行回退，不切半句）
 STATE_SECTIONS = ("当前位置", "长期约束", "核心角色状态", "活跃伏笔", "近三章速记", "下一章承诺", "连贯性风险")
 SLOT_MARK = "［主会话填］"
+WORK_ROOT = (".story", "work")
+
+
+def chapter_work_dir(project: Path, chapter: int) -> Path:
+    """本章临时文件的唯一落点；与 storyctl.py 提交后清理的目录同一口径。"""
+    width = max(3, len(str(chapter)))
+    return project.joinpath(*WORK_ROOT, f"第{chapter:0{width}d}章")
 
 
 def read_text(path: Path):
@@ -58,7 +73,7 @@ def find_chapter_file(directory: Path, chapter: int, prefix: str):
         return None
     pattern = re.compile(rf"^{prefix}第0*{chapter}章.*\.md$")
     for entry in sorted(directory.iterdir()):
-        if entry.is_file() and pattern.match(entry.name):
+        if entry.is_file() and pattern.match(entry.name) and "_原稿_" not in entry.name:
             return entry
     return None
 
@@ -125,6 +140,83 @@ def previous_chapter_tail(project: Path, chapter: int):
     return prev, "\n".join(reversed(picked))
 
 
+MEMORY_KINDS = ("prose_style", "story_design")
+# 限定「流程」的作者记忆里，这些取值指的就是长篇写正文。
+LONG_WRITE_WORKFLOWS = {"长篇", "长篇写作", "写长篇", "长篇连载", "长篇网文", "长篇正文", "story-long-write"}
+
+
+def scoped_memory_values(workspace: Path):
+    """项目级 store 里限定题材／流程的 active 条目取值：{"genre": {...}, "workflow": {...}}。"""
+    values = {"genre": set(), "workflow": set()}
+    state = read_text(workspace / ".story" / "作者记忆" / "_author-memory-state.json")
+    try:
+        items = (json.loads(state) if state else {}).get("items") or {}
+        items = list(items.values())
+    except (ValueError, AttributeError, TypeError):
+        return values
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        scope = item.get("scope") if isinstance(item.get("scope"), dict) else {}
+        if (item.get("status") == "active" and item.get("kind") in MEMORY_KINDS
+                and scope.get("level") in values and scope.get("value")):
+            values[scope["level"]].add(scope["value"])
+    return values
+
+
+def book_genres(project: Path):
+    """「题材类型」行按分隔符切成词；未填的模板占位（{…}）不算。"""
+    text = read_text(project / "设定" / "题材定位.md") or ""
+    match = re.search(r"^[ \t]*[-*+]?[ \t]*\**题材(?:类型)?\**[ \t]*[：:](.*)$", text, re.M)
+    if not match or "{" in match.group(1):
+        return set()
+    return {word.casefold() for word in re.split(r"[\W_丨×]+", match.group(1)) if word}
+
+
+def query_author_memory(project: Path):
+    """代主会话做写正文那一次作者记忆查询（prose_style + story_design，每次 ≤2KB）。
+
+    工作区取书目录及其祖先里第一个带 `.story-deployed` 的目录；找不到就把书目录当工作区。
+    限定题材的条目只在取值出现在本书「题材类型」里时代查，限定流程的只认长篇写作的取值；
+    其余限定条目不猜，报给主会话自己判断。
+    返回 (条目列表, 超编 ID 列表, 未代查的限定取值, 错误)；错误时由主会话按 author-memory.md 手动查询。
+    """
+    workspace = next((d for d in (project, *project.parents) if (d / ".story-deployed").is_file()), project)
+    script = Path(__file__).with_name("author_memory_commit.py")
+    if not script.is_file():
+        return None, [], {}, "author_memory_commit.py 缺失"
+    scoped = scoped_memory_values(workspace)
+    book = book_genres(project)
+    genres = sorted(v for v in scoped["genre"] if v.casefold() in book) or [None]
+    workflows = sorted(v for v in scoped["workflow"] if v.casefold() in {w.casefold() for w in LONG_WRITE_WORKFLOWS})
+    skipped = {"genre": sorted(v for v in scoped["genre"] if v not in genres),
+               "workflow": sorted(v for v in scoped["workflow"] if v not in workflows)}
+    items, omitted, seen = [], [], set()
+    for genre in genres:
+        for workflow in workflows or [None]:
+            command = [sys.executable, str(script), "query", "--workspace", str(workspace), "--book-root", str(project)]
+            for kind in MEMORY_KINDS:
+                command += ["--kind", kind]
+            if genre:
+                command += ["--genre", genre]
+            if workflow:
+                command += ["--workflow", workflow]
+            completed = subprocess.run(command, capture_output=True, text=True, encoding="utf-8", check=False)
+            try:
+                result = json.loads(completed.stdout or "{}")
+            except ValueError:
+                result = {}
+            if not result.get("ok"):
+                return None, [], {}, result.get("error") or completed.stderr.strip() or "query 失败"
+            for item in result.get("items") or []:
+                if item.get("id") not in seen:
+                    seen.add(item.get("id"))
+                    items.append(item)
+            omitted += [i for i in result.get("omitted_ids") or [] if i not in omitted and i not in seen]
+    omitted = [i for i in omitted if i not in seen]
+    return items, omitted, {k: v for k, v in skipped.items() if v}, None
+
+
 def learn_heading_form(project: Path, chapter: int, title: str):
     """从已有正文学标题行形态（层级／章号填充位数／分隔符），不按通用规则推导。
 
@@ -233,7 +325,7 @@ def build(project: Path, chapter: int, report: list):
         parts.append(
             "——— 文风 ———\n"
             "（本书无可用的 设定/文风.md，未进入自定义文风模式；"
-            "按 workflow-chapter 3(d) 走对标文风召回，由主会话补路径与召回指令）")
+            "按 benchmark-recall.md 走对标文风召回，由主会话补路径与召回指令）")
         report.append("文风：custom_style=false，文风召回归主会话（未跳过，留标题）")
 
     # ---- 上一章结尾（不给路径，避免写手回头读整章）----
@@ -296,15 +388,18 @@ def build(project: Path, chapter: int, report: list):
     else:
         slot_recall = ("——— 情绪与节奏召回 ———\n"
                        f"{SLOT_MARK} 降档不成立（" + "、".join(why) +
-                       "），按 workflow-chapter 3(a)(b)(e)(f) 走全量召回后填此槽")
+                       "），按 benchmark-recall.md 走全量召回后填此槽")
         report.append("召回降档：不成立（" + "、".join(why) + "）—— 全量召回归主会话")
 
     # ---- 需要主会话判断的槽位 ----
+    work_dir = chapter_work_dir(project, chapter)
     parts.append(
         "——— 执行安排 ———\n"
         f"{SLOT_MARK} 全章细纲用于整体编排。默认按自然转场或因果停顿分前后两组，"
-        "填写当前组的情节点/片段及临时输出路径；先只写前组，父流程测一次 checkpoint 后"
-        "再给后组和机器剩余区间。只有用户明确要求一次成文时才填「全章，直接写最终路径」。")
+        "填写当前组的情节点/片段；先只写前组，父流程测一次 checkpoint 后"
+        "再给后组和机器剩余区间。只有用户明确要求一次成文时才填「全章，直接写最终路径」。\n"
+        f"分组临时文件：前组 {work_dir / '前组.md'}，后组 {work_dir / '后组.md'}"
+        "（只写这里，不写 /tmp 或 正文/）。")
     parts.append(f"——— 本章意图（一句话）———\n{SLOT_MARK}")
     parts.append(slot_recall)
     # 伏笔与卷级禁忌走「主会话筛选后写进速记」这条原设计路线（步骤 3 状态筛选），
@@ -312,7 +407,7 @@ def build(project: Path, chapter: int, report: list):
     # 代价是它依赖主会话逐章想起来，所以这里把提示语写成写死的三问清单。
     parts.append(
         "——— 参考技法 ———\n"
-        f"{SLOT_MARK} 步骤 3 三问的第 ②③ 问：借鉴哪个参考文件的哪个技法、用在哪些段落。"
+        f"{SLOT_MARK} 借鉴哪个参考文件的哪个技法、用在哪些段落；没有就写「无」。"
         "按 reference 表的任务条件读取；本书文风只覆盖冲突表达条款，不停读整份文件。")
     parts.append(
         "——— 本节速记 ———\n"
@@ -328,15 +423,33 @@ def build(project: Path, chapter: int, report: list):
     parts.append("——— 题材正文提示卡（genre_prose_card，只含本章相关条目）———\n"
                  f"{SLOT_MARK} 主题材抽 3-5 条、辅题材 1-2 条；只作内部校准，不进正文")
     parts.append(slot_setting)
-    parts.append("——— style_resolution / author_preferences ———\n"
-                 f"{SLOT_MARK} author_memory query 命中本章的 prose_style/story_design 项；"
-                 "query 显式传本书/题材/流程；偏好是低优先级倾向，无则写「无」。附 style_resolution：生效要求及来源、被覆盖的默认条款和事实边界；同一裁决传去味与审稿，不逐条追求命中。")
-
-    parts.append("检查分工：写手负责编排、内容覆盖和格式自检；父流程质量阶段负责语义去味及最终文件扫描。写手不提前重复整轮去味或相同检查链，保留时空表、新增申报与原定交付。")
+    items, omitted, skipped, memory_error = query_author_memory(project)
+    if memory_error:
+        memory_block = (f"{SLOT_MARK} 组装脚本查询作者记忆失败（{memory_error}），"
+                        "按 author-memory.md 手动 query prose_style + story_design 后填入；无则写「无」")
+        report.append(f"作者记忆：脚本查询失败——{memory_error}，归主会话手动查询")
+    elif items:
+        memory_block = "\n".join(f"- {item.get('assertion', '').strip()}（{item.get('id', '')}）" for item in items)
+        report.append(f"作者记忆：已注入 {len(items)} 条" + (
+            f"；超编未装下 {len(omitted)} 条（{'、'.join(omitted)}），转告作者建议「整理作者记忆」" if omitted else ""))
+    else:
+        memory_block = "无"
+        report.append("作者记忆：无相关 active 条目")
+    if skipped and not memory_error:
+        named = "；".join(f"{'题材' if k == 'genre' else '流程'}：{'、'.join(v)}" for k, v in skipped.items())
+        memory_block += (f"\n{SLOT_MARK} 另有限定范围的作者记忆未代查（{named}）：本书适用的，"
+                         "按 author-memory.md 带 --genre／--workflow 查询后补进本块")
+        report.append(f"作者记忆：限定范围未代查（{named}），归主会话判断是否适用")
+    parts.append("——— author_preferences（作者记忆，低优先级倾向，不逐条追求命中）———\n" + memory_block)
+    parts.append("——— style_resolution ———\n"
+                 f"{SLOT_MARK} 本轮请求里作者对表达的明确要求及其覆盖的默认条款（没有写「无」）；"
+                 "本书文风与作者记忆的裁决见上方各块，同一裁决传去味与审稿。")
+
+    parts.append("检查分工：写手负责编排、内容覆盖和格式自检；父流程质量阶段负责语义去味及最终文件扫描。写手不提前重复整轮去味或相同检查链，保留情节点落点、新增申报与原定交付。")
 
     # ---- 固定块：压成指针，不重述 agent 定义 ----
     parts.append(
-        "本次照你的铁律 1-8 与被调用协议执行（细纲优先边界、正文形状、新增物三档、"
+        "本次照你的铁律 1-8 与被调用协议执行（细纲优先边界、正文形状、新增物三级、"
         "阅读体验字段、交付三附件均以你的定义为准，此处不重述）。")
     parts.append(
         "字数目标按细纲执行，字数口径 visible_chars_v1；按执行安排交付，"
@@ -360,7 +473,8 @@ def main(argv=None):
     parser = argparse.ArgumentParser()
     parser.add_argument("--project", required=True)
     parser.add_argument("--chapter", required=True, type=int)
-    parser.add_argument("--out", default=None)
+    parser.add_argument("--out", nargs="?", const="", default=None,
+                        help="prompt 留档路径；不带值时留档到本章工作目录 writer_prompt.md")
     args = parser.parse_args(argv)
 
     project = Path(args.project).resolve()
@@ -391,9 +505,16 @@ def main(argv=None):
             f"标题预检：《{title}》" + ("与既有章重名 → " + "、".join(clashes)
                                        if clashes else "无重名"))
 
-    if args.out:
-        io.open(args.out, "w", encoding="utf-8", newline="\n").write(prompt)
-        report.append(f"留档：{args.out}")
+    if args.out is not None:
+        out = Path(args.out) if args.out else chapter_work_dir(project, args.chapter) / "writer_prompt.md"
+        try:
+            out.parent.mkdir(parents=True, exist_ok=True)
+            with io.open(out, "w", encoding="utf-8", newline="\n") as handle:
+                handle.write(prompt)
+        except OSError as exc:
+            sys.stderr.write(f"留档写入失败：{out}（{exc}）\n")
+            return 2
+        report.append(f"留档：{out}")
 
     sys.stdout.write(prompt)
     sys.stdout.write("\n" + "=" * 60 + "\n")

package/lib/oh-story/skills/story-long-write/scripts/check-outline-contract.js

@@ -18,11 +18,13 @@
 const fs = require('fs')
 const path = require('path')
 
-// 权威模板：references/workflow-setup.md「细纲（全书每章）」
+// 权威模板：references/workflow-setup.md「排纲自查与细纲」里的细纲模板
+// 必填只留有证据或事故撑腰的核心字段；阶段位置、章节定位、结构公式、本章标价、闭环状态、
+// 写手自由区、契约风险、镜头准入、信息差触发点与「分辨率」列是可选的阅读体验字段——
+// 写了照样消费，没写不拦（#383 隔离实验：只补目标情绪与主角目标就复现了补满全部字段的收益）。
 const FIELDS = [
-  '核心事件', '字数目标', '字数口径', '阶段位置', '单元ID/位置', '目标情绪',
-  '主角目标/关键选择', '章节定位', '本章结构公式', '章首钩子', '爽点',
-  '本章标价', '闭环状态', '本章禁止提前释放', '写手自由区', '契约风险',
+  '核心事件', '字数目标', '字数口径', '单元ID/位置', '目标情绪',
+  '主角目标/关键选择', '章首钩子', '爽点', '本章禁止提前释放',
 ]
 const SUBSECTIONS = ['内容概括', '情节安排', '人物关系和出场顺序', '情节细化']
 const FIVE_ACT = ['起因', '发展', '转折', '高潮', '结尾']
@@ -101,7 +103,7 @@ function checkSettingRefs(text, name, file, projectRoot) {
     name,
     missing.length ? `引用的路径不是可用文件：${missing.join('、')}` : `${refs.size} 处项目内引用全部存在`,
     '细纲引用的每个项目内 .md 文件都真实存在——不许把槽位指向查无实据的权威文件',
-    '修正引用路径；或按「创作自主权分级」先把缺的设定落档（B 级直接补、C 级进《供给单》提案），再在细纲引用。'
+    '修正引用路径；或按新增物三级先把缺的设定落档（「写了要报」直接补并登记、「先问作者」进排纲底稿的供给自查提案），再在细纲引用。'
   )
 }
 
@@ -173,8 +175,8 @@ function verify(file, projectRoot = null) {
   let header = null
   for (const line of lines) {
     const cells = parseTableRow(line)
-    // 四列是旧表（# / 情节点 / 功能标签 / 执行边界），五列是现行模板（中间多一列「分辨率」）。
-    // 两种都收：功能标签固定在第 3 列，执行边界一律取最后一列，旧细纲不因加列而失效。
+    // 现行模板默认四列（# / 情节点 / 功能标签 / 执行边界（禁＋放）），需要时在功能标签后加「分辨率」列成五列。
+    // 两种都收：功能标签固定在第 3 列，执行边界一律取最后一列。
     if (cells && (cells.length === 4 || cells.length === 5) && PLOT_HEADER_FIRST.test(cells[0])) {
       header = cells
       break
@@ -189,21 +191,21 @@ function verify(file, projectRoot = null) {
     headerOk,
     name,
     header ? `表头：${header.join(' | ')}` : '未找到 | # | 情节点 | 功能标签 | [分辨率] | 执行边界 | 表头',
-    '情节细化使用五列表格：# / 情节点（谁做了什么） / 功能标签 / 分辨率 / 执行边界（四列旧表仍收，但新建细纲按五列模板走）',
-    '只把情节点序列改成五列表格，逐点补功能标签、分辨率与执行边界；不增删情节点本身。'
+    '情节细化使用表格：# / 情节点（谁做了什么） / 功能标签 / 执行边界（禁＋放）；需要时可在功能标签后加「分辨率」列',
+    '只把情节点序列改成这张表，逐点补功能标签与执行边界；不增删情节点本身。'
   ))
 
-  // 「放」半边：五列表的执行边界必须至少一个点解除限制（模板既有要求），
-  // 全是禁令的情节点表实测会把整章压成同一个温度（015 章十一个点全「不许」）。
-  if (headerOk && header.length === 5) {
+  // 「放」半边：五列表或表头写明「禁＋放」的四列表，执行边界必须至少一个点解除限制，
+  // 全是禁令的情节点表实测会把整章压成同一个温度（015 章十一个点全「不许」）。表头没写「禁＋放」的四列表不追溯。
+  if (headerOk && (header.length === 5 || /放/.test(header[header.length - 1]))) {
     const rows = []
     for (const line of lines) {
       const cells = parseTableRow(line)
-      if (cells && cells.length === 5 && /^\d+$/.test(cells[0])) rows.push(cells)
+      if (cells && cells.length === header.length && /^\d+$/.test(cells[0])) rows.push(cells)
     }
     if (rows.length) {
       const released = rows.filter((cells) => {
-        const match = cells[4].match(/(?:^|[。；;\s])放\s*[：:]([^]*?)(?=(?:禁|放)\s*[：:]|$)/)
+        const match = cells[cells.length - 1].match(/(?:^|[。；;\s])放\s*[：:]([^]*?)(?=(?:禁|放)\s*[：:]|$)/)
         if (!match) return false
         const value = match[1].replace(/[\s。；;，,、\[\]【】]/g, '')
         return value.length > 0 && !/^(?:无|暂无|待补充|待定|无缺口)$/.test(value)
@@ -303,8 +305,24 @@ function resolveChapter(project, chapter) {
   return { file: path.join(dir, hit) }
 }
 
-// --supply：批末验证《供给单》已落卷纲——定位单元卡块，确认其中有「供给自查」小节。
+// --supply：批末验证供给自查已落盘。新书写在卷纲旁的 排纲底稿_{单元ID}.md；老卷纲写在单元卡块内。
+function hasSupplyHeading(text) {
+  return text.split(/\r?\n/).some((line) => {
+    const heading = line.replace(/\*\*/g, '').match(/^#{1,6}\s+(.+)$/)
+    return Boolean(heading) && /^供给自查(?:\s|[（(]|$)/.test(heading[1])
+  })
+}
+
 function verifySupply(volumeFile, unitId) {
+  const draftFile = path.join(path.dirname(volumeFile), `排纲底稿_${unitId}.md`)
+  const draft = readUtf8(draftFile)
+  if (draft.ok) {
+    const ok = hasSupplyHeading(draft.text)
+    return {
+      schema_version: 1, verifier: 'story-long-write.outline-supply', file: path.resolve(draftFile), unit: unitId, ok,
+      evidence: ok ? '排纲底稿含「供给自查」小节' : `${path.basename(draftFile)} 里没有「供给自查」小节——每批出细纲前须做供给自查（含「无缺口」情形），见 workflow-setup.md「排纲自查与细纲」步骤 3`,
+    }
+  }
   const read = readUtf8(volumeFile)
   if (!read.ok) {
     return { schema_version: 1, verifier: 'story-long-write.outline-supply', file: path.resolve(volumeFile), unit: unitId, ok: false, evidence: read.error || '卷纲文件为空' }
@@ -345,7 +363,7 @@ function verifySupply(volumeFile, unitId) {
     file: path.resolve(volumeFile),
     unit: unitId,
     ok,
-    evidence: ok ? '单元卡含「供给自查」小节' : `剧情单元 ${unitId} 的卡内没有「供给自查」小节——每批出细纲前须产出《供给单》（含「无缺口」情形），见 workflow-setup.md「按剧情批出细纲」步骤 3`,
+    evidence: ok ? '单元卡含「供给自查」小节' : `没有 排纲底稿_${unitId}.md，剧情单元 ${unitId} 的卡内也没有「供给自查」小节——每批出细纲前须做供给自查（含「无缺口」情形），见 workflow-setup.md「排纲自查与细纲」步骤 3`,
   }
 }
 

package/lib/oh-story/skills/story-long-write/scripts/outline_view.py

@@ -217,9 +217,11 @@ def main():
     parser.add_argument("--check", action="store_true")
     parser.add_argument("--history", action="store_true")
     parser.add_argument("--strict", action="store_true", help="新建卷纲校验：缺作用域也视为错误")
-    parser.add_argument("--stage", choices=["outline", "write"], default="outline",
-                        help="outline＝排纲档（带在用批次底稿）；"
-                             "write＝写作档（只要卷级常任＋单元级，底稿一概不给）")
+    # 排纲底稿现在放在卷纲外的 大纲/排纲底稿_{单元ID}.md，默认输出就是写作要的闭包。
+    # --stage outline 只为老卷纲保留：它们的供给自查等底稿还写在卷纲里（作用域：批次底稿）。
+    parser.add_argument("--stage", choices=["outline", "write"], default="write",
+                        help="write（默认）＝卷级常任＋单元级；"
+                             "outline＝另带老卷纲里仍在用的批次底稿段")
     args = parser.parse_args()
 
     if hasattr(sys.stdout, "reconfigure"):

package/lib/oh-story/skills/story-long-write/scripts/storyctl.py

@@ -30,6 +30,9 @@ for _name in dir(core):
 
 CHAPTER_CHECK_SCHEMA = "story-chapter-check/v1"
 CHAPTER_ERROR_SCHEMA = "story-chapter-error/v1"
+# 书内工作目录：分组 segment、writer prompt 留档、逐章事务 JSON 的唯一落点。
+# 与 build_writer_prompt.py 同一口径；提交成功后整目录删除，失败时原样保留供重跑。
+WORK_ROOT = (".story", "work")
 
 
 class CliArgumentError(ValueError):
@@ -72,6 +75,32 @@ def _read_json_object(path: Path, label: str) -> dict[str, Any]:
     return value
 
 
+def chapter_work_dir(project: Path, chapter: int) -> Path:
+    width = max(3, len(str(chapter)))
+    return project.resolve().joinpath(*WORK_ROOT, f"第{chapter:0{width}d}章")
+
+
+def _remove_chapter_work_dir(project: Path, chapter: int) -> str | None:
+    """Delete this chapter's scratch directory after a successful commit.
+
+    Only the per-chapter directory is removed; `.story/work` and `.story` are
+    pruned only when empty, so book-level author memory under `.story/` stays.
+    """
+    path = chapter_work_dir(project, chapter)
+    if path.is_symlink():
+        path.unlink()
+    elif path.is_dir():
+        shutil.rmtree(path)
+    else:
+        return None
+    for parent in (path.parent, path.parent.parent):
+        try:
+            parent.rmdir()
+        except OSError:
+            break
+    return "/".join((*WORK_ROOT, path.name))
+
+
 def _project_files(project: Path, chapter: int) -> tuple[Path, Path, int]:
     root = project.resolve()
     outline = find_chapter_file(root / "大纲", chapter, outline=True)
@@ -200,6 +229,23 @@ def chapter_check(project: Path, chapter: int) -> dict[str, Any]:
     }
 
 
+def fix_punctuation(project: Path, chapter: int) -> bool:
+    """Run the deterministic punctuation normalizer on the chapter body in place.
+
+    Folding it into `chapter check --fix-punctuation` lets the parent flow close a
+    chapter with one call instead of running each cleanup script separately.
+    """
+    _, body, _ = _project_files(project, chapter)
+    node = shutil.which("node")
+    script = Path(__file__).with_name("normalize-punctuation.js")
+    if node is None or not script.is_file():
+        return False  # chapter check reports TOOL_UNAVAILABLE as a blocking finding
+    before = body.read_bytes()
+    subprocess.run([node, str(script), str(body)], text=True, encoding="utf-8",
+                   capture_output=True, check=False)
+    return body.read_bytes() != before
+
+
 def chapter_commit(project: Path, chapter: int, input_path: Path, *, accept_current_length: bool) -> dict[str, Any]:
     checked = chapter_check(project, chapter)
     require(checked["quality"]["status"] == "pass", "blocking quality findings must be fixed before commit")
@@ -220,6 +266,12 @@ def chapter_commit(project: Path, chapter: int, input_path: Path, *, accept_curr
     checked["tracking_committed"] = state["last_committed_chapter"] >= chapter
     checked["next_chapter_started"] = state["last_committed_chapter"] > chapter
     checked["wordcount"] = state["wordcount_records"].get(str(chapter))
+    # The commit is already durable; a cleanup failure is reported, never turned into a failed commit.
+    try:
+        checked["work_dir_removed"] = _remove_chapter_work_dir(project, chapter)
+    except OSError as exc:
+        checked["work_dir_removed"] = None
+        checked["work_dir_cleanup_error"] = str(exc)
     return checked
 
 
@@ -243,6 +295,9 @@ def _build_parser() -> StructuredArgumentParser:
         subparser.add_argument("--chapter", type=int, required=True)
         if command != "check":
             subparser.add_argument("--input", type=Path, required=True)
+        else:
+            subparser.add_argument("--fix-punctuation", action="store_true",
+                                   help="先就地整理正文标点，再做检查")
     return parser
 
 
@@ -286,7 +341,10 @@ def main(argv: Sequence[str] | None = None) -> int:
         return _wordcount_command(args)
     try:
         if args.chapter_command == "check":
+            fixed = fix_punctuation(args.project, args.chapter) if args.fix_punctuation else None
             result = chapter_check(args.project, args.chapter)
+            if fixed is not None:
+                result["punctuation_fixed"] = fixed
         else:
             result = chapter_commit(
                 args.project, args.chapter, args.input,