@waterwx/dsh-novel-forge 1.2.0 → 1.3.0-alpha

package/src/snapshots.ts

@@ -0,0 +1,174 @@
+/**
+ * 章节历史版本（快照）：覆盖写入前自动留存正文，支持列表 / 回滚 / 清理。
+ *
+ * 为什么需要它：生成、按意见重写、去 AI 味润色、采纳草稿都会**覆盖** `第N章_*.md`，
+ * 一旦改差（尤其是自动修订把好稿改坏）就没有退路。这里在覆盖前把旧稿存到
+ * `<书目录>/snapshots/`，并维护一份 `snapshots/index.json` 索引。
+ *
+ * 纯 Node 文件操作，不依赖模型；路由层只做参数校验与响应。
+ */
+
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { ChapterPlan, ChapterSnapshot } from './protocol.ts'
+
+/** 快照目录名（书目录下）。 */
+export const SNAPSHOT_DIR = 'snapshots'
+
+/** 索引文件名。 */
+const INDEX_FILE = 'index.json'
+
+/** 每章默认保留的快照数（超出后按时间淘汰最旧的）。 */
+export const DEFAULT_SNAPSHOT_KEEP = 20
+
+/** 快照目录绝对路径。 */
+export function snapshotDir(outputDir: string): string {
+  return join(outputDir, SNAPSHOT_DIR)
+}
+
+/** 读取索引（缺失/损坏时返回空数组）。 */
+export function loadSnapshots(outputDir: string): ChapterSnapshot[] {
+  const file = join(snapshotDir(outputDir), INDEX_FILE)
+  if (!existsSync(file)) return []
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8')) as { snapshots?: ChapterSnapshot[] }
+    return Array.isArray(parsed.snapshots) ? parsed.snapshots : []
+  } catch {
+    return []
+  }
+}
+
+/** 写回索引。 */
+function saveSnapshots(outputDir: string, snapshots: ChapterSnapshot[]): void {
+  const dir = snapshotDir(outputDir)
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, INDEX_FILE), JSON.stringify({ snapshots }, null, 2), 'utf8')
+}
+
+/** 快照占用字节数（索引 + 正文）。 */
+export function snapshotsBytes(outputDir: string): number {
+  const dir = snapshotDir(outputDir)
+  if (!existsSync(dir)) return 0
+  let total = 0
+  try {
+    for (const name of readdirSync(dir)) {
+      try { total += statSync(join(dir, name)).size } catch { /* 跳过读不到的条目 */ }
+    }
+  } catch { /* 目录不可读时按 0 计 */ }
+  return total
+}
+
+/** 生成快照文件名（章节 + 时间戳 + 原因短标识）。 */
+function snapshotFileName(chapterNo: number, reason: string, at: string): string {
+  const stamp = at.replace(/[:.]/g, '-')
+  const tag = reason.replace(/[^\w\u4e00-\u9fa5-]+/g, '').slice(0, 12) || 'snap'
+  return `ch${String(chapterNo).padStart(4, '0')}_${stamp}_${tag}.md`
+}
+
+/**
+ * 为一个章节留存快照（覆盖写入前调用）。
+ *
+ * @param outputDir 书目录。
+ * @param chapter 章节（需要已存在正文文件）。
+ * @param reason 留存原因（生成覆盖 / 采纳草稿 / 修订 / 润色 / 手工）。
+ * @param keep 每章保留数量（超出淘汰最旧）。
+ * @returns 新建的快照；无正文文件时返回 undefined（不产生空快照）。
+ */
+export function createSnapshot(
+  outputDir: string,
+  chapter: ChapterPlan,
+  reason: string,
+  keep = DEFAULT_SNAPSHOT_KEEP,
+): ChapterSnapshot | undefined {
+  if (chapter.file === undefined || chapter.file === '') return undefined
+  const source = join(outputDir, chapter.file)
+  if (!existsSync(source)) return undefined
+  const at = new Date().toISOString()
+  const dir = snapshotDir(outputDir)
+  mkdirSync(dir, { recursive: true })
+  const name = snapshotFileName(chapter.no, reason, at)
+  const target = join(dir, name)
+  try {
+    copyFileSync(source, target)
+  } catch {
+    return undefined
+  }
+  const chars = chapter.chars ?? 0
+  const snapshot: ChapterSnapshot = {
+    id: name,
+    chapterNo: chapter.no,
+    file: `${SNAPSHOT_DIR}/${name}`,
+    reason,
+    chars,
+    at,
+  }
+  const snapshots = [...loadSnapshots(outputDir), snapshot]
+  saveSnapshots(outputDir, pruneList(snapshots, keep))
+  return snapshot
+}
+
+/** 按「每章保留最近 keep 个」裁剪列表，并删除被淘汰的文件。 */
+function pruneList(snapshots: ChapterSnapshot[], keep: number): ChapterSnapshot[] {
+  const byChapter = new Map<number, ChapterSnapshot[]>()
+  for (const s of snapshots) {
+    const list = byChapter.get(s.chapterNo) ?? []
+    list.push(s)
+    byChapter.set(s.chapterNo, list)
+  }
+  const kept: ChapterSnapshot[] = []
+  for (const list of byChapter.values()) {
+    list.sort((a, b) => b.at.localeCompare(a.at))
+    kept.push(...list.slice(0, Math.max(1, keep)))
+  }
+  return kept.sort((a, b) => a.at.localeCompare(b.at))
+}
+
+/**
+ * 回滚到某个快照：把快照内容写回章节正文文件。
+ *
+ * 回滚前会**先给当前正文留一份快照**（reason=回滚前自动留存），所以回滚本身也可撤销。
+ *
+ * @param outputDir 书目录。
+ * @param chapter 目标章节。
+ * @param snapshotId 快照 id。
+ * @returns 回滚后的字符数。
+ * @throws 快照不存在或章节无正文文件时抛错。
+ */
+export function restoreSnapshot(outputDir: string, chapter: ChapterPlan, snapshotId: string): number {
+  const snapshots = loadSnapshots(outputDir)
+  const snapshot = snapshots.find(s => s.id === snapshotId)
+  if (snapshot === undefined) throw new Error(`快照不存在：${snapshotId}`)
+  if (snapshot.chapterNo !== chapter.no) throw new Error(`快照属于第 ${snapshot.chapterNo} 章，与目标第 ${chapter.no} 章不符`)
+  const source = join(outputDir, snapshot.file)
+  if (!existsSync(source)) throw new Error(`快照文件已丢失：${snapshot.file}`)
+  if (chapter.file === undefined || chapter.file === '') throw new Error(`第 ${chapter.no} 章没有正文文件，无法回滚`)
+  createSnapshot(outputDir, chapter, '回滚前留存')
+  const body = readFileSync(source, 'utf8')
+  writeFileSync(join(outputDir, chapter.file), body, 'utf8')
+  return body.length
+}
+
+/** 删除一个快照（连同文件）。 */
+export function removeSnapshot(outputDir: string, snapshotId: string): boolean {
+  const snapshots = loadSnapshots(outputDir)
+  const snapshot = snapshots.find(s => s.id === snapshotId)
+  if (snapshot === undefined) return false
+  try { rmSync(join(outputDir, snapshot.file), { force: true }) } catch { /* 文件已不在 */ }
+  saveSnapshots(outputDir, snapshots.filter(s => s.id !== snapshotId))
+  return true
+}
+
+/** 按每章保留数量清理（连文件一起删）。 */
+export function pruneSnapshots(outputDir: string, keep = DEFAULT_SNAPSHOT_KEEP): number {
+  const snapshots = loadSnapshots(outputDir)
+  const kept = pruneList(snapshots, keep)
+  const keptIds = new Set(kept.map(s => s.id))
+  let removed = 0
+  for (const s of snapshots) {
+    if (keptIds.has(s.id)) continue
+    try { rmSync(join(outputDir, s.file), { force: true }) } catch { /* ignore */ }
+    removed++
+  }
+  saveSnapshots(outputDir, kept)
+  return removed
+}

