@oh-story/dsh 0.1.10 → 0.1.11

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

@@ -16,10 +16,15 @@
 - 脚本做确定性部分：固定首行、定位、标题行字面量、细纲指针、文风全文路径与裁决、
   上一章结尾、降档判定与情绪/节奏槽、固定块指针。
 - 脚本代查作者记忆（prose_style + story_design）并填好 author_preferences。
-- 主会话填八槽：执行安排 / 本章意图 / 参考技法 / 本节速记 / 涉及角色 / genre_prose_card /
-  必读设定 / style_resolution。降档不成立时情绪与节奏槽也归主会话。
-  材料槽对应原流程步骤 3「写前准备」的四项输出（本节速记 / 情绪目标 / 涉及角色 /
-  参考技法）加上题材卡、设定补漏与作者偏好——都是判断，脚本做不了。
+- 脚本注入 `设定/题材定位.md`「作者已定」（本书的偏好、红线与否掉的方案），超过 AUTHOR_DECIDED_CHARS
+  可见字截断并注明去原文看；它是书级设定，优先于作者记忆。
+- 主会话填九个固定槽：执行安排 / 本章意图 / 作者本轮要求 / 本章技法 / 本节速记 / 涉及角色 /
+  genre_prose_card / 必读设定 / style_resolution。另有两个条件槽，出现时同样标［主会话填］：
+  author_preferences 块内的限定范围（--genre／--workflow）作者记忆未代查时，由主会话判断是否适用后补查
+  （脚本查询失败时则整块手查）；降档不成立时「情绪与节奏召回」也归主会话。
+  核对报告末尾的「待填槽位」给出本次实际个数（9-11）。
+  材料槽对应原流程步骤 3「写前准备」的四项输出（本节速记 / 目标情绪 / 涉及角色 /
+  本章技法）加上作者本轮要求、题材卡、设定补漏与作者偏好——都是判断，脚本做不了。
 - 续写状态卡校验后由主会话筛选，在「本节速记」槽内写入本章需要的状态。
 - 可选块缺失留标题并写明原因（「没有」与「漏了」在产物上必须长得不一样）。
   必在块缺失退出码 2 —— 那是数据问题，要修数据后重跑，不是回落手拼的理由。
@@ -39,6 +44,7 @@ from outline_view import parse as parse_volume
 TAIL_CHARS = 400          # 上一章结尾注入的目标字符数（按整行回退，不切半句）
 STATE_SECTIONS = ("当前位置", "长期约束", "核心角色状态", "活跃伏笔", "近三章速记", "下一章承诺", "连贯性风险")
 SLOT_MARK = "［主会话填］"
+AUTHOR_DECIDED_CHARS = 600  # 「作者已定」注入上限（去空白字数）；超了截断，写手按提示回原文看
 WORK_ROOT = (".story", "work")
 
 
@@ -164,13 +170,65 @@ def scoped_memory_values(workspace: Path):
     return values
 
 
