@waterwx/dsh-novel-forge 2.0.0-alpha.1 → 2.0.0

package/src/engine.ts

@@ -23,45 +23,38 @@ export const COMPLIANCE_REDLINES: ReadonlyArray<string> = [
   '9. 不得出现法律法规禁止的其他内容。',
 ]
 
-/** 审稿维度取值（与 review-policy.ts 的 REVIEW_DIMENSIONS 对齐，用于归一化模型输出的 dimension 字段）。 */
+/** 审稿维度取值：归一化模型输出的 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, dirname } from 'node:path'
-import { homedir, tmpdir } from 'node:os'
+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 { getGenreRules } from './manga-genre-rules.ts'
-import { findStyle, styleKeywords } from './style-library.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 {
-  normalizeShotSize,
-  normalizeCameras,
-  normalizeComposition,
-  normalizeLightings,
-  sizeZh,
-  cameraZh,
-  lightZh,
-} from './shot-language.ts'
-import {
-  normalizeStoryFunction,
-  normalizeEmotions,
-  functionZh,
-  emotionZh,
-} from './story-beat-language.ts'
 import type {
   AdaptationDimension,
   AdaptAnalyzeResponse,
   AdaptationMapping,
-  AdaptationProposal,
   AdaptationRules,
   AdaptProposeResponse,
-  AdaptExecuteResponse,
   AuditIssue,
   AuthorReview,
+  ExportScope,
+  TimelineEvent,
+  TimelineIssue,
   BreakdownResponse,
   ChapterPlan,
   Foreshadow,
@@ -72,39 +65,38 @@ import type {
   PlotlinePlan,
   ProjectState,
   ReviewDimension,
-  ReviewIssue,
   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,
-  Prop,
   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'
 
@@ -179,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
   }
 }
@@ -213,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
@@ -356,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 : []
 }
 
 /**
@@ -651,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++) {
@@ -670,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,
     })
@@ -695,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 [
@@ -707,6 +809,7 @@ 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,
@@ -717,7 +820,7 @@ function planSystemPrompt(volumes: Volume[] | undefined): string {
  *  `targetChars` 来自每章计划（规划时快照，= 设置的每章目标字数）；无则退回默认 3500。
  *  字数区间按目标动态生成（±15%，取整到百位），避免系统提示词与设置互相冲突。
  *  `lengthRule` 可覆盖第 1 条字数要求（整章修订/改编时按原文长度为准）。 */
-function writeSystemPrompt(project: ProjectState, targetChars?: number, lengthRule?: string): string {
+function writeSystemPrompt(project: ProjectState, targetChars?: number, lengthRule?: string, beforeChapter?: number): string {
   const bible = project.bible
   const sections: string[] = []
   if (bible !== undefined) {
@@ -800,6 +903,26 @@ function writeSystemPrompt(project: ProjectState, targetChars?: number, lengthRu
   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')
 }
 
@@ -819,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 = ''
@@ -861,6 +990,19 @@ 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
       ? (() => {
           // 从最近章节摘要动态生成「已发生事件禁令」，不绑定任何特定书
@@ -868,10 +1010,33 @@ export async function planChapters(
           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 + ' 章摘要），后续章节**绝对不得重写或重复**：\n' + eventLines.join('\n')
+            ? '以下情节已在已有章节中发生过（最近 ' + eventLines.length + ' 章摘要）' + scopeNote + '，后续章节**绝对不得重写或重复**：\n' + eventLines.join('\n')
             : '已有章节的剧情不得重写或重复（无章节摘要时以编年录为准）。'
-          return '【续写硬性要求】已有章节的剧情不得重写或重复，章节标题也不得与已有章节重复。' + NL + eventsText + NL + '若本次规划已进入大纲的收尾区间（接近全书规划总章数），最后 5-10 章必须按大纲推进到大结局（终极抉择/清算/双结局等），**禁止以悬念、逃离、未解之谜收尾**——收尾区间按大纲卷定位判断，不以当前剧情是否"感觉像结尾"为准。'
+          // 位置感知：把「全书总章数 / 当前所处卷 / 距收尾还有多远」算清楚直接喂给模型。
+          // 原先只模糊地说「接近全书规划总章数」，模型看到近期剧情是高光就自己收尾了
+          // （实测：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 !== ''
@@ -894,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
@@ -911,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),
@@ -918,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) {
@@ -926,6 +1118,29 @@ 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. */
@@ -944,8 +1159,10 @@ function reviewSystemPrompt(project: ProjectState): string {
     '8. 呈现方式：整章是否纯内心推理铺陈（无对话/无对抗，推理全靠解说）；反派是否纯背景板无行动；重要配角是否无名标签化（瘦高个/灰衣人全程代称）——命中即列为问题。',
     '9. 内容合规（最高优先级）：逐条核对下方「内容合规红线」，任何一条命中（含影射、暗示、详细描写）必须列为 high，并给出改写建议。',
     '输出必须是合法 JSON 对象，不要输出任何其他文字：',
-    '{"score": 0-100的整数, "verdict": "一句话总评", "issues": [{"severity": "high|medium|low", "dimension": "character|setting|redline|writing|pacing|logic|anti-ai|presentation|compliance", "item": "问题描述", "suggestion": "修改建议"}]}',
-    '维度 dimension 与上方 9 个审查维度一一对应：人设=character、设定=setting、红线=redline、文笔=writing、节奏=pacing、逻辑=logic、反AI=anti-ai、呈现=presentation、合规=compliance。每条 issue 都必须填 dimension。',
+    '{"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 结果本身，不要把思考过程写在输出里。',
   ]
@@ -980,9 +1197,9 @@ 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)
@@ -998,8 +1215,8 @@ export async function reviewChapter(
     '==================== 章节正文 ====================',
     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) })
-  const raw = parseJsonObject<{ score?: unknown; verdict?: unknown; issues?: unknown; resolvedIds?: unknown; unresolvedIds?: unknown }>(text)
+  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)
@@ -1012,10 +1229,19 @@ export async function reviewChapter(
             : 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
+  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)
@@ -1023,8 +1249,14 @@ export async function reviewChapter(
   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
@@ -1061,7 +1293,7 @@ export async function reviewChapterText(
   ].join('\n')
   // 验证模式：携带上一轮报告时，逐条核对原意见是否解决 + 只挑新增 high，不再全新找茬。
   const system = previousReport !== undefined ? verifySystemPrompt(project) : reviewSystemPrompt(project)
-  const raw = parseJsonObject<{ score?: unknown; verdict?: unknown; issues?: unknown; resolvedIds?: unknown; unresolvedIds?: unknown }>(
+  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)
@@ -1076,10 +1308,19 @@ export async function reviewChapterText(
             : 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
+  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)
@@ -1102,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(),
   }
 }
@@ -1140,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')
@@ -1188,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) }),
   )
@@ -1196,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) : '',
@@ -1204,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(),
   }
 }