package/src/stage-contract.ts

@@ -0,0 +1,189 @@
+/**
+ * 阶段契约（Stage Contract）——宿主计算的「当前阶段 → 本轮允许的动作」。
+ *
+ * 设计来源（「作者请求中的当前阶段决定唯一允许命令」这一约定）：
+ * 允许的动作必须由宿主根据真实项目状态算出，而不是指望模型记住或自律。
+ * 宿主计算结果同时用于三处：
+ *   1) 注入助手系统提示词：模型知道自己在哪一步、下一步该做什么；
+ *   2) 通用续写指令（「继续 / 下一步」）下的写操作白名单强约束（阶段即唯一命令）；
+ *   3) 拒绝写操作时给出可执行的、阶段相关的理由，而不是一句「不允许」。
+ *
+ * 注意：作者显式点名的写操作永远优先于阶段白名单（作者终审权）；
+ * 阶段强约束只在作者没有指定具体对象（通用续写）时生效。
+ */
+
+import type { ChapterPlan, ProjectState, StageInfo } from './protocol.ts'
+
+/** 创作阶段标识（线上形状见 protocol.ts 的 StageInfo）。 */
+export type BookStageId = StageInfo['id']
+
+/** 一个阶段契约。 */
+export type BookStage = StageInfo
+
+/** 大纲视为「已开书」的最短长度。 */
+const MIN_OUTLINE_CHARS = 50
+
+/** 通用续写指令（作者没有指定具体对象时，阶段白名单成为唯一命令）。 */
+const GENERIC_CONTINUE = /^(继续|下一步|接着来|接着写|往下|往下走|继续吧|go\s*on|continue|next)[。.!！?？\s]*$/i
+
+/**
+ * 作者这一轮是否只说了「继续/下一步」这类没有具体对象的指令。
+ *
+ * @param message 本轮用户消息。
+ * @returns 是通用续写指令时为 true。
+ */
+export function isGenericContinue(message: string): boolean {
+  return GENERIC_CONTINUE.test((message ?? '').trim())
+}
+
+/**
+ * 根据项目真实状态计算当前创作阶段。
+ *
+ * @param project 当前项目（未加载时为 undefined）。
+ * @returns 阶段契约（推荐动作 + 写操作白名单 + 判定理由）。
+ */
+export function computeBookStage(project: ProjectState | undefined): BookStage {
+  if (project === undefined || (project.outline ?? '').trim().length < MIN_OUTLINE_CHARS) {
+    return {
+      id: 'outline',
+      label: '开书',
+      recommend: ['outline_replace'],
+      allow: ['outline_replace'],
+      reason: project === undefined ? '尚无项目' : '大纲为空或过短',
+    }
+  }
+  if (project.bible === undefined) {
+    return {
+      id: 'bible',
+      label: '立设定',
+      recommend: ['bible_set_rule', 'bible_set_redline'],
+      allow: ['bible_set_rule', 'bible_set_redline'],
+      reason: '已有大纲，尚未提炼道藏',
+    }
+  }
+  const chapters = project.chapters ?? []
+  if (chapters.length === 0) {
+    return {
+      id: 'plan',
+      label: '排章节',
+      recommend: [],
+      // 章节规划不在助手的动作集里：通用「继续」不应被解释成改写总纲或设定。
+      allow: [],
+      reason: '有道藏但还没有章节计划（规划在「小说工坊」面板或生产单里执行）',
+    }
+  }
+  const generating = chapters.filter(c => c.status === 'generating')
+  if (generating.length > 0) {
+    return {
+      id: 'wait',
+      label: '等待中',
+      recommend: [],
+      allow: [],
+      reason: `第 ${generating.map(c => c.no).join('、')} 章正在生成，等它结束后再安排下一步`,
+    }
+  }
+  const errored = chapters.filter(c => c.status === 'error')
+  if (errored.length > 0) {
+    return {
+      id: 'write',
+      label: '逐章编译',
+      recommend: ['chapter_generate'],
+      allow: ['chapter_generate', 'chapter_rewrite', 'chapter_review'],
+      reason: `第 ${errored.map(c => c.no).join('、')} 章生成失败，需要重写`,
+    }
+  }
+  const rejected = chapters.filter(c => c.status === 'rejected')
+  if (rejected.length > 0) {
+    return {
+      id: 'revise',
+      label: '修订循环',
+      recommend: ['chapter_rewrite'],
+      allow: ['chapter_rewrite', 'chapter_review'],
+      reason: `第 ${rejected.map(c => c.no).join('、')} 章审稿未过，需要按意见修订`,
+    }
+  }
+  const awaitingReview = chapters.filter(c => c.status === 'written' || c.status === 'reviewing')
+  if (awaitingReview.length > 0) {
+    return {
+      id: 'review',
+      label: '审稿',
+      recommend: ['chapter_review'],
+      allow: ['chapter_review', 'chapter_rewrite'],
+      reason: `第 ${awaitingReview.map(c => c.no).join('、')} 章已写出但尚未审稿`,
+    }
+  }
+  const pending = chapters.filter(c => c.status === 'pending')
+  if (pending.length > 0) {
+    return {
+      id: 'write',
+      label: '逐章编译',
+      recommend: ['chapter_generate'],
+      allow: ['chapter_generate', 'chapter_rewrite', 'chapter_review'],
+      reason: `还有 ${pending.length} 章待写（下一章：第 ${pending[0]!.no} 章）`,
+    }
+  }
+  return {
+    id: 'export',
+    label: '定稿导出',
+    recommend: ['export_txt', 'blurb'],
+    // 全部通过后不再允许在「继续」下改写正文：要改必须由作者点名章节。
+    allow: ['export_txt', 'blurb'],
+    reason: `全书 ${chapters.length} 章均已通过审稿`,
+  }
+}
+
+/**
+ * 判断某写操作是否在当前阶段的允许白名单内。
+ *
+ * @param stage 阶段契约。
+ * @param tool 助手工具名。
+ * @returns 允许时为 true。
+ */
+export function stageAllows(stage: BookStage, tool: string): boolean {
+  return stage.allow.includes(tool)
+}
+
+/**
+ * 按阶段把一组动作分成「本阶段可用」与「阶段外」。
+ *
+ * @param stage 阶段契约。
+ * @param tools 动作名列表（通常是写操作登记表）。
+ * @returns 两个保持输入顺序的子集。
+ */
+export function splitByStage(stage: BookStage, tools: readonly string[]): { available: string[]; outside: string[] } {
+  const available: string[] = []
+  const outside: string[] = []
+  for (const tool of tools) {
+    if (stageAllows(stage, tool)) available.push(tool)
+    else outside.push(tool)
+  }
+  return { available, outside }
+}
+
+/**
+ * 渲染阶段契约为可注入提示词的一段文字。
+ *
+ * @param stage 阶段契约。
+ * @returns 多行文本。
+ */
+export function renderStageContract(stage: BookStage): string {
+  const recommend = stage.recommend.length > 0 ? stage.recommend.join('、') : '无（等待或由作者指定）'
+  const allow = stage.allow.length > 0 ? stage.allow.join('、') : '无'
+  return [
+    '==================== 当前创作阶段（宿主根据项目真实状态计算） ====================',
+    `阶段：${stage.label}（${stage.id}）`,
+    `判定依据：${stage.reason}`,
+    `建议下一步：${recommend}`,
+    `本阶段允许的写操作：${allow}`,
+    '阶段纪律：作者只说了「继续/下一步」而没指定具体对象时，只有上面的写操作会被执行，其余写操作一律拒绝；作者显式点名某个操作时以作者指令为准。',
+  ].join('\n')
+}
+
+/** 汇总章节状态计数（供面板/提示词展示，避免各处重复统计）。 */
+export function summarizeChapters(chapters: ChapterPlan[]): Record<string, number> {
+  const summary: Record<string, number> = {}
+  for (const chapter of chapters) {
+    summary[chapter.status] = (summary[chapter.status] ?? 0) + 1
+  }
+  return summary
+}

