@oh-story/dsh 0.1.8 → 0.1.10

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 = ['起因', '发展', '转折', '高潮', '结尾']
@@ -46,11 +48,11 @@ function readUtf8(file) {
   }
 }
 
-function makeCheck(id, ok, file, evidence, expected, repair) {
+function makeCheck(id, ok, file, evidence, expected, repair, severity = 'blocking') {
   return {
     id,
     ok,
-    severity: 'blocking',
+    severity,
     file,
     evidence,
     expected,
@@ -65,7 +67,47 @@ function parseTableRow(line) {
   return trimmed.slice(1, -1).split('|').map((cell) => cell.replace(/\*\*/g, '').replace(/`/g, '').trim())
 }
 
-function verify(file) {
+function resolveBookRoot(file, projectRoot) {
+  if (projectRoot) return path.resolve(projectRoot)
+  const parent = path.dirname(path.resolve(file))
+  if (path.basename(parent) === '大纲') return path.dirname(parent)
+  return null
+}
+
+// 项目引用须写目录路径；裸文件名可能指向 skill reference，不猜测其归属。
+const REF_DIR_PREFIX = /^(?:设定|大纲|追踪|正文|读者笔记|对标)\//
+
+function checkSettingRefs(text, name, file, projectRoot) {
+  const bookRoot = resolveBookRoot(file, projectRoot)
+  if (!bookRoot) {
+    return makeCheck('outline.setting-refs-exist', true, name, '未能定位书目录（细纲不在 大纲/ 下且未传 --project），跳过', '细纲引用的项目内文件真实存在', '无需修复。')
+  }
+  const refs = new Set()
+  const pattern = /`([^`\n]+?\.md)[^`\n]*`/g
+  let match
+  while ((match = pattern.exec(text)) !== null) {
+    const token = match[1].trim().replace(/\\/g, '/')
+    if (token.includes('{') || token.includes('}')) continue
+    if (REF_DIR_PREFIX.test(token) || /^\.{1,2}\//.test(token)) refs.add(token)
+  }
+  const missing = []
+  for (const token of refs) {
+    const base = /^\.{1,2}\//.test(token) ? path.dirname(path.resolve(file)) : bookRoot
+    try {
+      if (!fs.statSync(path.resolve(base, token)).isFile()) missing.push(token)
+    } catch { missing.push(token) }
+  }
+  return makeCheck(
+    'outline.setting-refs-exist',
+    missing.length === 0,
+    name,
+    missing.length ? `引用的路径不是可用文件：${missing.join('、')}` : `${refs.size} 处项目内引用全部存在`,
+    '细纲引用的每个项目内 .md 文件都真实存在——不许把槽位指向查无实据的权威文件',
+    '修正引用路径；或按新增物三级先把缺的设定落档（「写了要报」直接补并登记、「先问作者」进排纲底稿的供给自查提案），再在细纲引用。'
+  )
+}
+
+function verify(file, projectRoot = null) {
   const name = path.basename(file)
   const read = readUtf8(file)
   const checks = []
@@ -133,21 +175,82 @@ function verify(file) {
   let header = null
   for (const line of lines) {
     const cells = parseTableRow(line)
-    if (cells && cells.length === 4 && PLOT_HEADER_FIRST.test(cells[0])) {
+    // 现行模板默认四列（# / 情节点 / 功能标签 / 执行边界（禁＋放）），需要时在功能标签后加「分辨率」列成五列。
+    // 两种都收：功能标签固定在第 3 列，执行边界一律取最后一列。
+    if (cells && (cells.length === 4 || cells.length === 5) && PLOT_HEADER_FIRST.test(cells[0])) {
       header = cells
       break
     }
   }
-  const headerOk = Boolean(header) && header[2].includes('功能标签') && header[3].includes('执行边界')
+  const headerOk = Boolean(header)
+    && header[2].includes('功能标签')
+    && header[header.length - 1].includes('执行边界')
+    && (header.length === 4 || header[3].includes('分辨率'))
   checks.push(makeCheck(
     'outline.plotpoint-table',
     headerOk,
     name,
-    header ? `表头：${header.join(' | ')}` : '未找到 | # | 情节点 | 功能标签 | 执行边界 | 表头',
-    '情节细化使用四列表格：# / 情节点（谁做了什么） / 功能标签 / 执行边界',
-    '只把情节点序列改成四列表格，逐点补功能标签与执行边界；不增删情节点本身。'
+    header ? `表头：${header.join(' | ')}` : '未找到 | # | 情节点 | 功能标签 | [分辨率] | 执行边界 | 表头',
+    '情节细化使用表格：# / 情节点（谁做了什么） / 功能标签 / 执行边界（禁＋放）；需要时可在功能标签后加「分辨率」列',
+    '只把情节点序列改成这张表，逐点补功能标签与执行边界；不增删情节点本身。'
   ))
 
+  // 「放」半边：五列表或表头写明「禁＋放」的四列表，执行边界必须至少一个点解除限制，
+  // 全是禁令的情节点表实测会把整章压成同一个温度（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 === header.length && /^\d+$/.test(cells[0])) rows.push(cells)
+    }
+    if (rows.length) {
+      const released = rows.filter((cells) => {
+        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)
+      })
+      checks.push(makeCheck(
+        'outline.plotpoint-release',
+        released.length > 0,
+        name,
+        `${rows.length} 个情节点里 ${released.length} 个写了「放」`,
+        '执行边界写成「禁＋放」两半，每章至少一个点写了「放」——放行是解除限制，不是义务',
+        '给最该出彩的一两个点补「放」半边（谁可以出声、谁可以失态、允不允许当场标价），不改情节点本身。'
+      ))
+      if (released.length > 0 && rows.length >= 3 && released.length * 3 < rows.length) {
+        checks.push(makeCheck(
+          'outline.plotpoint-release-ratio',
+          false,
+          name,
+          `${rows.length} 个情节点里只有 ${released.length} 个写了「放」（不足三分之一）`,
+          '建议至少三分之一的情节点写「放」半边，避免整章只剩禁令',
+          '按人工判断酌情补「放」；本项不阻断。',
+          'advisory'
+        ))
+      }
+    }
+  }
+
+  // 章级「禁止提前释放」只写本章特有的三五条；条目过多多半是把卷级常任禁忌逐章复读了。
+  const releaseMatch = text.match(/^\s*[-*+]\s*\*{0,2}本章禁止提前释放\*{0,2}\s*[：:]\s*(.*)$/m)
+  if (releaseMatch) {
+    const items = releaseMatch[1].split(/[、；;，,\/]/).map((s) => s.trim()).filter(Boolean)
+    if (items.length > 5) {
+      checks.push(makeCheck(
+        'outline.release-brevity',
+        false,
+        name,
+        `本章禁止提前释放列了 ${items.length} 条`,
+        '章级只写本章特有的三五条；卷级常任禁忌写在卷纲「本卷禁碰的终局底牌」，不逐章复读',
+        '把与卷纲常任重复的条目删掉，只留本章特有；本项不阻断。',
+        'advisory'
+      ))
+    }
+  }
+
+  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)
@@ -164,7 +267,8 @@ function verify(file) {
 }
 
 function report(file, checks) {
-  const failures = checks.filter((check) => !check.ok)
+  const failures = checks.filter((check) => !check.ok && check.severity === 'blocking')
+  const advisories = checks.filter((check) => !check.ok && check.severity === 'advisory')
   return {
     schema_version: 1,
     verifier: 'story-long-write.outline-contract',
@@ -172,6 +276,7 @@ function report(file, checks) {
     ok: failures.length === 0,
     checks,
     failures,
+    advisories,
     repair_scope: failures.map((failure) => ({
       id: failure.id,
       file: failure.file,
@@ -200,13 +305,81 @@ function resolveChapter(project, chapter) {
   return { file: path.join(dir, hit) }
 }
 
+// --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 || '卷纲文件为空' }
+  }
+  // 只检查目标单元内的标题，不把正文提及或代码示例当成小节。
+  let fence = null
+  const lines = read.text.split(/\r?\n/).map((line) => {
+    const marker = line.match(/^\s{0,3}(`{3,}|~{3,})/)
+    if (marker) {
+      if (!fence) fence = marker[1]
+      else if (marker[1][0] === fence[0] && marker[1].length >= fence.length) fence = null
+      return ''
+    }
+    return fence ? '' : line.replace(/\*\*/g, '')
+  })
+  const headings = []
+  for (let index = 0; index < lines.length; index++) {
+    const heading = lines[index].match(/^(#{1,6})\s+(.+)$/)
+    if (heading) headings.push({ index, level: heading[1].length, title: heading[2] })
+  }
+  const card = headings.find((heading) => {
+    const id = heading.title.match(/剧情单元\s+([A-Za-z][\w-]*)/)
+    if (id) return id[1] === unitId
+    const end = headings.find((next) => next.index > heading.index)?.index ?? lines.length
+    return lines.slice(heading.index + 1, end).some((line) => {
+      const field = line.match(/^\s*[-*+]\s*单元ID\s*[：:]\s*([A-Za-z][\w-]*)\s*$/)
+      return field?.[1] === unitId
+    })
+  })
+  const end = card ? (headings.find((next) => next.index > card.index && next.level <= card.level)?.index ?? lines.length) : 0
+  const ok = Boolean(card) && headings.some((heading) => heading.index > card.index && heading.index < end && /^供给自查(?:\s|[（(]|$)/.test(heading.title))
+  if (!card) {
+    return { schema_version: 1, verifier: 'story-long-write.outline-supply', file: path.resolve(volumeFile), unit: unitId, ok: false, evidence: `卷纲中未找到剧情单元 ${unitId}` }
+  }
+  return {
+    schema_version: 1,
+    verifier: 'story-long-write.outline-supply',
+    file: path.resolve(volumeFile),
+    unit: unitId,
+    ok,
+    evidence: ok ? '单元卡含「供给自查」小节' : `没有 排纲底稿_${unitId}.md，剧情单元 ${unitId} 的卡内也没有「供给自查」小节——每批出细纲前须做供给自查（含「无缺口」情形），见 workflow-setup.md「排纲自查与细纲」步骤 3`,
+  }
+}
+
 function parseArgs(argv) {
   const files = []
   let project = null
   let chapter = null
+  let supply = null
   for (let index = 0; index < argv.length; index++) {
     const arg = argv[index]
     if (arg === '--json') continue
+    if (arg === '--supply') {
+      if (index + 2 >= argv.length) return null
+      supply = { volumeFile: argv[++index], unitId: argv[++index] }
+      continue
+    }
     if (arg === '--project' || arg === '--chapter') {
       if (index + 1 >= argv.length || argv[index + 1].startsWith('--')) return null
       const value = argv[++index]
@@ -217,6 +390,10 @@ function parseArgs(argv) {
     if (arg.startsWith('--')) return null
     files.push(arg)
   }
+  if (supply) {
+    if (project || chapter || files.length) return null
+    return { supply }
+  }
   if (project || chapter) {
     if (!project || !chapter || files.length || !/^\d+$/.test(chapter)) return null
     return { project, chapter }
@@ -228,9 +405,14 @@ function parseArgs(argv) {
 function main(argv) {
   const parsed = parseArgs(argv)
   if (!parsed) {
-    process.stderr.write('用法: node scripts/check-outline-contract.js --json <细纲路径...> | --json --project <书目录> --chapter N\n')
+    process.stderr.write('用法: node scripts/check-outline-contract.js --json <细纲路径...> | --json --project <书目录> --chapter N | --json --supply <卷纲路径> <单元ID>\n')
     return 2
   }
+  if (parsed.supply) {
+    const supplyReport = verifySupply(parsed.supply.volumeFile, parsed.supply.unitId)
+    process.stdout.write(`${JSON.stringify(supplyReport, null, 2)}\n`)
+    return supplyReport.ok ? 0 : 1
+  }
   let targets = parsed.files
   if (!targets) {
     const resolved = resolveChapter(parsed.project, parsed.chapter)
@@ -240,7 +422,7 @@ function main(argv) {
     }
     targets = [resolved.file]
   }
-  const reports = targets.map((file) => verify(file))
+  const reports = targets.map((file) => verify(file, parsed.project || null))
   const ok = reports.every((entry) => entry.ok)
   process.stdout.write(`${JSON.stringify(reports.length === 1 ? reports[0] : reports, null, 2)}\n`)
   return ok ? 0 : 1

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

@@ -31,8 +31,9 @@
  * 收尾复扫用 `正文/第XXX章_*.md` 这类通配传多章时，多出来的正文不能被当成细纲吞掉
  * ——那会让首个文件比错对象、其余文件根本不检，静默退 0 报「干净」。
  *
- * 退出码：0 = 干净或无法判定（缺细纲/非分章正文）；1 = 有重合待复核。
- * 无发现时完全静默，不污染上下文。
+ * 退出码：0 = 干净或未自动发现细纲而跳过；1 = 有重合待复核；
+ * 2 = 参数错误、输入不可读（含已发现的细纲）或非预期异常。
+ * 干净时静默；自动发现不到细纲时明确报告跳过，避免与「已检查且干净」混淆。
  */
 
 'use strict'
@@ -42,19 +43,59 @@ const path = require('path')
 const MIN_RUN = 16 // 判定阈值：连续重合 >15 字，即 >=16
 const REPORT_TOP = 8 // 最多列出的片段数
 
-function read(p) {
+function readTextFile(p) {
   try {
-    return fs.readFileSync(p, 'utf8').replace(/^/, '')
-  } catch {
-    return null
+    const stat = fs.statSync(p)
+    if (!stat.isFile()) return { ok: false, reason: '不是普通文件' }
+    return { ok: true, text: fs.readFileSync(p, 'utf8').replace(/^/, '') }
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return { ok: false, reason: '不存在' }
+    if (error && error.code) return { ok: false, reason: `无法读取（${error.code}）` }
+    return { ok: false, reason: `无法读取：${error instanceof Error ? error.message : String(error)}` }
   }
 }
 
+function reportInputError(kind, file, reason) {
+  process.stderr.write(`错误: 无法读取${kind} "${file}"：${reason}。\n`)
+}
+
+function reportUsageError(message) {
+  process.stderr.write(`错误: ${message}。\n`)
+  process.stderr.write('用法: node check-outline-copy.js [--outline <细纲路径>] <正文路径...>\n')
+  return 2
+}
+
 /** 只留汉字——剥掉标点/加粗/【】后比对，防止细纲标注造成假阴性 */
 function hanOnly(s) {
   return s.replace(/[^一-鿿]/g, '')
 }
 
+// 写后回填的完成记录不是誊抄来源。标题块包含子标题；字段块止于下一字段或标题。
+function stripCompletionRecord(outline) {
+  let headingLevel = 0
+  let inField = false
+  return outline.split('\n').filter((line) => {
+    const heading = line.match(/^ {0,3}(#{1,6})[\t ]+(.*)$/)
+    if (headingLevel) {
+      if (!heading || heading[1].length > headingLevel) return false
+      headingLevel = 0
+    }
+    if (inField) {
+      if (!heading && !/^[-*+][\t ]+/.test(line)) return false
+      inField = false
+    }
+    if (heading && heading[2].includes('实际完成情况')) {
+      headingLevel = heading[1].length
+      return false
+    }
+    if (/^[-*+][\t ]+(?:\*\*|__)?实际完成情况[^：:]*[：:]/.test(line)) {
+      inField = true
+      return false
+    }
+    return true
+  }).join('\n')
+}
+
 /**
  * 抽出细纲「复沓锚句」字段下的原话，一行一条。
  * 只认这一个字段，不扫情节点序列——锚句集中在固定区块，情节点保持只写「要发生什么」。
@@ -129,7 +170,9 @@ function findOutline(proseFile) {
       const fm = file.match(/^细纲_第0*(\d+)章.*\.md$/)
       if (fm && fm[1] === chapter) return path.join(dir, file)
     }
-  } catch {}
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
   return null
 }
 
@@ -137,34 +180,56 @@ function main() {
   const proseFiles = []
   let explicitOutline = null
   const argv = process.argv.slice(2)
+  let positionalOnly = false
   for (let k = 0; k < argv.length; k++) {
-    if (argv[k] === '--outline') explicitOutline = argv[++k] || null
-    else proseFiles.push(argv[k])
-  }
-  if (!proseFiles.length) {
-    process.stderr.write('用法: node check-outline-copy.js [--outline <细纲路径>] <正文路径...>\n')
-    return 0
+    const arg = argv[k]
+    if (!positionalOnly && arg === '--') {
+      positionalOnly = true
+    } else if (!positionalOnly && arg === '--outline') {
+      if (explicitOutline !== null) return reportUsageError('--outline 不能重复指定')
+      const value = argv[k + 1]
+      if (!value || value.startsWith('--')) return reportUsageError('--outline 缺少路径')
+      explicitOutline = value
+      k++
+    } else if (!positionalOnly && arg.startsWith('--')) {
+      return reportUsageError(`未知选项: ${arg}`)
+    } else {
+      proseFiles.push(arg)
+    }
   }
-  // 逐个文件独立判定；任一文件有重合即整体退 1
+  if (!proseFiles.length) return reportUsageError('缺少正文路径')
+
+  // 逐个文件独立判定；输入错误优先于重合发现
   let status = 0
   for (const proseFile of proseFiles) {
-    if (checkOne(proseFile, explicitOutline)) status = 1
+    status = Math.max(status, checkOne(proseFile, explicitOutline))
   }
   return status
 }
 
 function checkOne(proseFile, explicitOutline) {
-  const prose = read(proseFile)
-  if (prose === null) return 0
+  const proseResult = readTextFile(proseFile)
+  if (!proseResult.ok) {
+    reportInputError('正文', proseFile, proseResult.reason)
+    return 2
+  }
+  const prose = proseResult.text
 
   const outlineFile = explicitOutline || findOutline(proseFile)
-  if (!outlineFile) return 0
-  const outline = read(outlineFile)
-  if (outline === null) return 0
+  if (!outlineFile) {
+    process.stdout.write(`细纲照搬检测：跳过 "${proseFile}"（未自动发现细纲）。\n`)
+    return 0
+  }
+  const outlineResult = readTextFile(outlineFile)
+  if (!outlineResult.ok) {
+    reportInputError(explicitOutline ? '显式细纲' : '自动发现的细纲', outlineFile, outlineResult.reason)
+    return 2
+  }
+  const outline = outlineResult.text
 
   // 正文去掉标题行后比对
   const P = hanOnly(prose.replace(/^#.*$/gm, ''))
-  const O = hanOnly(outline)
+  const O = hanOnly(stripCompletionRecord(outline))
   if (P.length < MIN_RUN || O.length < MIN_RUN) return 0
 
   // 复沓锚句列出的原话允许逐字落地，命中后计入豁免、不判誊抄
@@ -236,6 +301,8 @@ function checkOne(proseFile, explicitOutline) {
 
 try {
   process.exit(main())
-} catch {
-  process.exit(0)
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error)
+  process.stderr.write(`错误: 细纲照搬检测异常：${message}。\n`)
+  process.exit(2)
 }

package/lib/oh-story/skills/story-long-write/scripts/normalize-punctuation.js

@@ -2,6 +2,7 @@
 'use strict';
 
 const fs = require('fs');
+const { loadStyleWhitelist, styleSpans } = require('./style-whitelist.js');
 const path = require('path');
 
 const USAGE = `Usage: node normalize-punctuation.js [--check] [--quote-mode keep|ascii|yan] <file...>
@@ -9,6 +10,7 @@ const USAGE = `Usage: node normalize-punctuation.js [--check] [--quote-mode keep
 Normalize正文 punctuation deterministically:
   - replace ellipses, em dashes, and double hyphens with Chinese punctuation
   - remove markdown divider lines (---) from正文
+  - preserve pause punctuation covered by book-local .deslop-whitelist literals
   - keep quote style by default; convert quotes only when explicitly requested
 `;
 
@@ -61,7 +63,10 @@ for (const file of options.files) {
     continue;
   }
 
-  const result = normalizeDocument(input, options.quoteMode);
+  let whitelist;
+  try { whitelist = loadStyleWhitelist(fullPath); }
+  catch (error) { die(`${file}: unable to read .deslop-whitelist (${error.message})`); }
+  const result = normalizeDocument(input, options.quoteMode, whitelist);
   totalFindings += result.findings.length;
 
   if (options.check) {
@@ -94,7 +99,7 @@ function die(message) {
   process.exit(2);
 }
 
-function normalizeDocument(input, quoteMode) {
+function normalizeDocument(input, quoteMode, whitelist) {
   const { lines, endings } = splitLinesKeepingEndings(input);
 
   const findings = [];
@@ -159,7 +164,7 @@ function normalizeDocument(input, quoteMode) {
     }
 
     const commentOpenBefore = commentOpen;
-    const punctuationResult = normalizePausePunctuation(line, lineNo, commentOpen);
+    const punctuationResult = normalizePausePunctuation(line, lineNo, commentOpen, whitelist);
     findings.push(...punctuationResult.findings);
     line = punctuationResult.line;
     commentOpen = punctuationResult.commentOpen;
@@ -237,7 +242,7 @@ function isClosingFence(line, fence) {
 // 一遍归一化留不干净，再跑一遍还会改已定稿的正文；所以反复归一化到不动点。
 // 每遍至少把一个 `…/./—/-` 换成非停顿字符，字符数严格递减，必然收敛。
 // findings 只留第一遍：同一处不重复计数，column 也仍然是原行的偏移。
-function normalizePausePunctuation(line, lineNo, commentOpen) {
+function normalizePausePunctuation(line, lineNo, commentOpen, whitelist) {
   let current = line;
   let findings = null;
   let commentOpenAfter = commentOpen;
@@ -245,7 +250,7 @@ function normalizePausePunctuation(line, lineNo, commentOpen) {
   for (;;) {
     const comments = htmlCommentSpans(current, commentOpen);
     commentOpenAfter = comments.open;
-    const pass = normalizePausePunctuationPass(current, lineNo, comments.spans);
+    const pass = normalizePausePunctuationPass(current, lineNo, comments.spans.concat(styleSpans(current, whitelist)));
     if (findings === null) findings = pass.findings;
     if (pass.line === current) break;
     current = pass.line;