@@ -1218,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 = [
     '你是一位网文剧情架构师。根据本书的大纲、卷计划、已写章节标题与编年录，为作者提炼建议的剧情线（主线/支线/人物线/悬念线）。',
@@ -1265,7 +1522,7 @@ export async function suggestPlotlines(ctx: Context, config: NovelConfig, projec
   return lines
 }
 
-/** AI 刷新单条剧情线的进度：结合编年录与各章摘要分析该线推进到哪。 */
+/** 刷新单条剧情线的进度：结合编年录与各章摘要分析该线推进到哪。 */
 export async function refreshPlotlineProgress(
   ctx: Context,
   config: NovelConfig,
@@ -1296,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,
@@ -1384,7 +1641,8 @@ export async function extractRoles(
       : '',
     '只输出 JSON 数组。',
   ].join('\n\n')
-  let text = await complete(ctx, config, { system, user, temperature: 0.3, maxTokens: Math.max(config.maxTokens, 16000), 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 < 6
@@ -1395,7 +1653,7 @@ export async function extractRoles(
       : tooFew
         ? '\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, 12000), 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'])
@@ -1465,135 +1723,7 @@ export async function extractRoles(
   return roles
 }
 
-/** ✨ AI 从全书提炼场景库：正文/编年录 → 高频重要场景的结构化视觉锚点。 */
-export async function extractScenes(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  chapterNo?: number,
-  styleId?: string,
-  filterId?: string,
-): Promise<SceneCard[]> {
-  const styleWords = styleKeywords(styleId, filterId)
-  const chapterLabel = chapterNo !== undefined ? '第' + chapterNo + '章' : '全书'
-  const system = [
-    '你是一位网文漫剧场景导演。根据指定章节的正文，提炼「镜头场景」——漫剧分镜/生图时每个镜头要知道"在哪、什么时间光态、拍什么情节、人物什么状态"。',
-    '当前提取范围：' + chapterLabel + '。只提炼本章实际出现的场景，不要提前提取后续章节的场景。',
-    '【当前视觉风格】（moment/palette/moods/zh/en 必须按此风格措辞，不能写中性描述）：' + styleWords,
-    '重要：每个场景的 zh 提示词段首必须原样嵌入【当前视觉风格】词块原文；en 提示词末尾追加风格标签。不得省略或改写。',
-    '每个场景必须是「镜头场景」而非仅场地：给出该场景的关键情节镜头（人物动作+情绪+镜头推进，只写进 beats，禁止写进 zh）；场景生图提示词 zh/en 必须是无人空镜。',
-    '数量控制：本章输出 3-5 个场景；每个场景必须能对应到本章正文实际出现过的地点与情节，不得凭空虚构。',
-    '每个场景输出：',
-    '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：依据来源说明（哪几章哪些描写）。',
-
-    '14. tier：场景分级——core（核心场景，反复出现≥3次或多章引用，需精修多图）/ secondary（次要场景，出现1-2次，一张全景图够）/ passing（路过场景，只被提到名字，不做图）。按出场重要性自动判断。',
-    '15. negativePrompt：负面提示词（场景专用，必须包含 no people, no characters, no text, no watermark, no logo，可补充场景相关负面词）。',    '若本章存在关键转折或抉择，最后 1 个场景应为「转折场景」，beats 里写明关键画面（禁止写进 zh）。',
-    '输出必须是合法 JSON 数组，不要输出其他文字：[{"name":"...", "act":"...", "moment":"...", "summary":"...", "beats":[...], "characterState":"...", "elements":[...], "palette":[...], "moods":[...], "zh":"...", "en":"...", "tags":[...], "source":"...", "tier":"...", "negativePrompt":"..."}]',
-    '重要：所有字符串值内部不得包含换行符；直接输出 JSON 结果本身。',
-  ].join('\n')
-  const targetChapters = chapterNo !== undefined
-    ? project.chapters.filter(c => c.no === chapterNo && c.status !== 'pending' && c.status !== 'generating')
-    : project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating').slice(0, 4)
-  const excerptParts: string[] = []
-  for (const chapter of targetChapters) {
-    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, 3000))
-  }
-  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, 32000), 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),
-
-      tier: (['core', 'secondary', 'passing'] as const).includes(str(entry.tier) as any) ? (str(entry.tier) as 'core' | 'secondary' | 'passing') : 'secondary',
-      negativePrompt: str(entry.negativePrompt) !== '' ? str(entry.negativePrompt).slice(0, 300) : 'no people, no characters, no text, no watermark, no logo, no subtitles, blurry, low quality, distorted, deformed',      styleId,
-    })
-  }
-  // 本地统计出场章节：自动补 tier 和 appearsInChapters（不依赖 LLM 判断，更准确）
-  const sceneShort = (n: string): string => n.split('·')[0].split('（')[0].split('(')[0].trim()
-  const writtenChapters = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating')
-  for (const sc of scenes) {
-    const appears: number[] = []
-    const short = sceneShort(sc.name)
-    for (const ch of writtenChapters) {
-      const body = readChapterFile(config.outputDir, ch)
-      if (body === undefined) continue
-      if (body.includes(sc.name) || (short.length >= 2 && body.includes(short))) {
-        if (!appears.includes(ch.no)) appears.push(ch.no)
-      }
-    }
-    appears.sort((a, b) => a - b)
-    sc.appearsInChapters = appears.length > 0 ? appears : sc.appearsInChapters
-    // tier 兜底：LLM 没给或给了 passing 但实际有出场时，按出场数重算
-    if (sc.tier === undefined || (sc.tier === 'passing' && appears.length > 0)) {
-      sc.tier = appears.length >= 3 ? 'core' : appears.length >= 1 ? 'secondary' : 'passing'
-    }
-    // negativePrompt 兜底
-    if (sc.negativePrompt === undefined || sc.negativePrompt === '') {
-      sc.negativePrompt = 'no people, no characters, no text, no watermark, no logo, no subtitles, blurry, low quality, distorted, deformed'
-    }
-  }
-  // 去重：与已有场景短名重复的 candidate 不返回（避免多次提取后累积重复）
-  const existingShorts = new Set((project.scenes ?? []).map(s => sceneShort(s.name)))
-  let deduped = scenes.filter(sc => !existingShorts.has(sceneShort(sc.name)))
-  // 数量控制：core≤5, secondary≤5, passing≤2，总计≤10
-  const coreScenes = deduped.filter(s => s.tier === 'core').slice(0, 5)
-  const secondaryScenes = deduped.filter(s => s.tier === 'secondary').slice(0, 5)
-  const passingScenes = deduped.filter(s => s.tier === 'passing').slice(0, 2)
-  deduped = [...coreScenes, ...secondaryScenes, ...passingScenes]
-  // 落盘：把每个场景的中文生图提示词写入资产库 manga-assets/场景/场景名/提示词.txt
-  for (const sc of deduped) {
-    try { saveMangaScenePrompt(config.outputDir, sc.name, sc.zh, sc.negativePrompt) } catch { /* 落盘失败不阻塞 */ }
-  }
-  return deduped
-}
-
-
-
-
-/** 从 txt/md 全本文本拆章（纯逻辑，不落盘）：识别章节头、剥离重复标题、去重、排序并统一重新编号。 */
+/**  AI 从全书提炼场景库：正文/编年录 → 高频重要场景的结构化视觉锚点。 */
 export function splitBookText(raw: string): Array<{ no: number; title: string; body: string }> {
   const lines = raw.split(/\r?\n/)
   // 拆章：中文「第X章/回/节/卷」、中文数字章节（一、二、三…）、特殊章节（序章/楔子/尾声/番外…）、英文 Chapter N（均可带 # 前缀）。
@@ -1705,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()
@@ -1723,617 +1853,7 @@ 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
-  /** 即梦/生图通用负面提示词。 */
-  negativePrompt?: string
-  /** 该角色所需情绪表情清单（6-12 个，如 疲惫/麻木/压抑悲伤）。 */
-  expressions?: string[]
-  /** 四类精修提示词（立绘/四视图/表情/细节，一次提炼直接产出）。 */
-  promptKit?: RoleRecord['promptKit']
-}
-
-/** 可提炼形象的「角色源」：小说角色卡或漫剧角色卡的最小公共面。 */
-interface RoleVisualSource {
-  name: string
-  identity?: string
-  traits?: string[]
-}
-
-/**
- * 底层实现：为任意角色源提炼「动漫形象描述词」（不写库，写库由上层调用方负责）。
- * 扫描该角色出场的已写章节正文，截取含外貌描写的段落，交给 LLM 提炼中文描述 + 英文绘图标签。
- */
-async function extractRoleVisualFrom(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  role: RoleVisualSource,
-  styleId?: string,
-  filterId?: string,
-  shortDrama = false,
-  tier: 'protagonist' | 'supporting' | 'extra' = 'protagonist',
-): 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)
-  const system = [
-    '你是一位动漫角色设定师与 AI 绘图提示词工程师。根据网文正文中该角色的实际外貌描写，输出「形象锚点」与「四类生图提示词」——一次完成，用于 AI 绘图（NovelAI / Stable Diffusion / Midjourney / 豆包等）生成一致的角色立绘。',
-    '【当前视觉风格】（portrait 立绘的「风格」字段必须原样使用，sheet/expressions/details 同样内嵌）：' + styleWords,
-    '重要：每段 zh 提示词的段首必须原样嵌入【当前视觉风格】词块原文；en 提示词末尾追加风格标签。不得省略或改写。',
-    '硬性要求（依据优先）：',
-    '1. 发色/发型/瞳色/服装/气质/标志物必须来自提供的正文段落，不得凭空发明。',
-    '2. 正文未明确写到的项目（如瞳色没写、身高没写），用「未定」标注或直接不写，不要编造数值。',
-    '3. 服装优先取正文明确出现的（颜色+款式），多次出现取最常穿的组合；服装按分件组织（上身/下身/鞋/配饰）。',
-    '4. 标志物（标签/印记/饰品）必须出现在每段提示词中——它们是一致性的命根子。',
-    '5. 立绘/四视图/细节是「角色设定稿」：禁止写瞬间动作与道具使用状态（握手机、看屏幕、未接来电、走路、回头等），禁止写剧情状态与场景背景；只保留可长期存在的外貌、服装与常驻标志物（工牌、饰品等）。',
-    ...(shortDrama ? ['6. 短剧精简模式·人设极致化：性格标签必须极致化（如「极端偏执」「绝对冷血」，单一维度拉到最满）；外貌只保留 1-2 个最强辨识度点，弱化平凡细节；服装/标志物更夸张醒目。'] : []),
-    ...(tier === 'supporting' ? ['配角模式：只需输出立绘提示词(portrait)，不需要四视图/表情/细节，外貌描述精简到80字以内。'] : []),
-    ...(tier === 'extra' ? ['路人模式：不需要输出精修提示词(promptKit)和表情清单(expressions)，只需基础外貌描述(40字以内)和英文标签。'] : []),
-    '【本书视觉规则】（必须内嵌进每段提示词，保证设定不跑偏）：',
-    ...rules.map(r => '- ' + r),
-    '输出六部分：',
-    '- zh：中文形象锚点，一段连贯文字（60-150 字）：发色发型、瞳色、脸型气质、服装（颜色款式）、身材、标志性物件。',
-    '- en：英文形象锚点，booru 风格、逗号分隔、小写，30-50 个标签：含性别（1boy/1girl）、发色、发型、瞳色、服装、气质、标志物。不要输出负面提示词。',
-    '- tags：中文关键标签数组，5-10 个（如 ["黑发","束发","青色道袍","清秀","腰悬古玉"]）。',
-    '- source：说明依据（如"第1章/第8章外貌描写；瞳色未明确"）。',
-    '- negativePrompt：即梦/生图通用负面提示词，中文逗号分隔，8-12个词：必须包含 低质量、模糊、变形、多指、断肢、文字、水印、丑陋、比例失调；可根据角色补充（如写实风加 卡通）。',
-    '- expressions：该角色在本书剧情中需要的情绪表情清单数组，6-12 个（如 ["疲惫","麻木","压抑悲伤","皱眉","紧绷","放空"]），依据正文情绪描写与角色处境推断。',
-    '- promptKit：四类精修提示词（字段化+出图约束，参考示例结构）：',
-    '  · portrait 立绘：严格按字段顺序写（参考示例结构）：开头构图定位（正面站立全身人像）→ 风格（3D动漫，超精细建模）→ 背景（纯白纯色背景）→ 身份（男子，{角色名}，外表{年龄}，男性）→ 发型发色 → 胡茬 → 眼眸 → 面部 → 气质 → 上身服装分件（颜色款式+磨损细节）→ 下身 → 鞋 → 标志物（标签/印记，含细节如洇暗翘边）→ 收尾（角色设计稿，细节完整展示，无多余杂物，全身完整无裁切）。',
-    '  · sheet 角色设定稿：专业角色设计参考图（character design sheet），纯白背景，最高品质细节丰富。结构：1.主视觉区（上方）：正面+侧面+背面三视图，直观呈现整体身形、服饰搭配和标志性特征；2.补充信息区（左侧）：面部特写+配色板（明确毛发/服饰色值），补充主视角没覆盖的细节与色彩标准；3.局部细节区（底部）：小模块单独展示关键部件设计（配饰、点缀、关键身份识别元素），把模糊细节拆分为精准制作参考；4.全身比例照（右侧）：黄金比例参考物与人物身高形成对比。画质要求：8K高清纹理，质感光照，自然光线，布料褶皱自然，皮肤纹理细节完整，艺术写实风格，营造震撼视觉效果。人物外观设定按字段：年龄、性别、发型发色、五官（眉/眼/鼻/唇）、脸型、身高、气质、服装分件、标志物。',
-    '  · expressions 表情：每个表情一段，脸部特写（头部到锁骨），纯白背景，五官与角色定稿完全一致，只换情绪表达（眼神/嘴角/眉），皮肤纹理细节完整，无多余杂物。',
-    '  · details 细节：多组局部细节集合参考图（一张图多个局部框），纯白背景；把该角色全部标志物逐项列出（如标签/印记/工牌/袖口磨损/鞋），每项一句特写描述；细节清晰锐利，角色细节参考稿，无多余杂物。',
-    'promptKit 每段 zh：连贯中文 60-150 字；en：booru 标签 30-50 个。',
-    '输出必须是合法 JSON 对象：{"zh": "...", "en": "...", "tags": [...], "source": "...", "negativePrompt": "...", "expressions": [...], "promptKit": {"portrait": {"zh":"...", "en":"..."}, "sheet": {"zh":"...", "en":"..."}, "expressions": [{"name":"疲惫","zh":"...","en":"..."}], "details": {"zh":"...", "en":"..."}}}',
-    '重要：所有字符串值内部不得包含换行符，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 对象。',
-  ].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; negativePrompt?: 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 defaultNegative = '低质量,模糊,变形,多指,断肢,文字,水印,丑陋,比例失调'
-  const negativePrompt = (typeof raw.negativePrompt === 'string' && raw.negativePrompt.trim() !== '') ? raw.negativePrompt.trim().slice(0, 300) : defaultNegative
-  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 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: promptKit.portrait !== undefined ? withStyle(promptKit.portrait, styleWords) : undefined,
-      sheet: promptKit.sheet !== undefined ? withStyle(promptKit.sheet, styleWords) : undefined,
-      expressions: promptKit.expressions !== undefined ? promptKit.expressions.map(e => ({ ...e, ...withStyle(e, styleWords) })) : undefined,
-      details: promptKit.details !== undefined ? withStyle(promptKit.details, styleWords) : undefined,
-    }
-  }
-  // 按角色级别过滤输出深度：主角完整 / 配角仅立绘 / 路人仅基础描述
-  if (tier === 'supporting') {
-    return { zh: zh.slice(0, 100), en, tags, source, negativePrompt, expressions: [], promptKit: promptKit !== undefined ? { portrait: promptKit.portrait } : undefined }
-  }
-  if (tier === 'extra') {
-    return { zh: zh.slice(0, 60), en, tags, source, negativePrompt, expressions: [], promptKit: undefined }
-  }
-  return { zh, en, tags, source, negativePrompt, 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)
-}
-
-/** 漫剧角色卡：提炼形象锚点并写回漫剧卡（status → anchored）。 */
-export async function extractMangaRoleVisual(
-  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.tier ?? 'protagonist')
-  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()
-
-    try { saveMangaRolePrompt(outputDir, card.name, visual.zh, visual.en, visual.negativePrompt) } catch { /* 资产库保存失败不阻塞 */ }
-  return visual
-}
-
-/** 可精修提示词包的「角色源」：小说角色卡或漫剧角色卡的最小公共面。 */
-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,
-  tier: 'protagonist' | 'supporting' | 'extra' = 'protagonist',
-): 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 立绘：正面站立全身人像，纯白纯色背景；按即梦官方7维度公式组织：①[年龄/种族]具体岁数+国籍/人种+风格形容词+脸型名词；②[肤色/皮肤质感]冷暖色调+具体肤色+皮肤质感形容词+保留真实微细毛孔与肌肤纹理；③[面部细节特征]眼型+眉骨+鼻梁+唇形+下颌线（至少3-4点组合）；④[眼神/灵魂]眼神形容词+目光传达的信息+透出的底层情绪；⑤[发型/发色]具体发色+头发状态/质感+具体发型+环境互动；⑥[服装/服装质感]版型/剪裁+颜色+具体服装名词+布料材质/新旧状态+穿着细节；⑦[体型/情绪/气质]骨架/肩部特征+整体散发的氛围词。收尾：角色设计稿，细节完整展示，无多余杂物，全身完整无裁切。',
-    '2. expressions 表情（高级可选）：每个表情一段，脸部特写（头部到锁骨），纯白背景，五官与角色定稿完全一致，只换情绪表达（眼神/嘴角/眉），皮肤纹理细节完整，无多余杂物。',
-    '3. 立绘为「角色设定稿」：禁止瞬间动作、道具使用状态与剧情状态（握手机、看屏幕、未接来电等），只保留可长期存在的外貌、服装与常驻标志物（工牌、饰品等）。即梦画布多角度编辑可生成侧面/背面，无需生成四视图。',
-    ...(shortDrama ? ['6. 短剧精简模式·人设极致化：性格标签必须极致化（单一维度拉到最满）；外貌只保留 1-2 个最强辨识度点；服装/标志物更夸张醒目，一眼可认。'] : []),
-    '【本书视觉规则】（必须内嵌进每段提示词，保证设定不跑偏）：',
-    ...rules.map(r => '- ' + r),
-    'zh 要求：连贯中文，写实电影感，60-150 字/段；en 要求：booru 风格逗号分隔标签，30-50 个/段。',
-    '输出必须是合法 JSON 对象：{"portrait": {"zh": "...", "en": "..."}, "expressions": [{"name": "疲惫", "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),
-    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),
-  }
-  if (kit.portrait === undefined || kit.portrait.zh === '' || kit.portrait.en === '') {
-    throw new Error('提示词精修失败：LLM 未返回有效 JSON')
-  }
-  // 按角色级别过滤精修包：主角立绘+表情 / 配角仅立绘 / 路人不输出
-  if (tier === 'supporting') return { portrait: kit.portrait }
-  if (tier === 'extra') return {}
-  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.tier ?? 'protagonist')
-  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 => {
-      const card = (project.mangaRoles ?? []).find(c => c.name === n || c.sourceRoleName === n)
-      return {
-    rawName: n,
-    verdict: 'already_imported' as const,
-    matches: [],
-    tier: card?.tier ?? 'supporting',
-    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'),
-    '==== 全书角色库（身份代称归属判定以这里为准，正式名只能从这里取） ====\n' + roles.map(r => `${r.name}（${r.roleLabel}）：${r.identity ?? ''}；特征：${(r.traits ?? []).slice(0, 3).join('/')}`).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)
-    : []
-
-  // 智能分级：根据小说角色库 roleLabel + LLM 给出的 coreFunction 判断 tier
-  const calcTier = (rawName: string, matched: string | undefined, fn: MangaRoleCard['coreFunction']): 'protagonist' | 'supporting' | 'extra' => {
-    if (matched !== undefined) {
-      const r = roles.find(x => x.name === matched)
-      if (r?.roleLabel === 'protagonist' || r?.roleLabel === 'female_lead') return 'protagonist'
-      if (r?.roleLabel === 'antagonist') return 'protagonist'
-      if (r?.roleLabel === 'support' || r?.roleLabel === 'female_support') return 'supporting'
-    }
-    if (fn === 'protagonist') return 'protagonist'
-    // 核心反派 / 感情线 → 主角级定妆（完整立绘+表情+细节），否则反派容易跨镜头崩脸。
-    if (fn === 'antagonist' || fn === 'love_interest') return 'protagonist'
-    // 功能性 / 出场即死 → 不做立绘。
-    if (fn === 'functional') return 'extra'
-    return 'supporting'
-  }
-  const out: MangaRoleCandidate[] = []
-  for (const item of shortlists) {
-    const judge = byName.get(item.rawName)
-    const judgeVerdict = judge !== undefined ? str(judge.verdict) : ''
-    let 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) || roles.some(r => r.name === chosen))) roleName = chosen
-    }
-    if (verdict === 'matched' && roleName === undefined && item.roleNames.length === 1) roleName = item.roleNames[0]
-    // LLM 从全书库认出代称对应正式角色（如「持枪男人」→「周野」）时，即使候选名单为空也视为 matched，不再漏。
-    if (roleName !== undefined && verdict === 'not_in_library') verdict = 'matched'
-    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,
-      tier: calcTier(item.rawName, roleName, suggested.coreFunction),
-      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,
@@ -2393,7 +1913,7 @@ export async function suggestOutlines(
 }
 
 /** 拆书分析：对已写章节做结构/人物/文风/卖点四维体检。
- *  两阶段管道（借鉴 AI-Novel-Writing-Assistant）：
+ *  两阶段管道（先抽取候选、再落库）：
  *  ① 源片段笔记：每章抽取结构化笔记（剧情/人物/设定/写法/卖点/短板信号）
  *  ② 分节分析：按维度各跑一次 LLM，输出可读分析稿 + 结构化数据 + 证据链。
  *  @param scope 'recent'(默认最近20章) | 'volume:N' | 'all'
@@ -2417,7 +1937,7 @@ export async function breakdownBook(
     const v = Number(scope.slice(7))
     selected = written.filter(c => c.volume === v)
   }
-  if (selected.length === 0) throw new Error('没有可分析的已写章节（需要已生成并带摘要）')
+  if (selected.length === 0) throw new NovelActionError('contract', '没有可分析的已写章节（需要已生成并带摘要）')
 
   // 2. token 预算：估算每章正文+摘要成本，超预算则只取最近的章节。
   let budget = budgetTokens
@@ -2590,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)
@@ -2651,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 */ }
@@ -2766,14 +2300,7 @@ export async function registerLlmModel(ctx: Context, req: AddModelRequest): Prom
   return { ok: true, saved, provider: route, message }
 }
 
