@lemoncat7/dsh-partner 2.8.1 → 2.8.3

package/resources/skills/story-creation/upstream/skills/story-short-write/scripts/check-outline-copy.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+/**
+ * check-outline-copy.js — 细纲照搬检测
+ *
+ * 治的病：细纲把情节点写成成品散文句，正文只剩誊抄，质量被锁死在细纲水平。
+ * 实测正文与细纲连续重合最高 13.5%、单段最长 40 字，且重合段落多为叙述而非台词
+ * ——即全章最好的那几句在细纲阶段就写完了。
+ *
+ * 判定：正文与同章细纲连续重合 > 阈值（默认 15 字）即报出
+ * ——细纲只锁功能与结果，句子一律在正文现场写。
+ *
+ * 词面相同不等于不良照搬：系统面板、任务要求、固定专名本就该保持一致。因此本脚本
+ * 只提供证据（位置与片段），是否重写由 agent 读上下文语义判断，同 check-ai-patterns.js
+ * 的 advisory 轨——但每条都要有结论，不允许只报不改，也不为归零机械改写。
+ * 判定保留的只由主会话补进细纲锚句：子代理不改大纲细纲（见 narrative-writer「不自行改纲」），
+ * 否则子代理误判的重合会被自己写进白名单，主会话复扫时不再报出，第二层复核失明。
+ *
+ * 免报：细纲「复沓锚句」字段下列出的原话允许逐字落地——誓言、系统面板、
+ * 旧案原话等写细纲时判定必须原文出现的部分，逐行一条。只扣除锚句自身的精确区间，
+ * 前后剩余片段照常按阈值判定，避免紧挨锚句的照搬被顺带赦免。
+ * 豁免量单独统计并在报告末尾列出，滥用锚句绕过检测时一眼可见。
+ *
+ * 由 narrative-writer 落盘后自查、主会话收尾复扫时调用（两侧同一份实现，口径一致）。
+ * 不进 hook：正文兜底 hook 的共享核是四端共用的，不为单项检测扩面。
+ *
+ * 用法：
+ *   node check-outline-copy.js <正文路径...>                    # 自动找同章细纲；短篇找同目录小节大纲
+ *   node check-outline-copy.js --outline <细纲路径> <正文路径...> # 指定细纲
+ *
+ * 位置参数一律按正文处理，与 check-ai-patterns.js 的 `<file...>` 口径一致：
+ * 收尾复扫用 `正文/第XXX章_*.md` 这类通配传多章时，多出来的正文不能被当成细纲吞掉
+ * ——那会让首个文件比错对象、其余文件根本不检，静默退 0 报「干净」。
+ *
+ * 退出码：0 = 干净或未自动发现细纲而跳过；1 = 有重合待复核；
+ * 2 = 参数错误、输入不可读（含已发现的细纲）或非预期异常。
+ * 干净时静默；自动发现不到细纲时明确报告跳过，避免与「已检查且干净」混淆。
+ */
+
+'use strict'
+const fs = require('fs')
+const path = require('path')
+
+const MIN_RUN = 16 // 判定阈值：连续重合 >15 字，即 >=16
+const REPORT_TOP = 8 // 最多列出的片段数
+
+function readTextFile(p) {
+  try {
+    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')
+}
+
+/**
+ * 抽出细纲「复沓锚句」字段下的原话，一行一条。
+ * 只认这一个字段，不扫情节点序列——锚句集中在固定区块，情节点保持只写「要发生什么」。
+ * 区块终止于行首无缩进的下一个字段（`- xxx`）或下一个小节标题，因此条目本身
+ * 用 `1.` 编号、缩进 `-` 列表或纯文本都能正确提取，不必额外标记。
+ */
+function extractAnchors(outline) {
+  const m = outline.match(/复沓锚句[^：:\n]*[：:]([\s\S]*?)(?=\n[-*+]\s|\n#{1,6}\s|$)/)
+  if (!m) return []
+  return m[1]
+    .split("\n")
+    // 去掉列表符号与「点N：」这类落点前缀，只留原话本身
+    .map((line) => line.replace(/^\s*[-*+]?\s*(?:\d+[.、)]\s*)?(?:点\s*\d+\s*[：:])?/, ""))
+    .map((line) => hanOnly(line))
+    .filter((a) => a.length >= 2)
+}
+
+/**
+ * 在片段里定位锚句的精确出现区间，挖掉后返回剩余子段与豁免字数。
+ * 不能只判「片段包含锚句」就整段放行——贪心扫描求的是最长延伸，锚句嵌在中间时
+ * 会连同紧挨着它的未授权重合一起赦免。
+ */
+function splitByAnchors(frag, anchors) {
+  // 片段完全落在某条锚句内：整段豁免（抄了锚句的一部分，仍在授权范围）
+  if (anchors.some((a) => a.includes(frag))) return { rest: [], anchoredLen: frag.length }
+
+  const spans = []
+  for (const a of anchors) {
+    for (let from = 0; from + a.length <= frag.length; ) {
+      const at = frag.indexOf(a, from)
+      if (at < 0) break
+      spans.push([at, at + a.length])
+      from = at + 1 // 同一锚句重复出现要逐次记录
+    }
+  }
+  if (!spans.length) return { rest: [frag], anchoredLen: 0 }
+
+  spans.sort((x, y) => x[0] - y[0])
+  const merged = [spans[0]] // 多锚句重叠/相邻时并成一段，避免重复计数
+  for (const [s, e] of spans.slice(1)) {
+    const last = merged[merged.length - 1]
+    if (s <= last[1]) last[1] = Math.max(last[1], e)
+    else merged.push([s, e])
+  }
+
+  const rest = []
+  let cursor = 0
+  let anchoredLen = 0
+  for (const [s, e] of merged) {
+    if (s > cursor) rest.push(frag.slice(cursor, s))
+    anchoredLen += e - s
+    cursor = e
+  }
+  if (cursor < frag.length) rest.push(frag.slice(cursor))
+  return { rest, anchoredLen }
+}
+
+/** 定位同章细纲：遍历 大纲/ 按章号正则匹配，支持带后缀的文件名 */
+function findOutline(proseFile) {
+  const base = path.basename(proseFile)
+  // 短篇没有章号：正文.md 与 小节大纲.md 在同目录平铺
+  if (base === '正文.md') {
+    const sibling = path.join(path.dirname(proseFile), '小节大纲.md')
+    return fs.existsSync(sibling) ? sibling : null
+  }
+  const m = base.match(/^第\s*0*(\d+)\s*章/)
+  if (!m) return null
+  const chapter = m[1]
+  const dir = path.join(path.dirname(path.dirname(proseFile)), '大纲')
+  try {
+    for (const file of fs.readdirSync(dir)) {
+      const fm = file.match(/^细纲_第0*(\d+)章.*\.md$/)
+      if (fm && fm[1] === chapter) return path.join(dir, file)
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
+  return null
+}
+
+function main() {
+  const proseFiles = []
+  let explicitOutline = null
+  const argv = process.argv.slice(2)
+  let positionalOnly = false
+  for (let k = 0; k < argv.length; k++) {
+    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)
+    }
+  }
+  if (!proseFiles.length) return reportUsageError('缺少正文路径')
+
+  // 逐个文件独立判定；输入错误优先于重合发现
+  let status = 0
+  for (const proseFile of proseFiles) {
+    status = Math.max(status, checkOne(proseFile, explicitOutline))
+  }
+  return status
+}
+
+function checkOne(proseFile, explicitOutline) {
+  const proseResult = readTextFile(proseFile)
+  if (!proseResult.ok) {
+    reportInputError('正文', proseFile, proseResult.reason)
+    return 2
+  }
+  const prose = proseResult.text
+
+  const outlineFile = explicitOutline || findOutline(proseFile)
+  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(stripCompletionRecord(outline))
+  if (P.length < MIN_RUN || O.length < MIN_RUN) return 0
+
+  // 复沓锚句列出的原话允许逐字落地，命中后计入豁免、不判誊抄
+  const anchors = extractAnchors(outline)
+
+  // 贪心扫描：每个起点二分求「仍是细纲子串」的最长延伸，命中区间不重叠
+  const hits = []
+  let copied = 0
+  let anchored = 0
+  let anchoredCount = 0
+  let i = 0
+  while (i < P.length) {
+    let best = 0
+    if (i + MIN_RUN <= P.length && O.includes(P.substr(i, MIN_RUN))) {
+      best = MIN_RUN
+      let lo = MIN_RUN
+      let hi = Math.min(P.length - i, 200)
+      while (lo <= hi) {
+        const mid = (lo + hi) >> 1
+        if (O.includes(P.substr(i, mid))) {
+          best = mid
+          lo = mid + 1
+        } else hi = mid - 1
+      }
+    }
+    if (best) {
+      const frag = P.substr(i, best)
+      const { rest, anchoredLen } = splitByAnchors(frag, anchors)
+      if (anchoredLen) {
+        anchored += anchoredLen
+        anchoredCount++
+      }
+      // 挖掉锚句后的剩余子段仍是细纲子串，只需按阈值重判
+      for (const seg of rest) {
+        if (seg.length >= MIN_RUN) {
+          hits.push({ frag: seg, len: seg.length })
+          copied += seg.length
+        }
+      }
+      i += best
+    } else i++
+  }
+  if (!hits.length) {
+    // 全部命中都是锚句豁免：静默放行，但把豁免量报出来供人工复核滥用
+    if (anchoredCount) {
+      process.stdout.write(
+        `细纲照搬检测（${path.basename(proseFile)}）：无未授权誊抄；` +
+          `另有 ${anchoredCount} 处 ${anchored} 字为复沓锚句的逐字落地。\n`
+      )
+    }
+    return 0
+  }
+
+  const rate = ((copied * 100) / P.length).toFixed(1)
+  // 短篇没有细纲：锚句登记在 小节大纲.md 末尾，措辞按短篇说，长篇原文不变
+  const isShort = path.basename(outlineFile) === '小节大纲.md'
+  const guidance = isShort
+    ? `逐条对照原文判断：确属把小节大纲叙述搬进正文就重写——大纲只锁功能与结果，句子在正文现场写；誓词、关键原话、固定专名等功能性重合可保留。每条都要有结论，不为归零机械改写。保留项由主会话登记进小节大纲.md 末尾「复沓锚句：」行下（每行一条原话，缩进写）再复检——子代理只重写正文或标 \`[需复核]\` 交回，不改小节大纲。`
+    : `逐条对照原文判断：确属把细纲叙述搬进正文就重写——细纲只锁功能与结果，句子在正文现场写；系统面板、誓词、案卷原话、固定专名等功能性重合可保留。每条都要有结论，不为归零机械改写。保留项由主会话补进细纲「复沓锚句」——子代理只重写正文或标 \`[需复核]\` 交回，不改大纲细纲。`
+  const out = [
+    `=== ${isShort ? '小节大纲' : '细纲'}照搬检测（${path.basename(proseFile)}）===`,
+    `正文 ${P.length} 字，与 ${path.basename(outlineFile)} 连续重合 >${MIN_RUN - 1} 字的片段 ${hits.length} 处，共 ${copied} 字（${rate}%）。`,
+    guidance,
+  ]
+  hits
+    .sort((a, b) => b.len - a.len)
+    .slice(0, REPORT_TOP)
+    .forEach((h) => out.push(`  · ${h.len} 字「${h.frag}」`))
+  if (hits.length > REPORT_TOP) out.push(`  · …另有 ${hits.length - REPORT_TOP} 处`)
+  if (anchoredCount) out.push(`（另有 ${anchoredCount} 处 ${anchored} 字为复沓锚句的逐字落地，不计入誊抄）`)
+  process.stdout.write(out.join('\n') + '\n')
+  return 1
+}
+
+try {
+  process.exit(main())
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error)
+  process.stderr.write(`错误: 细纲照搬检测异常：${message}。\n`)
+  process.exit(2)
+}

package/resources/skills/story-creation/upstream/skills/story-short-write/scripts/check-phase2-contract.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+/**
+ * Phase 2 deterministic contract verifier for story-short-write.
+ *
+ * This script is intentionally mechanical: it checks whether the two Phase 2
+ * artifacts expose the fields and table shape required by the skill. It does
+ * not pretend to judge story quality or whether a reference was genuinely
+ * understood.
+ *
+ * Usage: node scripts/check-phase2-contract.js --json [project-dir]
+ * Exit: 0 = pass, 1 = blocking contract failures, 2 = invalid invocation.
+ */
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const OUTLINE_HEADERS = [
+  '结构段/五段功能',
+  '主事件',
+  '情节推进',
+  '情绪',
+  '人物/关系变化',
+  '因果/逻辑链',
+  '读者新获知什么',
+  '结尾承接/钩子',
+  '伏笔/物件',
+  '场景形态',
+  '对白作用',
+  '目标字数',
+]
+
+const LEGACY_OUTLINE_HEADERS = new Map([
+  [2, '子事件×3-5'],
+  [9, '动静'],
+  [10, '对话密度'],
+])
+
+const FUNCTION_TAG = /\{(?:对话|冲突|伏笔|回忆|发现|递进)\}/
+
+function cleanCell(value) {
+  return value.replace(/\*\*/g, '').replace(/`/g, '').trim()
+}
+
+function parseTableLine(line) {
+  const trimmed = line.trim()
+  if (!trimmed.startsWith('|') || !trimmed.endsWith('|')) return null
+  return trimmed.slice(1, -1).split('|').map(cleanCell)
+}
+
+function isSeparatorRow(cells) {
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell))
+}
+
+function readUtf8(file) {
+  try {
+    const text = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '')
+    return { ok: text.trim().length > 0, text }
+  } catch (error) {
+    return { ok: false, text: '', error: error.message }
+  }
+}
+
+function makeCheck(id, ok, file, evidence, expected, references, repair) {
+  return { id, ok, severity: 'blocking', file, evidence, expected, references, repair }
+}
+
+function verify(projectDir) {
+  const project = path.resolve(projectDir)
+  const skillRoot = path.resolve(__dirname, '..')
+  const settingsFile = path.join(project, '设定.md')
+  const outlineFile = path.join(project, '小节大纲.md')
+  const settingsRead = readUtf8(settingsFile)
+  const outlineRead = readUtf8(outlineFile)
+  const checks = []
+
+  checks.push(makeCheck(
+    'phase2.settings-readable',
+    settingsRead.ok,
+    '设定.md',
+    settingsRead.ok ? '文件存在且非空' : (settingsRead.error || '文件为空'),
+    '项目目录下存在非空的 设定.md',
+    ['references/writing-workflow.md'],
+    '只补建或补全 设定.md，不改动已通过的 小节大纲.md。'
+  ))
+  checks.push(makeCheck(
+    'phase2.outline-readable',
+    outlineRead.ok,
+    '小节大纲.md',
+    outlineRead.ok ? '文件存在且非空' : (outlineRead.error || '文件为空'),
+    '项目目录下存在非空的 小节大纲.md',
+    ['references/writing-workflow.md'],
+    '只补建或补全 小节大纲.md，不改动已通过的 设定.md。'
+  ))
+
+  if (!settingsRead.ok || !outlineRead.ok) return report(project, checks)
+
+  const settings = settingsRead.text
+  const outline = outlineRead.text
+
+  const platformMatch = settings.match(/目标平台\s*[：:]\s*(知乎(?:盐选)?|小程序|番茄(?:短篇)?)/)
+  checks.push(makeCheck(
+    'phase2.platform-declared',
+    Boolean(platformMatch),
+    '设定.md',
+    platformMatch ? `目标平台：${platformMatch[1]}` : '未找到可识别的目标平台字段',
+    '写明“目标平台：知乎盐选 / 小程序 / 番茄短篇”之一',
+    ['references/submission-craft.md'],
+    '只在 设定.md 的基本信息或 Phase 2 设计校验区补目标平台。'
+  ))
+
+  const genreMatch = settings.match(/(?:题材参考|题材包)\s*[：:]\s*`?(references\/(?:genre-styles\/[^`\s|]+\.md|genre-writing-formulas\.md))`?/)
+  let genreEvidence = '未找到题材参考路径'
+  let genreOk = false
+  if (genreMatch) {
+    const resolved = path.resolve(skillRoot, genreMatch[1])
+    const insideSkill = resolved.startsWith(`${skillRoot}${path.sep}`)
+    genreOk = insideSkill && fs.existsSync(resolved) && fs.statSync(resolved).isFile()
+    genreEvidence = genreOk ? `题材参考：${genreMatch[1]}` : `题材参考不可读：${genreMatch[1]}`
+  }
+  checks.push(makeCheck(
+    'phase2.genre-reference-declared',
+    genreOk,
+    '设定.md',
+    genreEvidence,
+    '写明一个真实存在的 references/genre-styles/{题材}.md；冷门题材写 references/genre-writing-formulas.md',
+    ['references/writing-workflow.md', 'references/short-craft.md'],
+    '只补题材参考路径与从该参考选出的 2-3 个核心招式，不重写故事框架。'
+  ))
+
+  const movesMatch = settings.match(/核心招式\s*[：:]\s*([^\n]+)/)
+  const moves = movesMatch
+    ? movesMatch[1].split(/[；;]|\s\/\s/).map((item) => item.trim()).filter(Boolean)
+    : []
+  checks.push(makeCheck(
+    'phase2.genre-moves-declared',
+    moves.length >= 2 && moves.length <= 3,
+    '设定.md',
+    moves.length ? `识别到 ${moves.length} 个核心招式` : '未找到核心招式字段',
+    '“核心招式：招式一；招式二[；招式三]”，共 2-3 个',
+    ['references/writing-workflow.md'],
+    '只补或收敛核心招式字段到 2-3 个，并保持已选题材参考不变。'
+  ))
+
+  const villainSkipped = /反派(?:设计)?\s*[：:]\s*(?:无|不适用)\s*[（(][^)）]+[)）]/.test(settings)
+  const villainFields = ['身份', '动机', '作恶方式', '致命弱点', '报应']
+  const missingVillainFields = villainFields.filter((field) => !new RegExp(`(?:^|\\n)\\s*[-*]?\\s*${field}\\s*[：:]`, 'm').test(settings))
+  const villainOk = villainSkipped || missingVillainFields.length === 0
+  checks.push(makeCheck(
+    'phase2.villain-contract',
+    villainOk,
+    '设定.md',
+    villainSkipped ? '已明确反派不适用' : (villainOk ? '反派五字段齐全' : `缺字段：${missingVillainFields.join('、')}`),
+    '无反派时写“反派设计：不适用（原因）”；有反派时填写身份、动机、作恶方式、致命弱点、报应',
+    ['references/villain-and-reveal.md'],
+    '只补反派缺失字段；若确无反派，改为带原因的不适用声明。'
+  ))
+
+  const placeholderFields = ['题材参考', '核心招式', '反派设计', '反转类型', '反转位置', '付费点', '目标平台', '目标字数']
+  const placeholderLines = settings.split(/\r?\n/)
+    .map((line, index) => ({ line: index + 1, text: line }))
+    .filter((entry) => placeholderFields.some((field) => entry.text.includes(`${field}：`) || entry.text.includes(`${field}:`)))
+    .filter((entry) => /\{[^}]*\}/.test(entry.text))
+  checks.push(makeCheck(
+    'phase2.no-template-placeholders',
+    placeholderLines.length === 0,
+    '设定.md',
+    placeholderLines.length ? `仍是模板占位符的行：${placeholderLines.map((entry) => entry.line).join('、')}` : '契约字段没有未填写的 {} 占位符',
+    'Phase 2 契约字段写实际设计内容，不保留 {} 模板占位符',
+    ['references/writing-workflow.md'],
+    '只把报告行的占位符替换成本篇的实际设计，不重写其他字段。'
+  ))
+
+  const lines = outline.split(/\r?\n/)
+  let headerAt = -1
+  let headerCells = null
+  for (let index = 0; index < lines.length; index++) {
+    const cells = parseTableLine(lines[index])
+    if (cells && cells[0] === OUTLINE_HEADERS[0]) {
+      headerAt = index
+      headerCells = cells
+      break
+    }
+  }
+  const currentHeader = Boolean(headerCells) && headerCells.length === OUTLINE_HEADERS.length &&
+    headerCells.every((cell, index) => cell === OUTLINE_HEADERS[index])
+  const legacyHeader = Boolean(headerCells) && headerCells.length === OUTLINE_HEADERS.length &&
+    headerCells.every((cell, index) => cell === (LEGACY_OUTLINE_HEADERS.get(index) || OUTLINE_HEADERS[index]))
+  const headerOk = currentHeader || legacyHeader
+  checks.push(makeCheck(
+    'phase2.outline-12-columns',
+    headerOk,
+    '小节大纲.md',
+    headerCells
+      ? `表头 ${headerCells.length} 列：${headerCells.join(' | ')}${legacyHeader ? '（兼容旧项目；新建项目使用现行列名）' : ''}`
+      : '未找到以“结构段/五段功能”开头的 Markdown 表格',
+    `使用固定 12 列表头：${OUTLINE_HEADERS.join(' | ')}`,
+    ['references/writing-workflow.md'],
+    '只修表头和错位单元格，不改动各节已经成立的剧情内容。'
+  ))
+
+  const rows = []
+  if (headerAt >= 0) {
+    for (let index = headerAt + 1; index < lines.length; index++) {
+      const cells = parseTableLine(lines[index])
+      if (!cells) {
+        if (rows.length) break
+        continue
+      }
+      if (isSeparatorRow(cells)) continue
+      rows.push({ line: index + 1, cells })
+    }
+  }
+  const rowShapeFailures = rows.filter((row) => row.cells.length !== OUTLINE_HEADERS.length)
+  checks.push(makeCheck(
+    'phase2.outline-data-rows',
+    rows.length > 0 && rowShapeFailures.length === 0,
+    '小节大纲.md',
+    rows.length === 0 ? '固定表头下没有数据行' : (rowShapeFailures.length ? `列数错误行：${rowShapeFailures.map((row) => row.line).join('、')}` : `识别到 ${rows.length} 节，均为 12 列`),
+    '固定表头下至少一行数据，且每节恰好 12 列',
+    ['references/writing-workflow.md'],
+    '只补缺失节或修复报告行的列错位。'
+  ))
+
+  const progressionFailures = []
+  const progressionRows = rows.filter((item) => item.cells.length === OUTLINE_HEADERS.length)
+  for (const row of progressionRows) {
+    const progression = row.cells[2].split(/\s*(?:->|→)\s*/).filter(Boolean)
+    if (progression.length < 1 || progression.some((item) => !FUNCTION_TAG.test(item))) {
+      progressionFailures.push(row.line)
+    }
+  }
+  checks.push(makeCheck(
+    'phase2.outline-subevents',
+    rows.length > 0 && progressionFailures.length === 0,
+    '小节大纲.md',
+    progressionFailures.length
+      ? `情节推进为空或功能标签错误行：${progressionFailures.join('、')}`
+      : (progressionRows.length === rows.length
+          ? `所有 ${rows.length} 节均有至少一个带功能标签的真实推进`
+          : `已检查 ${progressionRows.length}/${rows.length} 行；其余行由 phase2.outline-data-rows 报告列错位`),
+    '每节至少一个真实推进；有先后关系时以 -> 连接，每个含 {对话/冲突/伏笔/回忆/发现/递进} 标签之一，不设固定数量',
+    ['references/writing-workflow.md', 'references/short-craft.md'],
+    '只修报告行的“情节推进”单元格，不重写其他列或其他节；不要为数量补事件。'
+  ))
+
+  const targetMatch = settings.match(/目标字数\s*[：:]\s*(?:约\s*)?([\d,，]+)\s*(?:字)?\s*(?:[-–—~～]|到|至)\s*([\d,，]+)\s*字?/) ||
+    settings.match(/目标字数\s*[：:]\s*(?:约\s*)?([\d,，]+)\s*字?/)
+  const toNumber = (value) => Number(String(value).replace(/[,，]/g, ''))
+  const targetLow = targetMatch ? toNumber(targetMatch[1]) : null
+  const targetHigh = targetMatch && targetMatch[2] !== undefined ? toNumber(targetMatch[2]) : targetLow
+  const statedTarget = targetLow
+  const rowTargets = progressionRows.map((row) => {
+    const match = row.cells[11].match(/([\d,，]+)/)
+    return match ? Number(match[1].replace(/[,，]/g, '')) : null
+  })
+  const targetSum = rowTargets.every((value) => Number.isFinite(value))
+    ? rowTargets.reduce((sum, value) => sum + value, 0)
+    : null
+  const isRange = targetHigh !== null && targetHigh !== targetLow
+  const targetOk = statedTarget !== null && statedTarget >= 1000 && targetHigh <= 200000 &&
+    targetHigh >= targetLow && progressionRows.length === rows.length && targetSum !== null &&
+    (isRange
+      ? targetSum >= targetLow && targetSum <= targetHigh
+      : Math.abs(targetSum - statedTarget) <= statedTarget * 0.05)
+  checks.push(makeCheck(
+    'phase2.target-word-sum',
+    targetOk,
+    '设定.md、小节大纲.md',
+    `设定目标：${statedTarget === null ? '未识别' : (isRange ? `${targetLow}-${targetHigh}` : statedTarget)}；大纲合计：${targetSum === null ? '有非数字目标字数' : targetSum}`,
+    '设定.md 的目标字数为 1000-200000 的正整数或区间（用户明确范围优先，未指定时默认 8000-20000）；大纲每行目标字数可解析，写区间时合计落在区间内，写单值时误差不超过 5%',
+    ['references/writing-workflow.md', 'references/submission-craft.md'],
+    '只修目标字数字段或各节“目标字数”单元格，使合计匹配；不要用增删剧情绕过数字错误。'
+  ))
+
+  const reversalMatch = settings.match(/反转位置\s*[：:]\s*第?\s*(\d+)\s*节?\s*(?:÷|\/)\s*(?:共|全文)?\s*(\d+)\s*节?\s*=\s*(\d+(?:\.\d+)?)\s*%/)
+  const noReversal = /反转类型\s*[：:]\s*无反转/.test(settings) &&
+    /反转位置\s*[：:]\s*不适用\s*[（(][^)）]+[)）]/.test(settings)
+  let reversalOk = false
+  let reversalEvidence = '未找到“反转位置：第 X 节 ÷ 共 Y 节 = Z%”'
+  if (noReversal) {
+    reversalOk = true
+    reversalEvidence = '反转类型为无反转，位置已带原因标为不适用'
+  } else if (reversalMatch) {
+    const reveal = Number(reversalMatch[1])
+    const total = Number(reversalMatch[2])
+    const stated = Number(reversalMatch[3])
+    const calculated = total > 0 ? (reveal / total) * 100 : NaN
+    reversalOk = reveal >= 1 && reveal <= total && total === rows.length &&
+      Math.abs(stated - calculated) <= 0.6
+    reversalEvidence = `声明第 ${reveal} 节 ÷ 共 ${total} 节 = ${stated}%；大纲识别 ${rows.length} 节`
+  }
+  checks.push(makeCheck(
+    'phase2.reversal-position',
+    reversalOk,
+    '设定.md',
+    reversalEvidence,
+    '有反转时写明揭穿节号、全文总节数和计算百分比；总节数须与大纲一致，计算误差不超过 0.6%。无反转时写明“反转类型：无反转”和带原因的“反转位置：不适用（…）”',
+    ['references/writing-workflow.md', 'references/short-reversal.md'],
+    '只修正反转位置计算或对应节次；位置质量按 short-reversal.md 的误判决策与揭示后果功能链判断，不为跨过固定百分比而搬节。'
+  ))
+
+  const paywallMatch = settings.match(/付费点\s*[：:]\s*第?\s*(\d+)\s*节末/)
+  const paywallSection = paywallMatch ? Number(paywallMatch[1]) : null
+  const paywallRows = rows
+    .map((row, index) => ({ section: index + 1, hook: row.cells[7] || '' }))
+    .filter((row) => /付费点/.test(row.hook))
+  const paywallOk = paywallSection !== null && paywallRows.length === 1 &&
+    paywallRows[0].section === paywallSection
+  let paywallEvidence = '设定.md 未按“付费点：第 X 节末”声明'
+  if (paywallSection !== null && paywallRows.length === 0) {
+    paywallEvidence = `设定.md 声明第 ${paywallSection} 节末；大纲“结尾承接/钩子”列未标出付费点`
+  } else if (paywallSection !== null && paywallRows.length > 0) {
+    paywallEvidence = `设定.md 声明第 ${paywallSection} 节末；大纲标在第 ${paywallRows.map((row) => row.section).join('、')} 节`
+  }
+  checks.push(makeCheck(
+    'phase2.paywall-in-both',
+    paywallOk,
+    '设定.md、小节大纲.md',
+    paywallEvidence,
+    '设定.md 写“付费点：第 X 节末”，且小节大纲.md 第 X 行数据的“结尾承接/钩子”单元格只标一次“付费点”',
+    ['references/submission-craft.md', 'references/writing-workflow.md'],
+    '只在缺失的文件补同一个付费断点，并确保它位于对应节末的钩子单元格。'
+  ))
+
+  return report(project, checks)
+}
+
+function report(project, checks) {
+  const failures = checks.filter((check) => !check.ok)
+  return {
+    schema_version: 1,
+    verifier: 'story-short-write.phase2-contract',
+    project,
+    ok: failures.length === 0,
+    checks,
+    failures,
+    repair_scope: failures.map((failure) => ({
+      id: failure.id,
+      file: failure.file,
+      evidence: failure.evidence,
+      expected: failure.expected,
+      references: failure.references,
+      repair: failure.repair,
+    })),
+  }
+}
+
+function main(argv) {
+  const args = argv.filter((arg) => arg !== '--json')
+  if (args.length > 1 || args.some((arg) => arg.startsWith('--'))) {
+    process.stderr.write('用法: node scripts/check-phase2-contract.js --json [project-dir]\n')
+    return 2
+  }
+  const result = verify(args[0] || '.')
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
+  return result.ok ? 0 : 1
+}
+
+if (require.main === module) process.exitCode = main(process.argv.slice(2))
+
+module.exports = { OUTLINE_HEADERS, verify }