@waterwx/dsh-novel-forge 1.10.1 → 2.0.0

package/src/engine.ts

@@ -8,7 +8,7 @@
 
 /**
  * 内容合规红线（平台硬性要求）：所有书籍、所有章节无条件生效，
- * 优先级高于单书大纲/圣经中的任何设定与作者自定义红线。
+ * 优先级高于单书大纲/道藏中的任何设定与作者自定义红线。
  * 注入点：章节生成系统提示 + 审稿系统提示（命中即 high）。
  */
 export const COMPLIANCE_REDLINES: ReadonlyArray<string> = [
@@ -23,39 +23,38 @@ export const COMPLIANCE_REDLINES: ReadonlyArray<string> = [
   '9. 不得出现法律法规禁止的其他内容。',
 ]
 
-import { mkdirSync, readFileSync, writeFileSync, readdirSync, existsSync, rmSync } from 'node:fs'
-import { join, basename, extname, dirname } from 'node:path'
-import { homedir, tmpdir } from 'node:os'
+/** 审稿维度取值：归一化模型输出的 dimension 字段。维度清单以 reviewSystemPrompt 的九条为准。 */
+const REVIEW_DIMENSION_IDS = new Set(['character', 'setting', 'redline', 'writing', 'pacing', 'logic', 'anti-ai', 'presentation', 'compliance'])
+
+import { mkdirSync, readFileSync, writeFileSync, readdirSync, existsSync, rmSync, renameSync } from 'node:fs'
+import { join, basename, extname } from 'node:path'
+import { tmpdir } from 'node:os'
 import { createUserMessage, BlockAssembler, ReasoningEffortId, type GenerateOptions, type Message, type StreamChunk } from '@deepseek-ai/dsh-llm'
 import type { Context } from '@deepseek-ai/cordis'
-import { emptyProjectAssets, renderAllAssets, styleEngineSystemPrompt } from './assets.ts'
-import { getComicStylePrompt } from './comic-presets.ts'
-import { findStyle, styleKeywords } from './style-library.ts'
-import {
-  normalizeShotSize,
-  normalizeCameras,
-  normalizeComposition,
-  normalizeLightings,
-  sizeZh,
-  cameraZh,
-  lightZh,
-} from './shot-language.ts'
-import {
-  normalizeStoryFunction,
-  normalizeEmotions,
-  functionZh,
-  emotionZh,
-} from './story-beat-language.ts'
+import { BUILTIN_GENRE_LIBRARY, BUILTIN_PROGRESSION_MODES, emptyProjectAssets, recommendStylePreset, renderAllAssets, styleEngineSystemPrompt, styleFormulaSystemPrompt } from './assets.ts'
+import { scanAiFlavor } from './ai-scan.ts'
+import { beginLiveCall, endLiveCall, markFirstToken } from './llm-live.ts'
+import { shouldSwitchModel, withModelFallback } from './llm-retry.ts'
+import { convergeRequestParams } from './model-capability.ts'
+import { renderLengthContract, resolveOutputBudget, STRUCTURED_FIELD_LIMITS } from './output-budget.ts'
+import { renderTensionBlock } from './tension.ts'
+import { renderPromptSlots } from './prompt-slots.ts'
+import { normalizeTimelineEvent, renderTimelineBlock, sortTimeline } from './timeline.ts'
+import { createSnapshot } from './snapshots.ts'
+import { renderChapterWriterSkeleton } from './prompting.ts'
+import { NovelActionError } from './action-guard.ts'
+import { buildChapterContext, renderContextBlocks } from './novel-context.ts'
 import type {
   AdaptationDimension,
   AdaptAnalyzeResponse,
   AdaptationMapping,
-  AdaptationProposal,
   AdaptationRules,
   AdaptProposeResponse,
-  AdaptExecuteResponse,
   AuditIssue,
   AuthorReview,
+  ExportScope,
+  TimelineEvent,
+  TimelineIssue,
   BreakdownResponse,
   ChapterPlan,
   Foreshadow,
@@ -65,37 +64,39 @@ import type {
   PlotlineHealthReport,
   PlotlinePlan,
   ProjectState,
+  ReviewDimension,
   ReviewReport,
   RoleRecord,
   RoleStatusCard,
-  SceneCard,
   StoryBible,
-  StoryboardSkeleton,
-  StoryboardBeat,
-  StoryboardTable,
-  StoryboardShot,
-  StoryboardPrompt,
-  ChapterStoryboard,
   AddModelRequest,
   AddModelResponse,
   SavedModel,
-  LlmModelOption,
   LlmModelsResponse,
   LlmVendorOption,
   LlmVendorsResponse,
   LlmProvidersResponse,
   RemoveProviderRequest,
   RemoveProviderResponse,
-  LlmTestRequest,
   LlmTestResponse,
-  MangaRoleCandidate,
-  MangaRoleCard,
   Volume,
   WorldState,
   AdaptMaterializeRequest,
   AdaptMaterializeResponse,
   AdaptMaterializeSaveRequest,
   AdaptMaterializeSaveResponse,
+  MarketRadarRequest,
+  MarketRadarResult,
+  MarketRadarSignal,
+  MarketRadarBriefRequest,
+  ProductionFoundation,
+  MarketCreativeBrief,
+  BookAnalysisRequest,
+  BookAnalysisResult,
+  IdeaInspirationRequest,
+  IdeaInspirationResult,
+  DirectorRequest,
+  DirectorAdvice,
 } from './protocol.ts'
 import { LLM_VENDORS } from './protocol.ts'
 
@@ -170,7 +171,9 @@ export function loadProject(outputDir: string): ProjectState | undefined {
     if (!Array.isArray(raw.facts)) raw.facts = []
     if (!Array.isArray(raw.plotlines)) raw.plotlines = []
     return raw
-  } catch {
+  } catch (error) {
+    // 项目文件损坏被静默当"无项目"会遮蔽数据丢失，留痕到服务端日志。
+    console.error(`[novel-forge] project file unreadable/corrupt: ${file} — ${(error as Error).message}`)
     return undefined
   }
 }
@@ -178,9 +181,20 @@ export function loadProject(outputDir: string): ProjectState | undefined {
 /** Persist the project state next to the chapters. */
 export function saveProject(outputDir: string, project: ProjectState): void {
   mkdirSync(outputDir, { recursive: true })
-  writeFileSync(join(outputDir, PROJECT_FILE), JSON.stringify(project, null, 2), 'utf8')
+  const target = join(outputDir, PROJECT_FILE)
+  const data = JSON.stringify(project, null, 2)
+  // no-op 检测：内容未变化则跳过写盘，减少连续保存的 I/O
+  try {
+    if (existsSync(target)) {
+      const existing = readFileSync(target, 'utf8')
+      if (existing === data) return
+    }
+  } catch { /* 读取失败时正常写入 */ }
+  // 原子写：先写临时文件再 rename，降低中途崩溃导致项目文件损坏的风险
+  const tmp = target + '.tmp'
+  writeFileSync(tmp, data, 'utf8')
+  renameSync(tmp, target)
 }
-
 /**
  * 并发保护：长任务（章节计划生成/正文生成）在内存中持有旧快照，
  * 期间其他请求可能修改了「易变字段」（道藏/角色库/剧情线/人物志存档/简介/封面）。
@@ -193,7 +207,6 @@ export function mergeVolatileFromDisk(outputDir: string, project: ProjectState):
     if (disk === undefined) return
     project.bible = disk.bible
     project.roles = disk.roles
-    project.mangaRoles = disk.mangaRoles
     project.plotlines = disk.plotlines
     project.roleStatus = disk.roleStatus
     project.blurb = disk.blurb
@@ -336,59 +349,158 @@ export function createProject(outline: string, outlinePath?: string): ProjectSta
 
 // ------------------------------------------------------------------- llm
 
+/** 一次非流式 LLM 调用的入参。 */
+interface CompleteOptions {
+  system: string
+  user: string
+  temperature?: number
+  maxTokens?: number
+  reasoning?: 'off' | 'low' | 'high' | 'max'
+  model?: string
+  liveLabel?: string
+  /**
+   * 该调用是否要求严格结构化输出（JSON）。为 true 时，模型参数能力层可以在
+   * 结构化稳定性优先的前提下覆盖用户的思考档位。
+   */
+  structured?: boolean
+}
+
+/**
+ * 把已经拼好的请求过一遍模型参数能力层。
+ *
+ * **凡是自己构造 `GenerateOptions`、不走 {@link complete} 的调用点都必须经过它**，
+ * 否则那条路径会绕过厂商参数约束（固定温度、不支持的 reasoning 等），对 Kimi
+ * 这类模型直接报参数错误 —— 而"测试连通"恰恰是用户用来判断配置对不对的地方。
+ *
+ * 抽成函数而不是在每个调用点内联：流式调用点有 5 处，还要各自处理备用模型切换，
+ * 内联五遍就是同一件事写五份，必然漂移。
+ * @param base - 已拼好的请求（调用方已确定 temperature / reasoningEffort）。
+ * @param model - **本次实际要调用的模型**（切换备用模型后必须重算，故在循环内调用）。
+ * @param options - `structured` 表示严格结构化输出任务。
+ * @returns 收敛后的请求（固定温度的模型会省略 temperature / 不支持的参数会被移除）。
+ */
+function applyModelCapability(
+  base: GenerateOptions,
+  model: string,
+  options: { structured?: boolean } = {},
+): GenerateOptions {
+  const converged = convergeRequestParams(
+    {
+      temperature: base.temperature ?? 0.7,
+      reasoningEffort: base.reasoningEffort === undefined
+        ? undefined
+        : String(base.reasoningEffort) as 'off' | 'low' | 'high' | 'max',
+    },
+    model,
+    { structured: options.structured === true, omitFixedTemperature: true },
+  )
+  return {
+    ...base,
+    model,
+    ...(converged.temperature === undefined ? { temperature: undefined } : { temperature: converged.temperature }),
+    ...(converged.reasoningEffort === undefined ? { reasoningEffort: undefined } : { reasoningEffort: ReasoningEffortId(converged.reasoningEffort) }),
+  }
+}
+
 /** One complete non-streaming LLM call. */
 async function complete(
   ctx: Context,
   config: NovelConfig,
-  options: { system: string; user: string; temperature?: number; maxTokens?: number; reasoning?: 'off' | 'low' | 'high' | 'max' },
+  options: CompleteOptions,
 ): Promise<string> {
+  const liveLabel = options.liveLabel ?? 'LLM 调用'
   const messages: Message[] = [createUserMessage({
     content: [{ type: 'text', text: options.user }],
     source: { kind: 'plugin', plugin: 'dsh-novel-forge' },
   })]
-  const request: GenerateOptions = {
-    provider: config.provider,
-    model: config.model,
-    messages,
-    system: options.system,
-    maxTokens: options.maxTokens ?? config.maxTokens,
-    temperature: options.temperature ?? 0.7,
-    reasoningEffort: ReasoningEffortId(options.reasoning ?? config.reasoningEffort ?? 'off'),
-  }
-  const assembler = new BlockAssembler()
-  for await (const chunk of ctx.llm.stream(request)) {
-    assembler.push(chunk)
-  }
-  const finish = assembler.finish
-  if (finish.kind === 'error' || finish.kind === 'aborted') {
-    throw new Error(`LLM 调用失败（${finish.kind}）: ${finish.failure.message}`)
-  }
-  if (finish.kind === 'max-tokens') {
-    throw new Error('LLM 输出达到 maxTokens 上限，请增大配置后重试')
+  /** 用指定模型跑一次完整调用（含实况打点、token 记账与诊断日志）。 */
+  const runOnce = async (model: string): Promise<string> => {
+    const live = beginLiveCall({ label: liveLabel, model, system: options.system, user: options.user })
+    // 用户偏好先成型，再经能力层按**实际模型**收敛：同一模型走不同 provider/中转
+    // 时约束不变，换备用模型后约束随新模型重算。
+    const converged = convergeRequestParams(
+      {
+        temperature: options.temperature ?? 0.7,
+        reasoningEffort: options.reasoning ?? config.reasoningEffort ?? 'off',
+      },
+      model,
+      {
+        structured: options.structured === true,
+        // 厂商建议固定温度的模型不要显式传入，优先省略，省得多余参数被拒。
+        omitFixedTemperature: true,
+      },
+    )
+    if (converged.adjustments.length > 0) {
+      ctx.logger('novel-forge').info('模型参数收敛（%s @ %s）：%s', liveLabel, model, converged.adjustments.join('；'))
+    }
+    const request: GenerateOptions = {
+      provider: config.provider,
+      model,
+      messages,
+      system: options.system,
+      maxTokens: options.maxTokens ?? config.maxTokens,
+      ...(converged.temperature === undefined ? {} : { temperature: converged.temperature }),
+      ...(converged.reasoningEffort === undefined ? {} : { reasoningEffort: ReasoningEffortId(converged.reasoningEffort) }),
+    }
+    const assembler = new BlockAssembler()
+    for await (const chunk of ctx.llm.stream(request)) {
+      if (chunk.type === 'text-delta') markFirstToken(live)
+      assembler.push(chunk)
+    }
+    const finish = assembler.finish
+    if (finish.kind === 'error' || finish.kind === 'aborted') {
+      const message = `LLM 调用失败（${finish.kind}）: ${finish.failure.message}`
+      endLiveCall(live, assembler, { phase: 'failed', error: message })
+      throw new Error(message)
+    }
+    if (finish.kind === 'max-tokens') {
+      const message = 'LLM 输出达到 maxTokens 上限，请增大配置后重试'
+      endLiveCall(live, assembler, { phase: 'failed', error: message })
+      throw new Error(message)
+    }
+    // Diagnostics: log the assembled block shape (reasoning-only turns yield no
+    // text blocks — some models answer entirely in the reasoning channel).
+    if (process.env.DSH_NOVEL_DEBUG === '1') {
+      console.error('[dsh-novel-forge] complete: finish=%j blocks=%j', JSON.stringify(finish), assembler.blocks().map(b => `${b.type}:${'text' in b ? b.text.length : '?'}`))
+    }
+    const text = textFromAssembler(assembler)
+    endLiveCall(live, assembler, { chars: text.length, preview: text.slice(0, 320), phase: text === '' ? 'failed' : 'completed' })
+    return text
   }
+  // 主模型失败（网络/限流/额度类）且配置了备用模型时，自动换模型重试一次。
+  return withModelFallback({ model: options.model || config.model, fallbackModel: config.fallbackModel }, runOnce)
+}
+
+/**
+ * 从 assembler 取模型文本；无文本块时回落到 reasoning 通道
+ * （部分模型会把答案整个放在思考通道，适配器以 reasoning 块呈现）。
+ */
+function textFromAssembler(assembler: BlockAssembler): string {
   const blocks = assembler.blocks()
-  // Diagnostics: log the assembled block shape (reasoning-only turns yield no
-  // text blocks — the v4-flash model can answer entirely in the reasoning
-  // channel, which the adapter surfaces as a reasoning block).
-  if (process.env.DSH_NOVEL_DEBUG === '1') {
-    console.error('[dsh-novel-forge] complete: finish=%j blocks=%j', JSON.stringify(finish), blocks.map(b => `${b.type}:${'text' in b ? b.text.length : '?'}`))
-  }
   const textBlocks = blocks
     .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
     .map(block => block.text)
-  let text = textBlocks.join('\n').trim()
-  // v4-flash can answer entirely in the reasoning channel (the adapter
-  // surfaces that as a 'reasoning' block). Fall back to it when no text came
-  // back — the reasoning content is the model's actual answer here.
-  if (text === '') {
-    const reasoning = blocks
-      .filter((block): block is { type: 'reasoning'; text: string } => block.type === 'reasoning')
-      .map(block => block.text)
-      .join('\n')
-      .trim()
-    if (reasoning !== '') text = reasoning
-  }
-  return text
+  const text = textBlocks.join('\n').trim()
+  if (text !== '') return text
+  return blocks
+    .filter((block): block is { type: 'reasoning'; text: string } => block.type === 'reasoning')
+    .map(block => block.text)
+    .join('\n')
+    .trim()
+}
+
+/** 解析 JSON 数组；失败或为空时给模型一次修复重试（对齐上游 structuredInvokeRepair 精神）。 */
+async function completeJsonArray(
+  ctx: Context,
+  config: NovelConfig,
+  options: CompleteOptions,
+  parse: (text: string) => unknown[],
+): Promise<unknown[]> {
+  let parsed = parse(await complete(ctx, config, options))
+  if (Array.isArray(parsed) && parsed.length > 0) return parsed
+  const repairOptions = { ...options, user: options.user + '\n\n注意：你上一次输出不是合法且非空的 JSON 数组。请重新输出：只输出一个合法 JSON 数组（不要 Markdown、不要解释、不要思考过程、不要代码块标记）。' }
+  const parsed2 = parse(await complete(ctx, config, repairOptions))
+  return Array.isArray(parsed2) ? parsed2 : []
 }
 
 /**
@@ -419,6 +531,44 @@ function parseJson<T>(text: string, wantArray: boolean): T {
   const start2 = trimmed.indexOf(opener)
   if (start2 !== -1) push(trimmed.slice(start2))
 
+  // Repair truncated JSON: find the last complete object/array element, close brackets.
+  const repairTruncated = (value: string): string => {
+    const firstOpen = value.indexOf(opener)
+    if (firstOpen === -1) return value
+    const body = value.slice(firstOpen)
+    let inStr = false
+    let depth = 0
+    let lastComplete = -1
+    for (let i = 0; i < body.length; i++) {
+      const ch = body[i]!
+      if (inStr) {
+        if (ch === '\\') { i++; continue }
+        if (ch === '"') inStr = false
+        continue
+      }
+      if (ch === '"') { inStr = true; continue }
+      if (ch === '{' || ch === '[') depth++
+      if (ch === '}' || ch === ']') {
+        depth--
+        if (depth === 1) lastComplete = i
+      }
+    }
+    if (lastComplete === -1 || depth <= 0) return value
+    const truncated = body.slice(0, lastComplete + 1)
+    let result = truncated
+    let d = 0
+    let inS = false
+    for (let i = 0; i < result.length; i++) {
+      const c = result[i]!
+      if (inS) { if (c === '\\') { i++; continue } if (c === '"') inS = false; continue }
+      if (c === '"') { inS = true; continue }
+      if (c === '{' || c === '[') d++
+      if (c === '}' || c === ']') d--
+    }
+    while (d > 0) { result += closer; d-- }
+    return result
+  }
+
   // Repair: models love raw newlines inside string values, which JSON forbids.
   const repair = (value: string): string => {
     let out = ''
@@ -450,7 +600,7 @@ function parseJson<T>(text: string, wantArray: boolean): T {
   }
 
   for (const candidate of candidates) {
-    for (const attempt of [candidate, repair(candidate)]) {
+    for (const attempt of [candidate, repair(candidate), repairTruncated(candidate)]) {
       try {
         const value = JSON.parse(attempt) as unknown
         if (!wantArray || Array.isArray(value)) return value as T
@@ -490,7 +640,7 @@ function parseJsonObject<T>(text: string): T {
 /** System prompt for story-bible extraction. */
 function bibleSystemPrompt(): string {
   return [
-    '你是一位资深网文编辑兼设定架构师。你会收到一份小说大纲，请把它提炼成结构化的「设定圣经」(Story Bible)，供后续写作时严格引用。',
+    '你是一位资深网文编辑兼设定架构师。你会收到一份小说大纲，请把它提炼成结构化的「道藏」，供后续写作时严格引用。',
     '要求：',
     '1. 忠于大纲，不自行发明大纲之外的设定。',
     '2. 角色卡覆盖大纲明确出现的角色（主角必含），每个角色给出性格标签、目标、关键关系。',
@@ -519,7 +669,7 @@ export async function extractBible(ctx: Context, config: NovelConfig, outline: s
   }
   const facts = (project?.facts ?? []).slice(-40)
   const user = [
-    `请为下面这部小说提炼设定圣经：\n\n${outline}`,
+    `请为下面这部小说提炼道藏：\n\n${outline}`,
     facts.length > 0
       ? `\n\n【已写章节事实（编年录）】用于确认真实角色姓名与已确立设定；忠于大纲，不要新增大纲外设定：\n${facts.map(f => `[第${f.chapterNo}章] ${f.text.slice(0, 100)}`).join('\n')}`
       : '',
@@ -531,7 +681,7 @@ export async function extractBible(ctx: Context, config: NovelConfig, outline: s
     system: bibleSystemPrompt(),
     user,
     temperature: 0.4,
-    maxTokens: Math.max(config.maxTokens, 16000),
+    maxTokens: Math.max(config.maxTokens, 8000),
     reasoning: config.analysisReasoning ?? 'low',
   })
   const raw = parseJsonObject<{
@@ -593,13 +743,21 @@ function volumeSystemPrompt(): string {
     '[{"no": 1, "title": "卷名", "summary": "卷定位与剧情重心", "chapterStart": 1, "chapterEnd": 80}]',
     '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
     '重要：直接输出 JSON 结果本身，不要把思考过程或推理内容写在输出里。',
+    // 长度合同与 resolve 端的截断口径共用一份声明，避免 prompt 与解析漂移。
+    renderLengthContract([
+      ['卷名', STRUCTURED_FIELD_LIMITS.chapterTitle],
+      ['每卷定位', STRUCTURED_FIELD_LIMITS.chapterSummary],
+    ]),
   ].join('\n')
 }
 
 /** Plan volumes from an outline. */
 export async function planVolumes(ctx: Context, config: NovelConfig, outline: string): Promise<Volume[]> {
   const user = `请为下面这部小说划分卷：\n\n${outline}`
-  const text = await complete(ctx, config, { system: volumeSystemPrompt(), user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 12000) })
+  // 卷数由大纲决定、此处未知，按「大纲暗示的规模」估算：约每 1200 字大纲对应一卷，
+  // 夹在 3-24 卷之间（与卷规划自身的 3-8 卷建议不冲突，只是给预算一个量级）。
+  const expectedVolumes = Math.min(24, Math.max(3, Math.round(outline.length / 1_200)))
+  const text = await complete(ctx, config, { system: volumeSystemPrompt(), user, temperature: 0.4, maxTokens: resolveOutputBudget('volume-strategy', { volumes: expectedVolumes }) })
   const parsed = parseJsonArray<Record<string, unknown>>(text)
   const volumes: Volume[] = []
   for (let i = 0; i < parsed.length; i++) {
@@ -612,8 +770,8 @@ export async function planVolumes(ctx: Context, config: NovelConfig, outline: st
     const end = typeof entry.chapterEnd === 'number' ? entry.chapterEnd : undefined
     volumes.push({
       no,
-      title: title.slice(0, 40),
-      summary: summary.slice(0, 300),
+      title: title.slice(0, STRUCTURED_FIELD_LIMITS.chapterTitle),
+      summary: summary.slice(0, STRUCTURED_FIELD_LIMITS.chapterSummary),
       chapterStart: start ?? 1,
       chapterEnd: end ?? 1,
     })
@@ -637,7 +795,9 @@ function volumeOf(chapterNo: number, volumes: Volume[] | undefined): number {
 function planSystemPrompt(volumes: Volume[] | undefined): string {
   const volumeBlock = volumes !== undefined && volumes.length > 0
     ? ['\n全书分卷结构（规划章节时需落在对应卷内）：']
-      .concat(volumes.map(v => `第${v.no}卷《${v.title}》：${v.summary}（章节 ${v.chapterStart}-${v.chapterEnd}）`))
+      .concat(volumes.map(v => `第${v.no}卷《${v.title}》：${v.summary}（章节 ${v.chapterStart}-${v.chapterEnd}）` +
+        (v.strategy !== undefined && v.strategy !== '' ? `\n  卷战略：${v.strategy}` : '') +
+        (v.pacing !== undefined && v.pacing !== '' ? `\n  卷节奏板：${v.pacing}` : '')))
       .join('\n')
     : ''
   return [
@@ -649,39 +809,53 @@ function planSystemPrompt(volumes: Volume[] | undefined): string {
     '3. 严格遵循大纲的人设、金手指规则、战力体系与世界观设定，不得自行发明冲突设定。',
     '4. 输出必须是合法的 JSON 数组，不要输出任何其他文字或 Markdown 代码块标记。',
     '5. 数组每个元素格式：{"title": "章节标题（10字以内，有网文感）", "beats": "结构化剧情要点（150-250字，必须包含四段，段间用换行分隔）：\\n本章目标：本章要完成的核心推进；\\n剧情要点：主要情节的起承转合（2-4 句）；\\n爽点/钩子：本章的爽点兑现或情绪钩子；\\n结尾钩子：本章结尾为下一章埋下的悬念"}',
+    '6. 每个章节对象可额外包含以下可选字段（尽量给出，缺失则跳过）：tension（0-100 整数：本章张力目标，对抗/揭示/抉择/代价的强度；铺垫与日常章明显偏低，与相邻章节形成起伏）、mustAdvance（数组，本章必须推进的局面/关系/信息/风险/决策变化）；mustPreserve（数组，本章必须保持不破坏的项）；characterHardFacts（数组，本章不可违背的人物硬事实：身份/阵营/境界/当前位置/知情度）；endingHook（字符串，本章结尾钩子要求）；obligation（字符串，本章义务合约一句话）。',
     '重要：beats 字段内部必须使用 \\n 转义表示换行（JSON 字符串内不得有真实换行符），其余字符串值也不得包含真实换行符，JSON 必须在一段内完整结束。',
     '重要：直接输出 JSON 结果本身，不要把思考过程或推理内容写在输出里。',
     volumeBlock,
   ].join('\n')
 }
 
-/** Build the writing system prompt (bible + outline + active foreshadows). */
-function writeSystemPrompt(project: ProjectState): string {
+/** Build the writing system prompt (bible + outline + active foreshadows).
+ *  `targetChars` 来自每章计划（规划时快照，= 设置的每章目标字数）；无则退回默认 3500。
+ *  字数区间按目标动态生成（±15%，取整到百位），避免系统提示词与设置互相冲突。
+ *  `lengthRule` 可覆盖第 1 条字数要求（整章修订/改编时按原文长度为准）。 */
+function writeSystemPrompt(project: ProjectState, targetChars?: number, lengthRule?: string, beforeChapter?: number): string {
   const bible = project.bible
   const sections: string[] = []
   if (bible !== undefined) {
-    sections.push('==================== 设定圣经（写作时严格遵守） ====================')
+    sections.push('==================== 道藏（写作时严格遵守） ====================')
     if (bible.genre !== '') sections.push(`题材基调：${bible.genre}`)
     if (bible.worldRules.length > 0) sections.push('世界规则：\n' + bible.worldRules.map(r => `- ${r}`).join('\n'))
-    if (bible.characters.length > 0) {
-      sections.push('角色卡：')
-      for (const card of bible.characters) {
-        const roleName = { protagonist: '主角', supporting: '配角', antagonist: '反派', other: '其他' }[card.role]
-        sections.push(`- ${card.name}（${roleName}）：${card.traits.join('、')}${card.goals !== '' ? `；目标：${card.goals}` : ''}${card.relations !== '' ? `；关系：${card.relations}` : ''}`)
-        if (Array.isArray(card.knowledge) && card.knowledge.length > 0) {
-          sections.push(`  已知信息（该角色知道的：${card.knowledge.join('；')}；未列出的信息该角色一律不知道，不得写其知晓或提及）`)
-        }
+    // 角色上下文：角色库（主表）与道藏角色卡合并去重，避免两份重复注入、互相打架。
+    const roleLib = project.roles ?? []
+    const labelName = { protagonist: '主角', female_lead: '女主', female_support: '女配', support: '配角', antagonist: '反派', extra: '路人' }
+    const seenRole = new Set<string>()
+    const mergedRoles: string[] = []
+    for (const r of roleLib) {
+      seenRole.add(r.name)
+      const card = bible.characters.find(c => c.name === r.name)
+      const traits = card !== undefined ? card.traits : (Array.isArray(r.traits) ? r.traits : [])
+      const goals = card !== undefined && card.goals !== '' ? card.goals : r.goals
+      const relations = card !== undefined && card.relations !== '' ? card.relations : (Array.isArray(r.relations) && r.relations.length > 0 ? r.relations.join('、') : '')
+      mergedRoles.push(`- ${r.name}（${labelName[r.roleLabel]}）：${r.identity}${traits.length > 0 ? `；性格：${traits.join('、')}` : ''}${goals !== '' ? `；目标：${goals}` : ''}${relations !== '' ? `；关系：${relations}` : ''}`)
+      if (card !== undefined && Array.isArray(card.knowledge) && card.knowledge.length > 0) {
+        mergedRoles.push(`  已知信息（该角色知道的：${card.knowledge.join('；')}；未列出的信息该角色一律不知道，不得写其知晓或提及）`)
       }
     }
-    // 角色库注入：定位 + 身份 + 关系（角色互动按定位规格写）。
-    const roleLib = project.roles ?? []
-    if (roleLib.length > 0) {
-      const labelName = { protagonist: '主角', female_lead: '女主', female_support: '女配', support: '配角', antagonist: '反派', extra: '路人' }
-      sections.push('角色库（出场角色按定位规格刻画互动）：')
-      for (const r of roleLib) {
-        sections.push(`- ${r.name}（${labelName[r.roleLabel]}）：${r.identity}${r.relations.length > 0 ? `；关系：${r.relations.join('、')}` : ''}`)
+    for (const card of bible.characters) {
+      if (seenRole.has(card.name)) continue
+      seenRole.add(card.name)
+      const roleName = { protagonist: '主角', supporting: '配角', antagonist: '反派', other: '其他' }[card.role]
+      mergedRoles.push(`- ${card.name}（${roleName}）：${card.traits.join('、')}${card.goals !== '' ? `；目标：${card.goals}` : ''}${card.relations !== '' ? `；关系：${card.relations}` : ''}`)
+      if (Array.isArray(card.knowledge) && card.knowledge.length > 0) {
+        mergedRoles.push(`  已知信息（该角色知道的：${card.knowledge.join('；')}；未列出的信息该角色一律不知道，不得写其知晓或提及）`)
       }
     }
+    if (mergedRoles.length > 0) {
+      sections.push('角色卡（角色库与道藏已合并去重）：')
+      sections.push(...mergedRoles)
+    }
     if (bible.redLines.length > 0) sections.push('写作红线（违反即失败）：\n' + bible.redLines.map(r => `- ${r}`).join('\n'))
     if (bible.style.length > 0) sections.push('风格要求：\n' + bible.style.map(r => `- ${r}`).join('\n'))
   }
@@ -713,9 +887,12 @@ function writeSystemPrompt(project: ProjectState): string {
   }
   sections.push('')
   sections.push('写作硬性要求：')
-  sections.push('1. 每章 3000-4000 字（按中文字符计），只输出章节正文，不要输出标题、章回名、作者的话或任何 Markdown 标记。')
+  const target = targetChars !== undefined && targetChars > 0 ? targetChars : 3500
+  const lo = Math.max(1000, Math.round((target * 0.85) / 100) * 100)
+  const hi = Math.max(lo + 100, Math.round((target * 1.15) / 100) * 100)
+  sections.push(lengthRule ?? `1. 每章 ${lo}-${hi} 字（目标 ${target} 字，按中文字符计），只输出章节正文，不要输出标题、章回名、作者的话或任何 Markdown 标记。`)
   sections.push('2. 以主角视角展开，动作、对话、心理描写交替推进，禁止大段设定说明。')
-  sections.push('3. 尊重大纲与设定圣经：人设不崩、金手指规则不自相矛盾、战力不随意膨胀。')
+  sections.push('3. 尊重大纲与道藏：人设不崩、金手指规则不自相矛盾、战力不随意膨胀。')
   sections.push('4. 章末留一个钩子（悬念、反转或新线索），吸引读者读下一章。')
   sections.push('5. 语言流畅自然，符合中文网文语感，避免翻译腔与病句。')
   sections.push('6. 对话与冲突密度：每章至少 1 处实质对话或正面对抗/交锋场面；推理与心理活动必须用动作、环境细节、微表情、对话呈现，禁止整章纯内心独白铺陈（禁止"解说式"交代线索）。')
@@ -726,6 +903,26 @@ function writeSystemPrompt(project: ProjectState): string {
   sections.push('==================== 内容合规红线（平台硬性要求，最高优先级，违反即失败） ====================')
   sections.push(COMPLIANCE_REDLINES.join('\n'))
   sections.push('以上九条为硬性底线，任何情况下不得以任何形式出现或影射；若剧情确需涉及（如批判、反讽），只能以明确否定、揭露、批判的立场呈现，且不得展开细节。')
+  sections.push(renderChapterWriterSkeleton({
+    targetChars: target,
+    minChars: lo,
+    maxChars: hi,
+    pov: '第三人称有限视角，严格跟随主角所见所知。',
+    endingHookPreference: '章末留一个明确钩子（新信息、新风险或未闭合选择）。',
+    tonePreference: '动作、对话、心理交替推进；重大信息用对话/动作/发现呈现。',
+    antiAiRules: '严格遵循上方「反 AI 规则」与写法资产，避免套话与 AI 腔。',
+  }))
+  // 故事时间线锚点：只注入本章之前的事件（回写旧章时不被后续章节剧透）。
+  const timelineBlock = renderTimelineBlock(project, beforeChapter ?? Number.MAX_SAFE_INTEGER)
+  if (timelineBlock !== '') sections.push(timelineBlock)
+  // 本章张力（目标值 + 参考曲线位置）：写作时把握松紧。
+  if (beforeChapter !== undefined) {
+    const tensionBlock = renderTensionBlock(project, beforeChapter)
+    if (tensionBlock !== '') sections.push(tensionBlock)
+  }
+  // 作者自定义槽位（只影响表达方式，不覆盖道藏/红线/合规）。
+  const slotBlock = renderPromptSlots(project)
+  if (slotBlock !== '') sections.push(slotBlock)
   return sections.join('\n')
 }
 
@@ -745,8 +942,14 @@ export async function planChapters(
   const startNo = existing.length === 0 ? 1 : Math.max(...existing.map(c => c.no)) + 1
   const NL = String.fromCharCode(10)
   const continuation = existing.length > 0
-  const latestFacts = continuation && Array.isArray(project.facts)
-    ? project.facts.slice(-15).map(f => `[第${f.chapterNo}章] ${f.text.slice(0, 150)}`).join('\n')
+  // 截断显式化：注入给模型的编年录必须自带条数声明，否则模型会把"注入的 15 条"
+  // 当成"全部事实"，从而在续写规划时漏掉更早的设定锚点。
+  const allFacts = Array.isArray(project.facts) ? project.facts : []
+  const latestFacts = continuation && allFacts.length > 0
+    ? (allFacts.length > 15
+        ? `（本书编年录共 ${allFacts.length} 条，此处只注入最近 15 条，较早 ${allFacts.length - 15} 条未注入）\n`
+        : '')
+      + allFacts.slice(-15).map(f => `[第${f.chapterNo}章] ${f.text.slice(0, 150)}`).join('\n')
     : ''
   // 上一章（已写章节中章号最大者）结尾原文，作为续写剧情起点。
   let prevTail = ''
@@ -762,14 +965,24 @@ export async function planChapters(
   }
   // 续写模式大纲注入：精简大纲（≤2 万字）直接全量，避免误伤「分卷收官规划」（如第五卷双结局）；
   // 超大 docx 大纲才节选——截到「记忆梗」之前，保留分卷大纲与红线，去掉后续冗余。
+  // 续写模式大纲注入：精简大纲（≤2 万字）直接全量；超大大纲按优先级裁剪——
+  // 优先保留当前卷/红线/道藏规则，不绑定任何特定书的章节标题。
   const outlineBlock = continuation
     ? (() => {
         if (project.outline.length <= 20000) return project.outline
-        const cut = project.outline.indexOf('十、全书核心弹幕记忆梗')
-        if (cut > 1500) return project.outline.slice(0, cut).trimEnd() + '\n（大纲过长，末尾记忆梗从略）'
-        return project.outline.slice(0, 8000) + '\n…（大纲过长已节选）'
+        // 找最后一个卷标记（支持「第X卷」「卷X」），截到该位置
+        const volMarkers = ['第' + (volume?.no ?? '') + '卷', '卷' + (volume?.no ?? '')]
+        let cut = -1
+        for (const marker of volMarkers) {
+          const idx = project.outline.lastIndexOf(marker)
+          if (idx > cut) cut = idx
+        }
+        // 没找到卷标记时，截取前 15000 字（保留足够设定，去掉末尾冗余）
+        if (cut < 2000) cut = Math.min(15000, project.outline.length)
+        return project.outline.slice(0, cut).trimEnd() + '\n…（大纲过长，已保留当前卷及之前内容，后续从略）'
       })()
     : project.outline
+
   const user = [
     '请为下面这部小说规划章节。',
     volume !== undefined
@@ -777,8 +990,54 @@ export async function planChapters(
       : continuation
         ? `本书已有 ${existing.length} 章已规划/已写作（见下方「已有章节」）。请规划**后续**章节：从第 ${startNo} 章开始。`
         : '请规划全书开篇章节。',
+    (() => {
+      const c = project.bookContract
+      const primary = project.assets?.primaryProgression
+      const aux = project.assets?.auxiliaryProgressions ?? []
+      const genre = project.assets?.genre
+      const parts: string[] = []
+      if (c?.promise !== undefined && c.promise !== '') parts.push(`书籍承诺：${c.promise}`)
+      if ((c?.primaryModeName ?? primary?.name) !== undefined) parts.push(`主推进模式：${c?.primaryModeName ?? primary!.name}`)
+      if (aux.length > 0) parts.push(`辅助推进模式：${aux.map(a => a.name).join('、')}`)
+      if ((c?.tone ?? genre?.template) !== undefined) parts.push(`文风基调：${c?.tone ?? genre!.template}`)
+      if (c?.targetPlatform !== undefined && c.targetPlatform !== '') parts.push(`目标平台：${c.targetPlatform}`)
+      return parts.length > 0 ? '【开书定盘】（章节规划须符合此定位）\n' + parts.join('\n') : ''
+    })(),
     continuation
-      ? '【续写硬性要求】已有章节的剧情不得重写或重复，章节标题也不得与已有章节重复。以下情节均已在已有章节中发生过，后续章节**绝对不得再次出现**：穿越、暴雨送餐、滴血认主/古玉认主、首次进入墟境、用废铁淬炼首件法器、绝境肉身入鼎洗炼（该机缘已用尽）、杀死白袍弟子与灰衣随从、藏尸水沟。' + NL + '若本次规划已进入大纲的收尾区间（接近全书规划总章数），最后 5-10 章必须按大纲推进到大结局（终极抉择/清算/双结局等），**禁止以悬念、逃离、未解之谜收尾**——收尾区间按大纲卷定位判断，不以当前剧情是否“感觉像结尾”为准。'
+      ? (() => {
+          // 从最近章节摘要动态生成「已发生事件禁令」，不绑定任何特定书
+          const recentChapters = existing.slice(-20)
+          const eventLines = recentChapters
+            .filter(c => c.summary !== undefined && c.summary.trim() !== '')
+            .map(c => '第' + c.no + '章《' + c.title + '》：' + c.summary!.slice(0, 80))
+          // 截断显式化：只列最近 20 章时说明全书规模，避免模型据此认为"前面没有内容"。
+          const scopeNote = existing.length > recentChapters.length
+            ? `（全书已规划 ${existing.length} 章，此处只列最近 ${recentChapters.length} 章）`
+            : ''
+          const eventsText = eventLines.length > 0
+            ? '以下情节已在已有章节中发生过（最近 ' + eventLines.length + ' 章摘要）' + scopeNote + '，后续章节**绝对不得重写或重复**：\n' + eventLines.join('\n')
+            : '已有章节的剧情不得重写或重复（无章节摘要时以编年录为准）。'
+          // 位置感知：把「全书总章数 / 当前所处卷 / 距收尾还有多远」算清楚直接喂给模型。
+          // 原先只模糊地说「接近全书规划总章数」，模型看到近期剧情是高光就自己收尾了
+          // （实测：600 章规划的书在第 81-100 章被规划成大结局）。
+          const vols = (project.volumes ?? []).slice().sort((a, b) => a.no - b.no)
+          const totalCh = vols.length > 0 ? Math.max(...vols.map(v => v.chapterEnd ?? 0)) : 0
+          const curVol = vols.find(v => startNo >= (v.chapterStart ?? 0) && startNo <= (v.chapterEnd ?? 0))
+          const lastVol = vols[vols.length - 1]
+          const remaining = totalCh > 0 ? totalCh - startNo + 1 : 0
+          const inEndgame = totalCh > 0 && lastVol !== undefined &&
+            startNo >= (lastVol.chapterStart ?? 0) + Math.floor(((lastVol.chapterEnd ?? 0) - (lastVol.chapterStart ?? 0)) * 0.8)
+          const posText = totalCh > 0 && curVol !== undefined
+            ? '【全书体量与当前进度（硬约束，优先级高于一切"感觉像结尾"的判断）】' + NL
+              + `全书规划共 ${totalCh} 章、${vols.length} 卷（` + vols.map(v => `第${v.no}卷《${v.title}》${v.chapterStart}-${v.chapterEnd}章`).join('；') + '）。' + NL
+              + `本次从第 ${startNo} 章开始规划，目前处于第${curVol.no}卷《${curVol.title}》（第${curVol.chapterStart}-${curVol.chapterEnd}章）。` + NL
+              + `距全书收尾尚余约 ${remaining} 章。` + NL
+              + (inEndgame
+                ? '当前已进入最后一卷末段，可以按大纲推进大结局。'
+                : `**当前处于全书前段，距离收尾还有约 ${remaining} 章——本次规划绝对禁止出现大结局、系统消失、真相揭开后完结、主角退隐、"全剧终"式收束。** 必须按第${curVol.no}卷的卷战略正常推进剧情，只完成本卷内的一段推进，并为后续留下足够的上升空间。近期章节即使处于高潮（打斗/揭秘/对抗），也只是本卷的中段高潮，不是全书高潮。`)
+            : ''
+          return '【续写硬性要求】已有章节的剧情不得重写或重复，章节标题也不得与已有章节重复。' + NL + eventsText + NL + posText
+        })()
       : '',
     prevTail !== ''
       ? `【上一章（第 ${startNo - 1} 章）结尾原文】第 ${startNo} 章必须紧接此状态继续，从新的事件写起，不得回顾重述：\n${prevTail}`
@@ -800,11 +1059,16 @@ export async function planChapters(
   const system = planSystemPrompt(project.volumes) + (continuation
     ? '\n重要：本次是**续写规划**——已有章节的剧情不得重写或重复，新章节标题不得与已有章节标题相同，新章节的剧情必须从上一章结尾自然接续（人物状态、时间线、地点衔接一致）。'
     : '')
-  const text = await complete(ctx, config, { system, user, temperature: 0.7, maxTokens: Math.max(config.maxTokens, 40000) })
-  const parsed = parseJsonArray<Record<string, unknown>>(text)
+  const parsed = (await completeJsonArray(
+    ctx, config,
+    { system, user, temperature: 0.7, maxTokens: resolveOutputBudget('chapter-list', { chapters: chapterCount }), liveLabel: '章节规划' },
+    t => parseJsonArray<Record<string, unknown>>(t),
+  )) as Record<string, unknown>[]
   const chapters: ChapterPlan[] = []
   const existingNos = new Set(existing.map(c => c.no))
   const existingTitles = new Set(existing.map(c => c.title))
+  const strArr = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && x.trim() !== '') : []
+  const str = (v: unknown): string => typeof v === 'string' ? v.trim() : ''
   let cursor = startNo
   for (const item of parsed) {
     if (chapters.length >= chapterCount) break
@@ -817,6 +1081,19 @@ export async function planChapters(
     if (title !== '' && existingTitles.has(title)) continue
     while (existingNos.has(cursor)) cursor++
     const no = cursor++
+    const pd: ChapterPlan['payoffDirectives'] = Array.isArray(entry.payoffDirectives)
+      ? entry.payoffDirectives
+          .filter((v): v is Record<string, unknown> => typeof v === 'object' && v !== null)
+          .map(p => ({
+            no: typeof p.no === 'number' ? p.no : undefined,
+            operation: (['seed', 'touch', 'pressure', 'partial_reveal', 'payoff', 'forbid'] as const).includes(p.operation as never)
+              ? p.operation as 'seed' | 'touch' | 'pressure' | 'partial_reveal' | 'payoff' | 'forbid'
+              : undefined,
+            text: str(p.text).slice(0, 120),
+          }))
+          .filter(p => p.text !== '' || p.operation !== undefined)
+          .slice(0, 4)
+      : undefined
     chapters.push({
       no,
       volume: volumeOf(no, project.volumes),
@@ -824,6 +1101,15 @@ export async function planChapters(
       beats,
       targetChars: config.chapterChars,
       status: 'pending',
+      tension: typeof entry.tension === 'number' && Number.isFinite(entry.tension)
+        ? Math.max(0, Math.min(100, Math.round(entry.tension)))
+        : undefined,
+      mustAdvance: strArr(entry.mustAdvance).slice(0, 4),
+      mustPreserve: strArr(entry.mustPreserve).slice(0, 4),
+      characterHardFacts: strArr(entry.characterHardFacts).slice(0, 6),
+      payoffDirectives: pd,
+      endingHook: str(entry.endingHook).slice(0, 120) || undefined,
+      obligation: str(entry.obligation).slice(0, 200) || undefined,
     })
   }
   if (chapters.length === 0) {
@@ -832,32 +1118,58 @@ export async function planChapters(
   return chapters
 }
 
+/** 书内知识库检索：按查询词匹配文档标题/内容，返回相关片段（供生成/规划注入）。 */
+function retrieveKnowledge(project: ProjectState, query: string, topN = 3): string {
+  const docs = project.knowledgeDocs ?? []
+  if (docs.length === 0) return ''
+  const terms = (query ?? '').split(/[\s,，。；;、/]+/).map(t => t.trim()).filter(t => t.length >= 2)
+  if (terms.length === 0) return ''
+  const scored = docs.map(d => {
+    let score = 0
+    for (const t of terms) {
+      if (d.title.includes(t)) score += 4
+      if (d.content.includes(t)) score += 1
+    }
+    return { d, score }
+  })
+  const hits = scored.filter(x => x.score > 0).sort((a, b) => b.score - a.score)
+  const top = hits.slice(0, topN)
+  if (top.length === 0) return ''
+  // 截断显式化：命中多于注入条数时说明总量，避免模型以为知识库只有这几条。
+  const scopeNote = hits.length > top.length ? `（命中 ${hits.length} 条，此处只注入最相关的 ${top.length} 条）` : ''
+  return '【书内知识库参考（与本章相关，写作时须遵守/可引用）】' + scopeNote + '\n'
+    + top.map(x => `- 《${x.d.title}》：${x.d.content.slice(0, 300)}`).join('\n')
+}
+
 // ------------------------------------------------------------------ writing
 
 /** The review system prompt. */
 function reviewSystemPrompt(project: ProjectState): string {
   const bible = project.bible
   const sections: string[] = [
-    '你是一位严格的网文审稿编辑。你会收到一章正文以及本书的设定圣经与红线。',
+    '你是一位严格的网文审稿编辑。你会收到一章正文以及本书的道藏与红线。',
     '请从以下维度审查本章：',
-    '1. 人设一致性：角色行为是否符合角色卡（主角不圣母、不无脑、痞坏有分寸等）。',
-    '2. 设定一致性：金手指规则、战力体系、世界观是否与设定圣经冲突。',
-    '3. 红线检查：是否触犯写作红线（无后宫、无擦边、无无脑碾压等）。',
+    '1. 人设一致性：角色行为是否符合下方角色卡的设定（性格/目标/知情度/说话方式）。',
+    '2. 设定一致性：金手指规则、战力体系、世界观是否与道藏冲突。',
+    '3. 红线检查：是否触犯下方「本书红线」与「内容合规红线」。',
     '4. 文笔质量：语病、翻译腔、AI 套话（"不禁""仿佛""一时间"等高频词滥用）、流水账。',
     '5. 节奏与爽点：本章是否有推进、有钩子，是否拖沓灌水。',
     '6. 逻辑漏洞：前后矛盾、时间线错误、对话失真。',
-    '7. 反 AI 规则：逐条核对下方「反 AI 规则」清单，命中即列为问题。',
+    '7. 反 AI 规则：逐条核对下方「反 AI 规则」清单——禁止类命中即列为问题，鼓励类只作低优先级建议、不阻塞通过。',
     '8. 呈现方式：整章是否纯内心推理铺陈（无对话/无对抗，推理全靠解说）；反派是否纯背景板无行动；重要配角是否无名标签化（瘦高个/灰衣人全程代称）——命中即列为问题。',
     '9. 内容合规（最高优先级）：逐条核对下方「内容合规红线」，任何一条命中（含影射、暗示、详细描写）必须列为 high，并给出改写建议。',
     '输出必须是合法 JSON 对象，不要输出任何其他文字：',
-    '{"score": 0-100的整数, "verdict": "一句话总评", "issues": [{"severity": "high|medium|low", "item": "问题描述", "suggestion": "修改建议"}]}',
+    '{"score": 0-100的整数, "riskScore": 0-100的整数(越高越需人工处理,可结合本地AI味指数), "tension": 0-100的整数(本章张力强度:对抗/揭示/抉择/代价;铺垫与日常章应明显偏低), "verdict": "一句话总评", "issues": [{"severity": "high|medium|low", "dimension": "character|setting|redline|writing|pacing|logic|anti-ai|presentation|compliance", "item": "问题描述", "suggestion": "修改建议", "ruleName": "命中的反AI规则名(见反AI规则清单)", "ruleType": "forbidden|risk|encourage", "category": "套话|句式|段落|心理|设定|节奏|对话|其他", "excerpt": "命中的原文摘录(不超过50字)", "reason": "判定理由", "canAutoRewrite": true|false}]}',
+    'tension 是本章张力强度评分（不是质量分）：对决/揭秘/生死抉择偏高，铺垫章、日常章、过渡章偏低；同一本书内保持同一尺度。',
+    '反 AI 类 issue 尽量给出 ruleName/ruleType/category/excerpt/reason/canAutoRewrite，便于统计与自动改写。',
+    'AI 套话高频模板词示例（集中出现必须整体降密度）：仿佛、似乎、极其、完美、深不见底、形成了、莫名、无法形容、难以言喻、精心雕琢、肤光胜雪、眉目如画、歌舞升平、觥筹交错、妙语连珠、不可名状、另一层真相、命运、真相。',
     '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
     '重要：直接输出 JSON 结果本身，不要把思考过程写在输出里。',
   ]
   const assetsBlock = renderAllAssets(project.assets)
   if (assetsBlock !== '') sections.push('\n' + assetsBlock)
   if (bible !== undefined) {
-    sections.push('\n==================== 设定圣经 ====================')
+    sections.push('\n==================== 道藏 ====================')
     if (bible.worldRules.length > 0) sections.push('世界规则：\n' + bible.worldRules.map(r => `- ${r}`).join('\n'))
     if (bible.characters.length > 0) {
       sections.push('角色卡：')
@@ -885,17 +1197,26 @@ export async function reviewChapter(
   chapterNo: number,
 ): Promise<ReviewReport> {
   const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
+  if (chapter === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 不在计划中`)
   const body = readChapterFile(outputDir, chapter)
-  if (body === undefined) throw new Error(`章节 ${chapterNo} 的正文文件不存在`)
+  if (body === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 的正文文件不存在`)
+  const bodyText = body.replace(/^#\s+.*$/m, '').trim()
+  // 本地 AI 味扫描（事实锚点，让 LLM 复核判断而非逐字统计）
+  const aiScan = scanAiFlavor(bodyText)
+  // 跨章上下文：上一章结尾 + 最近/相关事实 + 活跃剧情线/伏笔（审稿不再只看本章内部）
+  const chapterCtx = buildChapterContext(project, chapter, outputDir, { stage: 'review' })
+  const blocks = renderContextBlocks(chapterCtx)
+  const crossChapter = [blocks.continuityBlock, blocks.factsBlock, blocks.plotlinesBlock, blocks.foreshadowsBlock].filter(b => b !== '').join('\n')
   const user = [
     `本章标题：《${chapter.title}》`,
     `本章剧情要点：${chapter.beats}`,
+    `==================== 本地 AI 味扫描（事实锚点，你只需复核判断，不必再逐字统计） ====================\n${aiScan.summary}`,
+    crossChapter,
     '==================== 章节正文 ====================',
-    body.replace(/^#\s+.*$/m, '').trim(),
-  ].join('\n')
-  const text = await complete(ctx, config, { system: reviewSystemPrompt(project), user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 16000) })
-  const raw = parseJsonObject<{ score?: unknown; verdict?: unknown; issues?: unknown }>(text)
+    bodyText,
+  ].filter(line => line !== '').join('\n')
+  const text = await complete(ctx, config, { system: reviewSystemPrompt(project), user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 8000), reasoning: config.analysisReasoning ?? 'low', model: config.reviewModel, liveLabel: '审稿' })
+  const raw = parseJsonObject<{ score?: unknown; riskScore?: unknown; tension?: unknown; verdict?: unknown; issues?: unknown; resolvedIds?: unknown; unresolvedIds?: unknown }>(text)
   const issues = Array.isArray(raw.issues)
     ? raw.issues
         .filter((v): v is Record<string, unknown> => typeof v === 'object' && v !== null)
@@ -903,19 +1224,39 @@ export async function reviewChapter(
           severity: (['high', 'medium', 'low'] as const).includes(entry.severity as never)
             ? entry.severity as 'high' | 'medium' | 'low'
             : 'medium',
+          dimension: (typeof entry.dimension === 'string' && REVIEW_DIMENSION_IDS.has(entry.dimension))
+            ? entry.dimension as ReviewDimension
+            : undefined,
           item: typeof entry.item === 'string' ? entry.item : '',
           suggestion: typeof entry.suggestion === 'string' ? entry.suggestion : '',
+          ruleName: typeof entry.ruleName === 'string' ? entry.ruleName : undefined,
+          ruleType: (['forbidden', 'risk', 'encourage'] as const).includes(entry.ruleType as never)
+            ? entry.ruleType as 'forbidden' | 'risk' | 'encourage'
+            : undefined,
+          category: typeof entry.category === 'string' ? entry.category : undefined,
+          excerpt: typeof entry.excerpt === 'string' ? entry.excerpt.slice(0, 80) : undefined,
+          reason: typeof entry.reason === 'string' ? entry.reason.slice(0, 200) : undefined,
+          canAutoRewrite: typeof entry.canAutoRewrite === 'boolean' ? entry.canAutoRewrite : undefined,
         }))
         .filter(issue => issue.item !== '')
     : []
   const score = typeof raw.score === 'number' ? Math.max(0, Math.min(100, Math.round(raw.score))) : 60
-  // 无 high 问题且评分 ≥60 → 直接通过（medium/low 主观项记录但不阻塞，避免“72 分卡线”空转修订）
-  const passed = score >= config.reviewPassScore || (issues.every(i => i.severity !== 'high') && score >= 60)
+  const riskScore = typeof raw.riskScore === 'number' ? Math.max(0, Math.min(100, Math.round(raw.riskScore))) : undefined
+  // 通过条件：有 high 必须 ≥ reviewPassScore；无 high 可降 5 分但最低 65（避免低分稿直接放行）
+  const hasHigh = issues.some(i => i.severity === 'high')
+  const softThreshold = Math.max(65, config.reviewPassScore - 5)
+  const passed = hasHigh ? score >= config.reviewPassScore : score >= softThreshold
   const report: ReviewReport = {
     score,
     passed,
+    tension: typeof raw.tension === 'number' && Number.isFinite(raw.tension)
+      ? Math.max(0, Math.min(100, Math.round(raw.tension)))
+      : undefined,
     verdict: typeof raw.verdict === 'string' ? raw.verdict.slice(0, 200) : '',
     issues,
+    riskScore,
+    aiFlavor: aiScan.aiScore,
+    aiPhrases: aiScan.clicheHits.slice(0, 8),
     reviewedAt: new Date().toISOString(),
   }
   chapter.review = report
@@ -936,6 +1277,8 @@ export async function reviewChapterText(
   text: string,
   previousReport?: ReviewReport,
 ): Promise<ReviewReport> {
+  const bodyText = text.slice(0, 20000)
+  const aiScan = scanAiFlavor(bodyText)
   const user = [
     `书名：《${project.bookName}》`,
     previousReport !== undefined
@@ -945,12 +1288,13 @@ export async function reviewChapterText(
     previousReport !== undefined
       ? '==================== 修订稿（上一轮审稿后按意见修订的正文） ===================='
       : '==================== 待审查正文 ====================',
-    text.slice(0, 20000),
+    `==================== 本地 AI 味扫描（事实锚点，你只需复核判断，不必再逐字统计） ====================\n${aiScan.summary}`,
+    bodyText,
   ].join('\n')
   // 验证模式：携带上一轮报告时，逐条核对原意见是否解决 + 只挑新增 high，不再全新找茬。
   const system = previousReport !== undefined ? verifySystemPrompt(project) : reviewSystemPrompt(project)
-  const raw = parseJsonObject<{ score?: unknown; verdict?: unknown; issues?: unknown }>(
-    await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 16000) }),
+  const raw = parseJsonObject<{ score?: unknown; riskScore?: unknown; verdict?: unknown; issues?: unknown; resolvedIds?: unknown; unresolvedIds?: unknown }>(
+    await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 8000) }),
   )
   const issues = Array.isArray(raw.issues)
     ? raw.issues
@@ -959,18 +1303,39 @@ export async function reviewChapterText(
           severity: (['high', 'medium', 'low'] as const).includes(entry.severity as never)
             ? entry.severity as 'high' | 'medium' | 'low'
             : 'medium',
+          dimension: (typeof entry.dimension === 'string' && REVIEW_DIMENSION_IDS.has(entry.dimension))
+            ? entry.dimension as ReviewDimension
+            : undefined,
           item: typeof entry.item === 'string' ? entry.item : '',
           suggestion: typeof entry.suggestion === 'string' ? entry.suggestion : '',
+          ruleName: typeof entry.ruleName === 'string' ? entry.ruleName : undefined,
+          ruleType: (['forbidden', 'risk', 'encourage'] as const).includes(entry.ruleType as never)
+            ? entry.ruleType as 'forbidden' | 'risk' | 'encourage'
+            : undefined,
+          category: typeof entry.category === 'string' ? entry.category : undefined,
+          excerpt: typeof entry.excerpt === 'string' ? entry.excerpt.slice(0, 80) : undefined,
+          reason: typeof entry.reason === 'string' ? entry.reason.slice(0, 200) : undefined,
+          canAutoRewrite: typeof entry.canAutoRewrite === 'boolean' ? entry.canAutoRewrite : undefined,
         }))
         .filter(issue => issue.item !== '')
     : []
   const score = typeof raw.score === 'number' ? Math.max(0, Math.min(100, Math.round(raw.score))) : 60
-  // 非验证模式：无 high 且评分 ≥60 → 通过；验证模式判定：原 high 全部解决 + 无新增 high → 通过（主观项不再卡修订）。
-  let passed = score >= config.reviewPassScore || (issues.every(i => i.severity !== 'high') && score >= 60)
+  const riskScore = typeof raw.riskScore === 'number' ? Math.max(0, Math.min(100, Math.round(raw.riskScore))) : undefined
+  // 非验证模式：有 high 必须 ≥ reviewPassScore；无 high 可降 5 分但最低 65
+  const hasHighAny = issues.some(i => i.severity === 'high')
+  let passed = hasHighAny ? score >= config.reviewPassScore : score >= Math.max(65, config.reviewPassScore - 5)
   if (previousReport !== undefined) {
     const hasHigh = issues.some(i => i.severity === 'high')
     const prevHigh = previousReport.issues.filter(i => i.severity === 'high')
-    const prevHighResolved = prevHigh.every(p => !issues.some(i => i.item.includes(p.item.slice(0, 12))))
+    // 优先用模型输出的 unresolvedIds 精确判定（按编号），兼容旧报告回退到增强字符串匹配
+    const unresolvedIds = Array.isArray(raw.unresolvedIds) ? raw.unresolvedIds.filter((v: unknown): v is number => typeof v === 'number') : []
+    const resolvedIds = Array.isArray(raw.resolvedIds) ? raw.resolvedIds.filter((v: unknown): v is number => typeof v === 'number') : []
+    let prevHighResolved: boolean
+    if (unresolvedIds.length > 0 || resolvedIds.length > 0) {
+      prevHighResolved = prevHigh.every((_, idx) => !unresolvedIds.includes(idx + 1) || resolvedIds.includes(idx + 1))
+    } else {
+      prevHighResolved = prevHigh.every(p => !issues.some(i => i.item.replace(/^未解决\(\d+\)：/, '').includes(p.item.replace(/^未解决\(\d+\)：/, '').slice(0, 20))))
+    }
     passed = !hasHigh && prevHighResolved
   }
   return {
@@ -978,6 +1343,9 @@ export async function reviewChapterText(
     passed,
     verdict: typeof raw.verdict === 'string' ? raw.verdict.slice(0, 200) : '',
     issues,
+    riskScore,
+    aiFlavor: aiScan.aiScore,
+    aiPhrases: aiScan.clicheHits.slice(0, 8),
     reviewedAt: new Date().toISOString(),
   }
 }
@@ -987,16 +1355,20 @@ function verifySystemPrompt(project: ProjectState): string {
   return [
     '你是一位网文审稿验证员。作者已按上一轮审稿意见修订了本章，你需要验证修订效果。',
     '你的任务（严格按此执行）：',
-    '1. 逐条核对「上一轮意见」中的每一条是否已在修订稿中解决——已解决的不再列出；未解决或部分解决的，按原严重度列出（item 需注明"未解决：原意见 xxx"）。',
+    '1. 逐条核对「上一轮意见」中的每一条（按编号 1、2、3...）是否已在修订稿中解决。',
     '2. 只挑修订【新引入】的 high 级问题（设定矛盾/逻辑硬伤/事实错误）——新引入的 medium/low 主观项（文笔/套话/节奏）不要列。',
     '3. 禁止重复挑剔上一轮已指出且本次已解决的主观项（如"缓缓/微微"等套话、错别字）——即使换个说法再提也不行。',
-    '4. 严禁为了显得专业而新增"换一批毛病"式的意见；如果修订稿已解决全部 high 且无新增 high，输出 issues 为空数组。',
-    'score 评分：按修订稿整体质量给 50-90 分（解决全部 high 且无新增 high 时给 70 以上）。',
-    'verdict：一句话结论（如"原 high 已解决，无新增高风险问题"或"仍有未解决的 high"）。',
-    '输出必须是合法 JSON 对象：{"score": 数字, "verdict": "一句话", "issues": [{"severity": "high|medium|low", "item": "问题", "suggestion": "建议"}]}',
+    '4. 严禁为了显得专业而新增"换一批毛病"式的意见。',
+    '输出必须是合法 JSON 对象，包含以下字段：',
+    '- resolvedIds：已解决的上一轮意见编号数组（如 [1, 3, 5]）。',
+    '- unresolvedIds：未解决或部分解决的上一轮意见编号数组（如 [2, 4]）。',
+    '- issues：未解决的原意见 + 新引入的 high 级问题列表（格式同审稿：severity/item/suggestion）。未解决的原意见 item 需注明"未解决(编号N)：原意见摘要"。',
+    '- score：按修订稿整体质量给 50-90 分（解决全部 high 且无新增 high 时给 70 以上）。',
+    '- verdict：一句话结论。',
+    '完整格式：{"resolvedIds": [1,3], "unresolvedIds": [2], "score": 75, "verdict": "一句话", "issues": [{"severity": "high", "dimension": "character|setting|redline|writing|pacing|logic|anti-ai|presentation|compliance", "item": "未解决(2)：xxx", "suggestion": "xxx"}]}',
     '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
     '重要：直接输出 JSON 结果本身，不要把思考过程写在输出里。',
-    `本书设定圣经（核对设定冲突用）：\n${project.bible !== undefined ? JSON.stringify(project.bible).slice(0, 3000) : '（无）'}`,
+    `本书道藏（核对设定冲突用）：\n${project.bible !== undefined ? JSON.stringify(project.bible).slice(0, 3000) : '（无）'}`,
   ].join('\n')
 }
 
@@ -1012,8 +1384,12 @@ function authorReviewSystemPrompt(): string {
     '5. advancedLines：本章实际推进的剧情线名称数组——从「活跃剧情线」清单中选出推进了的线（名称必须与清单中的线名一字不差；没推进任何线则输出空数组）。',
     '6. continuity：与上一章结尾的衔接检查（人物位置/时间/伤势/资源/对话状态），发现问题要指出。',
     '7. trend：结合上一章复盘看近期节奏趋势（是否连续拖沓、爽点密度是否下降、是否需要调整）。',
+    '8. stateChanges：本章发生的关键状态变化数组（人物状态/世界局面/关系/资源，每条约 20 字，最多 6 条），供整本与事实库回灌。',
+    '9. newConflicts：本章新引入或明显升级的冲突数组（最多 4 条）。',
+    '10. clues：本章埋下或推进的新线索/伏笔数组（最多 4 条）。',
+    '11. absentRisks：本章缺席但按卷级职责应出场/该推进关系的重要角色，及其缺席带来的风险（最多 4 条）。',
     '输出必须是合法 JSON 对象，不要输出任何其他文字：',
-    '{"hookHonored": true或false, "hookNote": "一句话", "endingHook": 0-10整数, "plotlineProgress": "一句话", "advancedLines": ["线名"], "continuity": "一句话", "trend": "一句话"}',
+    '{"hookHonored": true或false, "hookNote": "一句话", "endingHook": 0-10整数, "plotlineProgress": "一句话", "advancedLines": ["线名"], "continuity": "一句话", "trend": "一句话", "stateChanges": ["状态变化"], "newConflicts": ["新冲突"], "clues": ["新线索"], "absentRisks": ["本章缺席但值得注意的角色及风险（卷级职责/缺席风险，最多4条）"]}',
     '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
     '重要：直接输出 JSON 结果本身，不要把思考过程写在输出里。',
   ].join('\n')
@@ -1060,6 +1436,10 @@ export async function authorReviewChapter(
     advancedLines?: unknown
     continuity?: unknown
     trend?: unknown
+    stateChanges?: unknown
+    newConflicts?: unknown
+    clues?: unknown
+    absentRisks?: unknown
   }>(
     await complete(ctx, config, { system: authorReviewSystemPrompt(), user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 4000) }),
   )
@@ -1068,6 +1448,7 @@ export async function authorReviewChapter(
   const advancedLines = Array.isArray(raw.advancedLines)
     ? raw.advancedLines.filter((n): n is string => typeof n === 'string' && n.trim() !== '' && knownLineNames.has(n.trim())).map(n => n.trim())
     : []
+  const strArr = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && x.trim() !== '').map(x => x.slice(0, 120)) : []
   return {
     hookHonored: raw.hookHonored === true,
     hookNote: typeof raw.hookNote === 'string' ? raw.hookNote.slice(0, 200) : '',
@@ -1076,6 +1457,10 @@ export async function authorReviewChapter(
     advancedLines,
     continuity: typeof raw.continuity === 'string' ? raw.continuity.slice(0, 200) : '',
     trend: typeof raw.trend === 'string' ? raw.trend.slice(0, 200) : '',
+    stateChanges: strArr(raw.stateChanges).slice(0, 6),
+    newConflicts: strArr(raw.newConflicts).slice(0, 4),
+    clues: strArr(raw.clues).slice(0, 4),
+    absentRisks: strArr(raw.absentRisks).slice(0, 4),
     reviewedAt: new Date().toISOString(),
   }
 }
@@ -1090,7 +1475,7 @@ export function autoLinkPlotlines(project: ProjectState, chapterNo: number, adva
   }
 }
 
-/** AI 建议剧情线：基于大纲/卷计划/已写章节/编年录，提炼候选线。 */
+/** 建议剧情线：基于大纲/卷计划/已写章节/编年录，提炼候选线。 */
 export async function suggestPlotlines(ctx: Context, config: NovelConfig, project: ProjectState): Promise<Plotline[]> {
   const system = [
     '你是一位网文剧情架构师。根据本书的大纲、卷计划、已写章节标题与编年录，为作者提炼建议的剧情线（主线/支线/人物线/悬念线）。',
@@ -1137,7 +1522,7 @@ export async function suggestPlotlines(ctx: Context, config: NovelConfig, projec
   return lines
 }
 
-/** AI 刷新单条剧情线的进度：结合编年录与各章摘要分析该线推进到哪。 */
+/** 刷新单条剧情线的进度：结合编年录与各章摘要分析该线推进到哪。 */
 export async function refreshPlotlineProgress(
   ctx: Context,
   config: NovelConfig,
@@ -1168,7 +1553,7 @@ export async function refreshPlotlineProgress(
   return typeof raw.progress === 'string' ? raw.progress.trim().slice(0, 300) : ''
 }
 
-/** ✨ AI 从全书提炼角色库：大纲 + 道藏 + 编年录 + 章节摘要 → 结构化角色清单。 */
+/**  AI 从全书提炼角色库：大纲 + 道藏 + 编年录 + 章节摘要 → 结构化角色清单。 */
 export async function extractRoles(
   ctx: Context,
   config: NovelConfig,
@@ -1177,8 +1562,8 @@ export async function extractRoles(
   const system = [
     '你是一位网文角色库管理员。请根据本书的大纲、设定、编年录与章节摘要，提炼完整的角色库。',
     '覆盖原则：所有在编年录/章节中实际出场或有名有姓的角色都应收录；无名的功能性人物（如"矮胖姑娘"）用其身份简称收录并标注；反复出现且有剧情作用的身份型角色（站长、律师、警察、法官、店主等）必须收录。',
-    '数量控制：最多输出 10 个角色；覆盖优先——主角、主要反派、重要配角（女主/关键配角）必须全收，所有有名有姓者必收；只有真正一次性路人（无名字、无剧情作用）才可省略。',
-    '重要：正常一部完整故事应提炼 6-10 个角色；若少于 4 个通常说明漏提炼，必须重新核对正文摘录。',
+    '数量控制：最多输出 20 个角色；覆盖优先——主角、主要反派、重要配角（女主/关键配角）必须全收，所有有名有姓者必收；只有真正一次性路人（无名字、无剧情作用）才可省略。',
+    '重要：正常一部完整故事应提炼 8-20 个角色；若少于 6 个通常说明漏提炼，必须重新核对正文摘录。',
     '重要：正文中若有明确的主角与主要反派，必须分别以 protagonist / antagonist 收录，禁止遗漏；反派确实未出场时才可省略。',
     '输出优先级：主角（protagonist）与主要反派（antagonist）必须优先输出并完整刻画，其次女主/重要配角；判断不出名字时用正文中的身份称呼。',
     '每个角色输出：',
@@ -1199,14 +1584,14 @@ export async function extractRoles(
   const written = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating')
   const existingRoles = project.roles ?? []
   // 正文摘录：均匀采样覆盖全书（开头/中间/结尾），避免只取前几章漏掉后期才出场的重要角色。
-  const sampleChapters: ChapterPlan[] = written.length <= 6
+  const sampleChapters: ChapterPlan[] = written.length <= 10
     ? written
     : (() => {
       const picked = new Set<number>()
       for (let i = 0; i < 3 && i < written.length; i++) picked.add(i)
-      const step = Math.max(1, Math.floor(written.length / 4))
-      for (let i = step; i < written.length - 2; i += step) picked.add(i)
-      for (let i = Math.max(0, written.length - 2); i < written.length; i++) picked.add(i)
+      const step = Math.max(1, Math.floor(written.length / 8))
+      for (let i = step; i < written.length - 3; i += step) picked.add(i)
+      for (let i = Math.max(0, written.length - 3); i < written.length; i++) picked.add(i)
       return [...picked].sort((a, b) => a - b).map(i => written[i])
     })()
   const excerptParts: string[] = []
@@ -1214,8 +1599,25 @@ export async function extractRoles(
     const body = readChapterFile(config.outputDir, chapter)
     if (body === undefined) continue
     const text = body.replace(/^#.*$/gm, '').trim()
-    if (text.length > 0) excerptParts.push(`第${chapter.no}章《${chapter.title}》\n${text.slice(0, 1500)}`)
+    if (text.length > 0) excerptParts.push(`第${chapter.no}章《${chapter.title}》\n${text.slice(0, 3000)}`)
+  }
+  // 出场频次统计：道藏角色名 + 已收录角色，扫全书统计出现次数，传给 LLM 做重要性判断参考
+  const freqCandidates = new Set<string>()
+  for (const c of project.bible?.characters ?? []) freqCandidates.add(c.name)
+  for (const r of existingRoles) freqCandidates.add(r.name)
+  const freqMap = new Map<string, number>()
+  if (freqCandidates.size > 0) {
+    for (const chapter of written) {
+      const body = readChapterFile(config.outputDir, chapter)
+      if (body === undefined) continue
+      for (const name of freqCandidates) {
+        let idx = 0, n = 0
+        while ((idx = body.indexOf(name, idx)) !== -1) { n++; idx += name.length }
+        if (n > 0) freqMap.set(name, (freqMap.get(name) ?? 0) + n)
+      }
+    }
   }
+  const freqLines = [...freqMap.entries()].filter(([, n]) => n >= 2).sort((a, b) => b[1] - a[1]).slice(0, 30).map(([name, n]) => name + '(' + n + '次)')
   const user = [
     `书名：《${project.bookName}》`,
     existingRoles.length > 0
@@ -1228,6 +1630,9 @@ export async function extractRoles(
     project.bible !== undefined && project.bible.characters.length > 0
       ? `已有角色卡（补充信息）：\n${project.bible.characters.map(c => `- ${c.name}（${c.role}）：${c.traits.join('、')}${c.goals !== '' ? `；目标：${c.goals}` : ''}`).join('\n')}`
       : '',
+    freqLines.length > 0
+      ? `角色出场频次参考（全书统计，次数越多越重要，优先收录高频角色）：${freqLines.join('、')}`
+      : '',
     (project.facts ?? []).length > 0
       ? `编年录（最近 30 条）：\n${(project.facts ?? []).slice(-30).map(f => `[第${f.chapterNo}章] ${f.text.slice(0, 60)}`).join('\n')}`
       : '',
@@ -1236,18 +1641,19 @@ export async function extractRoles(
       : '',
     '只输出 JSON 数组。',
   ].join('\n\n')
-  let text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 24000), reasoning: config.analysisReasoning ?? 'low' })
+  // 角色阵容：一次要产出 8-20 个角色，预算按预期角色数推算。
+  let text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: resolveOutputBudget('character-cast', { characters: 20 }), structured: true, reasoning: config.analysisReasoning ?? 'low' })
   let raw = parseJsonArray<Record<string, unknown>>(text)
   const hasProtagonist = raw.some(e => typeof e === 'object' && e !== null && e.roleLabel === 'protagonist')
-  const tooFew = raw.length > 0 && raw.length < 4
+  const tooFew = raw.length > 0 && raw.length < 6
   if (raw.length === 0 || !hasProtagonist || tooFew) {
     // LLM 偶发输出非 JSON / 空数组 / 漏主角 / 角色过少：重试一次（追加明确指令），避免静默返回空或缺角色的候选。
     const hint = raw.length === 0
       ? '\n上一次输出为空或格式不正确。请直接输出 JSON 数组（即使只有一个角色也要输出），不要输出其他文字。'
       : tooFew
-        ? '\n上一次输出角色过少（不足 4 个）。这是一部完整故事，请重新核对正文摘录：主角、主要反派、重要配角与所有有名有姓的角色都要收录（宁多勿漏），输出 6-10 个。'
+        ? '\n上一次输出角色过少（不足 6 个）。这是一部完整故事，请重新核对正文摘录：主角、主要反派、重要配角与所有有名有姓的角色都要收录（宁多勿漏），输出 8-20 个。'
         : '\n上一次输出中缺少主角（roleLabel 为 protagonist 的角色）。请重新输出完整 JSON 数组，务必包含正文中的主角。'
-    text = await complete(ctx, config, { system: system + hint, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 24000), reasoning: config.analysisReasoning ?? 'low' })
+    text = await complete(ctx, config, { system: system + hint, user, temperature: 0.3, maxTokens: resolveOutputBudget('character-cast', { characters: 24 }), structured: true, reasoning: config.analysisReasoning ?? 'low' })
     raw = parseJsonArray<Record<string, unknown>>(text)
   }
   const labels = new Set(['protagonist', 'female_lead', 'female_support', 'support', 'antagonist', 'extra'])
@@ -1285,12 +1691,12 @@ export async function extractRoles(
         if (role === undefined || existing.has(role.name)) continue
         existing.add(role.name)
         roles.push(role)
-        if (roles.length >= 10) break
+        if (roles.length >= 20) break
       }
     } catch { /* 补漏失败不阻塞主结果 */ }
   }
   // 确定性兜底：正文中反复出现的身份型称呼（站长/律师/警察等）若 LLM 仍漏掉，按出现次数直接补条（通用、不依赖名单）。
-  const ROLE_TITLE_HINTS = ['站长', '律师', '检察官', '法官', '警察', '店主', '老板', '经理', '局长', '医生', '老师', '护士', '房东', '司机', '保安', '主管', '队长', '厂长', '董事长', '总裁', '市长', '道长', '掌门', '师父', '师傅', '管家']
+  const ROLE_TITLE_HINTS = ['站长', '律师', '检察官', '法官', '警察', '店主', '老板', '经理', '局长', '医生', '老师', '护士', '房东', '司机', '保安', '主管', '队长', '厂长', '董事长', '总裁', '市长', '道长', '掌门', '师父', '师傅', '管家', '长老', '宗主', '殿主', '宫主', '师兄', '师姐', '师弟', '师妹', '老祖', '魔尊', '妖王', '将军', '军师', '太监', '宫女', '嬷嬷', '宰相', '尚书', '巡抚', '都督', '祭司', '圣女', '圣子']
   const existingNames = new Set(roles.map(r => r.name))
   const titleCount = new Map<string, number>()
   for (const chapter of written) {
@@ -1307,7 +1713,7 @@ export async function extractRoles(
     }
   }
   for (const t of ROLE_TITLE_HINTS) {
-    if (roles.length >= 10) break
+    if (roles.length >= 20) break
     const covered = existingNames.has(t) || [...existingNames].some(n => n.includes(t))
     if (!covered && (titleCount.get(t) ?? 0) >= 3) {
       existingNames.add(t)
@@ -1317,92 +1723,7 @@ export async function extractRoles(
   return roles
 }
 
-/** ✨ AI 从全书提炼场景库：正文/编年录 → 高频重要场景的结构化视觉锚点。 */
-export async function extractScenes(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  styleId?: string,
-  filterId?: string,
-): Promise<SceneCard[]> {
-  const styleWords = styleKeywords(styleId, filterId)
-  const system = [
-    '你是一位网文漫剧场景导演。根据本书的大纲、编年录与已写章节摘录，提炼「镜头场景」——漫剧分镜/生图时每个镜头要知道"在哪、什么时间光态、拍什么情节、人物什么状态"。',
-    '按五幕结构覆盖全书核心场景（短篇 10 章内可少于五幕，按实际剧情组织）：第一幕后场/核心主场、第二幕对外卖场/营业区、第三幕禁忌区域/地下深仓、第四幕外部人间世界（短暂出逃）、第五幕回归与抉择。',
-    '【当前视觉风格】（moment/palette/moods/zh/en 必须按此风格措辞，不能写中性描述）：' + styleWords,
-    '重要：每个场景的 zh 提示词段首必须原样嵌入【当前视觉风格】词块原文；en 提示词末尾追加风格标签。不得省略或改写。',
-    '每个场景必须是「镜头场景」而非仅场地：给出该场景的关键情节镜头（人物动作+情绪+镜头推进）。',
-    '数量控制：最多输出 8 个场景；每个场景必须能对应到正文实际出现过的地点与情节，不得凭空虚构。',
-    '每个场景输出：',
-    '1. name：场景名（地点+光态，如「后场通道·装卸口（雨夜）」）。',
-    '2. act：幕归属（第一幕后场/第二幕卖场/第三幕深仓/第四幕外界/第五幕抉择）。',
-    '3. moment：时间光态（夜间闭店后/雨夜/凌晨/频闪灯…）。',
-    '4. summary：一句话定位（空间类型/功能/氛围）。',
-    '5. beats：关键情节镜头 1-3 条（人物动作+情绪+镜头推进，如"沈放佝偻站在货架过道，镜头推近，情绪从漠然过渡到压抑悲伤"）。',
-    '6. characterState：主角/关键角色在该场景的状态一句话（含标志物细节如标签磨损、手腕红痕）。',
-    '7. elements：环境构成数组 3-6 项（空间结构/陈设/标志物）。',
-    '8. palette：色调与光影数组 2-4 项（颜色词，可附 HEX）。',
-    '9. moods：氛围关键词 2-4 个（压抑/神秘/空旷/悲凉…）。',
-    '10. zh：中文生图提示词（连贯一段，写实电影感，含环境/光线/氛围/人物状态）。',
-    '11. en：英文生图提示词（booru 风格逗号分隔，含 photorealistic/cinematic）。',
-    '12. tags：3-6 个关键标签。',
-    '13. source：依据来源说明（哪几章哪些描写）。',
-    '若故事存在结局抉择（如双分支），最后 1-2 个场景应为「抉择场景」，zh 里写明分支 A/B 两种画面。',
-    '输出必须是合法 JSON 数组，不要输出其他文字：[{"name":"...", "act":"...", "moment":"...", "summary":"...", "beats":[...], "characterState":"...", "elements":[...], "palette":[...], "moods":[...], "zh":"...", "en":"...", "tags":[...], "source":"..."}]',
-    '重要：所有字符串值内部不得包含换行符；直接输出 JSON 结果本身。',
-  ].join('\n')
-  const written = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating')
-  const excerptParts: string[] = []
-  for (const chapter of written.slice(0, 4)) {
-    const body = readChapterFile(config.outputDir, chapter)
-    if (body === undefined) continue
-    const text = body.replace(/^#.*$/gm, '').trim()
-    if (text.length > 0) excerptParts.push('第' + chapter.no + '章《' + chapter.title + '》' + '\n' + text.slice(0, 1800))
-  }
-  const user = [
-    '书名：《' + project.bookName + '》',
-    (project.facts ?? []).length > 0
-      ? '编年录（最近 80 条，场景地点以这里为准）：' + '\n' + (project.facts ?? []).slice(-80).map(f => '[第' + f.chapterNo + '章] ' + f.text.slice(0, 80)).join('\n')
-      : '',
-    excerptParts.length > 0
-      ? '已写正文摘录（场景描写以正文为准）：' + '\n' + excerptParts.join('\n')
-      : '',
-    '只输出 JSON 数组。',
-  ].filter(s => s !== '').join('\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonArray<Record<string, unknown>>(text)
-  const strArr = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && x.trim() !== '') : []
-  const str = (v: unknown): string => typeof v === 'string' ? v.trim() : ''
-  const scenes: SceneCard[] = []
-  for (const entry of raw) {
-    if (typeof entry !== 'object' || entry === null) continue
-    const name = str(entry.name).slice(0, 40)
-    if (name === '') continue
-    scenes.push({
-      name,
-      act: str(entry.act).slice(0, 40),
-      moment: str(entry.moment).slice(0, 60),
-      summary: str(entry.summary).slice(0, 120),
-      beats: strArr(entry.beats).map(t => t.slice(0, 120)).slice(0, 3),
-      characterState: str(entry.characterState).slice(0, 160),
-      elements: strArr(entry.elements).map(t => t.slice(0, 60)).slice(0, 6),
-      palette: strArr(entry.palette).map(t => t.slice(0, 40)).slice(0, 4),
-      moods: strArr(entry.moods).map(t => t.slice(0, 20)).slice(0, 4),
-      zh: ensureStyleEmbedded(str(entry.zh).slice(0, 800), styleWords, 'zh'),
-      en: ensureStyleEmbedded(str(entry.en).slice(0, 600), styleWords, 'en'),
-      tags: strArr(entry.tags).map(t => t.slice(0, 24)).slice(0, 6),
-      source: str(entry.source).slice(0, 120),
-      styleId,
-    })
-  }
-  return scenes
-}
-
-
-
-
-
-/** 从 txt/md 全本文本拆章（纯逻辑，不落盘）：识别章节头、剥离重复标题、去重、排序并统一重新编号。 */
+/**  AI 从全书提炼场景库：正文/编年录 → 高频重要场景的结构化视觉锚点。 */
 export function splitBookText(raw: string): Array<{ no: number; title: string; body: string }> {
   const lines = raw.split(/\r?\n/)
   // 拆章：中文「第X章/回/节/卷」、中文数字章节（一、二、三…）、特殊章节（序章/楔子/尾声/番外…）、英文 Chapter N（均可带 # 前缀）。
@@ -1514,7 +1835,7 @@ export function importBookTextFromText(
     }
     chapter.file = chapterFileName(chapter)
     writeFileSync(join(outputDir, chapter.file), '# 第' + c.no + '章 ' + chapter.title + '\n\n' + body + '\n', 'utf8')
-    chapter.chars = body.length
+    chapter.chars = countHanzi(body)
     project.chapters.push(chapter)
   }
   project.updatedAt = new Date().toISOString()
@@ -1532,674 +1853,104 @@ export function importBookText(
   return importBookTextFromText(raw, outputDir, bookName)
 }
 
-/** 常见职业/身份尾缀：角色名如「周野律师」正文可能只写「周野」或「周野的律师」。 */
-const ROLE_NAME_SUFFIXES = ['律师', '辩护律师', '医生', '老师', '教授', '先生', '女士', '小姐', '警官', '警察', '局长', '总经理', '经理', '老板', '师父', '师傅', '道长', '老祖', '长老', '掌门', '少主', '公主', '王子', '王妃', '皇后', '皇帝', '王爷', '公子', '姑娘', '夫人', '太太', '大人', '将军', '丞相', '尚书', '员外']
-
-/**
- * 从角色名/身份拆出正文可能使用的检索词：
- * - specific：具体称谓（含职业尾缀或 3 字以上身份片段），如「周野的律师」「辩护律师」「律师」——优先用，避免误抓到同名主干（周野）的段落；
- * - stems：名字主干（如「周野」），最后兜底。
- */
-function roleFallbackTokens(name: string, identity: string | undefined): { specific: string[]; stems: string[] } {
-  const specific = new Set<string>()
-  const stems = new Set<string>()
-  const addName = (s: string): void => {
-    const t = s.trim()
-    if (t.length < 2) return
-    specific.add(t)
-    for (const q of ['辩护', '助理', '高级', '首席', '御用', '御前', '专职']) {
-      if (t.includes(q)) specific.add(t.replace(q, ''))
-    }
-    for (const suf of ROLE_NAME_SUFFIXES) {
-      if (t.endsWith(suf) && t.length > suf.length + 1) {
-        const stem = t.slice(0, -suf.length)
-        // 「周野律师」→「周野的律师」（正文常见写法）
-        specific.add(stem + '的' + suf)
-        specific.add(suf)
-        if (stem.length >= 2) stems.add(stem)
-      }
-    }
-  }
-  addName(name)
-  for (const part of (identity ?? '').split(/[的，,。\s]+/)) {
-    const p = part.trim()
-    if (p.length < 2) continue
-    if (p.length >= 3 || ROLE_NAME_SUFFIXES.some(s => p.endsWith(s))) {
-      specific.add(p)
-      for (const suf of ROLE_NAME_SUFFIXES) {
-        if (p.endsWith(suf) && p.length > suf.length + 1) {
-          specific.add(suf)
-          stems.add(p.slice(0, -suf.length))
-        }
-      }
-    } else {
-      stems.add(p)
-    }
-  }
-  return { specific: [...specific].filter(t => t.length >= 2), stems: [...stems].filter(t => t.length >= 2) }
-}
-
 /** 保证风格词块已内嵌（LLM 偶发漏嵌时兜底）：zh 段首前缀，en 末尾追加。 */
-function ensureStyleEmbedded(text: string, styleWords: string, lang: 'zh' | 'en'): string {
-  const t = text.trim()
-  if (styleWords === '' || t === '') return t
-  if (t.includes(styleWords)) return t
-  return lang === 'zh' ? styleWords + '，' + t : t + '，' + styleWords
-}
-
-/** 对 zh/en 一对提示词统一补风格词块。 */
-function withStyle(pair: { zh: string; en: string }, styleWords: string): { zh: string; en: string } {
-  return { zh: ensureStyleEmbedded(pair.zh, styleWords, 'zh'), en: ensureStyleEmbedded(pair.en, styleWords, 'en') }
-}
-
-/** 动漫形象描述词（中文描述 + 英文 booru 标签 + 关键外貌标签）。 */
-export interface RoleVisualPrompt {
-  zh: string
-  en: string
-  tags: string[]
-  source: string
-  /** 该角色所需情绪表情清单（6-12 个，如 疲惫/麻木/压抑悲伤）。 */
-  expressions?: string[]
-  /** 四类精修提示词（立绘/四视图/表情/细节，一次提炼直接产出）。 */
-  promptKit?: RoleRecord['promptKit']
-}
-
-/** 可提炼形象的「角色源」：小说角色卡或漫剧角色卡的最小公共面。 */
-interface RoleVisualSource {
-  name: string
-  identity?: string
-  traits?: string[]
-}
-
-/**
- * 底层实现：为任意角色源提炼「动漫形象描述词」（不写库，写库由上层调用方负责）。
- * 扫描该角色出场的已写章节正文，截取含外貌描写的段落，交给 LLM 提炼中文描述 + 英文绘图标签。
- */
-async function extractRoleVisualFrom(
+export async function suggestOutlines(
   ctx: Context,
   config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  role: RoleVisualSource,
-  styleId?: string,
-  filterId?: string,
-  shortDrama = false,
-): Promise<RoleVisualPrompt> {
-  const roleName = role.name
-
-  // 1. 扫描正文：收集该角色出场且可能含外貌描写的段落（最近 60 章内，每章最多 2 段，共 12 段）。
-  // 支持“描述型角色名”（如「灰蓝工装女人」）：先精确匹配，匹配不到时用角色名拆分出的关键词兜底。
-  const appearanceHints = /(发|眉|眼|眸|脸|肤|唇|身材|身高|衣|袍|裙|衫|靴|腰带|气质|模样|长相|容貌|披|束|扎|戴|佩|挂|绣|青|白|黑|红|蓝|紫|灰|银|金|少年|青年|少女|汉子|老者|中年|纤细|挺拔|瘦削|壮实|清秀|俊朗|英气|阴鸷|慈眉)/
-  // 从角色名 + 身份描述中提取可检索关键词，支持“描述型角色名”（灰蓝工装女人）和“身份型角色名”（富商）。
-  const roleText = `${role.name} ${role.identity ?? ''}`
-  const colorWords = ['深灰', '灰蓝', '灰', '蓝', '白', '黑', '红', '青', '紫', '银', '金', '黄', '绿', '粉', '棕']
-  const garmentWords = ['工装', '西装', '定制西装', '袍', '裙', '衫', '衣', '裤', '靴', '鞋', '帽', '腰带', '制服', '外套', '马甲', '夹克']
-  const roleWords = ['女人', '男人', '老者', '老人', '中年', '青年', '少女', '姑娘', '男子', '女子', '工人', '路人', '购买者']
-  const locationWords = ['别墅', '小区', '街区']
-  const identityTokens = (role.identity ?? '').split(/[，,。\s]+/).filter(t => t.length >= 2)
-  const searchTokens = Array.from(new Set([
-    roleName,
-    ...identityTokens,
-    ...colorWords.filter(w => roleText.includes(w)),
-    ...garmentWords.filter(w => roleText.includes(w)),
-    ...roleWords.filter(w => roleText.includes(w)),
-    ...locationWords.filter(w => roleText.includes(w)),
-  ])).filter(t => t.length >= 2)
-  const matchesRole = (para: string, tokens: string[]): boolean => para.includes(roleName) || tokens.some(tok => para.includes(tok))
-  const excerpts: Array<{ no: number; text: string }> = []
-  const written = project.chapters
-    .filter(c => c.status !== 'pending' && c.status !== 'generating' && c.file !== undefined)
-  /** 扫描一批章节，收集该角色出场且可能含外貌描写的段落（每章最多 2 段，共 12 段）。 */
-  const scanChapters = (list: ChapterPlan[], tokens: string[]): void => {
-    for (const chapter of list) {
-      if (excerpts.length >= 12) break
-      const body = readChapterFile(outputDir, chapter)
-      if (body === undefined) continue
-      const paras = body.split(/\n{2,}/).map(p => p.trim()).filter(p => p.length > 0)
-      let perChapter = 0
-      for (const para of paras) {
-        if (perChapter >= 2 || excerpts.length >= 12) break
-        if (!matchesRole(para, tokens)) continue
-        // 优先外貌描写段（含外貌关键词），否则纯动作段也收（LLM 自己判断）。
-        if (appearanceHints.test(para) || excerpts.length < 4) {
-          excerpts.push({ no: chapter.no, text: para.slice(0, 220) })
-          perChapter++
-        }
-      }
-    }
-  }
-  // 第 1 优先：最近 60 章（快路径）。
-  scanChapters(written.slice(-60), searchTokens)
-  // 第 2 优先：角色可能只在早期出场（全书 >60 章时），全书回扫。
-  if (excerpts.length === 0) scanChapters(written, searchTokens)
-  // 第 3 优先：角色名/身份带职业尾缀（如「周野律师」→ 正文写「周野的律师/律师」），用具体称谓扫。
-  if (excerpts.length === 0) {
-    const fb = roleFallbackTokens(role.name, role.identity)
-    if (fb.specific.length > 0) scanChapters(written, fb.specific)
-  }
-  // 第 4 兜底：具体称谓也没找到时，退回名字主干（如「周野」），交给 LLM 判断是否目标角色。
-  if (excerpts.length === 0) {
-    const fb = roleFallbackTokens(role.name, role.identity)
-    if (fb.stems.length > 0) scanChapters(written, fb.stems)
-  }
-  if (excerpts.length === 0) {
-    throw new Error(`正文中未找到「${roleName}」的出场描写（已扫描全书及角色名拆分词），请确认角色名与正文一致，或该角色尚未在正文出场`)
-  }
-
-  // 2. LLM 提炼：一次输出 锚点 + 表情清单 + 四类精修提示词。
-  const rules = project.visualRules ?? []
-  const styleWords = styleKeywords(styleId, filterId)
+  idea: string,
+  count = 3,
+  exclude: string[] = [],
+): Promise<OutlineCandidate[]> {
+  const n = Math.max(1, Math.min(3, Math.floor(count)))
   const system = [
-    '你是一位动漫角色设定师与 AI 绘图提示词工程师。根据网文正文中该角色的实际外貌描写，输出「形象锚点」与「四类生图提示词」——一次完成，用于 AI 绘图（NovelAI / Stable Diffusion / Midjourney / 豆包等）生成一致的角色立绘。',
-    '【当前视觉风格】（portrait 立绘的「风格」字段必须原样使用，sheet/expressions/details 同样内嵌）：' + styleWords,
-    '重要：每段 zh 提示词的段首必须原样嵌入【当前视觉风格】词块原文；en 提示词末尾追加风格标签。不得省略或改写。',
-    '硬性要求（依据优先）：',
-    '1. 发色/发型/瞳色/服装/气质/标志物必须来自提供的正文段落，不得凭空发明。',
-    '2. 正文未明确写到的项目（如瞳色没写、身高没写），用「未定」标注或直接不写，不要编造数值。',
-    '3. 服装优先取正文明确出现的（颜色+款式），多次出现取最常穿的组合；服装按分件组织（上身/下身/鞋/配饰）。',
-    '4. 标志物（标签/印记/饰品）必须出现在每段提示词中——它们是一致性的命根子。',
-    '5. 立绘/四视图/细节是「角色设定稿」：禁止写瞬间动作与道具使用状态（握手机、看屏幕、未接来电、走路、回头等），禁止写剧情状态与场景背景；只保留可长期存在的外貌、服装与常驻标志物（工牌、饰品等）。',
-    ...(shortDrama ? ['6. 短剧精简模式·人设极致化：性格标签必须极致化（如「极端偏执」「绝对冷血」，单一维度拉到最满）；外貌只保留 1-2 个最强辨识度点，弱化平凡细节；服装/标志物更夸张醒目。'] : []),
-    '【本书视觉规则】（必须内嵌进每段提示词，保证设定不跑偏）：',
-    ...rules.map(r => '- ' + r),
-    '输出六部分：',
-    '- zh：中文形象锚点，一段连贯文字（60-150 字）：发色发型、瞳色、脸型气质、服装（颜色款式）、身材、标志性物件。',
-    '- en：英文形象锚点，booru 风格、逗号分隔、小写，30-50 个标签：含性别（1boy/1girl）、发色、发型、瞳色、服装、气质、标志物。不要输出负面提示词。',
-    '- tags：中文关键标签数组，5-10 个（如 ["黑发","束发","青色道袍","清秀","腰悬古玉"]）。',
-    '- source：说明依据（如"第1章/第8章外貌描写；瞳色未明确"）。',
-    '- expressions：该角色在本书剧情中需要的情绪表情清单数组，6-12 个（如 ["疲惫","麻木","压抑悲伤","皱眉","紧绷","放空"]），依据正文情绪描写与角色处境推断。',
-    '- promptKit：四类精修提示词（字段化+出图约束，参考示例结构）：',
-    '  · portrait 立绘：严格按字段顺序写（参考示例结构）：开头构图定位（正面站立全身人像）→ 风格（3D动漫，超精细建模）→ 背景（纯白纯色背景）→ 身份（男子，{角色名}，外表{年龄}，男性）→ 发型发色 → 胡茬 → 眼眸 → 面部 → 气质 → 上身服装分件（颜色款式+磨损细节）→ 下身 → 鞋 → 标志物（标签/印记，含细节如洇暗翘边）→ 收尾（角色设计稿，细节完整展示，无多余杂物，全身完整无裁切）。',
-    '  · sheet 四视图：同一角色的 正面/左侧面/右侧面/背面 四视图设定表（character sheet），纯白背景，全身完整，四个视角分别描述，服装与标志物细节完整展示。',
-    '  · expressions 表情：每个表情一段，脸部特写（头部到锁骨），纯白背景，五官与角色定稿完全一致，只换情绪表达（眼神/嘴角/眉），皮肤纹理细节完整，无多余杂物。',
-    '  · details 细节：多组局部细节集合参考图（一张图多个局部框），纯白背景；把该角色全部标志物逐项列出（如标签/印记/工牌/袖口磨损/鞋），每项一句特写描述；细节清晰锐利，角色细节参考稿，无多余杂物。',
-    'promptKit 每段 zh：连贯中文 60-150 字；en：booru 标签 30-50 个。',
-    '输出必须是合法 JSON 对象：{"zh": "...", "en": "...", "tags": [...], "source": "...", "expressions": [...], "promptKit": {"portrait": {"zh":"...", "en":"..."}, "sheet": {"zh":"...", "en":"..."}, "expressions": [{"name":"疲惫","zh":"...","en":"..."}], "details": {"zh":"...", "en":"..."}}}',
-    '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
+    '你是一位资深网文策划。作者只给了一句「想法」，你需要把它扩展成 2-3 个【方向差异明显】的完整小说大纲方案，供作者挑选。',
+    '每个方案必须满足：',
+    '1. bookName：书名（6 字以内，抓眼球、点题）。',
+    '2. genre：题材（如 仙侠修真 / 都市异能 / 玄幻 / 悬疑）。',
+    '3. sellingPoint：核心卖点一句话（金手指/爽点/差异化，40 字内）。',
+    '4. outline：完整大纲文本（至少 800 字，可直接作为开书大纲），结构包含：书名与题材、金手指/核心设定、主角人设与动机、主线剧情走向（至少 5 个阶段）、关键配角与势力、卖点与爽点设计、预计分卷（3-5 卷）。',
+    '方向差异要求：',
+    '- 方案之间的金手指/剧情走向必须明显不同（如：苟道发育流 vs 随身老爷爷流 vs 群像争霸流），不能只是换书名。',
+    '- 忠实于作者想法的核心要素，但允许在不同方向上进行合理演绎。',
+    '- 不输出任何与已列「需避开的方向」雷同的方案。',
+    '输出必须是合法 JSON 数组，只输出数组本身：',
+    '[{"id": "唯一id", "bookName": "...", "genre": "...", "sellingPoint": "...", "outline": "..."}]',
+    `本次只输出 ${n} 个方案。`,
+    '重要：所有字符串值内部不得包含换行符（大纲内部分段请用「。\n」或「；」自然断句），JSON 必须在一段内完整结束。',
     '重要：直接输出 JSON 结果本身，不要把思考过程写在输出里。',
   ].join('\n')
   const user = [
-    `书名：《${project.bookName}》`,
-    `目标角色：${role.name}（${role.identity}）`,
-    (role.traits ?? []).length > 0 ? `性格标签：${role.traits!.join('、')}` : '',
-    `正文出场描写（含外貌线索的段落）：`,
-    ...excerpts.map(e => `[第${e.no}章] ${e.text}`),
-    '只输出 JSON 对象。',
+    `作者的想法：${idea}`,
+    idea.trim().length < 40
+      ? '作者的想法非常简短（可能只有一句）。请基于通用网文套路合理扩展补全：为每个方案自洽地设计金手指/核心设定、主角人设与动机、主线走向，使其成为完整可开书的大纲；不同方案的方向仍须明显差异。'
+      : '',
+    exclude.length > 0
+      ? `需避开的已暂留方案方向（新方案不得与之雷同）：\n${exclude.map((e, i) => `${i + 1}. ${e}`).join('\n')}`
+      : '',
+    `请生成 ${n} 个大纲方案。`,
+    '只输出 JSON 数组。',
   ].join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonObject<{ zh?: unknown; en?: unknown; tags?: unknown; source?: unknown; expressions?: unknown; promptKit?: unknown }>(text)
-  let zh = typeof raw.zh === 'string' ? raw.zh.trim().slice(0, 500) : ''
-  let en = typeof raw.en === 'string' ? raw.en.trim().slice(0, 1500) : ''
-  const tags = Array.isArray(raw.tags)
-    ? raw.tags.filter((t): t is string => typeof t === 'string' && t.trim() !== '').map(t => t.trim().slice(0, 20)).slice(0, 12)
-    : []
-  const source = typeof raw.source === 'string' ? raw.source.trim().slice(0, 300) : ''
-  const expressions = Array.isArray(raw.expressions)
-    ? raw.expressions.filter((e): e is string => typeof e === 'string' && e.trim() !== '').map(e => e.trim().slice(0, 12)).slice(0, 12)
-    : []
-  // 四类精修提示词（一次提炼直接产出）
-  const str = (v: unknown): string => typeof v === 'string' ? v.trim() : ''
-  const pair = (v: unknown): { zh: string; en: string } => {
-    const o = (typeof v === 'object' && v !== null) ? v as Record<string, unknown> : {}
-    return { zh: str(o.zh).slice(0, 800), en: str(o.en).slice(0, 1200) }
+  const text = await complete(ctx, config, { system, user, temperature: 0.85, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low' })
+  const parsed = parseJsonArray<Record<string, unknown>>(text)
+  const candidates: OutlineCandidate[] = []
+  for (const entry of parsed) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const bookName = typeof entry.bookName === 'string' ? entry.bookName.trim().slice(0, 30) : ''
+    const outline = typeof entry.outline === 'string' ? entry.outline.trim() : ''
+    if (bookName === '' || outline.length < 300) continue
+    candidates.push({
+      id: typeof entry.id === 'string' && entry.id !== '' ? entry.id : `oc-${Date.now().toString(36)}-${candidates.length}`,
+      bookName,
+      genre: typeof entry.genre === 'string' ? entry.genre.trim().slice(0, 20) : '',
+      sellingPoint: typeof entry.sellingPoint === 'string' ? entry.sellingPoint.trim().slice(0, 120) : '',
+      outline,
+    })
   }
-  const kitRaw = (typeof raw.promptKit === 'object' && raw.promptKit !== null) ? raw.promptKit as Record<string, unknown> : {}
-  const kitExpr = Array.isArray(kitRaw.expressions) ? kitRaw.expressions.filter((e): e is Record<string, unknown> => typeof e === 'object' && e !== null) : []
-  let promptKit: RoleRecord['promptKit']
-  try {
-    promptKit = {
-      portrait: pair(kitRaw.portrait),
-      sheet: pair(kitRaw.sheet),
-      expressions: kitExpr.map(e => ({
-        name: str(e.name).slice(0, 12) || '表情',
-        zh: str(e.zh).slice(0, 800),
-        en: str(e.en).slice(0, 1200),
-      })).slice(0, 12),
-      details: pair(kitRaw.details),
-    }
-  } catch {
-    promptKit = undefined
-  }
-  if (zh === '' || en === '') {
-    throw new Error('形象描述提炼失败：LLM 未返回有效 JSON')
-  }
-  // 风格兜底：LLM 漏嵌时强制补上（zh 段首 / en 末尾），保证出图风格与当前方案一致。
-  zh = ensureStyleEmbedded(zh, styleWords, 'zh')
-  en = ensureStyleEmbedded(en, styleWords, 'en')
-  if (promptKit !== undefined) {
-    promptKit = {
-      portrait: withStyle(promptKit.portrait, styleWords),
-      sheet: withStyle(promptKit.sheet, styleWords),
-      expressions: promptKit.expressions.map(e => ({ ...e, ...withStyle(e, styleWords) })),
-      details: withStyle(promptKit.details, styleWords),
-    }
+  if (candidates.length === 0) {
+    throw new Error('大纲方案生成失败：LLM 未返回有效 JSON（可重试）')
   }
-  return { zh, en, tags, source, expressions, promptKit }
-}
-
-/** 小说角色库：提炼单个角色的形象锚点并写回角色卡。 */
-export async function extractRoleVisual(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  roleName: string,
-  styleId?: string,
-  filterId?: string,
-): Promise<RoleVisualPrompt> {
-  const role = (project.roles ?? []).find(r => r.name === roleName)
-  if (role === undefined) throw new Error(`角色「${roleName}」不在角色库中`)
-  role.promptStyleId = styleId
-  return extractRoleVisualFrom(ctx, config, project, outputDir, role, styleId, filterId)
+  return candidates.slice(0, n)
 }
 
-/** 漫剧角色卡：提炼形象锚点并写回漫剧卡（status → anchored）。 */
-export async function extractMangaRoleVisual(
+/** 拆书分析：对已写章节做结构/人物/文风/卖点四维体检。
+ *  两阶段管道（先抽取候选、再落库）：
+ *  ① 源片段笔记：每章抽取结构化笔记（剧情/人物/设定/写法/卖点/短板信号）
+ *  ② 分节分析：按维度各跑一次 LLM，输出可读分析稿 + 结构化数据 + 证据链。
+ *  @param scope 'recent'(默认最近20章) | 'volume:N' | 'all'
+ *  @param preset 'quick'(总览/剧情/人物/文风) | 'standard'(+卖点)
+ *  @param budgetTokens token 预算上限（超过即截断章节取样）。
+ */
+export async function breakdownBook(
   ctx: Context,
   config: NovelConfig,
   project: ProjectState,
   outputDir: string,
-  cardId: string,
-  styleId?: string,
-  filterId?: string,
-): Promise<RoleVisualPrompt> {
-  const card = (project.mangaRoles ?? []).find(c => c.id === cardId)
-  if (card === undefined) throw new Error(`漫剧角色卡 ${cardId} 不存在`)
-  const visual = await extractRoleVisualFrom(ctx, config, project, outputDir, { name: card.name, identity: card.identity, traits: card.traits }, styleId, filterId, project.shortDramaMode === true)
-  card.promptStyleId = styleId
-  card.imagePrompt = visual
-  if ((visual.expressions ?? []).length > 0) card.expressions = visual.expressions
-  if (visual.promptKit !== undefined) card.promptKit = visual.promptKit
-  if (card.status === 'imported' || card.status === 'pending_confirm') card.status = 'anchored'
-  card.updatedAt = new Date().toISOString()
-  return visual
-}
+  scope = 'recent',
+  preset: 'quick' | 'standard' = 'quick',
+  budgetTokens = 50000,
+): Promise<BreakdownResponse> {
+  // 1. 选章节范围。
+  const written = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating' && c.summary !== undefined && c.summary !== '')
+  let selected = written
+  if (scope === 'recent') selected = written.slice(-20)
+  else if (/^volume:\d+$/.test(scope)) {
+    const v = Number(scope.slice(7))
+    selected = written.filter(c => c.volume === v)
+  }
+  if (selected.length === 0) throw new NovelActionError('contract', '没有可分析的已写章节（需要已生成并带摘要）')
 
-/** 可精修提示词包的「角色源」：小说角色卡或漫剧角色卡的最小公共面。 */
-interface RoleKitSource {
-  name: string
-  identity?: string
-  imagePrompt: NonNullable<RoleRecord['imagePrompt']>
-  expressions?: string[]
-}
-
-/**
- * 底层实现：基于角色源的形象锚点 + 表情清单 + 视觉规则产出四类生图提示词（不写库）。
- */
-async function generateRolePromptKitFrom(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  role: RoleKitSource,
-  styleId?: string,
-  filterId?: string,
-  shortDrama = false,
-): Promise<RoleRecord['promptKit']> {
-  const roleName = role.name
-  const rules = project.visualRules ?? []
-  const styleWords = styleKeywords(styleId, filterId)
-  const system = [
-    '你是一位 AI 绘图提示词工程师。基于给定角色的形象锚点、表情清单与本书视觉规则，输出四类生图提示词（每类 zh+en 各一段）。',
-    '【当前视觉风格】（每类提示词必须内嵌）：' + styleWords,
-    '重要：每段 zh 提示词的段首必须原样嵌入【当前视觉风格】词块原文；en 提示词末尾追加风格标签。不得省略或改写。',
-    '四类：',
-    '1. portrait 立绘：正面站立全身人像，3D动漫超精细建模，纯白纯色背景；按字段流组织：身份（男子，角色名，外表年龄）→ 发型发色 → 胡茬 → 眼眸 → 面部 → 气质 → 上身服装分件（含磨损）→ 下身 → 鞋 → 标志物（含细节）→ 收尾（角色设计稿，细节完整展示，无多余杂物，全身完整无裁切）。',
-    '2. sheet 四视图：同一角色的 正面/左侧面/右侧面/背面 四视图设定表（character sheet），纯白背景，四个视角分别描述。',
-    '3. expressions 表情：每个表情一段，脸部特写（头部到锁骨），纯白背景，五官与角色定稿完全一致，只换情绪表达（眼神/嘴角/眉），皮肤纹理细节完整，无多余杂物。',
-    '4. details 细节：多组局部细节集合参考图（一张图多个局部框），纯白背景；把该角色全部标志物逐项列出，每项一句特写描述；细节清晰锐利，角色细节参考稿，无多余杂物。',
-    '5. 立绘/四视图/细节为「角色设定稿」：禁止瞬间动作、道具使用状态与剧情状态（握手机、看屏幕、未接来电等），只保留可长期存在的外貌、服装与常驻标志物（工牌、饰品等）。',
-    ...(shortDrama ? ['6. 短剧精简模式·人设极致化：性格标签必须极致化（单一维度拉到最满）；外貌只保留 1-2 个最强辨识度点；服装/标志物更夸张醒目，一眼可认。'] : []),
-    '【本书视觉规则】（必须内嵌进每段提示词，保证设定不跑偏）：',
-    ...rules.map(r => '- ' + r),
-    'zh 要求：连贯中文，写实电影感，60-150 字/段；en 要求：booru 风格逗号分隔标签，30-50 个/段。',
-    '输出必须是合法 JSON 对象：{"portrait": {"zh": "...", "en": "..."}, "sheet": {"zh": "...", "en": "..."}, "expressions": [{"name": "疲惫", "zh": "...", "en": "..."}], "details": {"zh": "...", "en": "..."}}',
-    '重要：所有字符串值内部不得包含换行符；直接输出 JSON 结果本身。',
-  ].join('\n')
-  const user = [
-    `角色：${role.name}（${role.identity ?? ''}）`,
-    `中文锚点：${role.imagePrompt.zh}`,
-    `英文锚点：${role.imagePrompt.en}`,
-    `关键标签：${role.imagePrompt.tags.join('、')}`,
-    `表情清单：${(role.expressions ?? []).join('、') || '（未提供，按角色气质推断 6 个）'}`,
-    '只输出 JSON 对象。',
-  ].join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonObject<Record<string, unknown>>(text)
-  const str = (v: unknown): string => typeof v === 'string' ? v.trim() : ''
-  const pair = (v: unknown): { zh: string; en: string } => {
-    const o = (typeof v === 'object' && v !== null) ? v as Record<string, unknown> : {}
-    return { zh: str(o.zh).slice(0, 800), en: str(o.en).slice(0, 1200) }
-  }
-  const expressionsRaw = Array.isArray(raw.expressions) ? raw.expressions.filter((e): e is Record<string, unknown> => typeof e === 'object' && e !== null) : []
-  const kit: RoleRecord['promptKit'] = {
-    portrait: withStyle(pair(raw.portrait), styleWords),
-    sheet: withStyle(pair(raw.sheet), styleWords),
-    expressions: expressionsRaw.map(e => ({
-      name: str(e.name).slice(0, 12) || '表情',
-      ...withStyle({ zh: str(e.zh).slice(0, 800), en: str(e.en).slice(0, 1200) }, styleWords),
-    })).slice(0, 12),
-    details: withStyle(pair(raw.details), styleWords),
-  }
-  if (kit.portrait.zh === '' || kit.portrait.en === '') {
-    throw new Error('提示词精修失败：LLM 未返回有效 JSON')
-  }
-  return kit
-}
-
-/** 小说角色库：角色四类生图提示词精修包（写回角色卡）。 */
-export async function generateRolePromptKit(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  roleName: string,
-  styleId?: string,
-  filterId?: string,
-): Promise<RoleRecord['promptKit']> {
-  const role = (project.roles ?? []).find(r => r.name === roleName)
-  if (role === undefined) throw new Error(`角色「${roleName}」不在角色库中`)
-  if (role.imagePrompt === undefined) throw new Error(`角色「${roleName}」还没有形象锚点，请先生成锚点`)
-  role.promptStyleId = styleId
-  return generateRolePromptKitFrom(ctx, config, project, { name: role.name, identity: role.identity, imagePrompt: role.imagePrompt, expressions: role.expressions }, styleId, filterId)
-}
-
-/** 漫剧角色卡：四类生图提示词精修包（写回漫剧卡，status → anchored）。 */
-export async function generateMangaRolePromptKit(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  cardId: string,
-  styleId?: string,
-  filterId?: string,
-): Promise<RoleRecord['promptKit']> {
-  const card = (project.mangaRoles ?? []).find(c => c.id === cardId)
-  if (card === undefined) throw new Error(`漫剧角色卡 ${cardId} 不存在`)
-  if (card.imagePrompt === undefined) throw new Error(`「${card.name}」还没有形象锚点，请先生成锚点`)
-  const kit = await generateRolePromptKitFrom(ctx, config, project, { name: card.name, identity: card.identity, imagePrompt: card.imagePrompt, expressions: card.expressions }, styleId, filterId, project.shortDramaMode === true)
-  card.promptStyleId = styleId
-  card.promptKit = kit
-  if (card.status === 'imported' || card.status === 'pending_confirm') card.status = 'anchored'
-  card.updatedAt = new Date().toISOString()
-  return kit
-}
-
-/**
- * 漫剧角色库·提名（两段式）：从某章分镜的 characters 提名候选角色名 →
- * 规则过滤（精确名 + 身份/简称匹配，短名单 ≤5）→ LLM 确认（是/否 + 选哪个，不做开放检索）→
- * 返回带漫剧卡建议的候选（未匹配时给出「回小说库补提炼 / 漫剧直接创建」判定）。
- */
-export async function nominateMangaRoles(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  chapterNo: number,
-): Promise<MangaRoleCandidate[]> {
-  const entry = (project.storyboards ?? []).find(e => e.chapterNo === chapterNo)
-  if (entry === undefined) throw new Error(`第 ${chapterNo} 章还没有分镜产出，请先在「分镜」页生成剧情骨架/分镜表`)
-
-  // 收集该章分镜的结构化角色引用（骨架 + 表级 + 镜头级，去重）。
-  const names: string[] = []
-  const pushNames = (list: string[] | undefined): void => {
-    for (const n of list ?? []) {
-      const t = n.trim().slice(0, 20)
-      if (t !== '' && !names.includes(t)) names.push(t)
-    }
-  }
-  pushNames(entry.skeleton?.characters)
-  pushNames(entry.table?.characters)
-  for (const s of entry.table?.shots ?? []) pushNames(s.characters)
-  if (names.length === 0) throw new Error(`第 ${chapterNo} 章的分镜还没有结构化角色（characters 为空），请重新生成剧情骨架/分镜表`)
-
-  // 已建漫剧卡的直接标 already_imported（按漫剧名或来源名匹配）。
-  const imported = new Set<string>()
-  for (const c of project.mangaRoles ?? []) {
-    imported.add(c.name)
-    if (c.sourceRoleName !== undefined && c.sourceRoleName !== '') imported.add(c.sourceRoleName)
-  }
-  const already: MangaRoleCandidate[] = names.filter(n => imported.has(n)).map(n => ({
-    rawName: n,
-    verdict: 'already_imported' as const,
-    matches: [],
-    suggested: emptyCandidateSuggestion(n),
-  }))
-  const fresh = names.filter(n => !imported.has(n))
-  if (fresh.length === 0) return already
-
-  const chapter = project.chapters.find(c => c.no === chapterNo)
-  const body = chapter !== undefined ? readChapterFile(outputDir, chapter) : undefined
-  const roles = project.roles ?? []
-
-  // 规则阶段：精确名 + 身份/简称匹配，短名单 ≤5。
-  const shortlists: Array<{ rawName: string; roleNames: string[] }> = fresh.map(rawName => {
-    const shortlist: string[] = []
-    const push = (n: string): void => { if (!shortlist.includes(n)) shortlist.push(n) }
-    for (const r of roles) {
-      if (shortlist.length >= 5) break
-      const n = r.name
-      if (n === rawName) { push(n); continue }
-      if (n.includes(rawName) || rawName.includes(n)) { push(n); continue }
-      const ident = r.identity ?? ''
-      if (ident !== '' && (ident === rawName || ident.includes(rawName) || rawName.includes(ident))) push(n)
-    }
-    return { rawName, roleNames: shortlist }
-  })
-
-  // LLM 阶段：确认是/否 + 选哪个 + 漫剧卡建议（只能从短名单里选，不做开放检索）。
-  const beats = (entry.skeleton?.beats ?? []).map(b => `[${b.id}] ${b.event}`).join('\n')
-  const system = [
-    '你是一位漫剧选角导演。下面给出「分镜角色提名」与「小说角色库候选名单」。',
-    '任务：为每个提名判定它对应小说角色库中的哪一个候选（或判定小说库没有对应角色），并预填一张「漫剧角色卡」的建议信息。',
-    '规则：',
-    '1. roleName 只能从该提名的候选名单中选，禁止输出名单之外的名字（不做开放检索）。',
-    '2. verdict：matched=候选名单里确实有对应角色（选最像的那个）；ambiguous=名单里有多个候选且无法确定（此时 roleName 可留空或选最可能的一个）；not_in_library=候选名单为空或都不对应。',
-    '3. matched/ambiguous 时给出漫剧卡建议：name（漫剧用名，默认与角色名一致）、identity（身份一句话，30 字内）、coreFunction（protagonist=主角/mentor=导师/love_interest=感情线/antagonist=反派/sidekick=搭档/informant=线人/functional=功能性）、protagonistRelation（enemy/friend/mentor/lover/exploit=利用/neutral）、speechStyle（口头禅或说话方式）、traits（不超过 3 个极致性格标签）、appearance（1-2 个辨识度外貌点）、keyScenes（本章该角色 1-2 个关键剧情节点，格式「第N章 xxx」）。',
-    '4. 身份型提名（如「持枪者」「围观群众」）：候选名单有则匹配；名单没有且正文确有该称谓 → not_in_library；正文也没有 → not_in_library。',
-    ...(project.shortDramaMode === true
-      ? ['5. 短剧精简模式（本书已开启）：只保留 5-8 个上镜角色——主角/反派/感情线/关键配角；功能性路人不上卡（此类提名直接 not_in_library）。每个角色必须给出明确的 coreFunction 与 protagonistRelation；性格标签极致化；候选超过 8 个时按戏份重要性裁剪到最核心 8 个。']
-      : []),
-    '输出必须是合法 JSON 数组：[{"rawName": "...", "verdict": "...", "roleName": "...或省略", "suggested": {...}}]，每个提名都要有，数组长度必须等于提名数。',
-    '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
-  ].join('\n')
-  const user = [
-    `章节：第 ${chapterNo} 章《${chapter?.title ?? ''}》`,
-    '==== 剧情骨架（节拍） ====',
-    beats !== '' ? beats : '（无骨架节拍）',
-    '==== 角色提名与候选名单 ====',
-    shortlists.map(s => s.roleNames.length > 0 ? `[提名] ${s.rawName} → 候选：${s.roleNames.join('、')}` : `[提名] ${s.rawName} → 候选：（无）`).join('\n'),
-    body !== undefined ? '==== 章节正文（前 2500 字，判断称谓归属用） ====\n' + body.replace(/^#.*$/gm, '').trim().slice(0, 2500) : '',
-    '只输出 JSON 数组。',
-  ].filter(x => x !== '').join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.2, maxTokens: Math.max(config.maxTokens, 8000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonArray<Record<string, unknown>>(text)
-
-  const verdicts = new Set(['matched', 'ambiguous', 'not_in_library'])
-  const fnMap: Record<string, MangaRoleCard['coreFunction']> = { protagonist: 'protagonist', mentor: 'mentor', love_interest: 'love_interest', antagonist: 'antagonist', sidekick: 'sidekick', informant: 'informant', functional: 'functional' }
-  const relMap: Record<string, MangaRoleCard['protagonistRelation']> = { enemy: 'enemy', friend: 'friend', mentor: 'mentor', lover: 'lover', exploit: 'exploit', neutral: 'neutral' }
-  const byName = new Map<string, Record<string, unknown>>()
-  for (const e of raw) {
-    if (typeof e === 'object' && e !== null && typeof e.rawName === 'string') byName.set(e.rawName.trim(), e)
-  }
-  const str = (v: unknown): string => typeof v === 'string' ? v.trim().slice(0, 100) : ''
-  const strArr = (v: unknown, n: number): string[] => Array.isArray(v)
-    ? v.filter((x): x is string => typeof x === 'string' && x.trim() !== '').map(x => x.trim().slice(0, 20)).slice(0, n)
-    : []
-
-  const out: MangaRoleCandidate[] = []
-  for (const item of shortlists) {
-    const judge = byName.get(item.rawName)
-    const judgeVerdict = judge !== undefined ? str(judge.verdict) : ''
-    const verdict = verdicts.has(judgeVerdict) ? judgeVerdict as MangaRoleCandidate['verdict'] : (item.roleNames.length > 0 ? 'ambiguous' : 'not_in_library')
-    let roleName: string | undefined
-    if (judge !== undefined) {
-      const chosen = str(judge.roleName)
-      if (chosen !== '' && item.roleNames.includes(chosen)) roleName = chosen
-    }
-    if (verdict === 'matched' && roleName === undefined && item.roleNames.length === 1) roleName = item.roleNames[0]
-    const sug = (typeof judge?.suggested === 'object' && judge?.suggested !== null) ? judge.suggested as Record<string, unknown> : {}
-    const novelHint: MangaRoleCandidate['novelHint'] = verdict === 'not_in_library' && body !== undefined
-      ? (body.includes(item.rawName) ? 'backfill' : 'manga_new')
-      : undefined
-    const suggested = {
-      name: (str(sug.name) !== '' ? str(sug.name) : (roleName ?? item.rawName)).slice(0, 30),
-      identity: str(sug.identity).slice(0, 60),
-      coreFunction: fnMap[str(sug.coreFunction)] ?? 'functional',
-      protagonistRelation: relMap[str(sug.protagonistRelation)] ?? 'neutral',
-      speechStyle: str(sug.speechStyle).slice(0, 60),
-      traits: strArr(sug.traits, 3),
-      appearance: str(sug.appearance).slice(0, 100),
-      keyScenes: strArr(sug.keyScenes, 3),
-    }
-    out.push({
-      rawName: item.rawName,
-      verdict,
-      matches: item.roleNames.map(n => ({ roleName: n, reason: roleName === n ? 'LLM 确认' : '规则候选' })),
-      matchedRoleName: roleName,
-      novelHint,
-      suggested,
-    })
-  }
-  return [...already, ...out]
-}
-
-/** 空建议（already_imported 等无需 LLM 的候选用）。 */
-function emptyCandidateSuggestion(name: string): MangaRoleCandidate['suggested'] {
-  return { name, identity: '', coreFunction: 'functional', protagonistRelation: 'neutral', speechStyle: '', traits: [], appearance: '', keyScenes: [] }
-}
-
-/** ✨ 从道藏/红线提炼「视觉世界观规则」：生图/生视频必须遵守的设定纠偏（如"商品=人，禁止常规超市商品"）。 */
-export async function extractVisualRules(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-): Promise<string[]> {
-  const system = [
-    '你是一位 AI 绘图的视觉规则设计师。本书的设定是"反常识"的，生图/生视频模型默认会画成现实世界的样子，你需要提炼 3-6 条「视觉规则」钉住本书的视觉世界观。',
-    '规则要求：',
-    '1. 每条必须可执行：明确"画面里必须出现什么/禁止出现什么"（如"货架上的一切商品都是活人，禁止画成罐头/饮料/日用品"）。',
-    '2. 覆盖本书最容易被模型画错的 2-4 个核心反常识点。',
-    '3. 每条 40 字内，禁止泛泛而谈。',
-    '输出必须是合法 JSON 数组：["规则1", "规则2", ...]，不要输出其他文字。',
-  ].join('\n')
-  const bible = project.bible
-  const user = [
-    `书名：《${project.bookName}》`,
-    `题材：${bible?.genre ?? ''}`,
-    bible !== undefined && bible.worldRules.length > 0
-      ? `世界规则：\n${bible.worldRules.map(r => '- ' + r).join('\n')}`
-      : '',
-    bible !== undefined && bible.redLines.length > 0
-      ? `红线：\n${bible.redLines.map(r => '- ' + r).join('\n')}`
-      : '',
-    '只输出 JSON 数组。',
-  ].filter(s => s !== '').join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 4000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonArray<string>(text)
-  return raw.map(r => typeof r === 'string' ? r.trim().slice(0, 80) : '').filter(r => r !== '').slice(0, 8)
-}
-
-
-/**
- * 开书想法 → AI 大纲：输入一句话想法，生成 2-3 个方向不同、可直接开书的完整大纲方案。
- * @param count 本次生成几个（默认 3，最多 3）
- * @param exclude 已暂留方案的剧情方向/卖点摘要（换批时避开，防止重复）
- */
-export async function suggestOutlines(
-  ctx: Context,
-  config: NovelConfig,
-  idea: string,
-  count = 3,
-  exclude: string[] = [],
-): Promise<OutlineCandidate[]> {
-  const n = Math.max(1, Math.min(3, Math.floor(count)))
-  const system = [
-    '你是一位资深网文策划。作者只给了一句「想法」，你需要把它扩展成 2-3 个【方向差异明显】的完整小说大纲方案，供作者挑选。',
-    '每个方案必须满足：',
-    '1. bookName：书名（6 字以内，抓眼球、点题）。',
-    '2. genre：题材（如 仙侠修真 / 都市异能 / 玄幻 / 悬疑）。',
-    '3. sellingPoint：核心卖点一句话（金手指/爽点/差异化，40 字内）。',
-    '4. outline：完整大纲文本（至少 800 字，可直接作为开书大纲），结构包含：书名与题材、金手指/核心设定、主角人设与动机、主线剧情走向（至少 5 个阶段）、关键配角与势力、卖点与爽点设计、预计分卷（3-5 卷）。',
-    '方向差异要求：',
-    '- 方案之间的金手指/剧情走向必须明显不同（如：苟道发育流 vs 随身老爷爷流 vs 群像争霸流），不能只是换书名。',
-    '- 忠实于作者想法的核心要素，但允许在不同方向上进行合理演绎。',
-    '- 不输出任何与已列「需避开的方向」雷同的方案。',
-    '输出必须是合法 JSON 数组，只输出数组本身：',
-    '[{"id": "唯一id", "bookName": "...", "genre": "...", "sellingPoint": "...", "outline": "..."}]',
-    `本次只输出 ${n} 个方案。`,
-    '重要：所有字符串值内部不得包含换行符（大纲内部分段请用「。\n」或「；」自然断句），JSON 必须在一段内完整结束。',
-    '重要：直接输出 JSON 结果本身，不要把思考过程写在输出里。',
-  ].join('\n')
-  const user = [
-    `作者的想法：${idea}`,
-    idea.trim().length < 40
-      ? '作者的想法非常简短（可能只有一句）。请基于通用网文套路合理扩展补全：为每个方案自洽地设计金手指/核心设定、主角人设与动机、主线走向，使其成为完整可开书的大纲；不同方案的方向仍须明显差异。'
-      : '',
-    exclude.length > 0
-      ? `需避开的已暂留方案方向（新方案不得与之雷同）：\n${exclude.map((e, i) => `${i + 1}. ${e}`).join('\n')}`
-      : '',
-    `请生成 ${n} 个大纲方案。`,
-    '只输出 JSON 数组。',
-  ].join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.85, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low' })
-  const parsed = parseJsonArray<Record<string, unknown>>(text)
-  const candidates: OutlineCandidate[] = []
-  for (const entry of parsed) {
-    if (typeof entry !== 'object' || entry === null) continue
-    const bookName = typeof entry.bookName === 'string' ? entry.bookName.trim().slice(0, 30) : ''
-    const outline = typeof entry.outline === 'string' ? entry.outline.trim() : ''
-    if (bookName === '' || outline.length < 300) continue
-    candidates.push({
-      id: typeof entry.id === 'string' && entry.id !== '' ? entry.id : `oc-${Date.now().toString(36)}-${candidates.length}`,
-      bookName,
-      genre: typeof entry.genre === 'string' ? entry.genre.trim().slice(0, 20) : '',
-      sellingPoint: typeof entry.sellingPoint === 'string' ? entry.sellingPoint.trim().slice(0, 120) : '',
-      outline,
-    })
-  }
-  if (candidates.length === 0) {
-    throw new Error('大纲方案生成失败：LLM 未返回有效 JSON（可重试）')
-  }
-  return candidates.slice(0, n)
-}
-
-/** 拆书分析：对已写章节做结构/人物/文风/卖点四维体检。
- *  两阶段管道（借鉴 AI-Novel-Writing-Assistant）：
- *  ① 源片段笔记：每章抽取结构化笔记（剧情/人物/设定/写法/卖点/短板信号）
- *  ② 分节分析：按维度各跑一次 LLM，输出可读分析稿 + 结构化数据 + 证据链。
- *  @param scope 'recent'(默认最近20章) | 'volume:N' | 'all'
- *  @param preset 'quick'(总览/剧情/人物/文风) | 'standard'(+卖点)
- *  @param budgetTokens token 预算上限（超过即截断章节取样）。
- */
-export async function breakdownBook(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  scope = 'recent',
-  preset: 'quick' | 'standard' = 'quick',
-  budgetTokens = 50000,
-): Promise<BreakdownResponse> {
-  // 1. 选章节范围。
-  const written = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating' && c.summary !== undefined && c.summary !== '')
-  let selected = written
-  if (scope === 'recent') selected = written.slice(-20)
-  else if (/^volume:\d+$/.test(scope)) {
-    const v = Number(scope.slice(7))
-    selected = written.filter(c => c.volume === v)
-  }
-  if (selected.length === 0) throw new Error('没有可分析的已写章节（需要已生成并带摘要）')
-
-  // 2. token 预算：估算每章正文+摘要成本，超预算则只取最近的章节。
-  let budget = budgetTokens
-  const chunks: Array<{ no: number; title: string; summary: string; body: string }> = []
-  for (const c of selected.slice().reverse()) {
-    const body = readChapterFile(outputDir, c) ?? ''
-    // 粗估：每 4 字符 ≈ 1 token（中文），章节正文截 4000 字上限。
-    const bodySlice = body.replace(/^#\s+.*$/m, '').trim().slice(0, 4000)
-    const est = Math.ceil((bodySlice.length + (c.summary?.length ?? 0)) / 4) + 400
-    if (est > budget && chunks.length > 0) break
-    chunks.unshift({ no: c.no, title: c.title, summary: c.summary ?? '', body: bodySlice })
-    budget -= est
-  }
+  // 2. token 预算：估算每章正文+摘要成本，超预算则只取最近的章节。
+  let budget = budgetTokens
+  const chunks: Array<{ no: number; title: string; summary: string; body: string }> = []
+  for (const c of selected.slice().reverse()) {
+    const body = readChapterFile(outputDir, c) ?? ''
+    // 粗估：每 4 字符 ≈ 1 token（中文），章节正文截 4000 字上限。
+    const bodySlice = body.replace(/^#\s+.*$/m, '').trim().slice(0, 4000)
+    const est = Math.ceil((bodySlice.length + (c.summary?.length ?? 0)) / 4) + 400
+    if (est > budget && chunks.length > 0) break
+    chunks.unshift({ no: c.no, title: c.title, summary: c.summary ?? '', body: bodySlice })
+    budget -= est
+  }
 
   // 3. 阶段一：源片段笔记（每章一次 LLM，串行控制 token）。
   const notes: string[] = []
@@ -2327,40 +2078,6 @@ export async function breakdownBook(
   }
 }
 
-/** 生图接口连通性测试（设置页模型条目用）：GET {baseURL}/models，计时返回延迟。 */
-export async function testImageEndpoint(baseURL: string, apiKey: string, model?: string): Promise<{ ok: boolean; ms: number; message?: string; modelFound?: boolean }> {
-  const trimmed = baseURL.trim()
-  if (trimmed === '') return { ok: false, ms: 0, message: '接口地址不能为空' }
-  const url = trimmed.replace(/\/+$/, '') + '/models'
-  const start = Date.now()
-  try {
-    const res = await fetch(url, {
-      method: 'GET',
-      headers: { Authorization: 'Bearer ' + apiKey, 'Content-Type': 'application/json' },
-    })
-    const ms = Date.now() - start
-    if (!res.ok) {
-      const text = (await res.text().catch(() => '')).slice(0, 200)
-      return { ok: false, ms, message: 'HTTP ' + res.status + (text !== '' ? '：' + text : '') }
-    }
-    let modelFound: boolean | undefined
-    if (model !== undefined && model !== '') {
-      const json = await res.json().catch(() => null)
-      const list = (json as { data?: unknown } | null)?.data
-      if (Array.isArray(list)) {
-        modelFound = list.some(m => {
-          if (typeof m !== 'object' || m === null) return false
-          const o = m as Record<string, unknown>
-          return o.id === model || o.model === model
-        })
-      }
-    }
-    return { ok: true, ms, modelFound }
-  } catch (err) {
-    return { ok: false, ms: Date.now() - start, message: (err as Error).message }
-  }
-}
-
 // ---------------------------------------------------------- llm catalog/test
 
 /** LLM 连通性失败的错误码 → 人话（供设置页“测试连通”回显）。 */
@@ -2393,13 +2110,16 @@ export async function testLlmModel(ctx: Context, provider: string, model: string
     content: [{ type: 'text', text: '只回复两个字：OK' }],
     source: { kind: 'plugin', plugin: 'dsh-novel-forge' },
   })]
-  const request: GenerateOptions = {
+  // 这里自己构造请求（为省 token 拿到首块即停），所以**必须显式过一遍能力层**：
+  // 否则「测试连通」会原样下发参数，对固定温度的模型必然报错 —— 而测试连通
+  // 正是用户用来判断配置对不对的地方。
+  const request = applyModelCapability({
     provider,
     model,
     messages,
     maxTokens: 16,
     temperature: 0,
-  }
+  }, model)
   // 真实流式调用 + 30 秒超时（GenerateOptions.signal 由适配器响应并中止）。
   const controller = new AbortController()
   const timer = setTimeout(() => controller.abort(), 30_000)
@@ -2454,11 +2174,22 @@ export async function listLlmVendors(ctx: Context): Promise<LlmVendorsResponse>
       }
     }
   } catch { /* 单个目录读取失败跳过 */ }
-  // 已注册的适配器路由（如 deepseek-official）
+  // 已注册的适配器路由（如 deepseek-official）：以 DSH 运行时目录为准刷新模型列表，
+  // 否则 LLM_VENDORS 里的预置模型一旦过期（模型改名/下线），下拉里就会挂着不存在的模型。
   try {
     for (const p of ctx.llm.listProviders()) {
-      if (!map.has(p.id)) {
-        map.set(p.id, { id: p.id, name: p.name !== '' && p.name !== p.id ? p.name : p.id, models: [], builtin: true })
+      const name = p.name !== '' && p.name !== p.id ? p.name : p.id
+      let models: string[] = []
+      try {
+        models = (await ctx.llm.listModels(p.id)).map(m => m.id).filter(id => id !== '')
+      } catch { /* 该 provider 目录不可用 → 保留预置兜底 */ }
+      const existing = map.get(p.id)
+      if (existing === undefined) {
+        map.set(p.id, { id: p.id, name, models, builtin: true })
+      } else if (models.length > 0) {
+        // 运行时目录优先：预置列表只作为目录不可用时的兜底
+        existing.models = models
+        if (existing.name === '' || existing.name === p.id) existing.name = name
       }
     }
   } catch { /* ignore */ }
@@ -2569,101 +2300,7 @@ export async function registerLlmModel(ctx: Context, req: AddModelRequest): Prom
   return { ok: true, saved, provider: route, message }
 }
 
-/** 底层：按形象锚点调用生图接口生成定妆图（不写库；写库由上层调用方负责）。 */
-async function generateReferenceImageFrom(
-  config: NovelConfig,
-  anchor: NonNullable<RoleRecord['imagePrompt']>,
-  style = '',
-  modelId?: string,
-): Promise<string> {
-  if (config.imageApiEnabled !== true) throw new Error('生图未启用，请在设置中启用一个生图模型')
-  const activeImage = (modelId !== undefined && modelId !== '' ? (config.imageModels ?? []).find(m => m.id === modelId) : undefined)
-    ?? (config.imageModels ?? []).find(m => m.enabled)
-    ?? (config.imageModels ?? [])[0]
-  const apiKey = activeImage?.apiKey ?? config.imageApiKey
-  const model = activeImage?.model ?? config.imageApiModel
-  const baseURL = (activeImage?.baseURL ?? config.imageBaseUrl ?? '').replace(/\/+$/, '')
-  if (baseURL === '') throw new Error('请先在设置中填写生图接口地址')
-  if (apiKey === undefined || apiKey === '' || model === undefined || model === '') {
-    throw new Error('请先在设置中配置生图模型的 API Key 和模型 id')
-  }
-  const stylePrompt = getComicStylePrompt(style)
-  const prompt = [
-    anchor.zh,
-    anchor.en,
-    anchor.tags.join(', '),
-    stylePrompt,
-    'character reference sheet, front view, clean background, consistent design',
-  ].filter(Boolean).join(', ')
-
-  const res = await fetch(baseURL + '/images/generations', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model,
-      prompt,
-      response_format: 'url',
-      size: '2K',
-      stream: false,
-      watermark: false,
-    }),
-  })
-  if (!res.ok) {
-    const text = await res.text()
-    throw new Error(`生图失败（${res.status}）：${text}`)
-  }
-  const json = (await res.json()) as { data?: Array<{ url?: string }> }
-  const url = json.data?.[0]?.url
-  if (url === undefined || url === '') throw new Error('生图接口未返回图片 URL')
-
-  const imgRes = await fetch(url)
-  if (!imgRes.ok) throw new Error('下载生图结果失败')
-  const buf = Buffer.from(await imgRes.arrayBuffer())
-  const contentType = imgRes.headers.get('content-type') || 'image/jpeg'
-  return `data:${contentType};base64,${buf.toString('base64')}`
-}
-
-/** 小说角色库：生成角色定妆图并写回角色卡（imageUrl）。 */
-export async function generateRoleReferenceImage(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  name: string,
-  style = '',
-  modelId?: string,
-): Promise<string> {
-  const role = project.roles?.find(r => r.name === name)
-  if (role === undefined) throw new Error(`角色 ${name} 不存在`)
-  if (role.imagePrompt === undefined) throw new Error(`角色 ${name} 还没有形象锚点，请先生成锚点`)
-  const dataUrl = await generateReferenceImageFrom(config, role.imagePrompt, style, modelId)
-  role.imageUrl = dataUrl
-  return dataUrl
-}
-
-/** 漫剧角色卡：生成定妆图并写回漫剧卡（imageUrl）。 */
-export async function generateMangaRoleReferenceImage(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  cardId: string,
-  style = '',
-  modelId?: string,
-): Promise<string> {
-  const card = (project.mangaRoles ?? []).find(c => c.id === cardId)
-  if (card === undefined) throw new Error(`漫剧角色卡 ${cardId} 不存在`)
-  if (card.imagePrompt === undefined) throw new Error(`「${card.name}」还没有形象锚点，请先生成锚点`)
-  const dataUrl = await generateReferenceImageFrom(config, card.imagePrompt, style, modelId)
-  card.imageUrl = dataUrl
-  card.updatedAt = new Date().toISOString()
-  return dataUrl
-}
-
-/** 🩺 剧情健康检查：基于已写章节数/各线状态/编年录，判断是否需要新线及添加时机。 */
+/**  剧情健康检查：基于已写章节数/各线状态/编年录，判断是否需要新线及添加时机。 */
 export async function analyzePlotlineHealth(
   ctx: Context,
   config: NovelConfig,
@@ -2722,7 +2359,7 @@ export async function analyzePlotlineHealth(
   }
 }
 
-/** ✨ AI 剧情方案：基于健康检查结果设计下一阶段方向与建议新线。 */
+/**  剧情方案：基于健康检查结果设计下一阶段方向与建议新线。 */
 export async function designPlotlinePlan(
   ctx: Context,
   config: NovelConfig,
@@ -2782,8 +2419,9 @@ export async function designPlotlinePlan(
 }
 
 /** Build the rewrite system prompt (fix review issues / instructions). */
-function rewriteSystemPrompt(project: ProjectState): string {
-  const base = writeSystemPrompt(project)
+function rewriteSystemPrompt(project: ProjectState, targetChars?: number, beforeChapter?: number): string {
+  // 整章修订以「与原文相当」为准，不套用目标字数区间（避免与原文长度冲突）。
+  const base = writeSystemPrompt(project, targetChars, '1. 输出完整的新正文（不要只输出修改片段、标题、章回名、作者的话或任何 Markdown 标记），字数与原章相当（允许 ±20%）。', beforeChapter)
   return base + '\n\n额外要求：你正在【修订】一章已写好的正文。保留原文中好的部分，只修改需要修改的地方，输出完整的新正文（不要只输出修改片段），字数与原文相当。'
 }
 
@@ -2803,9 +2441,9 @@ export async function* rewriteChapterStream(
   target?: string,
 ): AsyncGenerator<{ frame: 'start' } | { frame: 'delta'; text: string } | { frame: 'drafted'; chars: number; draft: string }, void, unknown> {
   const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
+  if (chapter === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 不在计划中`)
   const body = readChapterFile(outputDir, chapter)
-  if (body === undefined) throw new Error(`章节 ${chapterNo} 的正文文件不存在`)
+  if (body === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 的正文文件不存在`)
 
   const reviewBlock = chapter.review !== undefined
     ? '审稿意见：\n' + chapter.review.issues.map(i => `[${i.severity}] ${i.item} → ${i.suggestion}`).join('\n')
@@ -2824,7 +2462,7 @@ export async function* rewriteChapterStream(
     const paragraphs = bodyText.split(/\n{2,}/)
     const idx = paragraphs.findIndex(p => normalize(p).includes(wantedFlat))
     if (idx === -1) {
-      throw new Error(`在正文中未找到要修改的片段：「${wanted.slice(0, 40)}…」。请从正文中复制原文片段（无需整段，取片段即可）。`)
+      throw new NovelActionError('contract', `在正文中未找到要修改的片段：「${wanted.slice(0, 40)}…」。请从正文中复制原文片段（无需整段，取片段即可）。`)
     }
     localTarget = {
       paragraph: paragraphs[idx]!,
@@ -2854,8 +2492,33 @@ export async function* rewriteChapterStream(
       ].filter(line => line !== '').join('\n')
 
   const system = localTarget === undefined
-    ? rewriteSystemPrompt(project)
-    : '你是一位中文网文润色师。你会收到一章中的一个段落，请按修改要求重写该段。只输出新段落文本。'
+    ? rewriteSystemPrompt(project, chapter.targetChars || config.chapterChars, chapter.no)
+    : (() => {
+        // 局部修订：补齐合规红线/本书红线/反AI规则/角色卡，加「只改表达不改情节」约束
+        const bible = project.bible
+        const lines = [
+          '你是一位中文网文润色师。你会收到一章中的一个段落，请按修改要求重写该段。',
+          '硬性约束：',
+          '1. 只改表达，不改情节走向、人物设定、已确立事实、对话核心内容。',
+          '2. 必须遵守下方「内容合规红线」，任何一条命中（含影射、暗示）都必须避免。',
+          '3. 必须遵守下方「本书红线」（如有）。',
+          '4. 避免 AI 套话：不禁、仿佛、一时间、不由得、顿时、然而、缓缓、轻轻、微微、默默、似乎、终于等滥用。',
+          '5. 保留角色口吻与性格，角色行为需符合下方角色卡（如有）。',
+          '6. 只输出修改后的【这一个段落】的完整新文本，不要输出任何说明、标题或 Markdown 标记。',
+        ]
+        if (bible !== undefined) {
+          if (bible.redLines.length > 0) lines.push('本书红线：\n' + bible.redLines.map(r => '- ' + r).join('\n'))
+          if (bible.characters.length > 0) {
+            lines.push('相关角色卡：')
+            for (const card of bible.characters) {
+              lines.push('- ' + card.name + '（' + card.role + '）：' + card.traits.join('、'))
+            }
+          }
+        }
+        lines.push('内容合规红线（平台硬性要求，最高优先级）：')
+        lines.push(COMPLIANCE_REDLINES.join('\n'))
+        return lines.join('\n')
+      })()
 
   const messages: Message[] = [createUserMessage({
     content: [{ type: 'text', text: user }],
@@ -2874,24 +2537,43 @@ export async function* rewriteChapterStream(
   }
 
   yield { frame: 'start' }
-  const assembler = new BlockAssembler()
+  const primaryModel = request.model ?? config.model
+  let rewritten = ''
   let streamError: Error | undefined
-  for await (const chunk of ctx.llm.stream(request)) {
-    assembler.push(chunk)
-    if (chunk.type === 'text-delta') yield { frame: 'delta', text: chunk.text }
-  }
-  const finish = assembler.finish
-  if (finish.kind === 'error' || finish.kind === 'aborted') {
-    streamError = new Error(`修订失败（${finish.kind}）: ${finish.failure.message}`)
-  } else if (finish.kind === 'max-tokens') {
-    streamError = new Error('修订输出达到 maxTokens 上限，请增大配置后重试')
-  }
-  const rewritten = assembler
-    .blocks()
-    .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
-    .map(block => block.text)
-    .join('\n')
-    .trim()
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const model = attempt === 0 ? primaryModel : (config.fallbackModel ?? '').trim()
+    if (model === '') break
+    const live = beginLiveCall({
+      label: `修订 · 第${chapterNo}章`,
+      model,
+      system: request.system,
+      user: messages[0]?.content !== undefined ? JSON.stringify(messages[0].content).slice(0, 2000) : undefined,
+    })
+    const assembler = new BlockAssembler()
+    let produced = 0
+    for await (const chunk of ctx.llm.stream(applyModelCapability(request, model))) {
+      assembler.push(chunk)
+      if (chunk.type === 'text-delta') { produced += chunk.text.length; markFirstToken(live); yield { frame: 'delta', text: chunk.text } }
+    }
+    const finish = assembler.finish
+    streamError = undefined
+    if (finish.kind === 'error' || finish.kind === 'aborted') {
+      streamError = new Error(`修订失败（${finish.kind}）: ${finish.failure.message}`)
+    } else if (finish.kind === 'max-tokens') {
+      streamError = new Error('修订输出达到 maxTokens 上限，请增大配置后重试')
+    }
+    rewritten = assembler
+      .blocks()
+      .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
+      .map(block => block.text)
+      .join('\n')
+      .trim()
+    endLiveCall(live, assembler, streamError === undefined
+      ? { chars: rewritten.length, preview: rewritten.slice(0, 320), phase: rewritten === '' ? 'failed' : 'completed' }
+      : { chars: rewritten.length, phase: 'failed', error: streamError.message })
+    if (streamError === undefined) break
+    if (produced > 0 || !shouldSwitchModel(config.fallbackModel, model, streamError)) break
+  }
   if (streamError !== undefined) throw streamError
   if (rewritten.length < 20) throw new Error('修订结果过短，可能失败，请重试')
 
@@ -2917,16 +2599,24 @@ export async function* rewriteChapterStream(
 /** The de-AI-ify polish system prompt (with project writing assets injected). */
 function polishSystemPrompt(project: ProjectState): string {
   const assetsBlock = renderAllAssets(project.assets)
-  return [
+  const bible = project.bible
+  const lines = [
     '你是一位中文网文润色师。你会收到一章正文，请做「去 AI 味」润色：',
     '1. 删除/替换 AI 高频套话与模式词：如"不禁""仿佛""一时间""不由得""顿时""然而""缓缓""轻轻""微微""默默""似乎""终于"等滥用。',
     '2. 把书面翻译腔改成口语化的中文网文语感。',
     '3. 拆分过长的排比句与堆砌的修饰语。',
-    '4. 保留全部情节、人物、对话内容不变，只改表达。',
+    '4. 保留全部情节、人物、对话内容、已确立事实不变，只改表达。',
     '5. 输出完整的新正文，不要输出任何说明文字或 Markdown 标记。',
     '6. 必须遵守下方「反 AI 规则」与「写法资产」的表达边界；写法资产要求保留的风格特征（句式、台词、节奏）不得在润色中丢失。',
-    assetsBlock !== '' ? assetsBlock : '',
-  ].join('\n')
+    '7. 必须遵守下方「内容合规红线」与「本书红线」（如有），任何一条命中（含影射、暗示）都必须避免。',
+  ]
+  if (bible !== undefined && bible.redLines.length > 0) {
+    lines.push('本书红线：\n' + bible.redLines.map(r => '- ' + r).join('\n'))
+  }
+  lines.push('内容合规红线（平台硬性要求，最高优先级）：')
+  lines.push(COMPLIANCE_REDLINES.join('\n'))
+  if (assetsBlock !== '') lines.push(assetsBlock)
+  return lines.join('\n')
 }
 
 /** Stream a chapter polish (de-AI-ify). Draft-mode: the polished body lands
@@ -2939,9 +2629,9 @@ export async function* polishChapterStream(
   chapterNo: number,
 ): AsyncGenerator<{ frame: 'start' } | { frame: 'delta'; text: string } | { frame: 'drafted'; chars: number; draft: string }, void, unknown> {
   const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
+  if (chapter === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 不在计划中`)
   const body = readChapterFile(outputDir, chapter)
-  if (body === undefined) throw new Error(`章节 ${chapterNo} 的正文文件不存在`)
+  if (body === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 的正文文件不存在`)
   const messages: Message[] = [createUserMessage({
     content: [{ type: 'text', text: body.replace(/^#\s+.*$/m, '').trim() }],
     source: { kind: 'plugin', plugin: 'dsh-novel-forge' },
@@ -2958,24 +2648,43 @@ export async function* polishChapterStream(
     reasoningEffort: ReasoningEffortId('off'),
   }
   yield { frame: 'start' }
-  const assembler = new BlockAssembler()
+  const primaryModel = request.model ?? config.model
+  let newBody = ''
   let streamError: Error | undefined
-  for await (const chunk of ctx.llm.stream(request)) {
-    assembler.push(chunk)
-    if (chunk.type === 'text-delta') yield { frame: 'delta', text: chunk.text }
-  }
-  const finish = assembler.finish
-  if (finish.kind === 'error' || finish.kind === 'aborted') {
-    streamError = new Error(`润色失败（${finish.kind}）: ${finish.failure.message}`)
-  } else if (finish.kind === 'max-tokens') {
-    streamError = new Error('润色输出达到 maxTokens 上限')
-  }
-  const newBody = assembler
-    .blocks()
-    .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
-    .map(block => block.text)
-    .join('\n')
-    .trim()
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const model = attempt === 0 ? primaryModel : (config.fallbackModel ?? '').trim()
+    if (model === '') break
+    const live = beginLiveCall({
+      label: `去 AI 味润色 · 第${chapterNo}章`,
+      model,
+      system: request.system,
+      user: body.slice(0, 2000),
+    })
+    const assembler = new BlockAssembler()
+    let produced = 0
+    for await (const chunk of ctx.llm.stream(applyModelCapability(request, model))) {
+      assembler.push(chunk)
+      if (chunk.type === 'text-delta') { produced += chunk.text.length; markFirstToken(live); yield { frame: 'delta', text: chunk.text } }
+    }
+    const finish = assembler.finish
+    streamError = undefined
+    if (finish.kind === 'error' || finish.kind === 'aborted') {
+      streamError = new Error(`润色失败（${finish.kind}）: ${finish.failure.message}`)
+    } else if (finish.kind === 'max-tokens') {
+      streamError = new Error('润色输出达到 maxTokens 上限')
+    }
+    newBody = assembler
+      .blocks()
+      .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
+      .map(block => block.text)
+      .join('\n')
+      .trim()
+    endLiveCall(live, assembler, streamError === undefined
+      ? { chars: newBody.length, preview: newBody.slice(0, 320), phase: newBody === '' ? 'failed' : 'completed' }
+      : { chars: newBody.length, phase: 'failed', error: streamError.message })
+    if (streamError === undefined) break
+    if (produced > 0 || !shouldSwitchModel(config.fallbackModel, model, streamError)) break
+  }
   if (streamError !== undefined) throw streamError
   if (newBody.length < 100) throw new Error('润色结果过短，可能失败，请重试')
 
@@ -2986,6 +2695,12 @@ export async function* polishChapterStream(
   yield { frame: 'drafted', chars: newBody.length, draft: newBody }
 }
 
+/** 统计中文字符数（汉字），与「每章字数」红线口径一致（不含标点/换行）。 */
+export function countHanzi(text: string): number {
+  const m = text.match(/[\u4e00-\u9fff]/g)
+  return m === null ? 0 : m.length
+}
+
 /** Generate one chapter (streaming). Yields progress frames; persists when done. */
 export async function* generateChapterStream(
   ctx: Context,
@@ -2993,9 +2708,9 @@ export async function* generateChapterStream(
   project: ProjectState,
   outputDir: string,
   chapterNo: number,
-): AsyncGenerator<{ frame: 'start' } | { frame: 'delta'; text: string } | { frame: 'done'; file: string; chars: number }, void, unknown> {
+): AsyncGenerator<{ frame: 'start' } | { frame: 'delta'; text: string } | { frame: 'done'; file: string; chars: number; warn?: string }, void, unknown> {
   const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
+  if (chapter === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 不在计划中`)
   // Note: the route layer owns the 'generating' status + concurrency guard;
   // this function must not refuse when status is 'generating' (the route sets
   // it before calling us).
@@ -3055,10 +2770,22 @@ export async function* generateChapterStream(
     .filter(f => f.status === 'planned' && f.targetChapter !== undefined && f.targetChapter > 0)
     .filter(f => Math.abs((f.targetChapter as number) - chapterNo) <= 12)
     .map(f => `- ${f.description.slice(0, 120)}${f.targetChapter !== undefined ? `（计划回收于第 ${f.targetChapter} 章）` : ''}`)
-
+  const contractBlock = (() => {
+    const parts: string[] = []
+    if ((chapter.mustAdvance?.length ?? 0) > 0) parts.push(`本章必达（必须推进）：${chapter.mustAdvance!.join('；')}`)
+    if ((chapter.mustPreserve?.length ?? 0) > 0) parts.push(`本章保持（不得破坏）：${chapter.mustPreserve!.join('；')}`)
+    if ((chapter.characterHardFacts?.length ?? 0) > 0) parts.push(`人物硬事实（不得违背）：${chapter.characterHardFacts!.join('；')}`)
+    if ((chapter.payoffDirectives?.length ?? 0) > 0) parts.push(`伏笔指令：${chapter.payoffDirectives!.map(p => `${p.operation ?? 'touch'}${p.no !== undefined ? `(第${p.no}章)` : ''}${p.text !== undefined && p.text !== '' ? '：' + p.text : ''}`).join('；')}`)
+    if (chapter.endingHook !== undefined && chapter.endingHook !== '') parts.push(`章末钩子要求：${chapter.endingHook}`)
+    if (chapter.obligation !== undefined && chapter.obligation !== '') parts.push(`本章义务合约：${chapter.obligation}`)
+    return parts.length > 0 ? '==================== 本章合同（硬约束，必须满足） ====================\n' + parts.join('\n') : ''
+  })()
+  const knowledgeBlock = retrieveKnowledge(project, `${chapter.title} ${chapter.beats}`)
   const user = [
     `现在写第 ${chapter.no} 章，标题《${chapter.title}》。`,
     `本章剧情要点：${chapter.beats}`,
+    contractBlock,
+    knowledgeBlock,
     '',
     foreshadowHints.length > 0
       ? `本章附近需顺势埋下以下暗线（自然带过，不喧宾夺主，1-2 句即可，但细节要可辨识、与描述吻合）：\n${foreshadowHints.join('\n')}`
@@ -3081,446 +2808,140 @@ export async function* generateChapterStream(
 
   const messages: Message[] = [createUserMessage({
     content: [{ type: 'text', text: user }],
-    source: { kind: 'plugin', plugin: 'dsh-novel-forge' },
-  })]
-  const request: GenerateOptions = {
-    provider: config.provider,
-    model: config.model,
-    messages,
-    system: writeSystemPrompt(project),
-    // Full-chapter output: budget generously (4000 chars ≈ 8-12k tokens,
-    // plus the model's reasoning channel).
-    maxTokens: Math.max(config.maxTokens, 20000),
-    temperature: 0.85,
-  }
-
-  yield { frame: 'start' }
-
-  const assembler = new BlockAssembler()
-  let streamError: Error | undefined
-  for await (const chunk of ctx.llm.stream(request)) {
-    assembler.push(chunk)
-    if (chunk.type === 'text-delta') {
-      yield { frame: 'delta', text: chunk.text }
-    }
-  }
-  const finish = assembler.finish
-  if (finish.kind === 'error' || finish.kind === 'aborted') {
-    streamError = new Error(`生成失败（${finish.kind}）: ${finish.failure.message}`)
-  } else if (finish.kind === 'max-tokens') {
-    streamError = new Error('达到 maxTokens 上限，正文可能不完整，请增大 maxTokens 后重试')
-  }
-  const body = assembler
-    .blocks()
-    .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
-    .map(block => block.text)
-    .join('\n')
-    .trim()
-  if (streamError !== undefined) throw streamError
-  if (body.length < 100) throw new Error('生成内容过短，可能失败，请重试')
-
-  // Write the chapter file.
-  const fileName = chapterFileName(chapter)
-  mkdirSync(outputDir, { recursive: true })
-  writeFileSync(join(outputDir, fileName), `# 第${chapter.no}章 ${chapter.title}\n\n${body}\n`, 'utf8')
-
-  chapter.status = 'written'
-  chapter.chars = body.length
-  chapter.file = fileName
-  chapter.error = undefined
-  project.updatedAt = new Date().toISOString()
-  saveProject(outputDir, project)
-
-  yield { frame: 'done', file: fileName, chars: body.length }
-}
-
-/** Generate a chapter summary (narrative memory). */
-export async function summarizeChapter(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  chapterNo: number,
-): Promise<string> {
-  const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
-  const body = readChapterFile(outputDir, chapter)
-  if (body === undefined) throw new Error(`章节 ${chapterNo} 的正文文件不存在`)
-  const system = [
-    '你是一位网文编辑。请为下面一章写一段 120-200 字的摘要，供后续章节写作时保持连贯性。',
-    '摘要必须包含：本章发生的关键事件、主角状态变化（境界/资源/伤势/心境）、新增的伏笔或线索、角色关系变化。',
-    '用客观陈述句，不要评价，不要剧透式感叹。只输出摘要正文。',
-  ].join('\n')
-  const user = body.replace(/^#\s+.*$/m, '').trim()
-  const summary = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 4000) })
-  chapter.summary = summary.slice(0, 500)
-  project.updatedAt = new Date().toISOString()
-  saveProject(outputDir, project)
-  return chapter.summary
-}
-
-/** 把分镜产出写入项目持久化（按章 upsert）。重新生成上游时级联清掉下游旧产物：
- * 新骨架 → 清分镜表+提示词；新分镜表 → 清提示词；新提示词不动上游。 */
-function saveChapterStoryboard(project: ProjectState, outputDir: string, entry: ChapterStoryboard): void {
-  if (project.storyboards === undefined) project.storyboards = []
-  const idx = project.storyboards.findIndex(e => e.chapterNo === entry.chapterNo)
-  const prev = idx === -1 ? undefined : project.storyboards[idx]
-  const next: ChapterStoryboard = { ...(prev ?? {}), ...entry }
-  if (entry.skeleton !== undefined) {
-    next.table = undefined
-    next.prompts = undefined
-  }
-  if (entry.table !== undefined) {
-    next.prompts = undefined
-  }
-  if (idx === -1) project.storyboards.push(next)
-  else project.storyboards[idx] = next
-  project.updatedAt = new Date().toISOString()
-  saveProject(outputDir, project)
-}
-
-/** 确定性兜底：正文中出现的角色库角色名（LLM 漏填 characters 时使用）。 */
-function guessCharactersFromRoles(project: ProjectState, body: string, limit = 12): string[] {
-  const out: string[] = []
-  for (const r of project.roles ?? []) {
-    if (out.length >= limit) break
-    if (r.name !== '' && !out.includes(r.name) && body.includes(r.name)) out.push(r.name)
-  }
-  return out
-}
-
-/** 清洗 LLM 输出的角色名数组：去空 / 去重 / 限长 / 限字数。 */
-function sanitizeCharacters(raw: unknown, limit: number): string[] {
-  if (!Array.isArray(raw)) return []
-  const out: string[] = []
-  for (const v of raw) {
-    if (typeof v !== 'string') continue
-    const name = v.trim().slice(0, 20)
-    if (name === '' || out.includes(name)) continue
-    out.push(name)
-    if (out.length >= limit) break
-  }
-  return out
-}
-
-/** 漫剧卡绑定索引：按分镜称谓（正文确切名）解析漫剧卡（卡名/来源名精确优先，包含兜底）。 */
-interface MangaRoleBindingIndex {
-  byId: Map<string, MangaRoleCard>
-  resolve: (name: string) => MangaRoleCard | undefined
-}
-function buildMangaRoleBindings(project: ProjectState): MangaRoleBindingIndex {
-  const cards = project.mangaRoles ?? []
-  const byName = new Map<string, MangaRoleCard>()
-  for (const c of cards) {
-    if (c.name !== '') byName.set(c.name, c)
-    if (c.sourceRoleName !== undefined && c.sourceRoleName !== '') byName.set(c.sourceRoleName, c)
-  }
-  const byId = new Map<string, MangaRoleCard>(cards.map(c => [c.id, c]))
-  return {
-    byId,
-    resolve: (name: string): MangaRoleCard | undefined => {
-      const exact = byName.get(name)
-      if (exact !== undefined) return exact
-      for (const c of cards) {
-        if (c.name !== '' && (c.name.includes(name) || name.includes(c.name))) return c
-        if (c.sourceRoleName !== undefined && c.sourceRoleName !== '' && (c.sourceRoleName.includes(name) || name.includes(c.sourceRoleName))) return c
-      }
-      return undefined
-    },
-  }
-}
-
-/**
- * 分镜·导演级：剧情骨架 → 分镜表（镜头级）。
- * 只做画面层：景别/机位运镜/时长/画面/台词/音效/光效 + 状态连续；禁止改剧情（骨架只读）。
- */
-export async function generateStoryboardTable(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  chapterNo: number,
-  skeleton: StoryboardSkeleton,
-  styleId?: string,
-  filterId?: string,
-): Promise<StoryboardTable> {
-  const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
-  const body = readChapterFile(outputDir, chapter)
-  if (body === undefined) throw new Error(`章节 ${chapterNo} 的正文文件不存在`)
-  if ((skeleton.beats ?? []).length === 0) throw new Error('骨架为空，请先生成剧情骨架')
-
-
-  // 出场角色锚点：正文中出现过的角色名 + 身份（简短）。
-  const roles = (project.roles ?? [])
-    .filter(r => body.includes(r.name))
-    .slice(0, 8)
-    .map(r => `${r.name}（${r.roleLabel === 'protagonist' ? '主角' : r.roleLabel === 'antagonist' ? '反派' : r.roleLabel === 'female_lead' ? '女主' : '配角'}）：${r.identity ?? ''}`)
-  // 场景卡：仅列名称与定位（正文命中优先，至多 6 个）。
-  const usedScenes = (project.scenes ?? []).filter(s => body.includes(s.name)).slice(0, 6)
-  const scenes = usedScenes.map(s => `${s.name}：${s.summary ?? ''}`)
-  // 漫剧定妆卡：本章正文命中漫剧卡（卡名或来源名），注入定妆锚点供画面遵守。
-  const bindings = buildMangaRoleBindings(project)
-  const mangaCardsInBody = bindings.byId.size > 0
-    ? [...bindings.byId.values()].filter(c => body.includes(c.name) || (c.sourceRoleName !== undefined && body.includes(c.sourceRoleName))).slice(0, 8)
-    : []
-  const mangaLines = mangaCardsInBody.map(c => {
-    const anchor = c.imagePrompt !== undefined ? c.imagePrompt.zh.slice(0, 90) : (c.appearance !== '' ? c.appearance : '')
-    const ref = c.imageUrl !== undefined ? '；参考图：有' : (c.gallery ?? []).some(g => g.label.includes('立绘')) ? '；参考图：有（立绘）' : ''
-    return `${c.name}（${c.identity ?? ''}）：定妆${anchor !== '' ? '「' + anchor + '」' : '（锚点未生成）'}${ref}`
-  })
-  const rules = (project.visualRules ?? []).map(r => '- ' + r)
+    source: { kind: 'plugin', plugin: 'dsh-novel-forge' },
+  })]
+  const request: GenerateOptions = {
+    provider: config.provider,
+    model: config.generateModel || config.model,
+    messages,
+    system: writeSystemPrompt(project, chapter.targetChars || config.chapterChars, undefined, chapter.no),
+    // Full-chapter output: budget generously (4000 chars ≈ 8-12k tokens,
+    // plus the model's reasoning channel).
+    maxTokens: Math.max(config.maxTokens, 20000),
+    temperature: 0.85,
+  }
 
-  const baseStyle = styleId !== undefined ? findStyle(styleId) : undefined
-  const filterStyle = filterId !== undefined ? findStyle(filterId) : undefined
-  const styleLines: string[] = []
-  if (baseStyle !== undefined) styleLines.push('- 基底风格「' + baseStyle.name + '」：' + baseStyle.keywords)
-  if (filterStyle !== undefined) styleLines.push('- 叠加滤镜「' + filterStyle.name + '」：' + filterStyle.keywords)
-  if (styleLines.length === 0) styleLines.push('- （未选择风格，默认 3D 动漫超精细建模质感）')
+  yield { frame: 'start' }
 
-  const system = [
-    '你是一位从业 10 年的电影导演兼分镜师，专长网文改编影视化。',
-    '任务：把「剧情骨架」的每一个节拍展开为 1-3 个电影镜头，输出分镜表——只做画面层，禁止新增或改变剧情（骨架是只读输入）。',
-    '输出合法 JSON 对象：{"shots": [{"beatId": "骨架节拍id", "shot": "景别", "camera": "机位与运镜", "composition": "构图", "duration": 秒数, "visual": "画面内容", "line": "台词/旁白", "sound": "音效", "light": "光效", "prevState": "承接上一镜头结尾状态", "nextState": "本镜头结束状态", "characters": ["出镜角色名"]}]}',
-    '景别取值（只能从这些词中选一）：大远景/远景/全景/中景/中近景/近景/特写/大特写。',
-    '运镜取值（可组合，用加号连接）：固定机位/推近/拉远/左摇/右摇/左横移/右横移/跟随/升镜/降镜/环绕/手持晃动/低机位仰拍/高机位俯拍/过肩镜头。',
-    '光效取值（可组合，用加号连接）：顺光/侧光/逆光/顶光/伦勃朗光/霓虹光/硬光/柔光/氛围光/高反差。',
-    '构图取值（可选，只能从这些词中选一）：三分法/中心对称/引导线/前景遮挡/低机位/俯拍/对称构图。',
-    '硬性要求：',
-    '【视觉风格】（必须内嵌进 visual/light 的画面措辞与光效描述）：',
-    ...styleLines,
-    '1. 按骨架节拍顺序输出镜头，每个节拍至少 1 个镜头，总镜头数 8-25。',
-    '2. 镜头间连续：下一镜头的 prevState 必须与上一镜头的 nextState 一致（人物位置/动作/情绪/服装），禁止瞬移、服装消失、情绪跳变。',
-    '3. visual 必须写明：角色动作 + 表情 + 服装/标志物（标志物来自下方视觉规则与角色锚点，逐镜头保持）。',
-    '4. 台词/音效/光效无则空字符串，不要编造。',
-    '5. duration 1-12 秒。',
-    '6. 所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束，不要输出其他文字。',
-    '7. 每个镜头必须输出 characters：本镜头出镜角色名数组（1-4 个），从「出场角色锚点」或正文中选取，使用正文里的确切称谓（如「周野」「周野的律师」），禁止自造名/缩写；路人或群像可用身份词（如「围观群众」）。',
-    '8. 人物外观/服装/标志物必须遵守「漫剧定妆卡」与「出场角色锚点」：同一角色逐镜头保持完全一致（服装、发色、标志物禁止更换）；定妆卡未覆盖的路人可用通用描述。',
-  ].join('\n')
-  const user = [
-    `章节《${chapter.title}》（第 ${chapter.no} 章）`,
-    '==== 剧情骨架（只读，禁止改动） ====',
-    `弧线：${skeleton.arc}`,
-    skeleton.beats.map(b => `[${b.id}] [${b.function}] ${b.event}（情绪：${b.emotion}${b.cause !== undefined ? '；承接：' + b.cause : ''}）`).join('\n'),
-    roles.length > 0 ? '==== 出场角色锚点 ====\n' + roles.join('\n') : '',
-    mangaLines.length > 0 ? '==== 漫剧定妆卡（角色外观以此为准，禁止改换服装/发色/标志物） ====\n' + mangaLines.join('\n') : '',
-    scenes.length > 0 ? '==== 相关场景 ====\n' + scenes.join('\n') : '',
-    rules.length > 0 ? '==== 本书视觉规则（必须内嵌进 visual） ====\n' + rules.join('\n') : '',
-    '==== 章节正文（画面细节以此为准） ====',
-    body.replace(/^#\s+.*$/m, '').trim().slice(0, 3000),
-  ].filter(s => s !== '').join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 16000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonObject<{ shots?: unknown }>(text)
-  const beatIds = new Set(skeleton.beats.map(b => b.id))
-  const shots: StoryboardShot[] = Array.isArray(raw.shots)
-    ? raw.shots
-        .filter((v): v is Record<string, unknown> => typeof v === 'object' && v !== null)
-        .map((entry, i) => ({
-          id: 's' + (i + 1),
-          beatId: beatIds.has(entry.beatId as string) ? entry.beatId as string : skeleton.beats[0]!.id,
-          shot: normalizeShotSize(entry.shot as string | undefined),
-          camera: normalizeCameras(entry.camera as string | undefined),
-          composition: normalizeComposition(entry.composition as string | undefined),
-          duration: typeof entry.duration === 'number' && entry.duration >= 1 && entry.duration <= 12 ? Math.round(entry.duration) : 4,
-          visual: typeof entry.visual === 'string' ? entry.visual.trim().slice(0, 300) : '',
-          line: typeof entry.line === 'string' ? entry.line.trim().slice(0, 120) : '',
-          sound: typeof entry.sound === 'string' ? entry.sound.trim().slice(0, 80) : '',
-          light: normalizeLightings(entry.light as string | undefined),
-          prevState: typeof entry.prevState === 'string' ? entry.prevState.trim().slice(0, 150) : '',
-          nextState: typeof entry.nextState === 'string' ? entry.nextState.trim().slice(0, 150) : '',
-          characters: sanitizeCharacters(entry.characters, 4),
-        }))
-        .filter(s => s.visual !== '')
-    : []
-  if (shots.length === 0) throw new Error('模型未输出有效镜头，请重试')
-  // 覆盖自检：每个节拍至少 1 个镜头（缺失节拍告警）。
-  const covered = new Set(shots.map(s => s.beatId))
-  const missing = skeleton.beats.filter(b => !covered.has(b.id)).map(b => b.id)
-  if (missing.length > 0) {
-    console.warn(`[dsh-novel-forge] storyboard: beat ${missing.join(',')} 无镜头覆盖`)
-  }
-  // 表级 characters：各镜头去重汇总；LLM 漏标时用骨架/角色库兜底。
-  const tableChars: string[] = []
-  const tableRoleIds: string[] = []
-  for (const s of shots) {
-    // 定妆绑定：镜头 characters 称谓 → 漫剧卡 id（供出图/生视频时按卡取定妆图）。
-    const ids: string[] = []
-    for (const n of s.characters ?? []) {
-      const card = bindings.resolve(n)
-      if (card !== undefined && !ids.includes(card.id)) ids.push(card.id)
-    }
-    s.mangaRoleIds = ids.length > 0 ? ids : undefined
-    for (const c of s.characters ?? []) {
-      if (!tableChars.includes(c)) tableChars.push(c)
-      if (tableChars.length >= 12) break
+  const primaryModel = request.model ?? config.model
+  let body = ''
+  let streamError: Error | undefined
+  // 最多两次尝试：主模型 → （未产出任何文字且失败可重试时）备用模型。
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const model = attempt === 0 ? primaryModel : (config.fallbackModel ?? '').trim()
+    if (model === '') break
+    const live = beginLiveCall({
+      label: `正文生成 · 第${chapter.no}章`,
+      model,
+      system: request.system,
+      user,
+    })
+    const assembler = new BlockAssembler()
+    let produced = 0
+    for await (const chunk of ctx.llm.stream(applyModelCapability(request, model))) {
+      assembler.push(chunk)
+      if (chunk.type === 'text-delta') {
+        produced += chunk.text.length
+        markFirstToken(live)
+        yield { frame: 'delta', text: chunk.text }
+      }
     }
-    for (const id of ids) {
-      if (!tableRoleIds.includes(id)) tableRoleIds.push(id)
+    const finish = assembler.finish
+    streamError = undefined
+    if (finish.kind === 'error' || finish.kind === 'aborted') {
+      streamError = new Error(`生成失败（${finish.kind}）: ${finish.failure.message}`)
+    } else if (finish.kind === 'max-tokens') {
+      streamError = new Error('达到 maxTokens 上限，正文可能不完整，请增大 maxTokens 后重试')
     }
+    body = assembler
+      .blocks()
+      .filter((block): block is Extract<StreamChunk, { type: 'block-end' }>['block'] & { type: 'text' } => block.type === 'text')
+      .map(block => block.text)
+      .join('\n')
+      .trim()
+    endLiveCall(live, assembler, streamError === undefined
+      ? { chars: body.length, preview: body.slice(0, 320), phase: body === '' ? 'failed' : 'completed' }
+      : { chars: body.length, phase: 'failed', error: streamError.message })
+    if (streamError === undefined) break
+    // 只有「一个字都没产出」时才换模型重试——已有正文绝不能重复生成。
+    if (produced > 0 || !shouldSwitchModel(config.fallbackModel, model, streamError)) break
   }
-  const fallbackChars = (skeleton.characters ?? guessCharactersFromRoles(project, body, 12)).slice(0, 12)
-  const table: StoryboardTable = {
-    chapterNo,
-    shots,
-    usedScenes: usedScenes.map(s => s.name),
-    characters: tableChars.length > 0 ? tableChars : fallbackChars,
-    mangaRoleIds: tableRoleIds.length > 0 ? tableRoleIds : undefined,
+  if (streamError !== undefined) throw streamError
+  if (body.length < 100) throw new Error('生成内容过短，可能失败，请重试')
+
+  // 字数口径统一为「汉字数」（与每章字数红线一致）。不足目标 90% 时自动续写补齐（最多 2 轮）。
+  const target = chapter.targetChars > 0 ? chapter.targetChars : config.chapterChars
+  let hanzi = countHanzi(body)
+  for (let round = 0; round < 2 && target > 0 && hanzi < target * 0.9; round++) {
+    const need = Math.max(400, Math.round(target * 0.95) - hanzi)
+    const contUser = [
+      `第 ${chapter.no} 章《${chapter.title}》已写正文末尾如下：`,
+      body.slice(-2500),
+      '',
+      `请承接上文继续写约 ${need} 字，不要重复已有内容，不要重写开头，不要总结前文，直接续写新情节，结尾留一个章末钩子。只输出续写的正文，不要输出标题或任何说明。`,
+    ].join('\n')
+    const cont = await complete(ctx, config, {
+      system: writeSystemPrompt(project, target, undefined, chapter.no) + '\n\n【续写任务】严格承接已有正文往下写，不要重复已有内容、不要重写开头、不要总结前文，直接续写新情节，并在结尾留一个章末钩子。',
+      user: contUser,
+      temperature: 0.85,
+      maxTokens: Math.max(config.maxTokens, 12000),
+      model: config.generateModel || config.model,
+      liveLabel: '续写补齐',
+    })
+    const add = cont.trim()
+    if (add.length < 100) break
+    body = `${body}\n\n${add}`
+    hanzi = countHanzi(body)
   }
-  saveChapterStoryboard(project, outputDir, { chapterNo, table, updatedAt: new Date().toISOString() })
-  return table
-}
 
-/**
- * 分镜·提示词级：分镜表 → 即梦可粘贴视频提示词。
- * 每镜头一段：风格词块（基底+滤镜）+ 画面内容（角色动作/服装标志物）+ 机位运镜 + 光效。
- * 提示词聚焦画面与镜头（视频模型无音频，台词/音效不注入）。
- */
-export async function generateStoryboardPrompts(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  chapterNo: number,
-  table: StoryboardTable,
-  styleId?: string,
-  filterId?: string,
-): Promise<StoryboardPrompt[]> {
-  if ((table.shots ?? []).length === 0) throw new Error('分镜表为空，请先生成分镜表')
-  const chapter = project.chapters.find(c => c.no === chapterNo)
-  const baseStyle = styleId !== undefined ? findStyle(styleId) : undefined
-  const filterStyle = filterId !== undefined ? findStyle(filterId) : undefined
-  const stylePrefix = [
-    baseStyle?.keywords,
-    filterStyle?.keywords,
-  ].filter((v): v is string => v !== undefined && v !== '').join('，') || '3D动漫，超精细建模，电影光影'
-  const rules = (project.visualRules ?? []).map(r => '- ' + r)
-  const bindings = buildMangaRoleBindings(project)
-  const shotLines = table.shots.map(s => {
-    const bound = (s.characters ?? []).map(n => bindings.resolve(n)).filter((c): c is MangaRoleCard => c !== undefined)
-    const makeUp = bound.map(c => {
-      const anchor = c.imagePrompt !== undefined ? c.imagePrompt.zh.slice(0, 60) : (c.appearance !== '' ? c.appearance : '')
-      const ref = c.imageUrl !== undefined ? '（参考图）' : ''
-      return c.name + '：' + anchor + ref
-    }).join('；')
-    return `[${s.id}] 节拍${s.beatId} · ${sizeZh(s.shot)} · ${cameraZh(s.camera)} · ${s.duration}s
-出场：${s.characters !== undefined && s.characters.length > 0 ? s.characters.join('、') : '（未标注）'}
-定妆：${makeUp !== '' ? makeUp : '（未绑定漫剧卡）'}
-画面：${s.visual}
-台词：${s.line !== '' ? s.line : '（无）'}
-光效：${lightZh(s.light) !== '' ? lightZh(s.light) : '（无）'}
-承接：${s.prevState} → ${s.nextState}`
-  }).join('\n\n')
-  const system = [
-    '你是一位资深影视分镜提示词工程师，熟悉即梦 AI / Seedance 等视频生成模型的中文提示词写法。',
-    '任务：把分镜表的每个镜头写成一段可直接粘贴进视频生成工具的提示词。',
-    '提示词结构（按顺序）：风格词块 → 画面主体（人物动作+表情+服装标志物）→ 机位运镜（含时长感）→ 光效氛围。单段中文 60-140 字，逗号分隔，流畅自然。',
-    '风格词块（必须原样放在每段开头）：' + stylePrefix,
-    '重要：每段提示词开头必须原样嵌入风格词块原文，不得省略、不得改写。',
-    '硬性要求：',
-    '1. 只写画面与镜头，禁止写音频/台词配音说明（视频模型无音频）。',
-    '2. 服装/发色/标志物必须沿用镜头表、定妆卡与视觉规则，禁止自行更换（同一角色跨镜头保持一致）。',
-    '3. 运镜用通俗电影词（推近/拉远/跟随/低机位仰拍/过肩/手持晃动/固定机位），不要用分镜术语缩写。',
-    '4. 输出合法 JSON 对象：{"prompts": [{"shotId": "s1", "text": "..."}]}，所有镜头都要有，顺序一致。',
-    '5. 字符串内不得包含换行符，JSON 必须在一段内完整结束。',
-  ].join('\n')
-  const user = [
-    `章节《${chapter?.title ?? ''}》（第 ${chapterNo} 章）`,
-    rules.length > 0 ? '本书视觉规则（必须遵守）：\n' + rules.join('\n') : '',
-    '==== 分镜表 ====',
-    shotLines,
-    '只输出 JSON 对象。',
-  ].filter(x => x !== '').join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 16000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonObject<{ prompts?: unknown }>(text)
-  const shotIds = new Set(table.shots.map(s => s.id))
-  const shotBinding = new Map<string, string[]>(table.shots.map(s => [s.id, s.mangaRoleIds ?? []]))
-  const prompts: StoryboardPrompt[] = Array.isArray(raw.prompts)
-    ? raw.prompts
-        .filter((v): v is Record<string, unknown> => typeof v === 'object' && v !== null)
-        .map(entry => {
-          const shotId = shotIds.has(entry.shotId as string) ? entry.shotId as string : ''
-          const ids = shotBinding.get(shotId) ?? []
-          return {
-            shotId,
-            text: ensureStyleEmbedded(typeof entry.text === 'string' ? entry.text.trim().slice(0, 400) : '', stylePrefix, 'zh'),
-            mangaRoleIds: ids.length > 0 ? ids : undefined,
-          }
-        })
-        .filter(x => x.shotId !== '' && x.text !== '')
-    : []
-  if (prompts.length === 0) throw new Error('模型未输出有效提示词，请重试')
-  saveChapterStoryboard(project, outputDir, { chapterNo, prompts, updatedAt: new Date().toISOString() })
-  return prompts
-}
+  // 覆盖前留存历史版本：重新生成把好稿改坏时可以回滚（首次生成无旧稿，不产生空快照）。
+  if (chapter.file !== undefined && chapter.file !== '') createSnapshot(outputDir, chapter, '重新生成前')
+  // Write the chapter file.
+  const fileName = chapterFileName(chapter)
+  mkdirSync(outputDir, { recursive: true })
+  writeFileSync(join(outputDir, fileName), `# 第${chapter.no}章 ${chapter.title}\n\n${body}\n`, 'utf8')
 
+  chapter.status = 'written'
+  chapter.chars = hanzi
+  chapter.file = fileName
+  chapter.error = undefined
+  project.updatedAt = new Date().toISOString()
+  saveProject(outputDir, project)
 
-/**
- * 分镜·编剧级：单章 → 剧情骨架（节拍链）。
- * 只做故事层（事件/情绪/功能/因果），不做画面；导演级分镜在其上展开。
- */
-export async function generateStoryboardSkeleton(
+  const warn = target > 0
+    ? (hanzi < target * 0.85
+        ? `第${chapter.no}章实际 ${hanzi} 汉字，少于目标 ${target} 汉字`
+        : hanzi > target * 1.25
+          ? `第${chapter.no}章实际 ${hanzi} 汉字，多于目标 ${target} 汉字`
+          : undefined)
+    : undefined
+  yield { frame: 'done', file: fileName, chars: hanzi, warn }
+}
+
+/** Generate a chapter summary (narrative memory). */
+export async function summarizeChapter(
   ctx: Context,
   config: NovelConfig,
   project: ProjectState,
   outputDir: string,
   chapterNo: number,
-): Promise<StoryboardSkeleton> {
+): Promise<string> {
   const chapter = project.chapters.find(c => c.no === chapterNo)
-  if (chapter === undefined) throw new Error(`章节 ${chapterNo} 不在计划中`)
+  if (chapter === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 不在计划中`)
   const body = readChapterFile(outputDir, chapter)
-  if (body === undefined) throw new Error(`章节 ${chapterNo} 的正文文件不存在`)
+  if (body === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 的正文文件不存在`)
   const system = [
-    '你是一位从业 15 年的电影编剧，专长网文改编影视化，深谙三幕结构与节拍（beat）写作。',
-    '任务：把这一章改编成影视化「剧情骨架」——只做故事层，不做画面。',
-    '输出合法 JSON 对象：{"arc": "本章弧线一句话（起承转合，20-60字）", "beats": [{"event": "事件一句话（发生了什么）", "emotion": "人物情绪走向（情绪词数组）", "function": "铺垫|冲突|转折|高潮|收束|伏笔|人物塑造", "cause": "承接上一节拍的原因（可省略）"}], "characters": ["出镜角色名1", "出镜角色名2"]}',
-    '情绪词取值（从这些词中选 1-3 个，用数组输出，按情绪发展顺序）：平静/淡然/期待/好奇/警觉/压抑/隐忍/担忧/焦躁/不安/惊惧/愤怒/崩溃/决绝/痛心/释然/悲凉/得意/重生/麻木。',
-    '功能取值（只能从这些词中选一）：铺垫/冲突/转折/高潮/收束/伏笔/人物塑造。',
-    '硬性要求：',
-    '1. beats 数量 4-9 个，严格按时间顺序，因果链完整：前一个 beat 的结果是后一个 beat 的原因。',
-    '2. 必须覆盖本章全部剧情要点与正文关键事件，遗漏关键事件视为失败。',
-    '3. 只输出剧情骨架，禁止写画面描写、机位运镜、台词细节、音效（那是导演阶段的事）。',
-    '4. 所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
-    '5. 直接输出 JSON 本身，不要输出思考过程或其他文字。',
-    '6. 额外输出 characters：本章真正出镜（说话/行动/被正面描写）的角色名数组，全部使用正文中的确切称谓（如「周野」「周野的律师」，不要改名或拼接），去重，3-10 个；路人或群像可用身份词（如「围观群众」）。',
-  ].join('\n')
-  const user = [
-    `章节《${chapter.title}》（第 ${chapter.no} 章）`,
-    `剧情要点：${chapter.beats !== undefined && chapter.beats !== '' ? chapter.beats : '（未填写）'}`,
-    '==================== 章节正文 ====================',
-    body.replace(/^#\s+.*$/m, '').trim(),
+    '你是一位网文编辑。请为下面一章写一段 120-200 字的摘要，供后续章节写作时保持连贯性。',
+    '摘要必须包含：本章发生的关键事件、主角状态变化（境界/资源/伤势/心境）、新增的伏笔或线索、角色关系变化。',
+    '用客观陈述句，不要评价，不要剧透式感叹。只输出摘要正文。',
   ].join('\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 4000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonObject<{ arc?: unknown; beats?: unknown; characters?: unknown }>(text)
-  const arc = typeof raw.arc === 'string' ? raw.arc.trim().slice(0, 200) : ''
-  const beats: StoryboardBeat[] = Array.isArray(raw.beats)
-    ? raw.beats
-        .filter((v): v is Record<string, unknown> => typeof v === 'object' && v !== null)
-        .map((entry, i) => ({
-          id: 'b' + (i + 1),
-          event: typeof entry.event === 'string' ? entry.event.trim().slice(0, 200) : '',
-          emotion: Array.isArray(entry.emotion)
-            ? normalizeEmotions(entry.emotion.filter((x): x is string => typeof x === 'string').join('→'))
-            : normalizeEmotions(typeof entry.emotion === 'string' ? entry.emotion : undefined),
-          function: normalizeStoryFunction(typeof entry.function === 'string' ? entry.function : undefined),
-          cause: typeof entry.cause === 'string' && entry.cause.trim() !== '' ? entry.cause.trim().slice(0, 150) : undefined,
-        }))
-        .filter(b => b.event !== '')
-    : []
-  if (beats.length === 0) throw new Error('模型未输出有效节拍链，请重试')
-  // 出场角色：LLM 结构化输出优先，漏填时用角色库命中正文兜底。
-  const skeletonChars = sanitizeCharacters(raw.characters, 12)
-  const chars = skeletonChars.length > 0 ? skeletonChars : guessCharactersFromRoles(project, body, 12)
-  const skeleton: StoryboardSkeleton = {
-    chapterNo,
-    arc: arc !== '' ? arc : '（本章弧线未生成）',
-    beats,
-    characters: chars.length > 0 ? chars : undefined,
-  }
-  saveChapterStoryboard(project, outputDir, { chapterNo, skeleton, updatedAt: new Date().toISOString() })
-  return skeleton
+  const user = body.replace(/^#\s+.*$/m, '').trim()
+  const summary = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 4000) })
+  chapter.summary = summary.slice(0, 500)
+  project.updatedAt = new Date().toISOString()
+  saveProject(outputDir, project)
+  return chapter.summary
 }
-
 /**
  * 反向推大纲：从已写章节正文反推出全书总纲（分卷 + 章节要点 + 主线/人物弧线/伏笔清单）。
  * 两阶段：分批提取章节事件摘要 → 汇总生成大纲。不修改章节/设定，只返回大纲文本。
@@ -3536,7 +2957,7 @@ export async function reverseOutlineFromChapters(
     .filter(c => c.status !== 'pending' && c.status !== 'generating' && c.status !== 'error')
     .filter(c => readChapterFile(outputDir, c) !== undefined)
     .sort((a, b) => a.no - b.no)
-  if (written.length === 0) throw new Error('本书还没有已写章节，无法反推大纲')
+  if (written.length === 0) throw new NovelActionError('contract', '本书还没有已写章节，无法反推大纲')
 
   // 阶段 1：分批提取章节事件摘要（每批 10 章，正文各取前 1000 字控制成本）。
   const BATCH = 10
@@ -3597,7 +3018,7 @@ export async function analyzeAdaptation(
   const user = [
     '你是一位资深网文编辑兼改编策划。下面给你一部已完结/连载小说的若干章正文节选。请通读并输出该书的「原文设定卡片」与「可改范围矩阵」。',
     '输出合法 JSON 对象：',
-    '{"bookName": "书名", "outline": "一句话主线梗概（100字内）", "dimensions": [{"key":"realm","title":"大世界","mutability":"big|small|free|locked|visual","current":"当前值","evidence":"证据（出现章节/频次）","candidates":["候选1","候选2"],"impact":"改了会影响什么","risk":"high|medium|low"}]}',
+    '{"bookName": "书名", "outline": "一句话主线梗概（100字内）", "dimensions": [{"key":"realm","title":"大世界","mutability":"big|small|free|locked|visual","current":"当前值","evidence":"证据（出现章节/频次）","candidates":[{"name":"候选体系名","desc":"该体系一句话说明"}],"impact":"改了会影响什么","risk":"high|medium|low"}]}',
     'dimensions 至少覆盖以下维度（key/title）：realm 大世界、cultivation 修为体系、protagonist 主角、goldenFinger 金手指、supporting 配角与势力人物名、faction 势力/组织、style 文风与叙事、ending 结局走向、timeline 时间线/编年、foreshadow 伏笔/暗线。',
     'mutability 取值：locked=建议保留、big=可改影响大、small=可改影响小、free=可自由改、visual=仅视觉包装。',
     '每个 dimension.current 必须忠于文本，能引用原文就用原文（尤其角色名/境界名/势力名/金手指名）。',
@@ -3645,13 +3066,24 @@ function normalizeAdaptationDimension(d: Record<string, unknown>): AdaptationDim
   const risk = (['high', 'medium', 'low'] as const).includes(d.risk as AdaptationDimension['risk'])
     ? d.risk as AdaptationDimension['risk']
     : 'medium'
+  const rawCands = Array.isArray(d.candidates) ? d.candidates : []
+  const candidates = rawCands.map((x): { name: string; desc?: string } | null => {
+    if (typeof x === 'string') return x.trim() !== '' ? { name: x.trim() } : null
+    if (typeof x === 'object' && x !== null) {
+      const o = x as { name?: unknown; desc?: unknown }
+      const name = typeof o.name === 'string' ? o.name.trim() : ''
+      const desc = typeof o.desc === 'string' ? o.desc.trim() : undefined
+      return name !== '' ? { name, desc } : null
+    }
+    return null
+  }).filter((x): x is { name: string; desc?: string } => x !== null)
   return {
     key,
     title,
     mutability,
     current: typeof d.current === 'string' ? d.current : '',
     evidence: typeof d.evidence === 'string' ? d.evidence : undefined,
-    candidates: Array.isArray(d.candidates) ? d.candidates.filter((x): x is string => typeof x === 'string') : [],
+    candidates,
     impact: typeof d.impact === 'string' ? d.impact : '',
     risk,
   }
@@ -3691,7 +3123,7 @@ async function reverseOutlineFromAdaptationText(
 export async function proposeAdaptation(
   ctx: Context,
   config: NovelConfig,
-  text: string,
+  _text: string,
   selections: Array<{ key: string; title: string; current: string; target: string; mutability: string }>,
   dimensions?: AdaptationDimension[],
 ): Promise<AdaptProposeResponse> {
@@ -3834,7 +3266,7 @@ export async function rewriteAdaptationBook(
       adaptedParts.push('# 第' + c.no + '章 ' + title + '\n\n' + c.body.trim() + '\n')
       continue
     }
-    const user = [
+  const user = [
       mappingBlock,
       ruleBlock,
       '第 ' + c.no + ' 章《' + c.title + '》：',
@@ -3884,7 +3316,7 @@ export async function materializeAdaptedBook(
 ): Promise<Omit<AdaptMaterializeResponse, 'book'>> {
   const bookName = (args.bookName ?? '').trim().slice(0, 40) || '改编新书'
   const outDir = (args.outputDir ?? '').trim()
-  if (outDir === '') throw new Error('未指定新书输出目录')
+  if (outDir === '') throw new NovelActionError('contract', '未指定新书输出目录')
   const mappings = args.proposal?.mappings ?? []
   // 源文导入临时项目（复用角色/道藏/世界提炼：这些函数读取 config.outputDir 下的章节文件）。
   const tmpDir = join(tmpdir(), 'dsh-novel-forge-adapt-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8))
@@ -3894,7 +3326,7 @@ export async function materializeAdaptedBook(
     if (sourceProject === undefined) throw new Error('临时项目创建失败')
     const sourceConfig: NovelConfig = { ...config, outputDir: tmpDir }
 
-    // 源书设定圣经 + 角色库 + 大世界。
+    // 源书道藏 + 角色库 + 大世界。
     // 注意：extractWorld/extractRoles 内部读取 project.outline，所以要先把源文大纲写进临时项目。
     const srcOutline = (args.outline ?? '').trim() !== '' ? (args.outline ?? '').trim() : fallbackSourceOutline(sourceProject)
     sourceProject.outline = srcOutline
@@ -3959,7 +3391,7 @@ function applyAdaptationMappings(text: string, mappings: AdaptationMapping[]): s
   return applyAdaptationReplacements(text, mappings).adaptedText
 }
 
-/** 改编设定圣经：把人名/术语/势力按映射表替换。 */
+/** 改编道藏：把人名/术语/势力按映射表替换。 */
 function applyMappingsToBible(bible: StoryBible, mappings: AdaptationMapping[]): StoryBible {
   const t = (s: string): string => applyAdaptationMappings(s, mappings)
   return {
@@ -3984,13 +3416,6 @@ function applyMappingsToRoles(roles: RoleRecord[], mappings: AdaptationMapping[]
     relations: role.relations.map(t),
     arc: role.arc.map(t),
     knowledge: role.knowledge.map(t),
-    imagePrompt: role.imagePrompt !== undefined
-      ? { ...role.imagePrompt, zh: t(role.imagePrompt.zh), en: t(role.imagePrompt.en), tags: role.imagePrompt.tags.map(t), source: role.imagePrompt.source !== undefined ? t(role.imagePrompt.source) : undefined }
-      : undefined,
-    expressions: role.expressions?.map(t),
-    promptKit: role.promptKit !== undefined
-      ? { ...role.promptKit, portrait: { ...role.promptKit.portrait, zh: t(role.promptKit.portrait.zh), en: t(role.promptKit.portrait.en) }, sheet: { ...role.promptKit.sheet, zh: t(role.promptKit.sheet.zh), en: t(role.promptKit.sheet.en) }, expressions: role.promptKit.expressions.map(e => ({ ...e, zh: t(e.zh), en: t(e.en) })), details: { ...role.promptKit.details, zh: t(role.promptKit.details.zh), en: t(role.promptKit.details.en) } }
-      : undefined,
   }))
 }
 
@@ -4015,6 +3440,33 @@ function fallbackSourceOutline(project: ProjectState): string {
  * 批量生成时整体开销约省 25%）。
  * @returns 摘要与新增事实条数（失败返回空，调用方 best-effort）。
  */
+
+/**
+ * 事实库去重：新事实加入前检查与已有事实的相似度，
+ * 状态类事实（如"主角受伤"→"主角痊愈"）覆盖旧状态。
+ */
+function dedupAndAddFacts(project: ProjectState, chapterNo: number, newFacts: string[]): number {
+  const list = project.facts ?? []
+  const existingTexts = new Set(list.map(f => f.text))
+  let added = 0
+  for (const fact of newFacts.slice(0, 8)) {
+    if (existingTexts.has(fact)) continue
+    const isDuplicate = list.some(f => {
+      const a = f.text.slice(0, 30)
+      const b = fact.slice(0, 30)
+      if (a.length === 0 || b.length === 0) return false
+      let common = 0
+      for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] === b[i]) common++
+      return common / Math.max(a.length, b.length) > 0.7
+    })
+    if (isDuplicate) continue
+    list.push({ chapterNo, text: fact })
+    existingTexts.add(fact)
+    added++
+  }
+  project.facts = list.slice(-300)
+  return added
+}
 export async function summarizeAndExtractFacts(
   ctx: Context,
   config: NovelConfig,
@@ -4042,9 +3494,7 @@ export async function summarizeAndExtractFacts(
         .map(v => v.trim().slice(0, 140))
     : []
   if (summary !== '') chapter.summary = summary
-  const list = project.facts ?? []
-  for (const line of factLines.slice(0, 8)) list.push({ chapterNo, text: line })
-  project.facts = list.slice(-300)
+  dedupAndAddFacts(project, chapterNo, factLines)
   project.updatedAt = new Date().toISOString()
   saveProject(outputDir, project)
   return { summary, factCount: factLines.length }
@@ -4148,7 +3598,7 @@ async function auditBatch(
   batch: ChapterPlan[],
 ): Promise<AuditIssue[]> {
   const system = [
-    '你是一位严谨的网文连续性审校编辑。你会收到一本小说的设定圣经、事实库和一批章节正文节选。',
+    '你是一位严谨的网文连续性审校编辑。你会收到一本小说的道藏、事实库和一批章节正文节选。',
     '请找出这批章节中的一致性矛盾，例如：',
     '- 人物状态冲突：境界/修为/伤势/资源在同一章内或跨章前后矛盾。',
     '- 设定违背：正文与世界观规则、金手指规则、写作红线冲突。',
@@ -4169,7 +3619,7 @@ async function auditBatch(
   const user = [
     '请对以下小说做一致性质检。',
     project.bible !== undefined
-      ? '设定圣经：\n' + [
+      ? '道藏：\n' + [
           project.bible.worldRules.length > 0 ? `世界规则：\n${project.bible.worldRules.map(r => `- ${r}`).join('\n')}` : '',
           project.bible.redLines.length > 0 ? `写作红线：\n${project.bible.redLines.map(r => `- ${r}`).join('\n')}` : '',
           project.bible.characters.length > 0 ? `角色：\n${project.bible.characters.map(ch => `- ${ch.name}（${ch.traits.join('、')}）`).join('\n')}` : '',
@@ -4179,7 +3629,7 @@ async function auditBatch(
     `正文节选（每章前 700 字）：\n${chapterBlocks}`,
     '只输出 JSON 数组。',
   ].filter(s => s !== '').join('\n\n')
-  const text = await complete(ctx, config, { system, user, temperature: 0.2, maxTokens: Math.max(config.maxTokens, 12000) })
+  const text = await complete(ctx, config, { system, user, temperature: 0.2, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low', model: config.auditModel, liveLabel: '质检查询' })
   const parsed = parseJsonArray<Record<string, unknown>>(text)
   const issues: AuditIssue[] = []
   for (const entry of parsed) {
@@ -4224,7 +3674,7 @@ export async function auditBook(
   return all.slice(0, 50)
 }
 
-/** 小说简介：AI 生成或按已写开头补全（面向读者的作品门面）。 */
+/** 小说简介：生成或按已写开头补全（面向读者的作品门面）。 */
 export async function generateBlurb(
   ctx: Context,
   config: NovelConfig,
@@ -4268,7 +3718,7 @@ export function bookOverview(project: ProjectState, scope: 'recent' | 'full' | n
   s.push(`【大纲全文】\n${project.outline}`)
   if (project.bible !== undefined) {
     const bible = project.bible
-    s.push('【设定圣经】')
+    s.push('【道藏】')
     if (bible.genre !== '') s.push(`题材基调：${bible.genre}`)
     if (bible.worldRules.length > 0) s.push('世界规则：\n' + bible.worldRules.map(r => `- ${r}`).join('\n'))
     if (bible.characters.length > 0) {
@@ -4325,7 +3775,7 @@ export function bookOverview(project: ProjectState, scope: 'recent' | 'full' | n
 
 /** 一条影响分析结果（改动波及处）。 */
 export interface ImpactItem {
-  /** 位置：章节号 / 大纲 / 设定圣经 / 大世界 / 事实库 / 简介。 */
+  /** 位置：章节号 / 大纲 / 道藏 / 大世界 / 事实库 / 简介。 */
   location: string
   /** 原文片段（定位用）。 */
   quote: string
@@ -4348,7 +3798,7 @@ export async function analyzeImpact(
 ): Promise<ImpactItem[]> {
   const system = [
     '你是一位网文一致性审校。作者要做一处修改，请找出这次改动会波及的所有位置（设定、大纲、已写章节正文、事实库、简介中可能因此过时或矛盾的内容）。',
-    '输出必须是合法 JSON 数组，格式：[{"location": "位置（第N章/大纲/设定圣经-世界规则/大世界-境界/事实库/简介）", "quote": "原文片段（20-60字）", "suggestion": "修改建议", "kind": "must|optional|note"}]',
+    '输出必须是合法 JSON 数组，格式：[{"location": "位置（第N章/大纲/道藏-世界规则/大世界-境界/事实库/简介）", "quote": "原文片段（20-60字）", "suggestion": "修改建议", "kind": "must|optional|note"}]',
     'kind 含义：must=必须同步改否则矛盾；optional=建议改（影响观感）；note=备注（如旧称保留为古称、或无需改但需知晓）。',
     '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
   ].join('\n')
@@ -4419,20 +3869,20 @@ export function renderWorld(world: WorldState | undefined): string {
   return sections.join('\n')
 }
 
-/** AI 提炼大世界：从大纲 + 设定圣经生成结构化境界体系/区域/势力。 */
+/** 提炼大世界：从大纲 + 道藏生成结构化境界体系/区域/势力。 */
 export async function extractWorld(
   ctx: Context,
   config: NovelConfig,
   project: ProjectState,
 ): Promise<WorldState> {
   const system = [
-    '你是一位网文世界观架构师。请根据小说大纲与设定圣经，提炼结构化「大世界」数据。',
+    '你是一位网文世界观架构师。请根据小说大纲与道藏，提炼结构化「大世界」数据。',
     '输出必须是合法 JSON 对象：',
     '{"realms": [{"name": "境界名", "description": "突破条件/寿命/标志等"}], "regions": [{"name": "区域名", "description": "描述", "faction": "关联势力名或空"}], "factions": [{"name": "势力名", "kind": "宗门/家族/王朝/组织等", "description": "描述", "region": "驻地区域或空"}]}',
     '要求：',
     '1. realms 按由低到高顺序排列（修仙题材必须含完整境界链；无境界设定的题材可输出空数组）。',
     '2. 数量贴合大纲：realms 3-12 个，regions 2-10 个，factions 2-10 个。',
-    '3. 内容严格来自大纲与设定圣经，不要凭空发明与大纲冲突的设定。',
+    '3. 内容严格来自大纲与道藏，不要凭空发明与大纲冲突的设定。',
     '重要：所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束。',
   ].join('\n')
   const bibleBlock = project.bible !== undefined
@@ -4544,7 +3994,7 @@ export async function refreshCharacters(
     ].join('\n')
     const rosterBlock = roster.map(ch => `- ${ch.name}（${ch.traits.join('、')}）`).join('\n')
     const factsBlock = facts.map(f => `[第${f.chapterNo}章] ${f.text}`).join('\n')
-    const user = [
+  const user = [
       `角色名单：\n${rosterBlock}`,
       `已确立事实库（${facts.length} 条）：\n${factsBlock.slice(-6000)}`,
       '只输出 JSON 数组。',
@@ -4571,7 +4021,7 @@ export async function refreshCharacters(
       appearances: entry?.chapters.size ?? 0,
     })
   }
-  // 名单外的角色（从事实库中识别到但不在设定圣经名单）仅当有出场统计时补充。
+  // 名单外的角色（从事实库中识别到但不在道藏名单）仅当有出场统计时补充。
   for (const [name, entry] of stat) {
     if (!cards.some(c => c.name === name)) {
       cards.push({
@@ -4613,7 +4063,7 @@ export async function suggestForeshadows(
     `大纲：\n${project.outline}`,
     `已规划章节数：${project.chapters.length}`,
   ].join('\n')
-  const text = await complete(ctx, config, { system: foreshadowSystemPrompt(), user, temperature: 0.5, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low' })
+  const text = await complete(ctx, config, { system: foreshadowSystemPrompt(), user, temperature: 0.5, maxTokens: Math.max(config.maxTokens, 12000), reasoning: config.analysisReasoning ?? 'low', liveLabel: '伏笔建议' })
   const parsed = parseJsonArray<Record<string, unknown>>(text)
   const existing = new Set(project.foreshadows.map(f => f.description))
   const created: Foreshadow[] = []
@@ -4645,17 +4095,34 @@ export async function extractStyleAsset(
   ctx: Context,
   config: NovelConfig,
   sampleText: string,
-): Promise<{ proseRules: string[]; dialogueRules: string[]; descriptionRules: string[]; boundaries: string[] }> {
+): Promise<{
+  proseRules: string[]; dialogueRules: string[]; descriptionRules: string[]; boundaries: string[];
+  preset?: 'imitate' | 'balanced' | 'transfer'; fingerprintRisk?: 'low' | 'medium' | 'high';
+  writingGuidance?: string[]; forbiddenEntities?: string[];
+}> {
   const user = `请分析下面这段样本文本，提炼其叙事风格规则：\n\n${sampleText}`
-  const text = await complete(ctx, config, { system: styleEngineSystemPrompt(), user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 12000) })
-  const raw = parseJsonObject<{ proseRules?: unknown; dialogueRules?: unknown; descriptionRules?: unknown; boundaries?: unknown }>(text)
+  const text = await complete(ctx, config, { system: styleEngineSystemPrompt(), user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 12000), liveLabel: '写法提取' })
+  const raw = parseJsonObject<{
+    proseRules?: unknown; dialogueRules?: unknown; descriptionRules?: unknown; boundaries?: unknown;
+    preset?: unknown; fingerprintRisk?: unknown; writingGuidance?: unknown; forbiddenEntities?: unknown;
+  }>(text)
   const strArray = (value: unknown): string[] =>
     Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string' && v.trim() !== '') : []
+  // 结构化输出校验（轻量 schema）：归一 enum、截断、去空；preset 缺失时按指纹风险自动推荐。
+  const fingerprintRisk = (['low', 'medium', 'high'] as const).includes(raw.fingerprintRisk as never)
+    ? raw.fingerprintRisk as 'low' | 'medium' | 'high'
+    : 'medium'
   const result = {
-    proseRules: strArray(raw.proseRules),
-    dialogueRules: strArray(raw.dialogueRules),
-    descriptionRules: strArray(raw.descriptionRules),
-    boundaries: strArray(raw.boundaries),
+    proseRules: strArray(raw.proseRules).slice(0, 40),
+    dialogueRules: strArray(raw.dialogueRules).slice(0, 40),
+    descriptionRules: strArray(raw.descriptionRules).slice(0, 40),
+    boundaries: strArray(raw.boundaries).slice(0, 30),
+    preset: (['imitate', 'balanced', 'transfer'] as const).includes(raw.preset as never)
+      ? raw.preset as 'imitate' | 'balanced' | 'transfer'
+      : recommendStylePreset(fingerprintRisk),
+    fingerprintRisk,
+    writingGuidance: strArray(raw.writingGuidance).slice(0, 20),
+    forbiddenEntities: strArray(raw.forbiddenEntities).slice(0, 30),
   }
   if (result.proseRules.length + result.dialogueRules.length + result.descriptionRules.length + result.boundaries.length === 0) {
     throw new Error('写法提取失败：模型没有返回有效规则')
@@ -4663,6 +4130,404 @@ export async function extractStyleAsset(
   return result
 }
 
+/** 分层提取写作公式（basic/standard/deep）。 */
+export async function extractStyleFormula(
+  ctx: Context,
+  config: NovelConfig,
+  sampleText: string,
+  depth: 'basic' | 'standard' | 'deep',
+): Promise<{ name: string; focusAreas: string[]; formula: string; applyGuidance: string }> {
+  const user = `请提炼下面这段样本文本的写作公式：\n\n${sampleText}`
+  const text = await complete(ctx, config, { system: styleFormulaSystemPrompt(depth), user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 8000), liveLabel: '公式提取' })
+  const raw = parseJsonObject<{ name?: unknown; focusAreas?: unknown; formula?: unknown; applyGuidance?: unknown }>(text)
+  const formula = typeof raw.formula === 'string' ? raw.formula.trim() : ''
+  if (formula === '') throw new Error('公式提取失败：模型没有返回有效 formula')
+  return {
+    name: typeof raw.name === 'string' ? raw.name.trim().slice(0, 40) : `公式 ${Date.now().toString(36)}`,
+    focusAreas: Array.isArray(raw.focusAreas) ? raw.focusAreas.filter((x): x is string => typeof x === 'string' && x.trim() !== '').map(x => x.slice(0, 20)).slice(0, 6) : [],
+    formula,
+    applyGuidance: typeof raw.applyGuidance === 'string' ? raw.applyGuidance.trim().slice(0, 300) : '',
+  }
+}
+
+/** 市场雷达系统提示（对齐上游 marketRadar 分析师角色）。 */
+function marketRadarSystemPrompt(): string {
+  return [
+    '你是中文网络文学市场分析师。只分析输入中的公开榜单元数据或用户给出的市场线索，不补写作品正文，不假装知道未提供的信息。',
+    '只根据输入归纳热门题材和市场信号；对未提供的信息不要臆测。',
+    '重点分析：热门题材组合、主角身份、金手指机制、开篇危机、关系卖点、标题句式、拥挤套路和差异化机会。',
+    'kind 只能使用 genre、protagonist、advantage、opening、relationship、title_pattern、opportunity、crowding，不得创造近义枚举值。',
+    '榜单高频不等于适合照搬。机会建议必须说明读者满足点，同时避开直接复制具体作品。',
+    'productionFoundation 的题材/推进模式优先引用「资源库」中已有的 existingId（名称一字不差）；只有确无合适资产时才给出新资产（existingId 为 null）。',
+    'creativeBrief 严禁复用榜单作品的人名、专有设定、简介句子和完整书名；只能提炼读者需求、爽点机制和结构机会，不得输出任何具体人名/作品名，一律使用身份或通用场景称谓。',
+  ].join('\n')
+}
+
+/** 题材雷达：输入平台/题材/榜单文本 → 信号 + 生产底座 + 开书创意。 */
+export async function runMarketRadar(
+  ctx: Context,
+  config: NovelConfig,
+  req: MarketRadarRequest,
+): Promise<MarketRadarResult> {
+  const genreCatalog = BUILTIN_GENRE_LIBRARY.map((g, i) => `- [${i}] ${g.name}：${g.description}${g.template !== undefined ? `（写法：${g.template}）` : ''}`).join('\n')
+  const modeCatalog = BUILTIN_PROGRESSION_MODES.map((m, i) => `- [${i}] ${m.name}：${m.driver} / 期待：${m.readerExpectation}`).join('\n')
+  const user = [
+    req.platform !== undefined && req.platform !== '' ? `目标平台：${req.platform}` : '',
+    req.genre !== undefined && req.genre !== '' ? `目标题材：${req.genre}` : '',
+    req.keywords !== undefined && req.keywords !== '' ? `关键词：${req.keywords}` : '',
+    (req.candidates !== undefined && req.candidates.length > 0)
+      ? '【上榜记录（真实榜单）】\n' + req.candidates.map((c, i) => `- ${i + 1}.《${c.title}》${c.author !== undefined && c.author !== '' ? `（${c.author}）` : ''}${(c.tags?.length ?? 0) > 0 ? ` [${c.tags!.join('、')}]` : ''}${c.category !== undefined && c.category !== '' ? ` ${c.category}` : ''}${c.synopsis !== undefined && c.synopsis !== '' ? `：${c.synopsis.slice(0, 140)}` : ''}`).join('\n')
+      : (req.feedText !== undefined && req.feedText !== '')
+        ? '【榜单/市场线索】\n' + req.feedText.slice(0, 6000)
+        : '（无榜单数据，请基于平台/题材/关键词与你的市场知识归纳）',
+    '',
+    '现有题材基底库：\n' + (genreCatalog || '空'),
+    '',
+    '现有推进模式库：\n' + (modeCatalog || '空'),
+    '',
+    '输出必须是合法 JSON 对象，不要输出任何其他文字。',
+    'JSON 结构：{"signals":[{"id":"短横线稳定id","kind":"genre|protagonist|advantage|opening|relationship|title_pattern|opportunity|crowding","title":"一句话","detail":"说明（含读者满足点）","direction":"current|rising|stable|falling","recommended":true|false}], "productionFoundation":{"genre":{"existingId":null或资源名,"name":"题材名","description":"说明","template":"写法指引"},"primaryStoryMode":{"existingId":null或资源名,"name":"模式名","driver":"驱动力","readerExpectation":"读者期待"},"secondaryStoryMode":{同primary,可null或省略}}}',
+  ].filter(s => s !== '').join('\n\n')
+  const text = await complete(ctx, config, { system: marketRadarSystemPrompt(), user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 8000), liveLabel: '题材雷达' })
+  const raw = parseJsonObject<Record<string, unknown>>(text)
+  const signalAs = (v: unknown): MarketRadarSignal[] => Array.isArray(v)
+    ? v.filter((x): x is Record<string, unknown> => typeof x === 'object' && x !== null)
+        .map(x => ({
+          id: typeof x.id === 'string' ? x.id.slice(0, 40) : `sig-${Math.random().toString(36).slice(2, 7)}`,
+          kind: (['genre', 'protagonist', 'advantage', 'opening', 'relationship', 'title_pattern', 'opportunity', 'crowding'] as const).includes(x.kind as never)
+            ? x.kind as MarketRadarSignal['kind']
+            : 'genre',
+          title: typeof x.title === 'string' ? x.title.slice(0, 60) : '未命名信号',
+          detail: typeof x.detail === 'string' ? x.detail.slice(0, 300) : '',
+          direction: (['current', 'rising', 'stable', 'falling'] as const).includes(x.direction as never)
+            ? x.direction as MarketRadarSignal['direction']
+            : undefined,
+          recommended: typeof x.recommended === 'boolean' ? x.recommended : undefined,
+        }))
+    : []
+  const pf = (raw.productionFoundation ?? {}) as Record<string, unknown>
+  const genre = (pf.genre ?? {}) as Record<string, unknown>
+  const primary = (pf.primaryStoryMode ?? {}) as Record<string, unknown>
+  const secondary = (pf.secondaryStoryMode ?? {}) as Record<string, unknown>
+  const genreIds = new Set(BUILTIN_GENRE_LIBRARY.map(g => g.name))
+  const modeIds = new Set(BUILTIN_PROGRESSION_MODES.map(m => m.name))
+  const productionFoundation: ProductionFoundation = {
+    genre: {
+      existingId: typeof genre.existingId === 'string' && genre.existingId !== '' && genreIds.has(genre.existingId) ? genre.existingId : undefined,
+      name: typeof genre.name === 'string' ? genre.name.slice(0, 40) : '未定题材',
+      description: typeof genre.description === 'string' ? genre.description.slice(0, 300) : '',
+      template: typeof genre.template === 'string' ? genre.template.slice(0, 200) : undefined,
+    },
+    primaryStoryMode: {
+      existingId: typeof primary.existingId === 'string' && primary.existingId !== '' && modeIds.has(primary.existingId) ? primary.existingId : undefined,
+      name: typeof primary.name === 'string' ? primary.name.slice(0, 40) : '未定模式',
+      driver: typeof primary.driver === 'string' ? primary.driver.slice(0, 200) : '',
+      readerExpectation: typeof primary.readerExpectation === 'string' ? primary.readerExpectation.slice(0, 200) : '',
+    },
+    secondaryStoryMode: Object.keys(secondary).length > 0 && typeof secondary.name === 'string' && secondary.name !== ''
+      ? {
+          existingId: typeof secondary.existingId === 'string' && secondary.existingId !== '' && modeIds.has(secondary.existingId) ? secondary.existingId : undefined,
+          name: secondary.name.slice(0, 40),
+          driver: typeof secondary.driver === 'string' ? secondary.driver.slice(0, 200) : '',
+          readerExpectation: typeof secondary.readerExpectation === 'string' ? secondary.readerExpectation.slice(0, 200) : '',
+        }
+      : undefined,
+  }
+  return {
+    signals: signalAs(raw.signals),
+    productionFoundation,
+    // 报告 id 让前端能区分「同一份报告的重渲染」与「换了新报告」：只有后者才重置
+    // 作者手选的信号。用短随机 id 即可，无需持久化。
+    reportId: `mr-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+  }
+}
+
+const MARKET_MODE_HINT: Record<string, string> = {
+  follow_hot: '优先贴合当前热门满足点，但仍禁止复制具体作品。',
+  differentiate: '保留热门读者满足点，同时至少替换主角身份、舞台或金手指机制中的一项。',
+  light: '市场信号只作次要参考，用户自身想法和已选题材优先。',
+}
+
+/** 开书创意简报：用选中的市场信号 + 影响模式生成可执行 constraint / creative seed。 */
+export async function runMarketCreativeBrief(ctx: Context, config: NovelConfig, req: MarketRadarBriefRequest): Promise<MarketCreativeBrief> {
+  const user = [
+    `影响模式：${req.influenceMode}`,
+    MARKET_MODE_HINT[req.influenceMode] ?? '',
+    req.signals.length > 0
+      ? '选中的市场信号：\n' + req.signals.map(s => `- [${s.kind}] ${s.title}：${s.detail}`).join('\n')
+      : '（无选中信号，请结合题材与推进模式补齐）',
+    '',
+    '输出必须是合法 JSON 对象，不要输出任何其他文字。',
+    'JSON 结构：{"promptBlock":"可直接指导题材/金手指/首章爆点/整书方向的约束","openingIdea":"一段可直接开书的中文起始想法（主角身份、金手指或核心优势、开局事件、近期目标；不输出标题/大纲/Markdown）","coreAdvantage":"主角能做什么（含触发条件/使用边界/成长方向或代价至少一项）","bookSellingPoint":"读者持续追读的核心满足点","first30ChapterPromise":"前30章必须兑现的阶段结果/关系变化/能力成长"}',
+    '严禁复用榜单作品的人名、专有设定、简介句子和完整书名；一律使用身份或通用场景称谓，不得输出具体人名/作品名。',
+  ].filter(s => s !== '').join('\n\n')
+  const text = await complete(ctx, config, { system: marketRadarSystemPrompt(), user, temperature: 0.5, maxTokens: Math.max(config.maxTokens, 4000), liveLabel: '开书创意' })
+  const cb = parseJsonObject<Record<string, unknown>>(text)
+  return {
+    promptBlock: typeof cb.promptBlock === 'string' ? cb.promptBlock.slice(0, 800) : '',
+    openingIdea: typeof cb.openingIdea === 'string' ? cb.openingIdea.slice(0, 800) : '',
+    coreAdvantage: typeof cb.coreAdvantage === 'string' ? cb.coreAdvantage.slice(0, 600) : '',
+    bookSellingPoint: typeof cb.bookSellingPoint === 'string' ? cb.bookSellingPoint.slice(0, 400) : '',
+    first30ChapterPromise: typeof cb.first30ChapterPromise === 'string' ? cb.first30ChapterPromise.slice(0, 400) : '',
+  }
+}
+
+/** 书分析/拆书：输入一本书/章节文本 → 卖点/结构/可借鉴点/风险。 */
+export async function runBookAnalysis(ctx: Context, config: NovelConfig, req: BookAnalysisRequest): Promise<BookAnalysisResult> {
+  const system = [
+    '你是资深中文网文拆书编辑。分析输入的一本书或章节文本，提炼可复用的创作思路。',
+    '严禁照搬具体作品的人名/专有设定/简介句子；只能提炼读者需求、结构手法和风险。',
+  ].join('\n')
+  const user = [
+    '请分析下面文本：\n' + (req.text ?? '').slice(0, 8000),
+    '输出必须是合法 JSON 对象。',
+    'JSON 结构：{"sellingPoints":["读者为什么追(卖点)"],"structure":["可复用叙事结构/节奏/单元"],"lessons":["可借鉴手法/套路"],"risks":["易踩坑/风险"]}',
+  ].filter(s => s !== '').join('\n\n')
+  const text = await complete(ctx, config, { system, user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 4000), liveLabel: '书分析' })
+  const raw = parseJsonObject<Record<string, unknown>>(text)
+  const arr = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && x.trim() !== '').map(x => x.slice(0, 200)) : []
+  return {
+    sellingPoints: arr(raw.sellingPoints),
+    structure: arr(raw.structure),
+    lessons: arr(raw.lessons),
+    risks: arr(raw.risks),
+  }
+}
+
+/** 创意灵感：一句话/题材 → 多方向开书灵感。 */
+export async function runIdeaInspiration(ctx: Context, config: NovelConfig, req: IdeaInspirationRequest): Promise<IdeaInspirationResult> {
+  const count = Math.max(1, Math.min(10, req.count ?? 5))
+  const system = [
+    '你是中文网文开书灵感策划。根据用户一句话/题材方向，给出多个可开书的差异化创意。',
+    '严禁输出具体人名/作品名；用身份/通用称谓。每个创意都要有明确钩子、题材、视角、长期兑现。',
+  ].join('\n')
+  const user = [
+    `我的方向：${req.idea ?? ''}`,
+    `请给 ${count} 个开书创意。`,
+    '输出必须是合法 JSON 对象。',
+    'JSON 结构：{"ideas":[{"title":"书名/门面","hook":"一句话钩子/开局爆点","genre":"题材","pov":"主角视角/身份","payoff":"长期追读兑现"}]}',
+  ].filter(s => s !== '').join('\n\n')
+  const text = await complete(ctx, config, { system, user, temperature: 0.8, maxTokens: Math.max(config.maxTokens, 4000), liveLabel: '创意灵感' })
+  const raw = parseJsonObject<Record<string, unknown>>(text)
+  const str = (v: unknown): string => typeof v === 'string' ? v.trim().slice(0, 200) : ''
+  const arr = (v: unknown): Array<{ title: string; hook: string; genre: string; pov: string; payoff: string }> => Array.isArray(v)
+    ? v.filter((x): x is Record<string, unknown> => typeof x === 'object' && x !== null).map(x => ({ title: str(x.title), hook: str(x.hook), genre: str(x.genre), pov: str(x.pov), payoff: str(x.payoff) }))
+    : []
+  return { ideas: arr(raw.ideas).slice(0, count) }
+}
+
+/** 雷达→灵感：基于市场信号/生产底座/创意简报，生成贴合市场的开书灵感。 */
+export async function runMarketIdeaInspiration(
+  ctx: Context,
+  config: NovelConfig,
+  req: { signals?: MarketRadarSignal[]; foundation?: ProductionFoundation; brief?: MarketCreativeBrief; count?: number },
+): Promise<IdeaInspirationResult> {
+  const count = Math.max(1, Math.min(10, req.count ?? 5))
+  const system = [
+    '你是中文网文开书灵感策划，擅长从市场榜单分析中提炼可开书方向。',
+    '严禁输出具体人名/作品名；用身份/通用称谓。每个创意都要有明确钩子、题材、视角、长期兑现，且要与市场分析呼应但做差异化。',
+  ].join('\n')
+  const signalBlock = (req.signals ?? []).map(s => `- [${s.kind}] ${s.title}：${s.detail}`).join('\n') || '（无）'
+  const f = req.foundation
+  const foundationBlock = f !== undefined
+    ? `题材：${f.genre.name}（${f.genre.description}）\n主推进：${f.primaryStoryMode.name}（${f.primaryStoryMode.driver}）${f.secondaryStoryMode !== undefined ? `\n副推进：${f.secondaryStoryMode.name}` : ''}`
+    : '（无）'
+  const b = req.brief
+  const briefBlock = b !== undefined
+    ? `创作约束：${b.promptBlock}\n开篇想法：${b.openingIdea}\n核心优势：${b.coreAdvantage}\n追读卖点：${b.bookSellingPoint}\n前30章承诺：${b.first30ChapterPromise}`
+    : '（无）'
+  const user = [
+    '基于以下市场分析，给出多个【差异化、可开书】的灵感：',
+    `市场信号：\n${signalBlock}`,
+    `生产底座：\n${foundationBlock}`,
+    `创意简报：\n${briefBlock}`,
+    `请给 ${count} 个开书灵感。`,
+    '输出必须是合法 JSON 对象。',
+    'JSON 结构：{"ideas":[{"title":"书名/门面","hook":"一句话钩子/开局爆点","genre":"题材","pov":"主角视角/身份","payoff":"长期追读兑现"}]}',
+  ].filter(s => s !== '').join('\n\n')
+  const text = await complete(ctx, config, { system, user, temperature: 0.8, maxTokens: Math.max(config.maxTokens, 4000), liveLabel: '市场灵感' })
+  const raw = parseJsonObject<Record<string, unknown>>(text)
+  const str = (v: unknown): string => typeof v === 'string' ? v.trim().slice(0, 200) : ''
+  const arr = (v: unknown): Array<{ title: string; hook: string; genre: string; pov: string; payoff: string }> => Array.isArray(v)
+    ? v.filter((x): x is Record<string, unknown> => typeof x === 'object' && x !== null).map(x => ({ title: str(x.title), hook: str(x.hook), genre: str(x.genre), pov: str(x.pov), payoff: str(x.payoff) }))
+    : []
+  return { ideas: arr(raw.ideas).slice(0, count) }
+}
+
+/** 自动导演编排建议：基于全书上下文，给出下一卷/阶段编排 + 修复再平衡。 */
+export async function runDirectorAdvice(ctx: Context, config: NovelConfig, project: ProjectState, req: DirectorRequest): Promise<DirectorAdvice> {
+  const done = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating')
+  const last = done[done.length - 1]
+  const volumesBlock = (project.volumes ?? []).map(v => `第${v.no}卷《${v.title}》：${v.summary}`).join('\n') || '无'
+  const plotlinesBlock = (project.plotlines ?? []).filter(l => l.status === 'active' || l.status === 'paused').map(l => `[${l.kind}] ${l.name}：${l.goal}${l.progress ? `（${l.progress}）` : ''}`).join('\n') || '无'
+  const foreBlock = (project.foreshadows ?? []).filter(f => f.status === 'planted' || f.status === 'progressing').map(f => `- ${f.description}${f.targetChapter ? `（约${f.targetChapter}章回收）` : ''}`).join('\n') || '无'
+  const recentFacts = (project.facts ?? []).slice(-8).map(f => `[第${f.chapterNo}章] ${f.text}`).join('\n')
+  const user = [
+    `书名：《${project.bookName}》`,
+    req.focus !== undefined && req.focus !== '' ? `聚焦：${req.focus}` : '',
+    `当前进度：已写 ${done.length} 章，最后一章《${last?.title ?? '无'}》摘要：${last?.summary ?? ''}`,
+    '',
+    `分卷：\n${volumesBlock}`,
+    `剧情线：\n${plotlinesBlock}`,
+    `活跃伏笔：\n${foreBlock}`,
+    `最近事实：\n${recentFacts}`,
+    '',
+    '请作为本书的自动导演，给出下一卷/下一阶段的编排建议：续写方向、阶段弧光、节奏板、风险提示、需要修复/再平衡的点。',
+    '输出必须是合法 JSON 对象。',
+    'JSON 结构：{"summary":"总体判断一句话","nextArc":["下一阶段关键剧情节点(每条约一句话)"],"pacing":"节奏板(起承转合/爽点密度/章节节奏)","risks":["风险/跑偏提示"],"fixes":["需要修复/再平衡的点"]}',
+  ].filter(s => s !== '').join('\n\n')
+  const text = await complete(ctx, config, { system: '你是一位长篇网文自动导演，负责整本编排、节奏、风险与再平衡。只给出可执行建议，不输出正文。', user, temperature: 0.4, maxTokens: Math.max(config.maxTokens, 4000), liveLabel: '自动导演' })
+  const raw = parseJsonObject<Record<string, unknown>>(text)
+  const arr = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && x.trim() !== '').map(x => x.slice(0, 200)) : []
+  return {
+    summary: typeof raw.summary === 'string' ? raw.summary.slice(0, 300) : '',
+    nextArc: arr(raw.nextArc),
+    pacing: typeof raw.pacing === 'string' ? raw.pacing.slice(0, 400) : '',
+    risks: arr(raw.risks),
+    fixes: arr(raw.fixes),
+  }
+}
+
+// ---------------------------------------------------------------- timeline
+
+/**
+ * 从一章正文抽取时间线事件（时间点 / 地点 / 参与角色 / 事件）。
+ *
+ * 会**替换**该章已有事件（重复抽取幂等）；抽取结果按 order 递增排序后写回项目。
+ * 失败时抛错，由调用方决定是否降级（自动流程用 try/catch 包住，不阻断出章）。
+ *
+ * @param ctx 宿主上下文。
+ * @param config 运行时配置。
+ * @param project 项目状态（就地更新 `project.timeline`）。
+ * @param outputDir 书目录。
+ * @param chapterNo 章节号。
+ * @returns 本次抽取到的事件（已写入 project）。
+ */
+export async function extractTimelineForChapter(
+  ctx: Context,
+  config: NovelConfig,
+  project: ProjectState,
+  outputDir: string,
+  chapterNo: number,
+): Promise<TimelineEvent[]> {
+  const chapter = project.chapters.find(c => c.no === chapterNo)
+  if (chapter === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 不在计划中`)
+  const body = readChapterFile(outputDir, chapter)
+  if (body === undefined) throw new NovelActionError('contract', `章节 ${chapterNo} 的正文文件不存在`)
+  const NL = String.fromCharCode(10)
+  const system = [
+    '你是小说连续性编辑。任务：把一章正文压缩成「故事时间线」事件，供后续章节保持时间与地点的连续性。',
+    '要求：',
+    '1. 只抽取**正文里真实发生**的场景节点（3-8 条），不要抽取预告、回忆性的泛泛陈述；纯粹的回忆/插叙请在 event 里注明「（回忆）」并给出其故事内时间。',
+    '2. time 用正文里的说法（如「第三日黄昏」「入宗三个月后」「同日夜」）；正文没写时间就填相对说法（如「紧接上一场景」）。',
+    '3. order 是本章内的先后序号，从 1 递增；跨章我会用章号排序，你只需要保证章内顺序正确。',
+    '4. place 是场景地点（一处一个词，如「青云宗外门」）；characters 只列**在场**的角色名（用正文里的名字，不要写「主角」）。',
+    '5. event 一句话说清发生了什么（不超过 40 字）。',
+    '输出必须是合法 JSON 数组，不要输出任何其他文字或 Markdown 代码块标记：',
+    '[{"time":"第三日黄昏","order":1,"place":"青云宗外门","characters":["沈青"],"event":"沈青被外门弟子当众羞辱"}]',
+    '重要：字符串值内部不得包含换行符；JSON 必须在一段内完整结束。',
+  ].join('@NL@').replace('@NL@', NL)
+  const text = await complete(ctx, config, {
+    system,
+    user: `第 ${chapterNo} 章《${chapter.title}》正文：@NL@@NL@${body.replace(/^#\s+.*$/m, '').trim().slice(0, 24000)}`.replace('@NL@', NL),
+    temperature: 0.2,
+    maxTokens: Math.max(config.maxTokens, 4000),
+    model: config.auditModel || config.model,
+    liveLabel: `时间线抽取 · 第${chapterNo}章`,
+  })
+  let parsed: unknown = []
+  try {
+    parsed = parseJson<unknown>(text, true)
+  } catch {
+    parsed = []
+  }
+  const rawList = Array.isArray(parsed) ? parsed : []
+  const now = new Date().toISOString()
+  const extracted = rawList
+    .filter((item): item is Record<string, unknown> => typeof item === 'object' && item !== null)
+    .map((item, index) => normalizeTimelineEvent({
+      time: typeof item.time === 'string' ? item.time : '',
+      order: typeof item.order === 'number' ? item.order : index + 1,
+      place: typeof item.place === 'string' ? item.place : '',
+      characters: Array.isArray(item.characters) ? item.characters.filter((c): c is string => typeof c === 'string') : [],
+      event: typeof item.event === 'string' ? item.event : '',
+    }, chapterNo, index, now))
+    .filter(e => e.event !== '')
+  // 保留模型给出的**叙述顺序**（不按 order 重排）：时间线检查要靠这个顺序发现
+  // 「自报 order 与叙述顺序打架」；渲染/注入时再用 sortTimeline 按 order 排。
+  const kept = (project.timeline ?? []).filter(e => e.chapterNo !== chapterNo)
+  project.timeline = [...kept, ...extracted]
+  project.updatedAt = now
+  return extracted
+}
+
+/**
+ * AI 复核时间线：在规则初筛之外，让模型找规则抓不到的时序问题
+ * （年龄/季节错位、回忆与当前时间混淆、跨章跨度不合理等）。
+ *
+ * @param ctx 宿主上下文。
+ * @param config 运行时配置。
+ * @param project 项目状态。
+ * @returns 模型给出的问题清单（与规则初筛结果合并由调用方决定）。
+ */
+export async function reviewTimeline(
+  ctx: Context,
+  config: NovelConfig,
+  project: ProjectState,
+): Promise<TimelineIssue[]> {
+  const events = sortTimeline(project.timeline ?? [])
+  if (events.length === 0) return []
+  const NL = String.fromCharCode(10)
+  const lines = events.map(e => {
+    const parts = [`第${e.chapterNo}章`]
+    if (e.order !== undefined) parts.push(`#${e.order}`)
+    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(' ')
+  })
+  const system = [
+    '你是小说连续性编辑，只做一件事：找**时间线**上的矛盾。',
+    '检查项：1) 时间倒流（后一章早于前一章且没有明确插叙标注）；2) 地点瞬移（同一人物无移动交代就换场景）；',
+    '3) 时间跨度与事件量明显不匹配（如「一日之内」发生跨越数月的剧情）；4) 季节/年龄/节日前后矛盾；5) 回忆与现实混淆。',
+    '只报**能在给定事件表里指认**的问题，不要臆测；没有问题就返回空数组。',
+    '输出必须是合法 JSON 数组，不要任何其他文字：',
+    '[{"severity":"high|medium|low","chapters":[3,7],"item":"问题一句话","suggestion":"怎么修"}]',
+    '重要：字符串值内部不得包含换行符。',
+  ].join(NL)
+  const text = await complete(ctx, config, {
+    system,
+    user: `故事时间线（按章节顺序）：@NL@${lines.join(NL)}`.replace('@NL@', NL),
+    temperature: 0.2,
+    maxTokens: Math.max(config.maxTokens, 4000),
+    model: config.auditModel || config.model,
+    liveLabel: '时间线复核',
+  })
+  let parsed: unknown = []
+  try {
+    parsed = parseJson<unknown>(text, true)
+  } catch {
+    parsed = []
+  }
+  if (!Array.isArray(parsed)) return []
+  return parsed
+    .filter((item): item is Record<string, unknown> => typeof item === 'object' && item !== null)
+    .map(item => {
+      const severity = item.severity === 'high' || item.severity === 'low' ? item.severity : 'medium'
+      const chapters = Array.isArray(item.chapters)
+        ? item.chapters.filter((c): c is number => typeof c === 'number' && Number.isFinite(c))
+        : []
+      return {
+        severity,
+        chapters,
+        item: typeof item.item === 'string' ? item.item.slice(0, 300) : '',
+        suggestion: typeof item.suggestion === 'string' ? item.suggestion.slice(0, 300) : '',
+      } satisfies TimelineIssue
+    })
+    .filter(issue => issue.item !== '')
+}
+
 // ------------------------------------------------------------------ export
 
 /** Export the whole book as one txt/md file. */
@@ -4688,3 +4553,207 @@ export function exportBook(outputDir: string, project: ProjectState, format: 'tx
   writeFileSync(join(outputDir, file), content, 'utf8')
   return { file, chars: content.length, chapters: done.length }
 }
+
+/** 逐行渲染「- 名称：值」清单，跳过空值。 */
+function renderPairs(pairs: Array<[string, string | undefined]>): string {
+  return pairs
+    .filter(([, v]) => v !== undefined && v !== '')
+    .map(([k, v]) => `- ${k}：${v}`)
+    .join('\n')
+}
+
+/** 渲染项目设定（卷首语 / 开书定盘 / 总纲 / 道藏 / 大世界 / 写作资产）。 */
+function renderSettings(project: ProjectState): string {
+  const out: string[] = [`# ${project.bookName} · 项目设定`, '']
+  out.push('## 卷首语 / 简介', '', project.blurb !== undefined && project.blurb !== '' ? project.blurb : '（未填写）', '')
+  const c = project.bookContract
+  if (c !== undefined) {
+    out.push('## 开书定盘', '', renderPairs([
+      ['书籍承诺', c.promise],
+      ['主推进模式', c.primaryModeName],
+      ['辅助推进模式', (c.secondaryModeNames ?? []).join('、')],
+      ['文风基调', c.tone],
+      ['目标平台', c.targetPlatform],
+    ]), '')
+  }
+  out.push('## 总纲', '', project.outline.trim() === '' ? '（未导入）' : project.outline.trim(), '')
+  const bible = project.bible
+  if (bible !== undefined) {
+    out.push('## 道藏', '')
+    if (bible.worldRules.length > 0) out.push('### 世界规则', '', bible.worldRules.map((r, i) => `${i + 1}. ${r}`).join('\n'), '')
+    if (bible.redLines.length > 0) out.push('### 写作红线', '', bible.redLines.map(r => `- ${r}`).join('\n'), '')
+    if (bible.style.length > 0) out.push('### 文风', '', bible.style.map(x => `- ${x}`).join('\n'), '')
+    if (bible.characters.length > 0) {
+      out.push('### 角色（道藏）', '')
+      for (const ch of bible.characters) {
+        out.push(`- **${ch.name}**（${ch.role}）`)
+        if (ch.traits.length > 0) out.push(`  - 标签：${ch.traits.join('、')}`)
+        if (ch.goals !== '') out.push(`  - 目标：${ch.goals}`)
+        if (ch.relations !== '') out.push(`  - 关系：${ch.relations}`)
+        if ((ch.knowledge ?? []).length > 0) out.push(`  - 知情：${(ch.knowledge ?? []).join('；')}`)
+      }
+      out.push('')
+    }
+  }
+  const world = project.world
+  if (world !== undefined) {
+    out.push('## 大世界', '')
+    if (world.realms.length > 0) out.push('### 境界体系', '', world.realms.map((r, i) => `${i + 1}. ${r.name}${r.description !== '' ? `：${r.description}` : ''}`).join('\n'), '')
+    if (world.regions.length > 0) out.push('### 区域', '', world.regions.map(r => `- ${r.name}${r.description !== '' ? `：${r.description}` : ''}`).join('\n'), '')
+    if (world.factions.length > 0) out.push('### 势力', '', world.factions.map(f => `- ${f.name}（${f.kind}）${f.description !== '' ? `：${f.description}` : ''}`).join('\n'), '')
+  }
+  const assets = project.assets
+  if (assets !== undefined) {
+    const head: Array<[string, string | undefined]> = []
+    if (assets.genre !== undefined) head.push(['题材', assets.genre.name])
+    if (assets.primaryProgression !== undefined) head.push(['主推进', assets.primaryProgression.name])
+    if ((assets.auxiliaryProgressions ?? []).length > 0) head.push(['辅助推进', assets.auxiliaryProgressions.map(a => a.name).join('、')])
+    if (head.length > 0) out.push('## 写作资产', '', renderPairs(head), '')
+    if ((assets.antiAiRules ?? []).length > 0) {
+      out.push('### 反 AI 规则', '')
+      out.push(assets.antiAiRules.map(r => `- ${r.name}：避免「${r.avoid}」→ ${r.fix}`).join('\n'), '')
+    }
+    if ((assets.styleAssets ?? []).length > 0) {
+      out.push('### 笔法帖 / 写法资产', '')
+      out.push(assets.styleAssets.map(x => `- ${x.name}`).join('\n'), '')
+    }
+  }
+  return out.join('\n').replace(/\n(\n)+/g, '\n\n')
+}
+
+/** 渲染规划（卷计划 + 章节计划）。 */
+function renderPlan(project: ProjectState): string {
+  const out: string[] = [`# ${project.bookName} · 规划`, '']
+  const volumes = (project.volumes ?? []).slice().sort((a, b) => a.no - b.no)
+  if (volumes.length > 0) {
+    out.push('## 卷计划', '')
+    for (const v of volumes) {
+      out.push(`### 第${v.no}卷 ${v.title}`, '')
+      if (v.summary !== '') out.push(v.summary, '')
+    }
+  }
+  out.push(`## 章节计划（共 ${project.chapters.length} 章）`, '')
+  for (const c of project.chapters.slice().sort((a, b) => a.no - b.no)) {
+    out.push(`### 第${c.no}章 ${c.title}　[${c.status}]`, '')
+    if (c.beats !== '') out.push(c.beats.trim(), '')
+    const extra = renderPairs([
+      ['本章必达', (c.mustAdvance ?? []).join('；')],
+      ['不可破坏', (c.mustPreserve ?? []).join('；')],
+      ['人物硬事实', (c.characterHardFacts ?? []).join('；')],
+      ['结尾钩子', c.endingHook],
+      ['义务合约', c.obligation],
+    ])
+    if (extra !== '') out.push(extra, '')
+    if (c.summary !== undefined && c.summary !== '') out.push(`- 摘要：${c.summary}`, '')
+  }
+  return out.join('\n')
+}
+
+/** 渲染角色（角色库 + 人物志）。 */
+function renderCharacters(project: ProjectState): string {
+  const out: string[] = [`# ${project.bookName} · 角色`, '']
+  const roles = project.roles ?? []
+  out.push(`## 角色库（${roles.length}）`, '')
+  if (roles.length === 0) out.push('（空）', '')
+  for (const r of roles) {
+    out.push(`### ${r.name}（${r.roleLabel}）`, '')
+    const info = renderPairs([
+      ['身份', r.identity],
+      ['性格', r.traits.join('、')],
+      ['目标', r.goals],
+      ['关系网', r.relations.join('；')],
+      ['成长线', r.arc.join(' → ')],
+      ['知情度', r.knowledge.join('；')],
+      ['首次出场', r.firstChapter !== undefined ? `第${r.firstChapter}章` : undefined],
+    ])
+    if (info !== '') out.push(info, '')
+  }
+  const status = project.roleStatus ?? []
+  if (status.length > 0) {
+    out.push('## 人物志（当前状态）', '')
+    for (const card of status) {
+      out.push(`- **${card.name}**（${card.role}）${card.status}　—　最近出场第 ${card.lastChapter} 章，累计 ${card.appearances} 次`)
+    }
+  }
+  return out.join('\n')
+}
+
+/** 渲染质检记录（逐章审稿 + 作者复盘 + 暗线 + 剧情线 + 待办）。 */
+function renderReview(project: ProjectState): string {
+  const out: string[] = [`# ${project.bookName} · 质检记录`, '']
+  const reviewed = project.chapters.filter(c => c.review !== undefined).slice().sort((a, b) => a.no - b.no)
+  out.push(`## 审稿（${reviewed.length} / ${project.chapters.length} 章）`, '')
+  for (const c of reviewed) {
+    const r = c.review!
+    out.push(`### 第${c.no}章 ${c.title}　${r.score} 分 · ${r.passed ? '通过' : '未过'}`, '')
+    if (r.verdict !== '') out.push(r.verdict, '')
+    if (r.issues.length > 0) {
+      out.push(r.issues.map(i => `- [${i.severity}] ${i.item}${i.suggestion !== '' ? ` → ${i.suggestion}` : ''}`).join('\n'), '')
+    }
+  }
+  const author = project.chapters.filter(c => c.authorReview !== undefined).slice().sort((a, b) => a.no - b.no)
+  if (author.length > 0) {
+    out.push('## 作者复盘', '')
+    for (const c of author) {
+      const a = c.authorReview!
+      out.push(`### 第${c.no}章 ${c.title}`, '')
+      out.push(renderPairs([
+        ['上一章钩子兑现', a.hookHonored ? '是' : '否'],
+        ['钩子说明', a.hookNote],
+        ['结尾钩子强度', String(a.endingHook)],
+        ['剧情线推进', a.plotlineProgress],
+        ['连续性', a.continuity],
+      ]), '')
+    }
+  }
+  const fores = project.foreshadows ?? []
+  if (fores.length > 0) {
+    out.push('## 暗线 / 伏笔', '')
+    out.push(fores.map(f => `- [${f.status}] ${f.description}${f.targetChapter !== undefined ? `（预计第 ${f.targetChapter} 章回收）` : ''}`).join('\n'), '')
+  }
+  const plotlines = project.plotlines ?? []
+  if (plotlines.length > 0) {
+    out.push('## 剧情线', '')
+    out.push(plotlines.map(l => `- [${l.status}] ${l.name}：${l.goal}（${l.progress}）`).join('\n'), '')
+  }
+  const todos = project.todos ?? []
+  if (todos.length > 0) {
+    out.push('## 编辑待办', '')
+    out.push(todos.map(t => `- [${t.done ? 'x' : ' '}] ${t.text}`).join('\n'), '')
+  }
+  return out.join('\n')
+}
+
+/**
+ * 按范围导出：整本正文 / 设定 / 规划 / 角色 / 质检记录 / 项目 JSON。
+ *
+ * @param outputDir 书目录。
+ * @param project 项目状态。
+ * @param scope 导出范围。
+ * @param format txt / md / json（json 只对 `project` 范围有独立含义，其余按 md 落盘）。
+ * @returns 文件名、字符数与章节数。
+ */
+export function exportScope(
+  outputDir: string,
+  project: ProjectState,
+  scope: ExportScope,
+  format: 'txt' | 'md' | 'json',
+): { file: string; chars: number; chapters: number } {
+  if (scope === 'book') return exportBook(outputDir, project, format === 'json' ? 'md' : format)
+  if (scope === 'project') {
+    const payload = { schema: 'dsh-novel-forge/project@1', exportedAt: new Date().toISOString(), project }
+    const content = JSON.stringify(payload, null, 2)
+    const file = `《${safeFileName(project.bookName)}》项目备份.json`
+    writeFileSync(join(outputDir, file), content, 'utf8')
+    return { file, chars: content.length, chapters: project.chapters.length }
+  }
+  const body = scope === 'settings' ? renderSettings(project)
+    : scope === 'plan' ? renderPlan(project)
+      : scope === 'characters' ? renderCharacters(project)
+        : renderReview(project)
+  const ext = format === 'json' ? 'md' : format
+  const label = scope === 'settings' ? '项目设定' : scope === 'plan' ? '规划' : scope === 'characters' ? '角色' : '质检记录'
+  const file = `《${safeFileName(project.bookName)}》${label}.${ext}`
+  writeFileSync(join(outputDir, file), body, 'utf8')
+  return { file, chars: body.length, chapters: 0 }
+}