@waterwx/dsh-novel-forge 1.3.2 → 1.3.3-alpha

package/src/stage-contract.ts

@@ -0,0 +1,186 @@
+/**
+ * 阶段契约（Stage Contract）——宿主计算的「当前阶段 → 本轮允许的动作」。
+ *
+ * 设计来源（「作者请求中的当前阶段决定唯一允许命令」这一约定）：
+ * 允许的动作必须由宿主根据真实项目状态算出，而不是指望模型记住或自律。
+ * 宿主计算结果同时用于三处：
+ *   1) 注入助手系统提示词：模型知道自己在哪一步、下一步该做什么；
+ *   2) 通用续写指令（「继续 / 下一步」）下的写操作白名单强约束（阶段即唯一命令）；
+ *   3) 拒绝写操作时给出可执行的、阶段相关的理由，而不是一句「不允许」。
+ *
+ * 注意：作者显式点名的写操作永远优先于阶段白名单（作者终审权）；
+ * 阶段强约束只在作者没有指定具体对象（通用续写）时生效。
+ */
+
+import type { ChapterPlan, ProjectState, StageInfo } from './protocol.ts'
+
+/** 一个阶段契约（assistant 侧需要作为类型使用）。 */
+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,251 @@
+/**
+ * 张力曲线：把「每章该有多紧」显式化，并在出章后核对实际走向。
+ *
+ * 为什么要有它：长篇最常见的两种崩法——**一直高能没有呼吸**（读者疲劳）与
+ * **长时间低位打转**（读者流失）；这两种都不是单章问题，而是"曲线"问题，
+ * 单章审稿看不见。这里提供：
+ *   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 问题清单（可能为空）。
+ */
+/**
+ * run 型问题（连续同值 / 连续高位 / 连续低位）的受影响章号。
+ * 返回**完整区间**而不是首尾两点：中间章同样受这条曲线问题影响，
+ * 面板要能在每一章上给出「一键按建议修订」，合并层也要能把建议落到中间章。
+ */
+function runChapters(from: number, to: number): number[] {
+  const out: number[] = []
+  for (let no = from; no <= to; no++) out.push(no)
+  return out
+}
+
+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: runChapters(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: runChapters(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: runChapters(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
+    }),
+  }
+}

package/src/timeline.ts