-def book_genres(project: Path):
-    """「题材类型」行按分隔符切成词；未填的模板占位（{…}）不算。"""
+def genre_line(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}
+        return ""
+    return match.group(1).strip()
+
+
+def book_genres(project: Path):
+    """「题材类型」行按分隔符切成词。"""
+    return {word.casefold() for word in re.split(r"[\W_丨×]+", genre_line(project)) if word}
+
+
+GENRE_CARD_DIR = Path(__file__).resolve().parent.parent / "references" / "genre-prose-cards"
+
+
+def match_genre_cards(project: Path):
+    """题材正文提示卡缺失时，按「题材类型」原文匹配题材卡（卡头的 genre 与 aliases），替主会话省掉整读索引。
+
+    按在题材类型里出现得越靠前越优先（主题材在前），同位置按置信度高→低；最多返回主、辅两张：[(路径, 置信度)]。"""
+    raw = genre_line(project).casefold()
+    if not raw or not GENRE_CARD_DIR.is_dir():
+        return []
+    rank = {"high": 0, "medium": 1, "low": 2}
+    hits = []
+    for card in sorted(GENRE_CARD_DIR.glob("*.md")):
+        head = (read_text(card) or "").split("---")
+        meta = head[1] if len(head) > 2 else ""
+        genre = re.search(r"^genre:\s*(.+)$", meta, re.M)
+        aliases = re.search(r"^aliases:\s*\[(.*)\]", meta, re.M)
+        confidence = re.search(r"^confidence:\s*(\w+)", meta, re.M)
+        names = [genre.group(1).strip()] if genre else [card.stem]
+        names += [a.strip() for a in aliases.group(1).split(",")] if aliases else []
+        where = [raw.find(name.casefold()) for name in names if name and name.casefold() in raw]
+        if where:
+            level = confidence.group(1) if confidence else "low"
+            hits.append((min(where), rank.get(level, 2), card, level))
+    hits.sort(key=lambda row: (row[0], row[1], row[2].name))
+    return [(card, level) for _, _, card, level in hits[:2]]
+
+
+def author_decided(project: Path):
+    """`设定/题材定位.md`「## 作者已定」一节：去掉模板占位行；返回 (正文, 是否截断)。没有这一节返回 (None, False)。"""
+    text = read_text(project / "设定" / "题材定位.md") or ""
+    match = re.search(r"^##[ \t]*作者已定[^\n]*\n(.*?)(?=^#{1,2}[ \t]|\Z)", text, re.M | re.S)
+    if not match:
+        return None, False
+    lines = [line.rstrip() for line in match.group(1).splitlines()
+             if line.strip() and not re.fullmatch(r"\s*[-*+]?\s*\{.*\}\s*", line)]
+    kept, used, cut = [], 0, False
+    for line in lines:
+        size = len(re.sub(r"\s", "", line))
+        if used + size > AUTHOR_DECIDED_CHARS:
+            cut = True
+            break
+        kept.append(line)
+        used += size
+    return "\n".join(kept), cut
 
 
 def query_author_memory(project: Path):
@@ -369,7 +427,10 @@ def build(project: Path, chapter: int, report: list):
     needs = {"题材正文提示卡": card_text, "目标情绪": target_emotion,
              "单元情绪引擎": engine, "单元节拍/章功能分配": tempo}
     why = [name + "缺有效内容" for name, value in needs.items() if not substantive(value)]
-    if not custom_style:
+    # 无对标（项目与工作区都没有对标书）时文风本就没有对标可召回：不因 custom_style 缺失拒绝降档
+    no_benchmark = not any(d.is_dir() for base in (project / "对标", project / "拆文库", project.parent / "拆文库")
+                           if base.is_dir() for d in base.iterdir())
+    if not custom_style and not no_benchmark:
         why.append("custom_style=false")
     downgrade = not why
 
@@ -384,7 +445,7 @@ def build(project: Path, chapter: int, report: list):
         if tempo:
             lines.append(f"  {tempo}")
         slot_recall = "——— 情绪与节奏召回 ———\n" + "\n".join(lines)
-        report.append(f"召回降档：成立，文风、题材卡、目标情绪和单元 {unit_id} 情绪/节拍均可用")
+        report.append(f"召回降档：成立，{'无对标，' if no_benchmark and not custom_style else '文风、'}题材卡、目标情绪和单元 {unit_id} 情绪/节拍均可用")
     else:
         slot_recall = ("——— 情绪与节奏召回 ———\n"
                        f"{SLOT_MARK} 降档不成立（" + "、".join(why) +
@@ -396,19 +457,21 @@ def build(project: Path, chapter: int, report: list):
     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("——— 作者本轮要求 ———\n"
+                 f"{SLOT_MARK} 作者这次明确说的：字数范围、必须发生、不许发生、写到哪里停、章尾要留什么；没有写「无」。")
     parts.append(slot_recall)
     # 伏笔与卷级禁忌走「主会话筛选后写进速记」这条原设计路线（步骤 3 状态筛选），
     # 不由脚本整栏注入——筛选是判断，而整栏注入还会把伏笔栏里的作者侧真相一并下放。
     # 代价是它依赖主会话逐章想起来，所以这里把提示语写成写死的三问清单。
     parts.append(
-        "——— 参考技法 ———\n"
-        f"{SLOT_MARK} 借鉴哪个参考文件的哪个技法、用在哪些段落；没有就写「无」。"
-        "按 reference 表的任务条件读取；本书文风只覆盖冲突表达条款，不停读整份文件。")
+        "——— 本章技法 ———\n"
+        f"{SLOT_MARK} 按细纲主功能填 打脸／反转／感情／悬疑／日常／无 之一（对照 SKILL.md「本章技法」），"
+        "再写一句用在哪几段；写手按自己的读取表读对应文件，这里不摘技法。本书文风只覆盖冲突表达条款，不停读整份文件。")
     parts.append(
         "——— 本节速记 ———\n"
         f"{SLOT_MARK} 按 workflow-chapter 步骤 3「状态筛选」产出（`追踪/上下文.md` 不注入"
@@ -420,9 +483,26 @@ def build(project: Path, chapter: int, report: list):
         "——— 涉及角色 ———\n"
         f"{SLOT_MARK} 按细纲「人物出场顺序」与「镜头准入」的台词位／动作位分配，"
         "列出本章要读的角色卡；本节速记已给全状态的不必再列。")
