@oh-story/dsh 0.1.9 → 0.1.11

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,11 +18,13 @@
 const fs = require('fs')
 const path = require('path')
 
-// 权威模板：references/workflow-setup.md「细纲（全书每章）」
+// 权威模板：references/workflow-outline.md 的细纲模板
+// 必填只留有证据或事故撑腰的核心字段；阶段位置、章节定位、结构公式、本章标价、闭环状态、
+// 写手自由区、契约风险、镜头准入、信息差触发点与「分辨率」列是可选的阅读体验字段——
+// 写了照样消费，没写不拦（#383 隔离实验：只补目标情绪与主角目标就复现了补满全部字段的收益）。
 const FIELDS = [
-  '核心事件', '字数目标', '字数口径', '阶段位置', '单元ID/位置', '目标情绪',
-  '主角目标/关键选择', '章节定位', '本章结构公式', '章首钩子', '爽点',
-  '本章标价', '闭环状态', '本章禁止提前释放', '写手自由区', '契约风险',
+  '核心事件', '字数目标', '字数口径', '单元ID/位置', '目标情绪',
+  '主角目标/关键选择', '章首钩子', '爽点', '本章禁止提前释放',
 ]
 const SUBSECTIONS = ['内容概括', '情节安排', '人物关系和出场顺序', '情节细化']
 const FIVE_ACT = ['起因', '发展', '转折', '高潮', '结尾']
@@ -30,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) {
   // 允许 -/*/+ 项目符号、可选 ** 加粗、全角或半角冒号
@@ -54,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,
   }
 }
@@ -101,7 +166,7 @@ function checkSettingRefs(text, name, file, projectRoot) {
     name,
     missing.length ? `引用的路径不是可用文件：${missing.join('、')}` : `${refs.size} 处项目内引用全部存在`,
     '细纲引用的每个项目内 .md 文件都真实存在——不许把槽位指向查无实据的权威文件',
-    '修正引用路径；或按「创作自主权分级」先把缺的设定落档（B 级直接补、C 级进《供给单》提案），再在细纲引用。'
+    '修正引用路径；或按新增物三级先把缺的设定落档（「写了要报」直接补并登记、「先问作者」进排纲底稿的供给自查提案），再在细纲引用。'
   )
 }
 
@@ -173,8 +238,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 +254,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)
@@ -249,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 {
@@ -272,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,
@@ -303,8 +392,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-outline.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 +450,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-outline.md 步骤 3`,
   }
 }
 
@@ -412,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 }