@oh-story/dsh 0.1.10 → 0.1.11

package/lib/oh-story/skills/story-import/references/structure-mapping-short.md

@@ -1,6 +1,17 @@
 # 结构迁移映射规则（短篇）
 
-Phase 3-S 短篇结构迁移的详细映射规则。将 `拆文库/{导入书名}/` 短篇拆文产物转换为 `{短篇标题}/` 短篇工程结构，供 `story-short-write` Phase 3 无缝接手续写。
+Phase 3-S 短篇结构迁移只读本文件和 [format-and-structure.md](format-and-structure.md)：将 `拆文库/{导入书名}/` 短篇拆文产物转换为 `{短篇标题}/` 短篇工程结构，供 `story-short-write` Phase 3 无缝接手续写。外部对标与作者交代读导入记录（`{书目录}/.story/work/导入记录.md`）。
+
+## 迁移步骤
+
+目标工程只有 `{短篇标题}/设定.md`（核心框架 + 本书续写基线）、`小节大纲.md`、`正文.md` 三个单文件，外加可选的 `对标/{对标书名}/`（仅外部对标引用视图：拆文报告、情节节点、写作手法）。**短篇工程与长篇完全不同**：正文是单文件、不切章，**不产** `追踪/`、`大纲/`、`正文/` 等长篇目录，迁移时严禁误建。
+
+1. **正文迁移**：将 `拆文库/{导入书名}/原文/` 的全文迁移为单文件 `{标题}/正文.md`，按 format-and-structure.md 规范化格式（小节标记 `###1.`、段间仅单换行、对话引号按项目/平台约定统一）。原文已是成稿，不重写内容，只规范格式。
+2. **设定生成**：从 `拆文报告.md`、`写作手法.md` 反推 `{标题}/设定.md`，含核心框架（对齐 story-short-write 核心框架：基本信息、一句话梗概、核心反转、情绪设计、人设速写）与本书续写基线（已写内容的故事结构、情绪节奏、核心反转机制、既有写作手法；这是本书内部上下文，不是对标摘要）两个区块，规则见下方「设定.md 反推规则」。导入记录里作者交代的偏好与红线一并写进续写基线。
+3. **小节大纲生成**：从 `情节节点.md` 的功能分段反推 `{标题}/小节大纲.md`，按开头段/铺垫段/升级段/反转段/结尾段映射，用 story-short-write 的固定 12 列表格，每节一行，填法见下方「小节大纲表格」。相关情节点可由同一动作链或对话同时兑现，不为凑数量拆成多个子事件；原文判断不出的格子写 `[待补充]`，不套用长篇完整章节蓝图。
+4. **外部对标引用视图（可选）**：仅当导入记录已显式绑定外部 `{对标书名}` 时，才把 `拆文库/{对标书名}/` 同步为 `{标题}/对标/{对标书名}/`；没有绑定则跳过。不得把 `拆文库/{导入书名}/` 整体复制进 `对标/`。
+
+迁完按文末质量检查清单自检，在导入记录勾「结构迁移」，直接进入 Phase 5 汇报。
 
 > 长篇迁移规则见 `structure-mapping-long.md`。
 