+    if not substantive(card_text):
+        cards = match_genre_cards(project)
+        if cards:
+            named = "；".join(f"{'主' if i == 0 else '辅'}题材 {card}（置信度 {level}）" for i, (card, level) in enumerate(cards))
+            report.append(f"题材卡：本书还没有题材正文提示卡，按「题材类型」匹配到 {named}；生成后落盘，后续章直接读")
+        else:
+            report.append("题材卡：本书还没有题材正文提示卡，题材卡无匹配——读 style-genre-modules.md"
+                          "「题材正文提示卡」一节与最接近的流派一节生成后落盘")
     parts.append("——— 题材正文提示卡（genre_prose_card，只含本章相关条目）———\n"
                  f"{SLOT_MARK} 主题材抽 3-5 条、辅题材 1-2 条；只作内部校准，不进正文")
     parts.append(slot_setting)
+    decided, cut = author_decided(project)
+    if decided:
+        note = (f"\n（超过 {AUTHOR_DECIDED_CHARS} 字已截断，其余见 {project / '设定' / '题材定位.md'}「作者已定」，动笔前读完）"
+                if cut else "")
+        parts.append("——— 作者已定（本书的决定，高于作者记忆，与细纲冲突以细纲为准并在交付摘要里说明）———\n"
+                     + decided + note)
+        report.append("作者已定：已注入" + ("（超长截断，写手需回原文读完）" if cut else ""))
+    else:
+        report.append("作者已定：题材定位里没有或为空，未注入")
     items, omitted, skipped, memory_error = query_author_memory(project)
     if memory_error:
         memory_block = (f"{SLOT_MARK} 组装脚本查询作者记忆失败（{memory_error}），"
@@ -438,14 +518,14 @@ def build(project: Path, chapter: int, report: list):
     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 查询后补进本块")
+                         "带 --genre／--workflow 跑 SKILL.md「核心方法」的 query 命令（--kind prose_style --kind story_design）后补进本块")
         report.append(f"作者记忆：限定范围未代查（{named}），归主会话判断是否适用")
     parts.append("——— author_preferences（作者记忆，低优先级倾向，不逐条追求命中）———\n" + memory_block)
     parts.append("——— style_resolution ———\n"
                  f"{SLOT_MARK} 本轮请求里作者对表达的明确要求及其覆盖的默认条款（没有写「无」）；"
                  "本书文风与作者记忆的裁决见上方各块，同一裁决传去味与审稿。")
 