@@ -0,0 +1,159 @@
+/**
+ * 故事时间线：把「章节正文」压成可排序的时间事件，用于后续章节的时间连续性。
+ *
+ * 与编年录的分工：编年录记「事实」（人物状态/资源/关系），时间线记「顺序」
+ * （什么时候、在哪里、谁在场、发生了什么），专门用来抓时间倒流、地点瞬移与
+ * 跨越章节的时序矛盾。
+ *
+ * 本模块只放纯逻辑（可离线单测）：排序、注入渲染、规则初筛、事件归一化；
+ * 模型交互（抽取/复核）在 engine.ts，落盘与路由在 routes.ts。
+ */
+
+import type { ProjectState, TimelineEvent, TimelineIssue } from './protocol.ts'
+
+/** 注入后续章节的时间线锚点条数（超过则显式声明省略，遵循截断显式化规则）。 */
+export const TIMELINE_CONTEXT_LIMIT = 12
+
+/** 时间线矛盾初筛的最少事件数（太少没有意义）。 */
+const MIN_EVENTS_FOR_CHECK = 2
+
+/** 归一化事件（清洗字符串、补 id/时间戳）。 */
+export function normalizeTimelineEvent(raw: Partial<TimelineEvent>, chapterNo: number, index: number, now = new Date().toISOString()): TimelineEvent {
+  const characters = Array.isArray(raw.characters) ? raw.characters.filter(c => typeof c === 'string' && c.trim() !== '') : []
+  return {
+    id: typeof raw.id === 'string' && raw.id !== '' ? raw.id : `tl-${chapterNo}-${index}-${Math.random().toString(36).slice(2, 8)}`,
+    chapterNo: typeof raw.chapterNo === 'number' ? raw.chapterNo : chapterNo,
+    time: (raw.time ?? '').trim(),
+    order: typeof raw.order === 'number' && Number.isFinite(raw.order) ? raw.order : undefined,
+    place: (raw.place ?? '').trim(),
+    characters: characters.map(c => c.trim()),
+    event: (raw.event ?? '').trim(),
+    source: raw.source === 'manual' ? 'manual' : 'extracted',
+    createdAt: raw.createdAt ?? now,
+  }
+}
+
+/** 时间线排序：先章节、再 order（缺省排在该章末尾）、最后 createdAt。 */
+export function sortTimeline(events: readonly TimelineEvent[]): TimelineEvent[] {
+  return [...events].sort((a, b) => {
+    if (a.chapterNo !== b.chapterNo) return a.chapterNo - b.chapterNo
+    const ao = a.order ?? Number.MAX_SAFE_INTEGER
+    const bo = b.order ?? Number.MAX_SAFE_INTEGER
+    if (ao !== bo) return ao - bo
+    return a.createdAt.localeCompare(b.createdAt)
+  })
+}
+
+/**
+ * 渲染注入到「写作/规划」提示词的时间线锚点块。
+ *
+ * @param project 项目状态。
+ * @param beforeChapter 只注入该章之前的锚点（含该章本身不注入，避免剧透）。
+ * @returns 提示词片段（无事件时返回空串）。带显式截断声明。
+ */
+export function renderTimelineBlock(project: ProjectState, beforeChapter: number): string {
+  const all = sortTimeline(project.timeline ?? []).filter(e => e.chapterNo < beforeChapter)
+  if (all.length === 0) return ''
+  const shown = all.slice(-TIMELINE_CONTEXT_LIMIT)
+  const omitted = all.length - shown.length
+  const head = omitted > 0
+    ? `【故事时间线（共 ${all.length} 条，此处只列最近 ${shown.length} 条；更早 ${omitted} 条未列出）】`
+    : `【故事时间线（共 ${shown.length} 条）】`
+  const lines = shown.map(e => {
+    const parts = [`[第${e.chapterNo}章]`]
+    if (e.time !== '') parts.push(e.time)
+    if (e.place !== '') parts.push(`@${e.place}`)
+    if (e.characters.length > 0) parts.push(`(${e.characters.join('、')})`)
+    parts.push(e.event)
+    return '- ' + parts.join(' ')
+  })
+  return `${head}\n${lines.join('\n')}\n写作时必须与前文时间顺序、地点衔接一致；不得让时间倒流或让人物瞬移。`
+}
+
+/**
+ * 规则初筛时间线矛盾（不调模型，瞬时计算）。
+ *
+ * 覆盖三类最容易犯又最容易用规则抓到的错：
+ *   1) 同一章内事件顺序号倒退；
+ *   2) 全书顺序号在章节推进后倒退（时间倒流）；
+ *   3) 相邻两章之间地点瞬移（同一角色在未交代移动的情况下跨地点）。
+ *
+ * @param project 项目状态。
+ * @returns 问题清单（可能为空）。
+ */
+export function detectTimelineIssues(project: ProjectState): TimelineIssue[] {
+  // 注意：这里用**原始数组顺序**分组（= 模型/作者的叙述顺序），而不是按 order 排序后的顺序。
+  // 否则「模型自报 order 与叙述顺序打架」这一类问题会被排序抹平，永远查不出来。
+  const stored = project.timeline ?? []
+  if (stored.length < MIN_EVENTS_FOR_CHECK) return []
+  const issues: TimelineIssue[] = []
+
+  // 1) 同章内顺序倒退（叙述顺序 vs 自报 order）
+  const byChapter = new Map<number, TimelineEvent[]>()
+  for (const e of stored) {
+    const list = byChapter.get(e.chapterNo) ?? []
+    list.push(e)
+    byChapter.set(e.chapterNo, list)
+  }
+  for (const [no, list] of byChapter) {
+    let lastOrder: number | undefined
+    for (const e of list) {
+      if (e.order === undefined) continue
+      if (lastOrder !== undefined && e.order < lastOrder) {
+        issues.push({
+          severity: 'medium',
+          chapters: [no],
+          item: `第${no}章内时间顺序倒退：事件「${e.event}」的顺序号 ${e.order} 小于前一条 ${lastOrder}`,
+          suggestion: '检查这两条事件的先后关系，修正 order 或改写正文的时间描述。',
+        })
+      }
+      lastOrder = e.order
+    }
+  }
+
+  // 2) 跨章时间倒流（用每章最大 order 与上一章比较）
+  const chapterMax: Array<{ no: number; max: number; event: TimelineEvent }> = []
+  for (const [no, list] of [...byChapter].sort((a, b) => a[0] - b[0])) {
+    const withOrder = list.filter(e => e.order !== undefined)
+    if (withOrder.length === 0) continue
+    const maxEvent = withOrder.reduce((best, e) => ((e.order ?? 0) > (best.order ?? 0) ? e : best), withOrder[0]!)
+    chapterMax.push({ no, max: maxEvent.order ?? 0, event: maxEvent })
+  }
+  for (let i = 1; i < chapterMax.length; i++) {
+    const prev = chapterMax[i - 1]!
+    const cur = chapterMax[i]!
+    if (cur.max < prev.max) {
+      issues.push({
+        severity: 'high',
+        chapters: [prev.no, cur.no],
+        item: `时间倒流：第${cur.no}章（${cur.event.time || '未标注时间'}）早于第${prev.no}章（${prev.event.time || '未标注时间'}）`,
+        suggestion: '确认是否需要补写过渡（回忆/插叙）或调整章节顺序；若是有意插叙，请在正文中明确标注。',
+      })
+    }
+  }
+
+  // 3) 相邻章地点瞬移（同一角色、地点变化且新地点首次出现）
+  const seenPlaces = new Set<string>()
+  let prevPlace = ''
+  const lastChapterOf = new Map<string, string>()
+  for (const e of sortTimeline(stored)) {
+    if (e.place !== '') {
+      if (prevPlace !== '' && e.place !== prevPlace && !seenPlaces.has(e.place)) {
+        // 新地点首次出现：只有在同一角色上一章还在别处时才提示
+        const moved = e.characters.filter(c => lastChapterOf.get(c) !== undefined && lastChapterOf.get(c) !== e.place)
+        if (moved.length > 0) {
+          issues.push({
+            severity: 'medium',
+            chapters: [e.chapterNo],
+            item: `地点衔接存疑：${moved.join('、')} 上一场景在「${lastChapterOf.get(moved[0]!) ?? '?'}」，本章直接出现在「${e.place}」`,
+            suggestion: '补一句移动/时间流逝的交代，或确认是否漏写了赶路段落。',
+          })
+        }
+      }
+      seenPlaces.add(e.place)
+      prevPlace = e.place
+      for (const c of e.characters) lastChapterOf.set(c, e.place)
+    }
+  }
+  return issues
+}