-/** 获取当前激活漫剧方案的风格（styleId + filterId），用于生图/提示词兜底。 */
-export function getActiveMangaStyle(project: ProjectState): { styleId?: string; filterId?: string } {
-  const active = (project.mangaPlans ?? []).find(p => p.active === true)
-  if (active === undefined) return {}
-  return { styleId: active.styleId, filterId: active.filterId }
-}
-
-/** 🩺 剧情健康检查：基于已写章节数/各线状态/编年录，判断是否需要新线及添加时机。 */
+/**  剧情健康检查：基于已写章节数/各线状态/编年录，判断是否需要新线及添加时机。 */
 export async function analyzePlotlineHealth(
   ctx: Context,
   config: NovelConfig,
@@ -2832,7 +2359,7 @@ export async function analyzePlotlineHealth(
   }
 }
 
-/** ✨ AI 剧情方案：基于健康检查结果设计下一阶段方向与建议新线。 */
+/**  剧情方案：基于健康检查结果设计下一阶段方向与建议新线。 */
 export async function designPlotlinePlan(
   ctx: Context,
   config: NovelConfig,
@@ -2892,9 +2419,9 @@ export async function designPlotlinePlan(
 }
 
 /** Build the rewrite system prompt (fix review issues / instructions). */
-function rewriteSystemPrompt(project: ProjectState, targetChars?: number): string {
+function rewriteSystemPrompt(project: ProjectState, targetChars?: number, beforeChapter?: number): string {
   // 整章修订以「与原文相当」为准，不套用目标字数区间（避免与原文长度冲突）。
-  const base = writeSystemPrompt(project, targetChars, '1. 输出完整的新正文（不要只输出修改片段、标题、章回名、作者的话或任何 Markdown 标记），字数与原章相当（允许 ±20%）。')
+  const base = writeSystemPrompt(project, targetChars, '1. 输出完整的新正文（不要只输出修改片段、标题、章回名、作者的话或任何 Markdown 标记），字数与原章相当（允许 ±20%）。', beforeChapter)
   return base + '\n\n额外要求：你正在【修订】一章已写好的正文。保留原文中好的部分，只修改需要修改的地方，输出完整的新正文（不要只输出修改片段），字数与原文相当。'
 }
 
@@ -2914,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')
@@ -2935,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]!,
@@ -2965,7 +2492,7 @@ export async function* rewriteChapterStream(
       ].filter(line => line !== '').join('\n')
 
   const system = localTarget === undefined
-    ? rewriteSystemPrompt(project, chapter.targetChars || config.chapterChars)
+    ? rewriteSystemPrompt(project, chapter.targetChars || config.chapterChars, chapter.no)
     : (() => {
         // 局部修订：补齐合规红线/本书红线/反AI规则/角色卡，加「只改表达不改情节」约束
         const bible = project.bible
@@ -3010,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('修订结果过短，可能失败，请重试')
 
@@ -3083,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' },
@@ -3102,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('润色结果过短，可能失败，请重试')
 
@@ -3130,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,
@@ -3139,7 +2710,7 @@ export async function* generateChapterStream(
   chapterNo: number,
 ): 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).
@@ -3199,9 +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')}`
@@ -3228,9 +2812,9 @@ export async function* generateChapterStream(
   })]
   const request: GenerateOptions = {
     provider: config.provider,
-    model: config.model,
+    model: config.generateModel || config.model,
     messages,
-    system: writeSystemPrompt(project, chapter.targetChars || config.chapterChars),
+    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),
@@ -3239,50 +2823,99 @@ export async function* generateChapterStream(
 
   yield { frame: 'start' }
 
-  const assembler = new BlockAssembler()
+  const primaryModel = request.model ?? config.model
+  let body = ''
   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 }