package/src/tension.ts

@@ -0,0 +1,240 @@
+/**
+ * 张力曲线：把「每章该有多紧」显式化，并在出章后核对实际走向。
+ *
+ * 为什么要有它：长篇最常见的两种崩法——**一直高能没有呼吸**（读者疲劳）与
+ * **长时间低位打转**（读者流失）；这两种都不是单章问题，而是"曲线"问题，
+ * 单章审稿看不见。这里提供：
+ *   1) 参考曲线（本项目自行设计，仅作形状参照）；
+ *   2) 把「本章目标张力」注入写作提示词；
+ *   3) 规则核对：实际 vs 目标偏差、连续同值、高潮后不回落、长期低位。
+ *
+ * 本模块只放纯逻辑（可离线单测）；模型交互与落盘在 engine/routes。
+ */
+
+import type { ChapterPlan, ProjectState, TensionCurvePreset, TensionIssue } from './protocol.ts'
+
+/** 单章张力的取值范围。 */
+export const TENSION_MIN = 0
+export const TENSION_MAX = 100
+
+/**
+ * 本项目设计的参考曲线形状（0-100 的采样序列）。
+ * 只描述"形状"，不含任何外部数值表。
+ */
+const REFERENCE_SHAPES: Record<Exclude<TensionCurvePreset, 'custom'>, readonly number[]> = {
+  // 递进爬升：整体上行，波峰越来越大
+  escalation: [20, 26, 34, 32, 44, 52, 48, 62, 70, 66, 82, 92],
+  // 悬疑加压：中段起缓慢抬升，末段释放
+  suspense: [30, 42, 38, 50, 46, 58, 62, 56, 70, 78, 86, 74],
+  // 波浪呼吸：高低交替，给读者留呼吸口
+  wave: [45, 30, 55, 34, 62, 40, 70, 46, 78, 52, 84, 60],
+  // 前紧后稳：开篇抓人，中后段平缓推进
+  frontLoad: [78, 66, 58, 50, 46, 44, 42, 44, 46, 48, 50, 52],
+  // 平稳推进：几乎无起伏（适合日常/经营类）
+  flat: [40, 42, 44, 42, 46, 44, 48, 46, 50, 48, 52, 50],
+}
+
+/** 参考曲线的中文标签（面板展示）。 */
+export const TENSION_PRESET_LABELS: Record<TensionCurvePreset, string> = {
+  escalation: '递进爬升',
+  suspense: '悬疑加压',
+  wave: '波浪呼吸',
+  frontLoad: '前紧后稳',
+  flat: '平稳推进',
+  custom: '自定义',
+}
+
+/** 全部可选预设（UI 下拉用）。 */
+export const TENSION_PRESETS: readonly TensionCurvePreset[] = ['escalation', 'suspense', 'wave', 'frontLoad', 'flat', 'custom']
+
+/** 把参考形状按章节数重采样（最近邻，保持形状不引入平滑失真）。 */
+export function referenceCurve(preset: TensionCurvePreset, chapterCount: number): number[] {
+  if (chapterCount <= 0) return []
+  if (preset === 'custom') return []
+  const shape = REFERENCE_SHAPES[preset]
+  if (chapterCount === 1) return [shape[Math.floor(shape.length / 2)] ?? 50]
+  return Array.from({ length: chapterCount }, (_, i) => {
+    const pos = (i / (chapterCount - 1)) * (shape.length - 1)
+    const lo = Math.floor(pos)
+    const hi = Math.min(shape.length - 1, lo + 1)
+    const t = pos - lo
+    const a = shape[lo] ?? 50
+    const b = shape[hi] ?? a
+    return Math.round(a + (b - a) * t)
+  })
+}
+
+/** 读一章的目标张力（未设置时返回 undefined）。 */
+export function targetTension(chapter: ChapterPlan): number | undefined {
+  return typeof chapter.tension === 'number' ? clampTension(chapter.tension) : undefined
+}
+
+/** 读一章的实际张力（审稿时模型打分，未设置时返回 undefined）。 */
+export function actualTension(chapter: ChapterPlan): number | undefined {
+  const fromReview = chapter.review?.tension
+  if (typeof fromReview === 'number') return clampTension(fromReview)
+  return typeof chapter.tensionActual === 'number' ? clampTension(chapter.tensionActual) : undefined
+}
+
+/** 收敛到合法区间并取整。 */
+export function clampTension(value: number): number {
+  if (!Number.isFinite(value)) return TENSION_MIN
+  return Math.max(TENSION_MIN, Math.min(TENSION_MAX, Math.round(value)))
+}
+
+/**
+ * 渲染注入写作提示词的「本章张力」块。
+ *
+ * @param project 项目状态。
+ * @param chapterNo 本章章号。
+ * @returns 提示词片段；没有张力信息时返回空串。
+ */
+export function renderTensionBlock(project: ProjectState, chapterNo: number): string {
+  const preset = project.tensionCurve?.preset
+  const chapters = [...(project.chapters ?? [])].sort((a, b) => a.no - b.no)
+  const idx = chapters.findIndex(c => c.no === chapterNo)
+  if (idx === -1) return ''
+  const target = targetTension(chapters[idx]!)
+  const prev = idx > 0 ? targetTension(chapters[idx - 1]!) : undefined
+  if (target === undefined && prev === undefined) return ''
+  const ref = preset !== undefined && preset !== 'custom' ? referenceCurve(preset, chapters.length)[idx] : undefined
+  const parts: string[] = []
+  if (target !== undefined) parts.push(`本章目标张力 ${target}/100`)
+  if (prev !== undefined && target !== undefined) {
+    const delta = target - prev
+    parts.push(delta >= 10 ? '比上一章明显更紧' : delta <= -10 ? '比上一章明显放松（给读者呼吸口）' : '与上一章持平')
+  }
+  if (ref !== undefined) parts.push(`参考曲线（${TENSION_PRESET_LABELS[preset ?? 'custom']}）在此处约为 ${ref}`)
+  if (parts.length === 0) return ''
+  return [
+    '==================== 本章张力（写作时把握松紧） ====================',
+    parts.join('；') + '。',
+    '低张力段用于铺垫关系、交代信息、留呼吸；高张力段用于对抗、揭示、抉择与代价。',
+    '同一章内可以有起伏，但整章的平均松紧要贴近目标值；不要连续多章都停在同一个紧张度。',
+  ].join('\n')
+}
+
+/**
+ * 规则核对张力曲线（不调模型）。
+ *
+ * 检查四类曲线级问题：
+ *   1) 实际与目标偏差过大（>25）；
+ *   2) 连续多章几乎同值（≥4 章落差 <6，平台期无起伏）；
+ *   3) 高点之后没有回落（连续 ≥3 章处在高位 ≥80）；
+ *   4) 长期低位（连续 ≥5 章 <40，容易拖沓）。
+ *
+ * @param project 项目状态。
+ * @returns 问题清单（可能为空）。
+ */
+export function detectTensionIssues(project: ProjectState): TensionIssue[] {
+  const chapters = [...(project.chapters ?? [])].sort((a, b) => a.no - b.no)
+  const values = chapters.map(c => ({ no: c.no, target: targetTension(c), actual: actualTension(c) }))
+  const known = values.filter(v => v.target !== undefined || v.actual !== undefined)
+  if (known.length < 3) return []
+  const issues: TensionIssue[] = []
+
+  // 1) 偏差
+  for (const v of values) {
+    if (v.target === undefined || v.actual === undefined) continue
+    const gap = v.actual - v.target
+    if (Math.abs(gap) > 25) {
+      issues.push({
+        severity: Math.abs(gap) > 40 ? 'high' : 'medium',
+        chapters: [v.no],
+        item: `第${v.no}章张力偏差较大：目标 ${v.target}，实际 ${v.actual}（${gap > 0 ? '比目标更紧' : '比目标更松'}）`,
+        suggestion: gap > 0 ? '本章对抗/揭示密度偏高，考虑把部分冲突后移，留出呼吸段。' : '本章推进偏平，考虑加一处对抗、揭示或代价。',
+      })
+    }
+  }
+
+  // 2) 平台期（连续同值）
+  let run = 1
+  for (let i = 1; i < values.length; i++) {
+    const a = values[i - 1]!.target ?? values[i - 1]!.actual
+    const b = values[i]!.target ?? values[i]!.actual
+    if (a !== undefined && b !== undefined && Math.abs(b - a) < 6) {
+      run++
+      if (run === 4) {
+        const from = values[i - run + 1]!.no
+        issues.push({
+          severity: 'medium',
+          chapters: [from, values[i]!.no],
+          item: `第${from}-${values[i]!.no}章张力几乎无变化（连续 ${run} 章）`,
+          suggestion: '安排一次明显抬升或一次释放，让曲线有起伏，避免读者疲劳。',
+        })
+      }
+    } else {
+      run = 1
+    }
+  }
+
+  // 3) 高位不回落
+  let highRun = 0
+  for (const v of values) {
+    const val = v.target ?? v.actual
+    if (val !== undefined && val >= 80) {
+      highRun++
+      if (highRun === 3) {
+        issues.push({
+          severity: 'medium',
+          chapters: [v.no - 2, v.no],
+          item: `连续 ${highRun} 章处在高位（≥80），缺少呼吸口`,
+          suggestion: '高潮之后补一章缓冲（关系推进、信息消化或日常），再进入下一轮对抗。',
+        })
+      }
+    } else {
+      highRun = 0
+    }
+  }
+
+  // 4) 长期低位
+  let lowRun = 0
+  for (const v of values) {
+    const val = v.target ?? v.actual
+    if (val !== undefined && val < 40) {
+      lowRun++
+      if (lowRun === 5) {
+        issues.push({
+          severity: 'high',
+          chapters: [v.no - 4, v.no],
+          item: `连续 ${lowRun} 章张力低于 40，推进可能偏慢`,
+          suggestion: '提前兑现一个目标、抛出一个新风险，或让配角线产生冲撞。',
+        })
+      }
+    } else {
+      lowRun = 0
+    }
+  }
+
+  return issues
+}
+
+/**
+ * 组装面板需要的曲线数据（章节号 / 目标 / 实际 / 参考）。
+ *
+ * @param project 项目状态。
+ * @returns 逐章数据点与预设名。
+ */
+export function buildCurveData(project: ProjectState): {
+  preset: TensionCurvePreset
+  points: Array<{ no: number; title: string; target?: number; actual?: number; reference?: number }>
+} {
+  const preset: TensionCurvePreset = project.tensionCurve?.preset ?? 'escalation'
+  const chapters = [...(project.chapters ?? [])].sort((a, b) => a.no - b.no)
+  const custom = project.tensionCurve?.custom ?? []
+  const reference = preset === 'custom'
+    ? custom
+    : referenceCurve(preset, chapters.length)
+  return {
+    preset,
+    points: chapters.map((c, i) => {
+      const point: { no: number; title: string; target?: number; actual?: number; reference?: number } = { no: c.no, title: c.title }
+      const t = targetTension(c)
+      const a = actualTension(c)
+      if (t !== undefined) point.target = t
+      if (a !== undefined) point.actual = a
+      if (reference[i] !== undefined) point.reference = reference[i]
+      return point
+    }),
+  }
+}