-    parts.append("检查分工：写手负责编排、内容覆盖和格式自检；父流程质量阶段负责语义去味及最终文件扫描。写手不提前重复整轮去味或相同检查链，保留情节点落点、新增申报与原定交付。")
+    parts.append("检查分工：写手负责编排、内容覆盖和格式自检；主会话质量阶段负责语义去味及最终文件扫描。写手不提前重复整轮去味或相同检查链，保留情节点落点、新增申报与原定交付。")
 
     # ---- 固定块：压成指针，不重述 agent 定义 ----
     parts.append(

package/lib/oh-story/skills/story-long-write/scripts/check-ai-patterns.js

@@ -6,6 +6,7 @@ const { loadStyleWhitelist, maskStyleText } = require('./style-whitelist.js');
 const path = require('path');
 
 const USAGE = `Usage: node check-ai-patterns.js [--check] [--json] [--fail-on=blocking|all] <file...>
+       node check-ai-patterns.js --list-review-classes
 
 Detect high-risk AI-flavor prose patterns that need human rewrite:
   - negative setup followed by positive flip in the same sentence
@@ -33,8 +34,10 @@ Detect high-risk AI-flavor prose patterns that need human rewrite:
 
 Book-local .deslop-whitelist literal spans are excluded from style scanning (no regex or ancestor inheritance).
 Each finding carries severity: blocking by default for generation/deslop cleanup (not-is-comparison / em-dash / voice-contrast / negation-parade / reverse-not-is / trailer-ending / trailer-summary). This is a local style/readability gate, not an AIGC detector score; functional human text can be marked for review instead of hard-edited for a detector.
-或 advisory (period-stutter / long-paragraph / micro-action-tic / stock-reaction-tic / action-list-tic / abstract-summary-tic / cliche-density-tic / metaphor-density-tic / reasoning-chain-tic / system-notice-formality-tic / overcompressed-prose-tic / low-connective-density-tic / quote-emphasis-tic / formulaic-parallelism，是提示，justified 的长推理/氛围段可保留)。
+或 advisory (period-stutter / long-paragraph / micro-action-tic / negation-pair-tic / stock-reaction-tic / action-list-tic / abstract-summary-tic / cliche-density-tic / metaphor-density-tic / reasoning-chain-tic / system-notice-formality-tic / overcompressed-prose-tic / low-connective-density-tic / quote-emphasis-tic / formulaic-parallelism，是提示，justified 的长推理/氛围段可保留)。
 --fail-on=blocking 只在出现 blocking finding 时退出 1；默认 --fail-on=all 有任何 finding 即退出 1。
+Each finding also carries review: mechanical（表面形态确定、就地改写即可）或 semantic（可能承担叙事功能，需读上下文判断是否保留）；blocking 一律 mechanical。--list-review-classes 输出完整分类表（JSON）。
+HTML comments (<!-- ... -->, e.g. the 去味:跳过 exemption marker) are metadata, not prose, and are never scanned.
 
 The script reports findings only. It never rewrites text, because the safe fix is
 contextual: usually delete the negative setup, write the positive term directly,
@@ -58,6 +61,10 @@ const LONG_PARAGRAPH_CHARS = 200;
 // 单次出现是正常中文。
 const MICRO_TIC_PATTERN = /了(?:[一两三几半])?[下阵圈道声眼口气会]/g;
 const MICRO_TIC_MIN_HITS = 5;
+// 「没A，也没B」「不A，也不B」否定对偶：七猫人类长篇约 0.07 处/千字，模型稿 0.4-1.5 处/千字；
+// 写人物没做什么是英文式节奏，一章 3 处以上报一条提示。
+const NEGATION_PAIR_PATTERN = /(?:没有|没|不)[^，。！？；,!?\n]{1,10}[，,；]\s*[^，。！？；,!?\n]{0,6}?也(?:没有|没|不)/g;
+const NEGATION_PAIR_MIN_HITS = 3;
 const MICRO_TIC_PER_KILO = 6;
 
 // 套式反应细节：不是禁写身体，而是提示成片出现的“部位 + 轻微动作/状态”、
@@ -239,7 +246,7 @@ const REVERSE_NOT_IS_PREV_EXCLUDE = new Set([...COMPACT_EITHER_OR_PREV, '还', '
 const TRAILER_ENDING_PATTERN = /没人知道|谁也不知道|谁也没想到|殊不知|(?:这)?才刚刚开(?:始|头)|正(?:朝着|向着)[^。！？!?\n]{0,24}(?:压|涌|袭|逼)(?:了?过去|了?过来|来)|(?<!正式)拉开(?:序幕|帷幕)|即将(?:开始|来临|降临)/g;
 const TRAILER_ENDING_WINDOW_CHARS = 600;
 
-// 章尾状态总结体：把细纲「结尾设定/收束状态」原样写成总结句收章（「这一夜注定无人入眠」
+// 章尾状态总结体：把细纲「结尾设定」原样写成总结句收章（「这一夜注定无人入眠」
 // 「这一切都结束了」「新的人生才刚刚开始」「命运的齿轮」）。与 trailer-ending 共用文末窗口，
 // 区别是它盖章过去、trailer-ending 预告将来；收的都是 banned-words 已按名禁掉的形态。
 // 不收「(这|那)一刻…终于明白」：真人语料里那是正常的认知节拍，短篇第一人称审判句还是卖点
@@ -266,6 +273,58 @@ const QUOTE_EMPHASIS_MIN_HITS = 3;
 const QUOTE_EMPHASIS_MAX_VISIBLE = 4;
 const QUOTE_EMPHASIS_SPEECH_VERB_PATTERN = /[说道问喊答念叫回吼骂写读唱嘀咕]/;
 
+// review 分类：下游按它分流。mechanical = 命中的表面形态本身就是问题，写作端就地改写即可；
+// semantic = 同一形态可能承担叙事功能，要读上下文判断保留还是改（交语义审查）。blocking 只能是
+// mechanical（blocking 的含义就是不需判断、必须清零）。新增 finding type 必须在此登记，否则运行期
+// 直接报错退出（scripts/test-ai-patterns.sh 另从源码抽 type 与本表双向核对）。
+//   type                         review      理由
+//   not-is-comparison            mechanical  固定句式模板「不是A，而是B」，blocking
+//   voice-contrast               mechanical  固定反差模板「声音不大…却」，blocking
+//   negation-parade              mechanical  固定否定排比模板，blocking
+//   reverse-not-is               mechanical  固定反序对比模板「是A，不是B」，blocking
+//   trailer-ending               mechanical  文末窗口固定预告短语，blocking
+//   trailer-summary              mechanical  文末窗口固定总结短语，blocking
+//   em-dash                      mechanical  标点，blocking
+//   long-paragraph               mechanical  段长阈值，断段即可
+//   period-stutter               mechanical  连续短句计数，合句即可
+//   micro-action-tic             mechanical  固定补语「了下/了一下」密度
+//   negation-pair-tic            semantic    「没A，也没B」否定对偶，留真正要强调的
+//   cliche-density-tic           mechanical  固定禁用词表密度
+//   stock-reaction-tic           semantic    身体反应可能承担物理后果或情绪，要逐处做删除测试
+//   action-list-tic              semantic    打斗/追逐等功能性动作编排可保留
+//   abstract-summary-tic         semantic    作者总结/上帝视角，是否越位要看语境
+//   metaphor-density-tic         semantic    比喻是否服务画面、删哪几个要读上下文
+//   reasoning-chain-tic          semantic    替读者推理的解释链，长推理段可能是正当的
+//   system-notice-formality-tic  semantic    系统/规则文本本就可以公文腔，看体裁功能
+//   overcompressed-prose-tic     semantic    短段过密可能是节奏选择，禁止机械注水
+//   low-connective-density-tic   semantic    同上，连接词补不补要看读感
+//   quote-emphasis-tic           semantic    标语/转述载体的引号是正常写法
+//   formulaic-parallelism        semantic    工整并列可能承担辩解或悬念排除
+const REVIEW_CLASSES = Object.freeze({
+  'not-is-comparison': 'mechanical',
+  'voice-contrast': 'mechanical',
+  'negation-parade': 'mechanical',
+  'reverse-not-is': 'mechanical',
+  'trailer-ending': 'mechanical',
+  'trailer-summary': 'mechanical',
+  'em-dash': 'mechanical',
+  'long-paragraph': 'mechanical',
+  'period-stutter': 'mechanical',
+  'micro-action-tic': 'mechanical',
+  'negation-pair-tic': 'semantic',
+  'cliche-density-tic': 'mechanical',
+  'stock-reaction-tic': 'semantic',
+  'action-list-tic': 'semantic',
+  'abstract-summary-tic': 'semantic',
+  'metaphor-density-tic': 'semantic',
+  'reasoning-chain-tic': 'semantic',
+  'system-notice-formality-tic': 'semantic',
+  'overcompressed-prose-tic': 'semantic',
+  'low-connective-density-tic': 'semantic',
+  'quote-emphasis-tic': 'semantic',
+  'formulaic-parallelism': 'semantic',
+});
+
 const options = {
   json: false,
   files: [],
@@ -276,6 +335,9 @@ for (let i = 2; i < process.argv.length; i += 1) {
   const arg = process.argv[i];
   if (arg === '--check') {
     // Accepted for symmetry with normalize-punctuation.js; detection is always check-only.
+  } else if (arg === '--list-review-classes') {
+    process.stdout.write(`${JSON.stringify(REVIEW_CLASSES, null, 2)}\n`);
+    process.exit(0);
   } else if (arg === '--json') {
     options.json = true;
   } else if (arg.startsWith('--fail-on=')) {
@@ -313,7 +375,7 @@ for (const file of options.files) {
   let whitelist;
   try { whitelist = loadStyleWhitelist(fullPath); }
   catch (error) { die(`${file}: unable to read .deslop-whitelist (${error.message})`); }
-  const findings = scanDocument(maskStyleText(input, whitelist)).map((finding) => ({ file, ...finding }));
+  const findings = scanDocument(maskStyleText(input, whitelist)).map((finding) => ({ file, ...finding, review: reviewClass(finding.type) }));
   allFindings.push(...findings);
 }
 
@@ -330,6 +392,15 @@ if (failed) process.exit(2);
 const hasBlocking = allFindings.some((f) => f.severity === 'blocking');
 if (options.failOn === 'blocking' ? hasBlocking : allFindings.length > 0) process.exit(1);
 
+function reviewClass(type) {
+  const review = REVIEW_CLASSES[type];
+  if (!review) {
+    console.error(`internal error: finding type '${type}' has no review class (add it to REVIEW_CLASSES)`);
+    process.exit(2);
+  }
+  return review;
+}
+
 function escapeRegExp(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -344,11 +415,15 @@ function die(message) {
   process.exit(2);
 }
 
-function scanDocument(input) {
+// unclosedOpenings：到文末都没闭合的 `<!--` 位置（"行号:列号"）。未闭合的注释不是注释，
+// 否则一个漏写的 `-->` 会把后面整章藏起来；这些位置按正文扫描，只把 `<!--` 本身抹掉。
+function scanDocument(input, unclosedOpenings = new Set()) {
   const lines = input.split(/\r?\n/);
   const findings = [];
   let fence = null;
   let inFrontMatter = hasYamlFrontMatter(lines);
+  let commentOpen = false;
+  let commentStart = null;
   let block = [];
   const proseLines = [];
 
@@ -375,14 +450,25 @@ function scanDocument(input) {
       continue;
     }
 
-    if (fenceMarker) {
+    if (fenceMarker && !commentOpen) {
       flushBlock();
       fence = fenceMarker;
       continue;
     }
 
-    block.push({ text: line, lineNo: index + 1 });
-    proseLines.push({ text: line, lineNo: index + 1 });
+    // HTML 注释（如 `<!-- 去味:跳过 -->` 豁免标记）是元信息不是正文：注释段等长换成空格
+    // 保列号，整行都是注释的直接跳过；注释可跨行。
+    const masked = maskHtmlComments(line, commentOpen, index, unclosedOpenings);
+    commentOpen = masked.open;
+    if (masked.openedAt !== null) commentStart = masked.openedAt;
+    if (masked.text !== line && !masked.text.trim()) continue;
+
+    block.push({ text: masked.text, lineNo: index + 1 });
+    proseLines.push({ text: masked.text, lineNo: index + 1 });
+  }
+
+  if (commentOpen && commentStart !== null) {
+    return scanDocument(input, new Set([...unclosedOpenings, commentStart]));
   }
 
   flushBlock();
@@ -432,6 +518,7 @@ function scanProsePatterns(proseLines) {
   findings.push(...findQuoteEmphasisTic(proseLines));
   findings.push(...findPeriodStutter(proseLines));
   findings.push(...findMicroActionTic(proseLines));
+  findings.push(...findNegationPairTic(proseLines));
   findings.push(...findStockReactionTic(proseLines));
   findings.push(...findActionListTic(proseLines));
   findings.push(...findAbstractSummaryTic(proseLines));
@@ -638,7 +725,7 @@ function findTrailerEnding(proseLines) {
         column: summaryMatch.index + 1,
         type: 'trailer-summary',
         severity: 'blocking',
-        message: '章尾状态总结体：「这一夜注定…/这一切都结束了/新的人生才刚刚开始/命运的齿轮」是把细纲的收束状态原样写成了总结句；收束状态是规划口径，正文落到最后一个具体动作、画面或台词上，别替读者盖章。',
+        message: '章尾状态总结体：「这一夜注定…/这一切都结束了/新的人生才刚刚开始/命运的齿轮」是把细纲的结尾设定原样写成了总结句；结尾设定要落成最后一个具体动作、画面或台词，别替读者盖章。',
         excerpt: compact(text.slice(summaryMatch.index, summaryMatch.index + summaryMatch[0].length)),
       });
     }
@@ -691,6 +778,34 @@ function findQuoteEmphasisTic(proseLines) {
   }];
 }
 
+// 否定对偶：统计引号外叙述里「没A，也没B」式句子，全文只报一条。
+function findNegationPairTic(proseLines) {
+  let hits = 0;
+  let firstLine = null;
+  const samples = [];
+  for (const { text, lineNo } of proseLines) {
+    const trimmed = text.trim();
+    if (!trimmed || isDivider(trimmed) || isStructural(trimmed)) continue;
+    const narrative = stripQuoted(trimmed);
+    NEGATION_PAIR_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = NEGATION_PAIR_PATTERN.exec(narrative)) !== null) {
+      hits += 1;
+      if (firstLine === null) firstLine = lineNo;
+      if (samples.length < 4) samples.push(match[0]);
+    }
+  }
+  if (hits < NEGATION_PAIR_MIN_HITS) return [];
+  return [{
+    line: firstLine,
+    column: 1,
+    type: 'negation-pair-tic',
+    severity: 'advisory',
+    message: `否定对偶偏多：「没A，也没B」式叙述 ${hits} 处；写人物没做什么是英文式节奏，改成他做了什么（留一两处真正要强调的）。`,
+    excerpt: compact(samples.join(' | ')),
+  }];
+}
+
 // 微动作复读：统计引号外叙述里「了X量词」轻量补语的密度。次数与每千字密度双门槛，
 // 全文只报一条（这是分布级指纹，不是逐处问题）。
 function findMicroActionTic(proseLines) {
@@ -1242,6 +1357,38 @@ function countTerms(text, terms) {
   return count;
 }
 
+// 把行内 HTML 注释（含 `<!--`、`-->` 本身）换成等长空格；openBefore 表示上一行留下未闭合注释。
+// unclosedOpenings 里的 `<!--` 到文末都没闭合：只抹掉这四个字符，后面照常当正文。
+// openedAt 是本行最后一个开始注释的 `<!--` 位置（"行号:列号"），没有则为 null。
+function maskHtmlComments(line, openBefore, lineIndex = 0, unclosedOpenings = new Set()) {
+  let out = '';
+  let open = openBefore;
+  let cursor = 0;
+  let openedAt = null;
+  while (cursor < line.length) {
+    if (open) {
+      const close = line.indexOf('-->', cursor);
+      const end = close === -1 ? line.length : close + 3;
+      out += ' '.repeat(end - cursor);
+      cursor = end;
+      if (close !== -1) open = false;
+      continue;
+    }
+    const start = line.indexOf('<!--', cursor);
+    if (start === -1) {
+      out += line.slice(cursor);
+      break;
+    }
+    out += line.slice(cursor, start) + '    ';
+    cursor = start + 4;
+    const key = `${lineIndex}:${start}`;
+    if (unclosedOpenings.has(key)) continue;
+    open = true;
+    openedAt = key;
+  }
+  return { text: out, open, openedAt };
+}
+
 function parseFenceMarker(trimmedLine) {
   const match = /^(?:`{3,}|~{3,})/.exec(trimmedLine);
   if (!match) return null;

package/lib/oh-story/skills/story-long-write/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 }