+  // 最多两次尝试：主模型 → （未产出任何文字且失败可重试时）备用模型。
+  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 }
+      }
     }
+    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 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('生成内容过短，可能失败，请重试')
 
+  // 字数口径统一为「汉字数」（与每章字数红线一致）。不足目标 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)
+  }
+
+  // 覆盖前留存历史版本：重新生成把好稿改坏时可以回滚（首次生成无旧稿，不产生空快照）。
+  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 = body.length
+  chapter.chars = hanzi
   chapter.file = fileName
   chapter.error = undefined
   project.updatedAt = new Date().toISOString()
   saveProject(outputDir, project)
 
-  const target = chapter.targetChars > 0 ? chapter.targetChars : config.chapterChars
   const warn = target > 0
-    ? (body.length < target * 0.8
-        ? `第${chapter.no}章实际 ${body.length} 字，明显少于目标 ${target} 字`
-        : body.length > target * 1.25
-          ? `第${chapter.no}章实际 ${body.length} 字，明显多于目标 ${target} 字`
+    ? (hanzi < target * 0.85
+        ? `第${chapter.no}章实际 ${hanzi} 汉字，少于目标 ${target} 汉字`
+        : hanzi > target * 1.25
+          ? `第${chapter.no}章实际 ${hanzi} 汉字，多于目标 ${target} 汉字`
           : undefined)
     : undefined
-  yield { frame: 'done', file: fileName, chars: body.length, warn }
+  yield { frame: 'done', file: fileName, chars: hanzi, warn }
 }
 
 /** Generate a chapter summary (narrative memory). */