@@ -48,7 +59,7 @@ Phase 3-S 短篇结构迁移的详细映射规则。将 `拆文库/{导入书名
 - 标题：{导入书名}
 - 目标字数：{原文实际字数} 字
 - 目标平台：{从拆文报告提取，无则填 [待补充]}
-- 情绪目标：{从拆文报告「情感线/爆点分析」提取读者预期感受}
+- 目标情绪：{从拆文报告「情感线/爆点分析」提取读者预期感受}
 
 ### 一句话梗概
 {主角 + 困境 + 反转 + 情绪落点（从拆文报告故事核提取）}
@@ -108,20 +119,21 @@ Phase 3-S 短篇结构迁移的详细映射规则。将 `拆文库/{导入书名
 | 反转段 | 高潮（核心反转引爆） | 通常 1-2 个小节，情绪峰值 |
 | 结尾段 | 结局（收束/情绪落点） | 通常 1-2 个小节 |
 
-### 小节条目模板
+### 小节大纲表格
+
+`小节大纲.md` 用 story-short-write 的固定 12 列表格，每节一行，列名和顺序不改：
 
 ```markdown
-## 开头段
-
-### 小节 1
-- 核心事件：{从情节节点提取该分段的主要情节点}
-- 情绪目标：{对应情感曲线节点的情绪词}
-- 章首钩子：[待补充]
-- 章尾钩子：[待补充]
-- 参考字数：{按原文对应段落字数估算}
+| 结构段/五段功能 | 主事件 | 情节推进 | 情绪 | 人物/关系变化 | 因果/逻辑链 | 读者新获知什么 | 结尾承接/钩子 | 伏笔/物件 | 场景形态 | 对白作用 | 目标字数 |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| 开头 | 从情节节点提取的主要情节点 | 具体发生了什么{发现} -> 具体发生了什么{冲突} | 前状态→后状态 | 本节前后变化，或 无（本节改变：…） | 原因 → 行动 → 结果 → 后果 | [待补充] | [待补充] | [待补充] | [待补充] | [待补充] | 按原文该节实际字数 |
 ```
 
-> 钩子字段标 `[待补充]`——无法可靠提取，留给用户或续写时填写。
+- `结构段/五段功能` 填 开头/铺垫/升级/反转/结尾。
+- `情节推进` 每个推进单元带 `{对话}` `{冲突}` `{伏笔}` `{回忆}` `{发现}` `{递进}` 之一，有先后用 `->` 连接，按原文实际发生的写，不为凑数拆分。
+- 从原文判断不出的格子写 `[待补充]`，留给作者或续写时填写；不写 `{}` 模板占位。
+- `目标字数` 写原文该节实际字数，各节之和与 `设定.md` 的目标字数对得上。
+- 付费点在哪一节末能从原文认出来时，在该行 `结尾承接/钩子` 标「付费点」；认不出写 `[待补充]`。
 
 ### 小节数量推算
 

package/lib/oh-story/skills/story-import/references/tracking-initialization.md

@@ -2,7 +2,7 @@
 
 ## 初始化事务
 
-新书从第 0 章初始化。`story-import` 导入已有小说时把最后完整章写入 `last_chapter=N`；第 1..N 章不伪造日更记录，常规续写从 N+1 章开始。
+新书从第 0 章初始化：把下面的 JSON 写到 `{书目录}/.story/work/init.json`，跑 `{PYTHON} {skill 根}/scripts/tracking_commit.py init --project {书目录} --input {书目录}/.story/work/init.json`，成功后删掉临时文件。`story-import` 导入已有小说时把最后完整章写入 `last_chapter=N`；第 1..N 章不伪造日更记录，常规续写从 N+1 章开始。
 
 ```json
 {

package/lib/oh-story/skills/story-import/references/tracking-transaction.md

@@ -21,22 +21,23 @@ Markdown 只负责给作者和 Agent 阅读，工具不再反向解析 Markdown
 {PYTHON} {当前 skill 根}/scripts/tracking_commit.py init   --project {书项目根} --input {书项目根}/.story/work/init.json
 {PYTHON} {当前 skill 根}/scripts/tracking_commit.py check  --project {书项目根}
 {PYTHON} {当前 skill 根}/scripts/tracking_commit.py draft  --project {书项目根} --chapter {N}
-{PYTHON} {story-long-write skill 根}/scripts/storyctl.py chapter check   --project {书项目根} --chapter {N}
+{PYTHON} {story-long-write skill 根}/scripts/storyctl.py chapter check   --project {书项目根} --chapter {N} [--min-chars {下限} --max-chars {上限}]
 {PYTHON} {story-long-write skill 根}/scripts/storyctl.py chapter commit  --project {书项目根} --chapter {N} --input {书项目根}/.story/work/第{NNN}章/tracking.json
 {PYTHON} {story-long-write skill 根}/scripts/storyctl.py chapter accept-current-length --project {书项目根} --chapter {N} --input {书项目根}/.story/work/第{NNN}章/tracking.json
 ```
 
 - `init`：只在 `_tracking-state.json` 不存在时执行，绝不覆盖已初始化项目。
-- `draft`：按当前 state 把逐章事务预填到 `.story/work/第NNN章/tracking.json`（修订号、模式、章名、`context` 四项当前值），并输出各文本字段的字数上限与在场核心角色的当前快照；调用方只填 `delta` 与有变化角色的快照。
-- `wordcount measure` / `wordcount checkpoint`：纯测量入口；不写正文、不写 tracking、不做语义判断。长篇正文只在前组写完后由父流程调用一次 `checkpoint`（见 workflow-chapter 步骤 6），整章长度由 `chapter check` 收口。
-- `chapter check`：重新读取当前正文与细纲目标，返回确定性长度状态、现有 blocking quality、`state_revision` 和当前可执行动作，不保存 approval。`under` 不提供自动补写；`over` 额外返回一次净删型 `compress-once` 及回到内部区间或作者给定区间所需的删除字数。
-- `chapter commit`：再次读取当前文件、重新计数并重跑 blocking quality；只接受用户带内章节，把简短字数记录与逐章事务一起原子提交。
-- `chapter accept-current-length`：只接受带外但 quality pass 的章节；接受动作发生时重新读取、重新计数并立即原子提交，不保存可陈旧的历史决议。
+- `draft`：按当前 state 把逐章事务预填到 `.story/work/第NNN章/tracking.json`（修订号、模式、章名、`context` 四项当前值），并输出各文本字段的字数上限与在场核心角色的当前快照。新章（append）调用方只填 `delta` 与有变化角色的快照；已提交章（revision）的 `delta` 与相关角色快照按该章现有逐章记录预填（伏笔、时间线取当前值），调用方在上面改成修订后的完整记录，不清空重写。
+- 作者字数范围：细纲可写一行 `字数范围：2000-2600`（作者明确给了上下限时）；本轮临时给的范围用 `--min-chars` / `--max-chars`（两者同给，优先于细纲）。`wordcount check` / `checkpoint` 与 `chapter check` / `commit` / `accept-current-length` 都认，给了就同时替代默认 ±12% 内部带与 ±15% 用户带，结果里 `band_source` 为 `author`，提交的字数记录多一项 `author_range`。
+- `wordcount measure` / `wordcount checkpoint`：纯测量入口；不写正文、不写 tracking、不做语义判断。长篇正文只在前组写完后由主会话带 `--project` 调用一次 `checkpoint`（目标与字数范围读细纲，见 workflow-chapter 步骤 6），整章长度由 `chapter check` 收口；`remaining_user_range` 按生效区间（作者区间或默认用户带）计算。
+- `chapter check`：重新读取当前正文与细纲目标，返回确定性长度状态、现有 blocking quality、`state_revision` 和当前可执行动作，不保存 approval。顶层 `status`：`ready`（可提交，exit 0）/ `needs_decision`（长度带外，按 `available_actions` 交作者，exit 0）/ `blocked`（有 blocking 正文问题，exit 1）/ `invalid`（正文为空等，exit 1）/ `tool_unavailable`（找不到 node 或检测脚本，见 `quality.tool_errors`，不是正文问题，exit 3）。参数错误或文件缺失输出 `story-chapter-error/v1`（`status: error`，exit 2）。`under` 不提供自动补写；`over` 额外返回一次净删型 `compress-once` 及回到生效区间所需的删除字数。`quality.semantic_advisories` 是语义类 advisory 条数（检测器标 `review: mechanical` 的不计）。
+- `chapter commit`：再次读取当前文件、重新计数并重跑 blocking quality；只接受生效区间内的章节，把简短字数记录与逐章事务一起原子提交。新章与修订都走它。
+- `chapter accept-current-length`：只接受带外但 quality pass 的章节；接受动作发生时重新读取、重新计数并立即原子提交，不保存可陈旧的历史决议。低于字数目标一半（`BELOW_ACCEPT_FLOOR`），或超长却还没做过那一次压缩（`COMPRESSION_REQUIRED`），都拒绝；作者明确拍板时加 `--force`。
 - `check`：严格验证 state schema、逐章记录连续性/规范名/体积、固定 7 栏、角色快照硬上限、派生文件集合，以及所有派生视图与 state 的逐字一致性。
 
 每本书由 `追踪/.tracking-commit.lock` 串行写事务，`expected_state_revision` 再拒绝基于旧状态构造的 stale transaction。两个不同事务并发时至多一个修订成功。字数记录也在锁内对当前正文和目标重新验证，正文或目标变化会让预先构造的记录直接失败。
 
-事务 JSON 是临时输入，不是项目产物：只写在书目录 `.story/work/` 下（逐章事务放 `.story/work/第NNN章/tracking.json`），不写系统 `/tmp`、书根、`大纲/` 或 `正文/`；成功前必须保留，提交成功后即可删除（`storyctl.py chapter commit` / `accept-current-length` 成功时自动删除该章目录；直接调用 `tracking_commit.py commit` 时由调用方删除）——之后 `check` 失败按下文提交 `mode=revision` 新事务修复，不需要原事务。若文件写入失败，`_tracking-state.json` 尚未推进；修正环境后直接重跑**同一份** `commit`。append 重跑只接受内容完全相同的既有逐章记录，不维护 `dirty/pending/repair` 状态机。
+事务 JSON 是临时输入，不是项目产物：只写在书目录 `.story/work/` 下（逐章事务放 `.story/work/第NNN章/tracking.json`），不写系统 `/tmp`、书根、`大纲/` 或 `正文/`；成功前必须保留，提交成功后即可删除（`storyctl.py chapter commit` / `accept-current-length` 成功时自动删除该章目录；直接调用 `tracking_commit.py commit` 时由调用方删除。已有字数记录的章节正文或目标改过后，`tracking_commit.py commit` 拒绝修订事务，须走 `storyctl.py chapter commit`）——之后 `check` 失败按下文提交 `mode=revision` 新事务修复，不需要原事务。若文件写入失败，`_tracking-state.json` 尚未推进；修正环境后直接重跑**同一份** `commit`。append 重跑只接受内容完全相同的既有逐章记录，不维护 `dirty/pending/repair` 状态机。
 
 校验失败与写入失败处理方式不同：校验失败（字段非法、退役结构、容量超限）要按报错改事务本身，重跑同一份结果不变。派生视图被手改或外部改动导致 `check` 报 `derived view differs from _tracking-state.json` 时，重新提交**该章**的 `mode=revision` 事务让工具整份重建，`expected_state_revision` 取 `追踪/_tracking-state.json` 的 `state_revision` 字段——`check` 失败时只往 stderr 打 ERROR，不输出 JSON；不手改派生文件，也不删 `_tracking-state.json` 重来。手写出的逐章记录会让同章 `append` 永久报 `chapter delta N already exists with different content`——删掉那个手写文件后重跑原事务即可。
 
@@ -46,7 +47,7 @@ Markdown 只负责给作者和 Agent 阅读，工具不再反向解析 Markdown
 
 仅新书或导入初始化时，执行 `init` 前必须完整读取 [tracking-initialization.md](tracking-initialization.md)，按其中原始 JSON 与导入边界构造事务。已有项目续写直接使用下方逐章事务，不重复读初始化示例。
 
-调用方的逐章 JSON 不写 `wordcount`；正式入口 `chapter commit` 或 `chapter accept-current-length` 在提交当下生成并注入。最终 state 只为已提交章节保留 `metric / target / actual / status / resolution / body_sha256`，不保存 MEASURE/RESOLVE 事件、ID 链、policy fingerprint 或独立 chapter state。
+调用方的逐章 JSON 不写 `wordcount`；正式入口 `chapter commit` 或 `chapter accept-current-length` 在提交当下生成并注入。最终 state 只为已提交章节保留 `metric / target / actual / status / resolution / body_sha256`（生效了作者字数范围时另加 `author_range`），不保存 MEASURE/RESOLVE 事件、ID 链、policy fingerprint 或独立 chapter state。
 
 ## 逐章事务
 
@@ -121,12 +122,13 @@ Markdown 只负责给作者和 Agent 阅读，工具不再反向解析 Markdown
 - `character_snapshots` 中出现的角色视为核心复用角色，必须同时出现在 `character_changes`；已经建立快照的核心角色再次变化时必须提交新快照。
 - 角色快照的四个列表不限制条数，只限制单项长度和最终文件总字节：目标 ≤4096 字节，超过警告；硬上限 8192 字节，超过则在任何写入前拒绝。
 - 没有快照的角色变化视为临时角色，不建立状态文件；`context.active_character_names` 最多 6 人且必须已有当前快照。
+- `context.long_term_constraints` 最多 6 条：要加第 7 条先合并语义重叠项或请作者取舍，不自动删旧约束；永久生效的设定裁定进它，短期强承诺进 `next_chapter_commitments`，过程决策不进续写状态卡。
 - `context.long_term_constraints` 和 `context.continuity_risks` 是整份提交的当前值。凡是上一版有、本次没有的条目，必须逐条列进 `delta.retired_context_items`，否则工具在任何写入前拒绝——漏写不会被当成删除。实际退役的条目由工具写进本章逐章记录的 `## 本章退役登记`，随后仍可回查。
 - 不再复用的核心角色写进 `delta.retired_characters`：工具删除其当前快照与 `角色状态/{角色名}.md`，并在逐章记录留档。同一事务里不能既退役又提交快照，也不能退役仍列在 `context.active_character_names` 的角色。角色阵亡/退场这一章，把变化照写进 `character_changes` 即可，本章退役的角色不必再交一份马上要删的快照，逐章记录仍按核心角色标注。退役只表示不再进入热上下文，正文与逐章记录不受影响。
 - 两类退役都只能在 `mode=append` 提交。退役表示「从此刻起离开当前状态」，而修订事务的逐章记录属于被改写的旧章，落在那里会谎报退役发生的章节；`mode=revision` 必须原样重交当前全部上下文条目，需要退役就放到下一次 append。
 - `伏笔.md` 只呈现已经埋设过的当前状态。未来规划仍留在大纲。
 - `timeline_events.action` 可为 `upsert/delete`。`未揭示` 的 `reveal_chapter` 必须为 `null`；部分/完全揭示只能填写已经发生的实际章节。
-- `mode=revision` 时，逐章记录必须重算为修订后该章仍然成立的完整连续性记录；当前角色、伏笔、时间线和上下文则提交受影响对象截至最新已写章的当前值。
+- `mode=revision` 时，逐章记录必须重算为修订后该章仍然成立的完整连续性记录（用 `draft` 预填的草稿改，漏写的项会从记录里消失，工具在 stderr 警告被清空的栏目；原有的退役登记原样保留）；当前角色、伏笔、时间线和上下文则提交受影响对象截至最新已写章的当前值。
 - 修订导入截止章内的正文时，会新增或覆盖该章的逐章记录；`imported_through_chapter` 不变。
 
 ## 续写状态卡固定格式

package/lib/oh-story/skills/story-import/scripts/build_outline_brief.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""build_outline_brief.py — 拼出导入长篇「逐批反推细纲」的任务包。
+
+用法:
+    python build_outline_brief.py --project <书目录> --chapters A-B [--analysis <拆文库/导入书名>]
+
+导入按作者时间线分时刻（见 SKILL.md「时刻表与交接」）。细纲按批反推，负载按批计、不随全书章数增长。
+有 story-architect 时主会话只跑本脚本、把任务包路径交给它（它没有执行命令的权限），没有时主会话
+自己读包写本批。任务包写在书内 `.story/work/排纲/`，是这次任务的输入数据，不是 reference。
+
+包里只有本批需要的东西，执行者不再整读每章约 4K 字的摘要：
+- 反推规则与细纲模板：references/outline-reverse-rules.md 全文；
+- 本批每章：正文路径、按 visible_chars_v1 测好的历史长度（与写作时章节检查同一口径，
+  story-architect 不能自己跑测量），以及从拆文库摘要里抽出的、写细纲真正要用的字段
+  （关键事件、因果、局面结果、涉及、信息变化、状态变化、章尾钩子，情节点只取「标题｜类型｜基调」）；
+  拆文库没有摘要时改用 `.story/work/简化摘要/第NNN章.md`（超过 200 章的书，未深拆章节的简化摘要）；
+- 卷纲「剧情单元（反推）」表里与本批章节重叠的行（只按表头「章节范围」那一列判断重叠）。
+本书设定与作者已定的事不进包，执行者按规则定点读项目文件与 `.story/work/导入记录.md`。
+
+批大小按总量定：请求 10–20 章（全书最后一批可以更少）；执行者要读的总量（任务包 + 没有摘要、
+只能读正文的章）超过约 25K 字时，从请求范围末尾往前少排几章（可少于 10 章，至少 1 章）。
+
+stdout 输出一行 JSON：任务包路径、本批实际章节范围与下一批起点、执行者要读的总量 chars（去空白）、
+本批每章长度、没找到摘要的章。
+Exit: 0 = 已写出；2 = 参数错误、正文或卷纲缺失、长度测不出。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from wordcount_core import METRIC, WordcountError, find_chapter_file, measure_wordcount  # noqa: E402
+
+RULES = Path(__file__).resolve().parent.parent / "references" / "outline-reverse-rules.md"
+WORK_DIR = (".story", "work", "排纲")
+BRIEF_SUMMARY_DIR = (".story", "work", "简化摘要")
+MIN_BATCH, MAX_BATCH = 10, 20
+LOAD_LIMIT = 25000  # 执行者一次要读的量（去空白字数）；再加上 agent 模板或 SKILL 入口仍在 35K 内
+# 摘要里写细纲要用的字段（与 story-long-analyze 摘要投影同名）；旧版摘要的同义标签放在别名里。
+SUMMARY_FIELDS = (
+    ("关键事件", ()),
+    ("因果", ()),
+    ("局面结果", ()),
+    ("涉及", ("涉及人物", "出场人物")),
+    ("信息变化", ()),
+    ("状态变化", ()),
+    ("章尾钩子", ("卡点与伏笔",)),
+)
+FIELD_NAMES = "|".join(name for field in SUMMARY_FIELDS for name in (field[0], *field[1]))
+# `**标签**：`（当前投影与旧版加粗写法）或不加粗的 `- 关键事件：`（只认上面这些字段名）。
+LABEL_RE = re.compile(r"^\s*(?:[-*+]\s*)?(?:\*\*([^*]+?)\*\*|(%s))\s*[：:（(]" % FIELD_NAMES)
+POINT_HEADER_RE = re.compile(r"^P(\d+)\s+\*\*(.+?)\*\*\s*[：:]\s*(.+)$")
+POINT_TAG_RE = re.compile(r"^主题标签\s*[：:]?\s*[^|｜]*?\s*[|｜]\s*基调\s*[：:]?\s*(.*?)\s*$")
+# 「章节范围」单元格的一段：第X章—第Y章 / 第X-Y章 / 第X章 / 章X-Y / X-Y。
+SPAN_CELL_RE = re.compile(
+    r"^\s*(?:第|章)?\s*(\d+)\s*章?\s*(?:(?:-|~|～|—|–|－|至|到)+\s*第?\s*(\d+)\s*章?)?\s*$"
+)
+
+
+def emit(text: str, stream) -> None:
+    """统一按 UTF-8 写出：Windows 控制台默认 GBK/ASCII 时直接 print 中文会崩。"""
+    stream.buffer.write((text + "\n").encode("utf-8"))
+    stream.flush()
+
+
+def weight(text: str) -> int:
+    return len(re.sub(r"\s", "", text))
+
+
+def parse_range(value: str) -> tuple[int, int]:
+    match = re.fullmatch(r"\s*(\d+)\s*(?:-\s*(\d+))?\s*", value or "")
+    if not match:
+        raise SystemExit("ERROR: --chapters 写成 A-B，如 1-20")
+    first = int(match.group(1))
+    last = int(match.group(2) or first)
+    if first < 1 or last < first:
+        raise SystemExit("ERROR: --chapters 范围无效")
+    return first, last
+
+
+def last_body_chapter(project: Path) -> int:
+    numbers = [int(m.group(1)) for p in (project / "正文").glob("第*章*.md")
+               if "_原稿_" not in p.name and (m := re.match(r"^第0*(\d+)章", p.name))]
+    return max(numbers, default=0)
+
+
+def check_batch_size(first: int, last: int, final: int) -> None:
+    size = last - first + 1
+    if size > MAX_BATCH:
+        raise SystemExit(f"ERROR: 一批细纲最多 {MAX_BATCH} 章，拆成两批")
+    # 只有全书最后一批可以不足 10 章（包太大时脚本自己少排几章不受此限）。
+    if size < MIN_BATCH and last < final:
+        raise SystemExit(f"ERROR: 一批细纲至少 {MIN_BATCH} 章（全书最后一批除外），把范围扩到第{first}-{min(final, first + MIN_BATCH - 1)}章")
+
+
+def shown_path(path: Path, base: Path) -> str:
+    """项目根下的路径写相对路径（story-architect 从项目根解析），在外面的写绝对路径。"""
+    try:
+        return path.resolve().relative_to(base.resolve()).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def measure(project: Path, chapter: int) -> tuple[Path, str, int]:
+    try:
+        body = find_chapter_file(project / "正文", chapter, outline=False)
+        text = body.read_bytes().decode("utf-8")
+    except (WordcountError, OSError, UnicodeError) as exc:
+        raise SystemExit(f"ERROR: 第{chapter}章正文读不到（{exc}），先完成正文迁移")
+    result = measure_wordcount(text, chapter=chapter)
+    if result["status"] != "measured":
+        raise SystemExit(f"ERROR: 第{chapter}章长度测不出（{result['invalid_reason']}）")
+    return body, text, result["actual"]
+
+
+# ---------- 摘要字段抽取 ----------
+
+def label_blocks(text: str) -> dict[str, str]:
+    """把摘要按 `**标签**：` 切块；情节点之后的内容另行解析，不进字段块。"""
+    blocks: dict[str, list[str]] = {}
+    current = None
+    for line in text.replace("\r\n", "\n").split("\n"):
+        stripped = line.strip()
+        if POINT_HEADER_RE.match(stripped) or stripped.startswith("#"):
+            current = None
+            continue
+        match = LABEL_RE.match(line)
+        if match:
+            current = (match.group(1) or match.group(2)).strip()
+            rest = re.split(r"[：:]", line, maxsplit=1)
+            blocks.setdefault(current, []).append(rest[1] if len(rest) > 1 else "")
+            continue
+        if current is not None:
+            blocks[current].append(line)
+    return {name: "\n".join(lines).strip() for name, lines in blocks.items()}
+
+
+def flatten(value: str) -> str:
+    """列表/表格压成一行：表格只取第一列（人物名），跳过表头与分隔行。"""
+    rows = [line.strip() for line in value.split("\n") if line.strip()]
+    if rows and all(row.startswith("|") for row in rows):
+        names = [row.strip("|").split("|")[0].strip() for row in rows[2:]]
+        return "、".join(name for name in names if name)
+    return " ".join(re.sub(r"^(?:\d+[.、]|[-*+])\s*", "", row) for row in rows)
+
+
+def summary_points(text: str) -> list[str]:
+    lines = text.replace("\r\n", "\n").split("\n")
+    points = []
+    for index, line in enumerate(lines):
+        header = POINT_HEADER_RE.match(line.strip())
+        if not header:
+            continue
+        kind = re.split(r"[|｜]", header.group(3))[0].strip()
+        kind = kind[2:].lstrip(" ：:") if kind.startswith("类型") else kind
+        tone = "—"
+        for follow in lines[index + 1:index + 12]:
+            if POINT_HEADER_RE.match(follow.strip()):
+                break
+            tag = POINT_TAG_RE.match(follow.strip())
+            if tag:
+                tone = tag.group(1) or "—"
+                break
+        points.append(f"P{header.group(1)} {header.group(2).strip()}｜{kind}｜{tone}")
+    return points
+
+
+def summary_lines(text: str) -> list[str]:
+    blocks = label_blocks(text)
+    out = []
+    for name, aliases in SUMMARY_FIELDS:
+        raw = next((blocks[key] for key in (name, *aliases) if blocks.get(key)), "")
+        out.append(f"- {name}：{flatten(raw) or '（摘要未写）'}")
+    points = summary_points(text)
+    out.append("- 情节点（标题｜类型｜基调）：" + ("；".join(points) if points else "（摘要里没有可读的情节点）"))
+    return out
+
+
+def chapter_block(project: Path, analysis: Path, chapter: int) -> tuple[str, int, int, bool]:
+    """返回（本章块、历史长度、执行者还需另读的正文量、是否缺摘要）。"""
+    body, body_text, actual = measure(project, chapter)
+    head = [f"### 第{chapter}章", "",
+            f"- 正文：`{shown_path(body, project.parent)}`；字数目标 {actual}（{METRIC}）"]
+    summary = analysis / "章节" / f"第{chapter}章_摘要.md"
+    brief = project.joinpath(*BRIEF_SUMMARY_DIR) / f"第{chapter:03d}章.md"
+    if summary.is_file():
+        lines = [f"- 摘要要点（抽自 `{shown_path(summary, project.parent)}`）："] + [
+            "  " + line for line in summary_lines(summary.read_text(encoding="utf-8").lstrip(""))]
+        return "\n".join(head + lines), actual, 0, False
+    if brief.is_file():
+        text = brief.read_text(encoding="utf-8").lstrip("").strip()
+        return "\n".join(head + ["- 简化摘要（未深拆章节）：", "", text]), actual, 0, False
+    note = "- 摘要：未找到，读该章正文反推，证据不足处写 [待补充]"
+    return "\n".join(head + [note]), actual, weight(body_text), True
+
+
+# ---------- 卷纲剧情单元 ----------
+
+def parse_span_cell(cell: str) -> list[tuple[int, int]]:
+    """只解析「章节范围」这一格；认不出的写法返回空，不去别的列找数字。"""
+    spans = []
+    for part in re.split(r"[、，,；;/]", cell):
+        match = SPAN_CELL_RE.match(part)
+        if not match:
+            continue
+        start = int(match.group(1))
+        end = int(match.group(2) or start)
+        if start <= end:
+            spans.append((start, end))
+    return spans
+
+
+def split_row(row: str) -> list[str]:
+    return [cell.strip() for cell in row.strip().strip("|").split("|")]
+
+
+def unit_rows(project: Path, first: int, last: int) -> list[str]:
+    """从各卷纲的「剧情单元」表里取与本批章节重叠的行，连同表头。"""
+    volumes = sorted((project / "大纲").glob("卷纲_第*卷.md"))
+    if not volumes:
+        raise SystemExit("ERROR: 大纲/ 下没有卷纲，先在结构迁移时刻写定卷纲")
+    out: list[str] = []
+    for volume in volumes:
+        lines = volume.read_text(encoding="utf-8").splitlines()
+        start = next((i for i, line in enumerate(lines) if re.match(r"^#+\s*剧情单元", line)), None)
+        if start is None:
+            continue
+        table: list[str] = []
+        for line in lines[start + 1:]:
+            if line.lstrip().startswith("|"):
+                table.append(line)
+            elif table or line.strip():
+                break  # 表格结束，或标题下先出现了非表格内容
+        if len(table) < 3:
+            continue
+        column = next((i for i, cell in enumerate(split_row(table[0])) if "章节范围" in cell), None)
+        if column is None:
+            continue
+        hits = []
+        for row in table[2:]:
+            cells = split_row(row)
+            spans = parse_span_cell(cells[column]) if column < len(cells) else []
+            if any(a <= last and b >= first for a, b in spans):
+                hits.append(row)
+        if hits:
+            out += [f"来源：`{project.name}/大纲/{volume.name}`", "", *table[:2], *hits, ""]
+    if not out:
+        raise SystemExit(f"ERROR: 卷纲「剧情单元」表里找不到覆盖第{first}-{last}章的行（表头要有「章节范围」列，写成「第X-Y章」），先补卷纲")
+    return out
+
+
+# ---------- 拼包 ----------
+
+def render(project: Path, first: int, last: int, blocks: list[str]) -> str:
+    head = (f"# 任务包：反推第{first}-{last}章细纲（导入）\n\n"
+            f"只交付 `{project.name}/大纲/细纲_第{first:03d}章.md` 到 `细纲_第{last:03d}章.md`，每章一个文件（已有的同名文件按本包重写覆盖）；"
+            f"不改正文、卷纲和 `设定/`，不建 `追踪/`。证据用下方每章的摘要要点，不整读拆文库摘要；某个字段要点里没有、"
+            f"又必须写实际内容时，只回看该章正文的相关段落。作者已定的事在 `{project.name}/.story/work/导入记录.md`；"
+            "不要另读本包以外的写作技法文件。交付后只回：写了哪些文件、每章一句核心事件、"
+            "证据不足标了 [待补充] 的要点（没有写「无」）。\n\n"
+            "包里提到的检查由主会话在你交付后跑，你不执行命令；需要的测量结果已放进包里。")
+    parts = [head, f"\n## 本批章节\n\n路径相对项目根（`{project.parent}`）。\n\n" + "\n\n".join(blocks),
+             "\n## 卷纲剧情单元（覆盖本批）\n\n" + "\n".join(unit_rows(project, first, last)).rstrip(),
+             "\n---\n\n<!-- 资料：outline-reverse-rules.md -->\n\n" + RULES.read_text(encoding="utf-8").lstrip("").strip()]
+    return "\n".join(parts) + "\n"
+
+
+def build(project: Path, analysis: Path, first: int, last: int) -> dict:
+    if not RULES.is_file():
+        raise SystemExit(f"ERROR: 缺少 reference：{RULES}")
+    fixed = weight(render(project, first, last, []))  # 包头、剧情单元行与规则：章数减少只会更少
+    blocks: list[str] = []
+    lengths: dict[int, int] = {}
+    missing: list[int] = []
+    load, extra_reading = fixed, 0
+    for chapter in range(first, last + 1):
+        block, actual, extra, absent = chapter_block(project, analysis, chapter)
+        cost = weight(block) + extra
+        if blocks and load + cost > LOAD_LIMIT:
+            break  # 包已够大：本章留给下一批
+        blocks.append(block)
+        lengths[chapter] = actual
+        load += cost
+        extra_reading += extra
+        if absent:
+            missing.append(chapter)
+    end = first + len(blocks) - 1
+    text = render(project, first, end, blocks)
+    return {"text": text, "end": end, "lengths": lengths, "missing": missing,
+            "chars": weight(text) + extra_reading}
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description="拼出导入长篇逐批反推细纲的任务包")
+    parser.add_argument("--project", required=True, type=Path, help="书目录（{导入书名}/）")
+    parser.add_argument("--chapters", required=True, help="章节范围 A-B，请求 10–20 章；包过大时自动少排")
+    parser.add_argument("--analysis", type=Path, help="拆文库目录，默认 书目录的上一级/拆文库/{书目录名}")
+    args = parser.parse_args(argv)
+    try:
+        project = args.project.resolve()
+        if not project.is_dir():
+            raise SystemExit(f"ERROR: 书目录不存在：{args.project}")
+        first, last = parse_range(args.chapters)
+        final = last_body_chapter(project)
+        if last > final:
+            raise SystemExit(f"ERROR: 正文只迁到第{final}章，范围超出")
+        check_batch_size(first, last, final)
+        analysis = (args.analysis or project.parent / "拆文库" / project.name).resolve()
+        result = build(project, analysis, first, last)
+    except SystemExit as exc:
+        emit(str(exc), sys.stderr)
+        return 2
+    end = result["end"]
+    out_dir = project.joinpath(*WORK_DIR)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out = out_dir / f"导入细纲_第{first:03d}-{end:03d}章.md"
+    out.write_text(result["text"], encoding="utf-8")
+    emit(json.dumps({"brief": str(out), "chapters": f"{first}-{end}",
+                     "next": end + 1 if end < final else None, "chars": result["chars"], "limit": LOAD_LIMIT,
+                     "metric": METRIC, "lengths": {str(k): v for k, v in result["lengths"].items()},
+                     "missing_summaries": result["missing"]},
+                    ensure_ascii=False), sys.stdout)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -18,7 +18,7 @@
 const fs = require('fs')
 const path = require('path')
 