@@ -3294,9 +2927,9 @@ export async function summarizeChapter(
   chapterNo: number,
 ): 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 = [
     '你是一位网文编辑。请为下面一章写一段 120-200 字的摘要，供后续章节写作时保持连贯性。',
     '摘要必须包含：本章发生的关键事件、主角状态变化（境界/资源/伤势/心境）、新增的伏笔或线索、角色关系变化。',
@@ -3309,484 +2942,6 @@ export async function summarizeChapter(
   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 sceneShortName = (n: string): string => n.split('·')[0].split('（')[0].split('(')[0].trim()
-  const usedScenes = (project.scenes ?? []).filter(s => body.includes(s.name) || body.includes(sceneShortName(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)
-
-  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 动漫超精细建模质感）')
-
-  const system = [
-    '你是一位从业 10 年的电影导演兼分镜师，专长网文改编影视化。',
-    '任务：把「剧情骨架」的每一个节拍展开为 1-3 个电影镜头，输出分镜表——只做画面层，禁止新增或改变剧情（骨架是只读输入）。',
-    '输出合法 JSON 对象：{"shots": [{"beatId": "骨架节拍id", "shot": "景别", "camera": "机位与运镜", "composition": "构图", "duration": 秒数, "visual": "画面内容", "line": "台词/旁白", "sound": "音效", "light": "光效", "prevState": "承接上一镜头结尾状态", "nextState": "本镜头结束状态", "jimengCamera": "即梦运镜自然语言描述", "characters": ["出镜角色名"]}]}',
-    '景别取值（只能从这些词中选一）：大远景/远景/全景/中景/中近景/近景/特写/大特写。',
-    '运镜取值（可组合，用加号连接）：固定机位/推近/拉远/左摇/右摇/左横移/右横移/跟随/升镜/降镜/环绕/手持晃动/低机位仰拍/高机位俯拍/过肩镜头。',
-    '光效取值（可组合，用加号连接）：顺光/侧光/逆光/顶光/伦勃朗光/霓虹光/硬光/柔光/氛围光/高反差。',
-    '构图取值（可选，只能从这些词中选一）：三分法/中心对称/引导线/前景遮挡/低机位/俯拍/对称构图。',
-    '硬性要求：',
-    '【视觉风格】（必须内嵌进 visual/light 的画面措辞与光效描述）：',
-    ...styleLines,
-    '1. 按骨架节拍顺序输出镜头，每个节拍至少 1 个镜头，总镜头数 8-15。',
-    '2. 镜头间连续：下一镜头的 prevState 必须与上一镜头的 nextState 一致（人物位置/动作/情绪/服装），禁止瞬移、服装消失、情绪跳变。',
-    '3. visual 必须写明：主体位置（左/中/右/前景/背景）+ 角色动作 + 表情 + 服装/标志物（标志物来自下方视觉规则与角色锚点，逐镜头保持）。',
-    '4. 台词/音效/光效无则空字符串，不要编造。',
-    '5. duration 只能取 5/6/7/8/10 五个值（即梦单条视频时长上限）。',
-    '6. 所有字符串值内部不得包含换行符，JSON 必须在一段内完整结束，不要输出其他文字。',
-    '7. 每个镜头必须输出 characters：本镜头出镜角色名数组（1-4 个），从「出场角色锚点」或正文中选取，使用正文里的确切称谓（如「周野」「周野的律师」），禁止自造名/缩写；路人或群像可用身份词（如「围观群众」）。',
-    '8. 人物外观/服装/标志物必须遵守「漫剧定妆卡」与「出场角色锚点」：同一角色逐镜头保持完全一致（服装、发色、标志物禁止更换）；定妆卡未覆盖的路人可用通用描述。',
-    '9. jimengCamera：即梦运镜自然语言描述，必须写具体起止（如「镜头从中景缓慢推进到近景」「镜头从左向右缓慢横移」），禁止只写「推近」「拉远」；静止镜头写「固定机位」。',
-    '10. 单镜只承载一个连续动作，动作必须在5-10秒内可完成；禁止复杂打斗、多人群舞、快速切换场景。',
-    '11. 画面禁止出现任何文字、字幕、水印、符号、UI界面、屏幕显示内容。',
-    '12. 单镜出镜角色不超过2个主要角色，多人同框时必须明确谁是画面主体。',
-  ].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: (() => { const d = typeof entry.duration === 'number' ? Math.round(entry.duration) : 0; return [5,6,7,8,10].includes(d) ? d : 6; })(),
-          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),
-          jimengCamera: typeof entry.jimengCamera === 'string' && entry.jimengCamera.trim() !== '' ? entry.jimengCamera.trim().slice(0, 80) : undefined,
-        }))
-        .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
-    }
-    for (const id of ids) {
-      if (!tableRoleIds.includes(id)) tableRoleIds.push(id)
-    }
-  }
-  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,
-  }
-  saveChapterStoryboard(project, outputDir, { chapterNo, table, updatedAt: new Date().toISOString() })
-  return table
-}
-
-/**
- * 提炼常驻道具（跨镜头需一致）：从已写章节正文识别反复出现的关键道具 + 一行统一外观描述。
- * 生成分镜提示词前自动调用，若道具库为空则补齐；道具库存 project.props，注入提示词保持跨镜头一致。
- */
-export async function extractProps(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-): Promise<Prop[]> {
-  const written = project.chapters.filter(c => c.status !== 'pending' && c.status !== 'generating')
-  const excerpt = written.slice(0, 6).map(c => {
-    const body = readChapterFile(config.outputDir, c)
-    return body !== undefined ? '第' + c.no + '章《' + c.title + '》\n' + body.replace(/^#.*$/gm, '').trim().slice(0, 1500) : ''
-  }).filter(s => s !== '').join('\n\n')
-  if (excerpt.length < 200) return []
-  const system = [
-    '你是一位网文漫剧道具导演。从下面的已写章节正文中，识别「常驻道具」——跨多个镜头/场景反复出现、需要保持外观一致的关键道具（如外卖电动车、外卖箱、手机、名片；一次性出现的忽略）。',
-    '每个道具给一行统一外观描述（可辨识、具体的颜色/材质/状态），供每个镜头遵循。',
-    '输出必须是合法 JSON 数组：[{"name":"道具名","desc":"一行统一外观描述"}]，3-8 个。',
-    '重要：字符串内不含换行符；直接输出 JSON 结果本身。',
-  ].join('\n')
-  const text = await complete(ctx, config, { system, user: excerpt, temperature: 0.2, maxTokens: Math.max(config.maxTokens, 8000), reasoning: config.analysisReasoning ?? 'low' })
-  const raw = parseJsonArray<Record<string, unknown>>(text)
-  const props: Prop[] = []
-  for (const e of raw) {
-    if (typeof e !== 'object' || e === null) continue
-    const n = typeof e.name === 'string' ? e.name.trim().slice(0, 20) : ''
-    const d = typeof e.desc === 'string' ? e.desc.trim().slice(0, 120) : ''
-    if (n !== '' && d !== '' && !props.some(p => p.name === n)) props.push({ name: n, desc: d })
-  }
-  return props.slice(0, 8)
-}
-
-/**
- * 分镜·提示词级：分镜表 → 即梦可粘贴视频提示词。
- * 每镜头一段：风格词块（基底+滤镜）+ 画面内容（角色动作/服装标志物）+ 机位运镜 + 光效。
- * 提示词聚焦画面与镜头（视频模型无音频，台词/音效不注入）。
- */
-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)
-  // 常驻道具：道具库为空时从已写章节自动提炼一次并回存，此后跨镜头统一注入
-  let props = project.props ?? []
-  if (props.length === 0) {
-    try {
-      props = await extractProps(ctx, config, project)
-      if (props.length > 0) {
-        project.props = props
-        project.updatedAt = new Date().toISOString()
-        saveProject(config.outputDir, project)
-      }
-    } catch { /* 提炼失败不阻塞生成 */ }
-  }
-  const propsBlock = (props.length > 0)
-    ? '常驻道具（每个镜头必须按此外观/状态呈现，保持跨镜头一致）：\n' + props.map(p => `- ${p.name}：${p.desc}`).join('\n') : ''
-  let accTime = 0
-  const shotLines = table.shots.map(s => {
-    const startSec = accTime
-    const endSec = accTime + s.duration
-    accTime = endSec
-    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}] 时间戳 ${startSec}s-${endSec}s · 节拍${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.jimengCamera !== undefined ? s.jimengCamera : cameraZh(s.camera)}
-承接：${s.prevState} → ${s.nextState}`
-  }).join('\n\n')
-  const system = [
-    '你是一位资深影视分镜提示词工程师，精通即梦 Seedance 2.5 视频生成模型的提示词写法与参数调优。',
-    '任务：把分镜表的每个镜头写成「可直接粘贴到即梦」的视频提示词——精简、只留能生成画面的内容，不要混入给用户的说明/元信息（如模型版本、画幅、参考图是否上传）。',
-    '每镜 text 按以下段序组织（内容精简）：',
-    '① 风格段：' + stylePrefix + '（一句，放最前）。',
-    '② 场景段：写"场景：<地点名> — <环境/光线/氛围>"（如"场景：雨夜道路 — 暴雨积水、昏黄路灯、雨幕"）；场景名标清楚（供用户@对应场景图），不写@。场景名优先复用下方「可用场景名清单」里已有的名字（按镜头地点/氛围就近匹配），只有清单里确实没有该地点时才新建场景名；新建名也要简短、能同时指示地点与氛围。',
-    '③ 人物段：主体写"@角色名"（智能角色，如"@林深"）+ 位置/朝向/简短动作，不写外貌细节（角色一致性靠智能主体多角度），多角色明确谁是主体。',
-    '④ 时间轴段：必须把单镜按动作拆成 2~3 段（每段 3~5s，如"0s-3s / 3s-7s"），每段写清画面+动作+运镜，不要整镜单段；有台词用『台词(声音层)："…"（音色：…）』；音效用 [SFX: …]。',
-    '⑤ 结尾负面：不要字幕、不要水印、禁止变形 + 行为级禁止项（按镜头定）。',
-    ...(getGenreRules((project.mangaPlans ?? []).find(p => p.active)?.genre).length > 0
-      ? ['题材专用规则（本题材必须遵守）：', ...getGenreRules((project.mangaPlans ?? []).find(p => p.active)?.genre).map(r => '- ' + r), '']
-      : []),
-    '题材无关硬性要求：',
-    '1. 台词走声音层，不写进画面提示词当口型（避免即梦硬配口型）；台词用『台词(声音层)："……"（音色：低沉平静）』单独标注在时间轴段，画面描述不重复人声。',
-    '2. 音效用原生 [SFX: 具体音效] 标记（如 [SFX: 雨声，心跳声]），叠在对应时间轴段，禁空泛"震撼音效"。',
-    '3. 时长预算：单镜 4~15s；text 完整覆盖该镜全部秒数，时间轴写起止。',
-    '4. 服装/发色/标志物沿用镜头表、定妆卡、视觉规则，禁止自行更换（同一角色跨镜一致）。',
-    '4b. 若用户给出「常驻道具」清单，每个涉及该道具的镜头必须按清单里那行统一外观/状态呈现（颜色/材质/特征完全一致），禁止换成别的样子；只出现台词不提道具的镜头可忽略。',
-    '5. 每镜主体锚定：画面主体是[角色名]，位于画面[左/中/右/前景]，多角色明确谁是主体。',
-    '6. 高动态/动作镜头：时间轴可细化到 0.5s~1s 微步进（运镜/动作/粒子/环境受力四要素）。',
-    '7. text 结尾含"不要字幕、不要水印、禁止变形"。',
-    '8. 输出合法 JSON 对象：{"prompts": [{"shotId":"s1","text":"...","camera":"...","motion":"low|medium|high","negativePrompt":"...","sceneName":"..."}]}，所有镜头都有，顺序一致。',
-    '9. 字符串内不得含换行符，JSON 必须在一段内完整结束。',
-  ].join('\n')
-  const speechLines = [...bindings.byId.values()]
-    .map(c => `${c.name}：${(c.speechStyle ?? '').trim()}`)
-    .filter(x => !x.endsWith('：'))
-  // 场景库：场景名须与场景库对齐（供用户按名字@场景图）
-  const sceneLibLines = (project.scenes ?? []).map(s => {
-    const moods = (s.moods ?? []).join('、')
-    const extra = (s.moment !== undefined && s.moment !== '' ? '时间光态：' + s.moment : '')
-    const tag = [moods, extra].filter(x => x !== '').join('；')
-    return `- ${s.name}${s.summary !== '' ? '：' + s.summary : ''}${tag !== '' ? '（' + tag + '）' : ''}`
-  })
-  const sceneLibBlock = sceneLibLines.length > 0
-    ? '可用场景名清单（场景名只允许从这里选，或确无此地点时新建）：\n' + sceneLibLines.join('\n') : ''
-  const user = [
-    `章节《${chapter?.title ?? ''}》（第 ${chapterNo} 章）`,
-    rules.length > 0 ? '本书视觉规则（必须遵守）：\n' + rules.join('\n') : '',
-    propsBlock,
-    sceneLibBlock,
-    speechLines.length > 0 ? '出场角色说话方式（写台词音色参考时用）：\n' + speechLines.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))
-  // 实时绑定：用当前漫剧卡库解析每镜角色，不依赖分镜表预存的 mangaRoleIds（角色可能在分镜表之后才导入）
-  const shotBinding = new Map<string, string[]>(table.shots.map(s => {
-    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)
-    }
-    return [s.id, ids]
-  }))
-  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) ?? []
-          const motionVal = typeof entry.motion === 'string' ? entry.motion.trim().toLowerCase() : ''
-          return {
-            shotId,
-            text: ensureStyleEmbedded(typeof entry.text === 'string' ? entry.text.trim().slice(0, 400) : '', stylePrefix, 'zh'),
-            mangaRoleIds: ids.length > 0 ? ids : undefined,
-            camera: typeof entry.camera === 'string' && entry.camera.trim() !== '' ? entry.camera.trim().slice(0, 100) : undefined,
-            motion: motionVal in {'low':1,'medium':1,'high':1} ? motionVal as 'low'|'medium'|'high' : undefined,
-            negativePrompt: typeof entry.negativePrompt === 'string' && entry.negativePrompt.trim() !== '' ? entry.negativePrompt.trim().slice(0, 200) : undefined,
-            sceneName: typeof entry.sceneName === 'string' && entry.sceneName.trim() !== '' && entry.sceneName.trim() !== '（未标注）' ? entry.sceneName.trim().slice(0, 50) : undefined,
-          }
-        })
-        .filter(x => x.shotId !== '' && x.text !== '')
-    : []
-  if (prompts.length === 0) throw new Error('模型未输出有效提示词，请重试')
-  saveChapterStoryboard(project, outputDir, { chapterNo, prompts, updatedAt: new Date().toISOString() })
-  // 落盘：逐镜即梦提示词 → 资产库（manga-assets/分镜脚本/第N章-标题-提示词.md）
-  try {
-    const chTitle = (project.chapters.find(c => c.no === chapterNo)?.title ?? '')
-    const pLines: string[] = []
-    for (const p of prompts) pLines.push('### 镜头 ' + p.shotId + '\n' + (p.text ?? ''))
-    saveMangaChapterPrompts(outputDir, chapterNo, chTitle, pLines.join('\n\n'))
-  } catch { /* 落盘失败不阻塞 */ }
-  // 回写实时绑定到分镜表（直接操作 project 对象，不触发级联清除）
-  const sbEntry = (project.storyboards ?? []).find(e => e.chapterNo === chapterNo)
-  if (sbEntry !== undefined && sbEntry.table !== undefined) {
-    for (const s of sbEntry.table.shots) {
-      const ids = shotBinding.get(s.id) ?? []
-      s.mangaRoleIds = ids.length > 0 ? ids : undefined
-    }
-    project.updatedAt = new Date().toISOString()
-    saveProject(outputDir, project)
-  }
-  return prompts
-}
-
-
-/**
- * 分镜·编剧级：单章 → 剧情骨架（节拍链）。
- * 只做故事层（事件/情绪/功能/因果），不做画面；导演级分镜在其上展开。
- */
-export async function generateStoryboardSkeleton(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
-  outputDir: string,
-  chapterNo: number,
-): Promise<StoryboardSkeleton> {
-  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 = [
-    '你是一位从业 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(),
-  ].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
-}
-
 /**
  * 反向推大纲：从已写章节正文反推出全书总纲（分卷 + 章节要点 + 主线/人物弧线/伏笔清单）。
  * 两阶段：分批提取章节事件摘要 → 汇总生成大纲。不修改章节/设定，只返回大纲文本。
@@ -3802,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
@@ -3863,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 必须忠于文本，能引用原文就用原文（尤其角色名/境界名/势力名/金手指名）。',
@@ -3911,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,
   }
@@ -3957,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> {
@@ -4150,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))
@@ -4250,19 +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 !== undefined ? { ...role.promptKit.portrait, zh: t(role.promptKit.portrait.zh), en: t(role.promptKit.portrait.en) } : undefined,
-        sheet: role.promptKit.sheet !== undefined ? { ...role.promptKit.sheet, zh: t(role.promptKit.sheet.zh), en: t(role.promptKit.sheet.en) } : undefined,
-        expressions: role.promptKit.expressions !== undefined ? role.promptKit.expressions.map(e => ({ ...e, zh: t(e.zh), en: t(e.en) })) : undefined,
-        details: role.promptKit.details !== undefined ? { ...role.promptKit.details, zh: t(role.promptKit.details.zh), en: t(role.promptKit.details.en) } : undefined,
-      }
-      : undefined,
   }))
 }
 
@@ -4341,7 +3494,7 @@ export async function summarizeAndExtractFacts(
         .map(v => v.trim().slice(0, 140))
     : []
   if (summary !== '') chapter.summary = summary
-  const added = dedupAndAddFacts(project, chapterNo, factLines)
+  dedupAndAddFacts(project, chapterNo, factLines)
   project.updatedAt = new Date().toISOString()
   saveProject(outputDir, project)
   return { summary, factCount: factLines.length }
@@ -4476,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) {
@@ -4521,7 +3674,7 @@ export async function auditBook(
   return all.slice(0, 50)
 }
 
-/** 小说简介：AI 生成或按已写开头补全（面向读者的作品门面）。 */
+/** 小说简介：生成或按已写开头补全（面向读者的作品门面）。 */
 export async function generateBlurb(
   ctx: Context,
   config: NovelConfig,
@@ -4716,7 +3869,7 @@ export function renderWorld(world: WorldState | undefined): string {
   return sections.join('\n')
 }
 
-/** AI 提炼大世界：从大纲 + 道藏生成结构化境界体系/区域/势力。 */
+/** 提炼大世界：从大纲 + 道藏生成结构化境界体系/区域/势力。 */
 export async function extractWorld(
   ctx: Context,
   config: NovelConfig,
@@ -4910,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[] = []
@@ -4942,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('写法提取失败：模型没有返回有效规则')
@@ -4960,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. */
@@ -4986,215 +4554,206 @@ export function exportBook(outputDir: string, project: ProjectState, format: 'tx
   return { file, chars: content.length, chapters: done.length }
 }
 
-
-// ==================== 漫剧资产库（manga-assets） ====================
-
-/** 漫剧资产库根目录：outputDir/manga-assets */
-export function mangaAssetsDir(outputDir: string): string {
-  return join(outputDir, 'manga-assets')
-}
-
-/** 确保子目录存在，返回完整路径。 */
-function ensureAssetDir(outputDir: string, ...sub: string[]): string {
-  const dir = join(mangaAssetsDir(outputDir), ...sub)
-  mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-/** 清理文件名中的非法字符。 */
-function safeAssetName(name: string): string {
-  return name.replace(/[\\/:*?"<>|]/g, '_').slice(0, 40)
-}
-
-/** 保存角色定妆图到资产库：manga-assets/角色/角色名/标签.png */
-export function saveMangaRoleImage(outputDir: string, roleName: string, label: string, dataUrl: string): string {
-  const dir = ensureAssetDir(outputDir, '角色', safeAssetName(roleName))
-  const safeLabel = safeAssetName(label !== '' ? label : '定妆图')
-  const file = join(dir, safeLabel + '.png')
-  const base64 = dataUrl.includes(',') ? dataUrl.slice(dataUrl.indexOf(',') + 1) : dataUrl
-  writeFileSync(file, Buffer.from(base64, 'base64'))
-  return file
-}
-
-/** 保存角色提示词到资产库：manga-assets/角色/角色名/提示词.txt */
-export function saveMangaRolePrompt(outputDir: string, roleName: string, zh: string, en: string, negative?: string): string {
-  const dir = ensureAssetDir(outputDir, '角色', safeAssetName(roleName))
-  const file = join(dir, '提示词.txt')
-  const content = [
-    '【正面提示词（中文）】', zh, '',
-    '【正面提示词（英文）】', en, '',
-    negative !== undefined && negative !== '' ? ['【负面提示词】', negative, ''].join('\n') : '',
-  ].filter(x => x !== '').join('\n')
-  writeFileSync(file, content, 'utf8')
-  return file
-}
-
-/** 保存场景底图到资产库：manga-assets/场景/场景名.png */
-export function saveMangaSceneImage(outputDir: string, sceneName: string, label: string, dataUrl: string): string {
-  const dir = ensureAssetDir(outputDir, '场景')
-  const file = join(dir, safeAssetName(sceneName + '-' + label) + '.png')
-  const base64 = dataUrl.includes(',') ? dataUrl.slice(dataUrl.indexOf(',') + 1) : dataUrl
-  writeFileSync(file, Buffer.from(base64, 'base64'))
-  return file
-}
-
-/** 保存分镜即梦脚本到资产库：manga-assets/分镜脚本/第N章-标题.md */
-export function saveMangaStoryboardScript(outputDir: string, chapterNo: number, title: string, markdown: string): string {
-  const dir = ensureAssetDir(outputDir, '分镜脚本')
-  const file = join(dir, '第' + chapterNo + '章-' + safeAssetName(title) + '.md')
-  writeFileSync(file, markdown, 'utf8')
-  return file
-}
-
-/** 保存「即梦素材包」到资产库：manga-assets/素材包/第N章-标题·即梦素材包.md */
-export function saveMangaAssetPackage(outputDir: string, chapterNo: number, title: string, markdown: string): string {
-  const dir = ensureAssetDir(outputDir, '素材包')
-  const file = join(dir, '第' + chapterNo + '章-' + safeAssetName(title) + '·即梦素材包.md')
-  writeFileSync(file, markdown, 'utf8')
-  return file
+/** 逐行渲染「- 名称：值」清单，跳过空值。 */
+function renderPairs(pairs: Array<[string, string | undefined]>): string {
+  return pairs
+    .filter(([, v]) => v !== undefined && v !== '')
+    .map(([k, v]) => `- ${k}：${v}`)
+    .join('\n')
 }
 
-/** 保存场景中文生图提示词到资产库：manga-assets/场景/场景名/提示词.txt */
-export function saveMangaScenePrompt(outputDir: string, sceneName: string, zh: string, negative?: string): string {
-  const dir = ensureAssetDir(outputDir, '场景', safeAssetName(sceneName))
-  const file = join(dir, '提示词.txt')
-  const content = [
-    '【场景生图提示词（中文）】', zh, '',
-    negative !== undefined && negative !== '' ? ['【负面提示词】', negative, ''].join('\n') : '',
-  ].filter(x => x !== '').join('\n')
-  writeFileSync(file, content, 'utf8')
-  return file
+/** 渲染项目设定（卷首语 / 开书定盘 / 总纲 / 道藏 / 大世界 / 写作资产）。 */
+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')
 }
 
-/** 保存逐镜即梦提示词到资产库：manga-assets/分镜脚本/第N章-标题-提示词.md */
-export function saveMangaChapterPrompts(outputDir: string, chapterNo: number, title: string, markdown: string): string {
-  const dir = ensureAssetDir(outputDir, '分镜脚本')
-  const file = join(dir, '第' + chapterNo + '章-' + safeAssetName(title) + '-提示词.md')
-  writeFileSync(file, markdown, 'utf8')
-  return file
+/** 渲染规划（卷计划 + 章节计划）。 */
+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')
 }
 
-// ==================== 一键生成（全自动流水线） ====================
-
-export interface AutoGenerateResult {
-  chapterNo: number
-  skeletonBeats: number
-  shotCount: number
-  promptCount: number
-  importedRoles: number
-  needMakeupRoles: number
-  extraRoles: number
-  pendingCandidates: number
-  pendingRoleNames: string[]
+/** 渲染质检记录（逐章审稿 + 作者复盘 + 暗线 + 剧情线 + 待办）。 */
+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 async function autoGenerateMangaChapter(
-  ctx: Context,
-  config: NovelConfig,
-  project: ProjectState,
+export function exportScope(
   outputDir: string,
-  chapterNo: number,
-  styleId?: string,
-  filterId?: string,
-): Promise<AutoGenerateResult> {
-  // 1. 剧情骨架（已有则跳过）
-  let entry = (project.storyboards ?? []).find(e => e.chapterNo === chapterNo)
-  if (entry === undefined) {
-    entry = { chapterNo, skeleton: undefined, table: undefined, prompts: undefined, updatedAt: new Date().toISOString() }
-    if (project.storyboards === undefined) project.storyboards = []
-    project.storyboards.push(entry)
-  }
-  const sb = entry
-  if (sb.skeleton === undefined) {
-    sb.skeleton = await generateStoryboardSkeleton(ctx, config, project, outputDir, chapterNo)
-  }
-
-  // 2. 分镜表（已有则跳过）
-  if (sb.table === undefined) {
-    sb.table = await generateStoryboardTable(ctx, config, project, outputDir, chapterNo, sb.skeleton, styleId, filterId)
-  }
-
-  // 3. 角色提名
-  const candidates = await nominateMangaRoles(ctx, config, project, outputDir, chapterNo)
-
-  // 4. 为分镜中每个上镜角色建卡，绝不留白：
-  //    matched → 自动定型(imported，用正式角色名)；ambiguous/not_in_library → 建「待确认」卡(pending_confirm，用代为名，供改名映射)。
-  let imported = 0
-  for (const cand of candidates) {
-    if (cand.verdict === 'already_imported') continue
-    // 已导入跳过（按名或来源名）
-    if ((project.mangaRoles ?? []).some(c => c.name === cand.rawName || (cand.matchedRoleName !== undefined && c.sourceRoleName === cand.matchedRoleName))) continue
-    const sug = cand.suggested
-    const matched = cand.verdict === 'matched' && cand.matchedRoleName !== undefined && cand.matchedRoleName !== ''
-    const baseName = (cand.matchedRoleName !== undefined && cand.matchedRoleName !== '' ? cand.matchedRoleName : sug.name) || cand.rawName
-    const name = baseName.trim().slice(0, 30) || cand.rawName.trim().slice(0, 30)
-    // 分级：matched 用脚本 tier（来自 nominate 的 calcTier）；代称/存疑按功能定级，避免把反派/关键角色误降成 extra。
-    const tier: MangaRoleCard['tier'] =
-      cand.tier ?? (sug.coreFunction === 'functional' && cand.matchedRoleName === undefined ? 'extra' : 'supporting')
-    const card: MangaRoleCard = {
-      id: 'mr-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6),
-      sourceRoleName: cand.matchedRoleName,
-      name,
-      identity: sug.identity,
-      coreFunction: sug.coreFunction,
-      protagonistRelation: sug.protagonistRelation,
-      speechStyle: sug.speechStyle,
-      traits: sug.traits,
-      appearance: sug.appearance,
-      keyScenes: sug.keyScenes,
-      appearsInEpisodes: [chapterNo],
-      status: matched ? 'imported' : 'pending_confirm',
-      tier,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    }
-    if (project.mangaRoles === undefined) project.mangaRoles = []
-    project.mangaRoles.push(card)
-    if (matched) imported++
-  }
-
-  // 5. 视频提示词：不在「一键生成」里自动产，留到「分镜·提示词」页生成（角色/场景定妆就绪后再产，@引用才完整）。
-
-  // 落盘：骨架 + 分镜表 → 资产库（manga-assets/分镜脚本/第N章-标题.md）
-  try {
-    if (sb.table !== undefined) {
-      const chTitle = (project.chapters.find(c => c.no === chapterNo)?.title ?? '')
-      const mdLines: string[] = []
-      mdLines.push('# 第' + chapterNo + '章《' + chTitle + '》· 分镜')
-      if (sb.skeleton !== undefined) {
-        mdLines.push('', '## 剧情骨架')
-        mdLines.push('弧线：' + (sb.skeleton.arc ?? ''))
-        for (const b of sb.skeleton.beats ?? []) mdLines.push(`- [${b.id}] ${b.event}（情绪：${emotionZh(b.emotion)}）`)
-      }
-      mdLines.push('', '## 分镜表')
-      for (const s of sb.table.shots ?? []) mdLines.push(`- s${s.id} ${sizeZh(s.shot)} · ${cameraZh(s.camera)} · ${s.duration}s · ${s.visual}`)
-      saveMangaStoryboardScript(outputDir, chapterNo, chTitle, mdLines.join('\n'))
-    }
-  } catch { /* 落盘失败不阻塞 */ }
-
-  project.updatedAt = new Date().toISOString()
-  saveProject(outputDir, project)
-
-  const allCards = project.mangaRoles ?? []
-  const needMakeup = allCards.filter(c => c.tier !== 'extra' && (c.appearsInEpisodes ?? []).includes(chapterNo)).length
-  const extra = allCards.filter(c => c.tier === 'extra' && (c.appearsInEpisodes ?? []).includes(chapterNo)).length
-  const pendingList = candidates.filter(c => c.verdict === 'ambiguous' || c.verdict === 'not_in_library')
-  const pending = pendingList.length
-  const pendingRoleNames = pendingList.map(c => c.rawName).slice(0, 10)
-
-  return {
-    chapterNo,
-    skeletonBeats: sb.skeleton?.beats?.length ?? 0,
-    shotCount: sb.table?.shots?.length ?? 0,
-    promptCount: sb.prompts?.length ?? 0,
-    importedRoles: imported,
-    needMakeupRoles: needMakeup,
-    extraRoles: extra,
-    pendingCandidates: pending,
-    pendingRoleNames,
-  }
-}
+  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 }
+}