-// 权威模板：references/workflow-setup.md「排纲自查与细纲」里的细纲模板
+// 权威模板：references/workflow-outline.md 的细纲模板
 // 必填只留有证据或事故撑腰的核心字段；阶段位置、章节定位、结构公式、本章标价、闭环状态、
 // 写手自由区、契约风险、镜头准入、信息差触发点与「分辨率」列是可选的阅读体验字段——
 // 写了照样消费，没写不拦（#383 隔离实验：只补目标情绪与主角目标就复现了补满全部字段的收益）。
@@ -32,6 +32,69 @@ const PLOT_HEADER_FIRST = /^(?:#|序号)$/
 // 这两个字段实测直接影响正文质量，必须有实际内容
 const INTENT_FIELDS = ['目标情绪', '主角目标/关键选择']
 const CALIBER = 'visible_chars_v1'
+// 可选字段「契约风险」只收三档；值未知可写 [待补充]。旧稿里的「风险等级」按同一字段认（旧名）。
+const CONTRACT_RISK_LEVELS = ['契约安全', '需补强', '契约破坏']
+
+// 「字数目标」「字数范围」「字数口径」的写法语法与 wordcount_core.py 逐字同构（scripts/test-storyctl.py 双跑同一批写法），
+// 细纲验收通过的写法，storyctl chapter check 不能再拒。值里一个数字都没有的目标/范围行是说明文字，不参与取值。
+const NUMBER = '([1-9][0-9]{0,2}(?:[,，][0-9]{3})+|[1-9][0-9]*)'
+const NOTE = '(?:[（(][^（）()]*[）)])?'
+const TARGET_VALUE = new RegExp(`^(?:约|大约)?[ \\t]*${NUMBER}[ \\t]*字?(?:左右)?[ \\t]*${NOTE}$`)
+const RANGE_VALUE = new RegExp(`^${NUMBER}[ \\t]*字?[ \\t]*(?:-|~|～|—|–|－|至|到)[ \\t]*${NUMBER}[ \\t]*字?[ \\t]*${NOTE}$`)
+const METRIC_VALUE = new RegExp(`^([A-Za-z0-9_-]+)[ \\t]*${NOTE}$`)
+const HAS_DIGIT = /[0-9０-９]/
+
+function fieldValues(text, label) {
+  const pattern = new RegExp(`^[ \\t>]*(?:[-*+][ \\t]*)?(?:\\*\\*)?${label}(?:\\*\\*)?[ \\t]*[:：][ \\t]*(.*?)[ \\t]*$`, 'gm')
+  const values = []
+  let match
+  const normalized = text.replace(/\r\n?/g, '\n').replace(/^\uFEFF/, '')
+  while ((match = pattern.exec(normalized)) !== null) values.push(match[1].replace(/\*\*/g, '').trim())
+  return values
+}
+
+const numericFieldValues = (text, label) => fieldValues(text, label).filter((value) => HAS_DIGIT.test(value))
+const toNumber = (raw) => Number(raw.replace(/[,，]/g, ''))
+
+function parseWordcountTarget(text) {
+  const raw = numericFieldValues(text, '字数目标')
+  if (!raw.length) return { status: 'missing', value: null, raw }
+  const matches = raw.map((value) => value.match(TARGET_VALUE))
+  if (!matches.every(Boolean)) return { status: 'invalid', value: null, raw }
+  const values = [...new Set(matches.map((match) => toNumber(match[1])))]
+  if (values.length !== 1) return { status: 'conflict', value: null, raw }
+  return { status: 'ok', value: values[0], raw }
+}
+
+function parseWordcountRange(text) {
+  const raw = numericFieldValues(text, '字数范围')
+  if (!raw.length) return { status: 'missing', value: null, raw }
+  const matches = raw.map((value) => value.match(RANGE_VALUE))
+  if (!matches.every(Boolean)) return { status: 'invalid', value: null, raw }
+  const pairs = [...new Set(matches.map((match) => `${toNumber(match[1])}-${toNumber(match[2])}`))]
+  if (pairs.length !== 1) return { status: 'invalid', value: null, raw }
+  const [min, max] = pairs[0].split('-').map(Number)
+  if (min > max) return { status: 'invalid', value: null, raw }
+  return { status: 'ok', value: { min, max }, raw }
+}
+
+function parseWordcountCaliber(text) {
+  const raw = fieldValues(text, '字数口径')
+  const matches = raw.map((value) => value.match(METRIC_VALUE))
+  return raw.length > 0 && matches.every(Boolean) && new Set(matches.map((match) => match[1])).size === 1 && matches[0][1] === CALIBER
+}
+
+function parseContractRisk(text) {
+  let raw = fieldValues(text, '契约风险')
+  if (!raw.length) raw = fieldValues(text, '风险等级')
+  if (!raw.length) return null
+  const value = raw[raw.length - 1].replace(/`/g, '')
+  if (/^\[待补充\]$/.test(value)) return { status: 'unknown', level: null, detail: '', raw: value }
+  const level = CONTRACT_RISK_LEVELS.find((name) => value.startsWith(name))
+  if (!level) return { status: 'invalid', level: null, detail: '', raw: value }
+  const detail = value.slice(level.length).replace(/^[\s；;，,。：:—\-（(]+/, '').replace(/[）)]$/, '').trim()
+  return { status: 'ok', level, detail, raw: value }
+}
 
 function fieldPattern(name) {
   // 允许 -/*/+ 项目符号、可选 ** 加粗、全角或半角冒号
@@ -56,7 +119,7 @@ function makeCheck(id, ok, file, evidence, expected, repair, severity = 'blockin
     file,
     evidence,
     expected,
-    references: ['references/workflow-setup.md', 'references/artifact-protocols.md'],
+    references: ['references/workflow-outline.md'],
     repair,
   }
 }
@@ -251,22 +314,45 @@ function verify(file, projectRoot = null) {
 
   checks.push(checkSettingRefs(text, name, file, projectRoot))
 
-  const targetMatch = text.match(/字数目标\s*[：:]\s*(?:约\s*)?([\d,，]+)/)
-  const target = targetMatch ? Number(targetMatch[1].replace(/[,，]/g, '')) : null
-  const caliberOk = new RegExp(`字数口径\\s*[：:]\\s*${CALIBER}`).test(text)
+  const targetParse = parseWordcountTarget(text)
+  const rangeParse = parseWordcountRange(text)
+  const target = targetParse.value
+  const caliberOk = parseWordcountCaliber(text)
+  const targetLabel = { ok: target, missing: '未识别', invalid: `写法认不出（${targetParse.raw.join('、')}）`, conflict: `多个不同的值（${targetParse.raw.join('、')}）` }[targetParse.status]
+  const rangeLabel = rangeParse.status === 'invalid' ? `；字数范围写法不对（${rangeParse.raw.join('、')}）` : (rangeParse.value ? `；字数范围：${rangeParse.value.min}-${rangeParse.value.max}` : '')
   checks.push(makeCheck(
     'outline.wordcount-target',
-    Boolean(target) && Number.isFinite(target) && target >= 500 && target <= 20000 && caliberOk,
+    targetParse.status === 'ok' && target >= 500 && target <= 20000 && caliberOk && rangeParse.status !== 'invalid',
     name,
-    `字数目标：${target === null ? '未识别' : target}；字数口径 ${CALIBER}：${caliberOk}`,
-    `字数目标为 500-20000 的正整数，并声明 字数口径：${CALIBER}`,
-    '只补字数目标或字数口径行，不调整情节安排。'
+    `字数目标：${targetLabel}；字数口径 ${CALIBER}：${caliberOk}${rangeLabel}`,
+    `字数目标为 500-20000 的正整数（可写「2300 字」「约 2300」「2,300」，可带括号备注），并声明 字数口径：${CALIBER}；作者给了上下限时另写一行「字数范围：2000-2600」`,
+    '只补字数目标、字数范围或字数口径行，不调整情节安排。'
   ))
 
-  return report(file, checks)
+  const risk = parseContractRisk(text)
+  if (risk) {
+    checks.push(makeCheck(
+      'outline.contract-risk',
+      risk.status !== 'invalid',
+      name,
+      risk.status === 'invalid' ? `契约风险写的是「${risk.raw}」` : `契约风险：${risk.level || '[待补充]'}`,
+      `契约风险只写 ${CONTRACT_RISK_LEVELS.join(' / ')} 三档之一（需补强时后面写补强方式），未定写 [待补充]`,
+      '只把契约风险改成三档之一，不改其他字段。'
+    ))
+  }
+
+  return report(file, checks, {
+    wordcount: {
+      target,
+      target_status: targetParse.status,
+      range: rangeParse.value,
+      range_status: rangeParse.status,
+    },
+    contract_risk: risk ? { level: risk.level, detail: risk.detail, status: risk.status } : null,
+  })
 }
 
-function report(file, checks) {
+function report(file, checks, extra = {}) {
   const failures = checks.filter((check) => !check.ok && check.severity === 'blocking')
   const advisories = checks.filter((check) => !check.ok && check.severity === 'advisory')
   return {
@@ -274,6 +360,7 @@ function report(file, checks) {
     verifier: 'story-long-write.outline-contract',
     file: path.resolve(file),
     ok: failures.length === 0,
+    ...extra,
     checks,
     failures,
     advisories,
@@ -320,7 +407,7 @@ function verifySupply(volumeFile, unitId) {
     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`,
+      evidence: ok ? '排纲底稿含「供给自查」小节' : `${path.basename(draftFile)} 里没有「供给自查」小节——每批出细纲前须做供给自查（含「无缺口」情形），见 workflow-outline.md 步骤 3`,
     }
   }
   const read = readUtf8(volumeFile)
@@ -363,7 +450,7 @@ function verifySupply(volumeFile, unitId) {
     file: path.resolve(volumeFile),
     unit: unitId,
     ok,
-    evidence: ok ? '单元卡含「供给自查」小节' : `没有 排纲底稿_${unitId}.md，剧情单元 ${unitId} 的卡内也没有「供给自查」小节——每批出细纲前须做供给自查（含「无缺口」情形），见 workflow-setup.md「排纲自查与细纲」步骤 3`,
+    evidence: ok ? '单元卡含「供给自查」小节' : `没有 排纲底稿_${unitId}.md，剧情单元 ${unitId} 的卡内也没有「供给自查」小节——每批出细纲前须做供给自查（含「无缺口」情形），见 workflow-outline.md 步骤 3`,
   }
 }
 
@@ -430,4 +517,4 @@ function main(argv) {
 
 if (require.main === module) process.exitCode = main(process.argv.slice(2))
 
-module.exports = { verify, FIELDS, SUBSECTIONS, FIVE_ACT }
+module.exports = { verify, parseWordcountTarget, parseWordcountRange, parseContractRisk, FIELDS, SUBSECTIONS, FIVE_ACT }