@cloud411716/fancy-webnovel 3.0.4 → 4.0.0

package/docs/material-library/README.md

@@ -297,12 +297,13 @@ DEFINE ANALYZER material_zh
 /fancy-material export          导出 <工作区>/素材库.md
 ```
 
-如果 `扫榜结果` 下有多份 `topic_decision_*.md`，不带参数运行时会先弹窗，
-让你选择本次使用哪一份；插件只读取选中的那份文件里的「选题方向」，不会合并
-多个报告。只有一份时自动使用；没有时回退到番茄扫榜题材。
+素材题材只认用户选题链路：
 
-带参数运行（例如 `/fancy-material 地名`）不弹窗，沿用最新的
-`topic_decision` 文件。
+1. `_novel_topic.json`（最终选题）
+2. `_novel_topic_suggestion.json`（扫榜候选方向选择结果）
+3. 两者都没有时，弹框确认后使用内置全题材（番茄男频 + 女频）
+
+不再从 `topic_decision` 里猜题材。
 
 不带参数时，插件会覆盖全部 54 个 kind：
 

package/docs/material-library/prompt.md

@@ -238,8 +238,9 @@ brainstorm         → 给活人打印死亡证明的打印店
 ## 七、题材来源与优先级
 
 - 当前模式：`{{MATERIAL_MODE}}`
-- `topic_decision`：从 `{{TOPIC_FILE}}` 的「选题方向」中提取全部题材。
-- `all_genres`：使用番茄扫榜数据中的全部题材。
+- `topic`：题材来自 `_novel_topic.json`。
+- `suggestion`：题材来自 `_novel_topic_suggestion.json`。
+- `builtin`：没有选题记录，使用内置全题材。
 - 本次题材列表：{{GENRES}}
 
 不同题材优先补充的 kind：

package/docs/workspace-mcp.md

@@ -147,8 +147,8 @@ namespace: fancy
 ### 创作
 
 ```text
-/fancy-topic              # 在工作区读扫榜结果，生成选题建议
-/fancy-topic setup        # 敲定选题 → 创建 projects/<uuid>/ + 项目库 + 用户
+/fancy-topic              # 选 decision 文件、平台和候选方向 → _novel_topic_suggestion.json
+/fancy-topic setup        # 素材驱动生成 5 个候选方案 → _novel_topic.json + 项目库 + 用户
 /fancy-build scale|macro|cast|rhythm|outline|write
 /fancy-export
 ```

package/lib/material-topic.js

@@ -0,0 +1,248 @@
+/**
+ * material-topic.js —— 素材驱动选题的最小契约
+ *
+ * 2026-11 新链路：
+ *   - `_novel_topic_suggestion.json` 只保存扫榜候选方向的选择结果；
+ *   - `_novel_topic.json` 只保存题材 +「能力」组 +「剧情与脑洞」组的素材。
+ *
+ * 不再保存 11 项方向设计字段。fancy-build 目前仍读旧格式，
+ * 这轮先不动，等后续单独适配。
+ */
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join, resolve } from 'path';
+
+/** 「能力」组：与 plugins/fancy-material/kinds.js 的 KIND_GROUPS 保持一致 */
+export const ABILITY_KINDS = [
+  'ability_mechanism',
+  'ability_activation',
+  'ability_cost',
+  'ability_limit',
+  'ability_counter',
+  'power_source',
+];
+
+/** 「剧情与脑洞」组 */
+export const PLOT_KINDS = [
+  'brainstorm',
+  'conflict_seed',
+  'conflict_escalation',
+  'plot_twist',
+  'mystery_seed',
+  'payoff_scene',
+  'trope',
+];
+
+/** 内置题材：番茄男频 + 女频主流分类（fancy-material 兜底） */
+export const BUILTIN_GENRES = [
+  '西方奇幻',
+  '东方仙侠',
+  '科幻末世',
+  '都市日常',
+  '都市修真',
+  '都市高武',
+  '历史古代',
+  '战神赘婿',
+  '都市种田',
+  '传统玄幻',
+  '历史脑洞',
+  '悬疑脑洞',
+  '都市脑洞',
+  '玄幻脑洞',
+  '悬疑灵异',
+  '抗战谍战',
+  '游戏体育',
+  '动漫衍生',
+  '男频衍生',
+  '古风世情',
+  '女频衍生',
+  '玄幻言情',
+  '种田',
+  '年代',
+  '现言脑洞',
+  '宫斗宅斗',
+  '古言脑洞',
+  '快穿',
+  '青春甜宠',
+  '星光璀璨',
+  '女频悬疑',
+  '职场婚恋',
+  '豪门总裁',
+  '民国言情',
+];
+
+export const TOPIC_PLATFORMS = ['番茄', '起点', '晋江', '七猫'];
+
+export const NOVEL_TOPIC_FILE = '_novel_topic.json';
+export const NOVEL_SUGGESTION_FILE = '_novel_topic_suggestion.json';
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function isControlFree(text) {
+  return !/[\x00-\x1f\x7f]/.test(text);
+}
+
+function validateKindGroup(group, kinds, label) {
+  const errors = [];
+  if (!isPlainObject(group)) {
+    return [`${label} 必须是对象`];
+  }
+  const keys = Object.keys(group);
+  for (const kind of kinds) {
+    if (!(kind in group)) {
+      errors.push(`${label} 缺 kind: ${kind}`);
+      continue;
+    }
+    const value = group[kind];
+    if (!nonEmptyString(value)) {
+      errors.push(`${label}.${kind} 必须是非空字符串`);
+    } else if (!isControlFree(value)) {
+      errors.push(`${label}.${kind} 不能含换行/控制字符`);
+    }
+  }
+  for (const key of keys) {
+    if (!kinds.includes(key)) {
+      errors.push(`${label} 出现未知 kind: ${key}`);
+    }
+  }
+  return errors;
+}
+
+/**
+ * 校验最小选题对象：{ genre, ability, plot }。
+ *
+ * @param {object} data
+ * @returns {{ok: boolean, errors: string[], normalized: object|null}}
+ */
+export function validateMinimalTopic(data) {
+  const errors = [];
+  if (!isPlainObject(data)) {
+    return { ok: false, errors: ['顶层必须是 JSON 对象'], normalized: null };
+  }
+  if (!nonEmptyString(data.genre)) {
+    errors.push('genre 必须是非空字符串');
+  } else if (!isControlFree(data.genre)) {
+    errors.push('genre 不能含换行/控制字符');
+  }
+  errors.push(...validateKindGroup(data.ability, ABILITY_KINDS, 'ability'));
+  errors.push(...validateKindGroup(data.plot, PLOT_KINDS, 'plot'));
+  if (errors.length) return { ok: false, errors, normalized: null };
+  return {
+    ok: true,
+    errors: [],
+    normalized: {
+      genre: data.genre.trim(),
+      ability: Object.fromEntries(ABILITY_KINDS.map(k => [k, data.ability[k].trim()])),
+      plot: Object.fromEntries(PLOT_KINDS.map(k => [k, data.plot[k].trim()])),
+    },
+  };
+}
+
+/**
+ * 校验 `_novel_topic_suggestion.json`。
+ *
+ * @param {object} data
+ * @returns {{ok: boolean, errors: string[], normalized: object|null}}
+ */
+export function validateSuggestion(data) {
+  const errors = [];
+  if (!isPlainObject(data)) {
+    return { ok: false, errors: ['顶层必须是 JSON 对象'], normalized: null };
+  }
+  for (const field of ['direction_title', 'genre', 'positioning']) {
+    if (!nonEmptyString(data[field])) errors.push(`${field} 必须是非空字符串`);
+    else if (!isControlFree(data[field])) errors.push(`${field} 不能含换行/控制字符`);
+  }
+  if (!nonEmptyString(data.platform)) {
+    errors.push('platform 必须是非空字符串');
+  } else if (!TOPIC_PLATFORMS.includes(data.platform)) {
+    errors.push(`platform 必须是 ${TOPIC_PLATFORMS.join(' / ')} 之一`);
+  }
+  if (!nonEmptyString(data.source_decision_file)) {
+    errors.push('source_decision_file 必须是非空字符串');
+  } else {
+    const source = resolve(data.source_decision_file);
+    if (!existsSync(source) || !statSync(source).isFile()) {
+      errors.push('source_decision_file 不存在或不是文件');
+    }
+  }
+  if (data.market_score !== undefined && data.market_score !== null
+    && typeof data.market_score !== 'number' && typeof data.market_score !== 'string') {
+    errors.push('market_score 必须是数字或字符串');
+  }
+  if (data.recommendation !== undefined && data.recommendation !== null
+    && typeof data.recommendation !== 'string') {
+    errors.push('recommendation 必须是字符串');
+  }
+  if (errors.length) return { ok: false, errors, normalized: null };
+  return {
+    ok: true,
+    errors: [],
+    normalized: {
+      platform: data.platform,
+      source_decision_file: resolve(data.source_decision_file),
+      direction_title: data.direction_title.trim(),
+      genre: data.genre.trim(),
+      positioning: data.positioning.trim(),
+      market_score: data.market_score ?? null,
+      recommendation: typeof data.recommendation === 'string' ? data.recommendation.trim() : '',
+    },
+  };
+}
+
+function readJson(file) {
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'));
+    return isPlainObject(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 读取最小 `_novel_topic.json`；旧格式没有 ability/plot 时返回 null */
+export function readMinimalTopic(root) {
+  const data = readJson(join(root, NOVEL_TOPIC_FILE));
+  if (!data) return null;
+  const v = validateMinimalTopic(data);
+  return v.ok ? v.normalized : null;
+}
+
+/** 读取 suggestion；旧格式也兼容（有 genre 即可） */
+export function readSuggestion(root) {
+  const data = readJson(join(root, NOVEL_SUGGESTION_FILE));
+  if (!data) return null;
+  const v = validateSuggestion(data);
+  return v.ok ? v.normalized : null;
+}
+
+/**
+ * fancy-material 的题材来源。
+ *
+ * 优先级：_novel_topic.json > _novel_topic_suggestion.json > null。
+ * null 表示两个文件都不存在/不可读，由调用方弹框确认后使用 BUILTIN_GENRES。
+ *
+ * @param {string} root
+ * @returns {{mode: 'topic'|'suggestion'|null, genres: string[], source: string|null}}
+ */
+export function resolveMaterialTopic(root) {
+  // 新格式优先；旧格式（有 genre、没有 ability/plot）也继续可用。
+  const topic = readJson(join(root, NOVEL_TOPIC_FILE));
+  if (topic && nonEmptyString(topic.genre)) {
+    const normalized = validateMinimalTopic(topic);
+    if (normalized.ok || (Array.isArray(topic.genres) && topic.genres.length)) {
+      const genres = normalized.ok ? [normalized.normalized.genre] : [String(topic.genre).trim()];
+      return { mode: 'topic', genres, source: NOVEL_TOPIC_FILE };
+    }
+    return { mode: 'topic', genres: [String(topic.genre).trim()], source: NOVEL_TOPIC_FILE };
+  }
+  const suggestion = readJson(join(root, NOVEL_SUGGESTION_FILE));
+  if (suggestion && nonEmptyString(suggestion.genre)) {
+    return { mode: 'suggestion', genres: [String(suggestion.genre).trim()], source: NOVEL_SUGGESTION_FILE };
+  }
+  return { mode: null, genres: [], source: null };
+}

package/lib/topic-candidates.js

@@ -0,0 +1,157 @@
+/**
+ * topic-candidates.js —— 从 topic_decision 文件里解析候选方向。
+ *
+ * 新格式（2026-11）每个方向只要求四项：
+ *   - **题材**：
+ *   - **一句话定位**：
+ *   - **市场评分**：
+ *   - **推荐理由**：
+ *
+ * 旧格式里的 11 项仍然兼容：只取「定位」，题材从方向标题前缀推导。
+ */
+import { TOPIC_PLATFORMS } from '#material-topic';
+
+export const PLATFORM_OPTIONS = [
+  { label: '番茄', value: 'fanqie' },
+  { label: '起点', value: 'qidian' },
+  { label: '晋江', value: 'jinjiang' },
+  { label: '七猫', value: 'qimao' },
+];
+
+const PLATFORM_DIR = PLATFORM_OPTIONS.map((p) => ({
+  value: p.value,
+  label: p.label,
+  lowerValue: String(p.value).toLowerCase(),
+}));
+
+function platformOfHeader(text) {
+  const core = String(text || '')
+    .trim()
+    .replace(/[-—–\s]*(start|end)\s*$/i, '')
+    .trim();
+  if (!core) return null;
+  for (const p of PLATFORM_DIR) {
+    if (core.startsWith(p.label)) return p.value;
+    if (core.toLowerCase().startsWith(p.lowerValue)) return p.value;
+  }
+  return null;
+}
+
+function platformLabel(value) {
+  return PLATFORM_OPTIONS.find((p) => p.value === value)?.label || value;
+}
+
+function cleanValue(value) {
+  return String(value || '')
+    .replace(/\*\*/g, '')
+    .trim();
+}
+
+function parseScore(value) {
+  const text = cleanValue(value);
+  const m = text.match(/-?\d+(?:\.\d+)?/);
+  return m ? Number(m[0]) : null;
+}
+
+function splitTitleGenre(title) {
+  const text = cleanValue(title);
+  const m = text.match(/^([^·:：|—–-]+?)\s*(?:[·:：|—–-]|$)/);
+  return m ? m[1].trim() : '';
+}
+
+/**
+ * @typedef {object} CandidateDirection
+ * @property {string} title
+ * @property {string} genre
+ * @property {string} positioning
+ * @property {number|string|null} market_score
+ * @property {string} recommendation
+ */
+
+/**
+ * @param {string} content
+ * @returns {{platforms: Array<{value:string,label:string,directions:CandidateDirection[]}>}}
+ */
+export function parseDecisionCandidates(content) {
+  const lines = String(content || '').split(/\r?\n/);
+  const sections = [];
+  let cur = null;
+  let inFence = false;
+
+  for (const line of lines) {
+    if (/^\s*(?:```|~~~)/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+
+    const heading = line.match(/^#{1,6}\s+(.+?)\s*$/);
+    if (heading && /^#\s/.test(line)) {
+      const platform = platformOfHeader(heading[1]);
+      if (platform) {
+        if (cur) sections.push(cur);
+        cur = { platform, lines: [] };
+        continue;
+      }
+    }
+    if (cur) cur.lines.push(line);
+  }
+  if (cur) sections.push(cur);
+
+  const byPlatform = new Map();
+  for (const section of sections) {
+    const directions = parseDirections(section.lines);
+    if (!directions.length) continue;
+    const existing = byPlatform.get(section.platform);
+    if (existing) existing.directions.push(...directions);
+    else byPlatform.set(section.platform, {
+      value: section.platform,
+      label: platformLabel(section.platform),
+      directions,
+    });
+  }
+
+  const order = new Map(PLATFORM_OPTIONS.map((p, i) => [p.value, i]));
+  const platforms = [...byPlatform.values()].sort(
+    (a, b) => (order.get(a.value) ?? 99) - (order.get(b.value) ?? 99),
+  );
+  return { platforms };
+}
+
+function parseDirections(lines) {
+  const starts = [];
+  lines.forEach((line, index) => {
+    if (/^#{2,4}\s*方向\s*\d+\s*[:：]/.test(line.trim())) starts.push(index);
+  });
+  const out = [];
+  for (let i = 0; i < starts.length; i += 1) {
+    const start = starts[i];
+    const end = i + 1 < starts.length ? starts[i + 1] : lines.length;
+    const block = lines.slice(start, end);
+    const title = cleanValue(block[0].replace(/^#{2,4}\s*方向\s*\d+\s*[:：]\s*/, ''));
+    const fields = {};
+    for (const line of block.slice(1)) {
+      const m = line.match(/^\s*[-*+]?\s*\*\*([^*]+?)\*\*\s*[:：]\s*(.+)$/);
+      if (!m) continue;
+      const key = cleanValue(m[1]);
+      const value = cleanValue(m[2]);
+      if (!value) continue;
+      fields[key] = value;
+    }
+    const positioning = fields['一句话定位'] || fields['定位'] || '';
+    const genre = fields['题材'] || splitTitleGenre(title);
+    const recommendation = fields['推荐理由'] || fields['优先级'] || '';
+    const market_score = parseScore(fields['市场评分'] ?? fields['评分'] ?? '');
+    if (!title || !genre || !positioning) continue;
+    out.push({
+      title,
+      genre,
+      positioning,
+      market_score,
+      recommendation,
+    });
+  }
+  return out;
+}
+
+export { TOPIC_PLATFORMS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud411716/fancy-webnovel",
-  "version": "3.0.4",
+  "version": "4.0.0",
   "type": "module",
   "main": "index.js",
   "exports": {
@@ -26,7 +26,9 @@
     "#projects": "./lib/projects.js",
     "#db-init": "./lib/db-init.js",
     "#surreal-server": "./lib/surreal-server.js",
-    "#material-db": "./lib/material-db.js"
+    "#material-db": "./lib/material-db.js",
+    "#material-topic": "./lib/material-topic.js",
+    "#topic-candidates": "./lib/topic-candidates.js"
   },
   "engines": {
     "node": ">=18.0.0",

package/plugins/fancy-material/genres.js

@@ -15,42 +15,10 @@ import fs from 'fs';
 import path from 'path';
 import { workspacePaths } from '#workspace';
 
-export const FALLBACK_GENRES = [
-  '西方奇幻',
-  '东方仙侠',
-  '科幻末世',
-  '都市日常',
-  '都市修真',
-  '都市高武',
-  '历史古代',
-  '战神赘婿',
-  '都市种田',
-  '传统玄幻',
-  '历史脑洞',
-  '悬疑脑洞',
-  '都市脑洞',
-  '玄幻脑洞',
-  '悬疑灵异',
-  '抗战谍战',
-  '游戏体育',
-  '动漫衍生',
-  '男频衍生',
-  '古风世情',
-  '女频衍生',
-  '玄幻言情',
-  '种田',
-  '年代',
-  '现言脑洞',
-  '宫斗宅斗',
-  '古言脑洞',
-  '快穿',
-  '青春甜宠',
-  '星光璀璨',
-  '女频悬疑',
-  '职场婚恋',
-  '豪门总裁',
-  '民国言情',
-];
+import { BUILTIN_GENRES } from '#material-topic';
+
+/** 兼容旧名字：内置全题材列表统一放在 lib/material-topic.js */
+export const FALLBACK_GENRES = BUILTIN_GENRES;
 
 function unique(values) {
   const seen = new Set();

package/plugins/fancy-material/index.js

@@ -22,9 +22,10 @@ import {
   workspacePaths,
 } from '#workspace';
 import { connectMaterial, ensureMaterialDatabase, materialDatabaseName, removeMaterialDatabase } from '#material-db';
+import { BUILTIN_GENRES, resolveMaterialTopic } from '#material-topic';
 import { makeWaitForTurn } from '../fancy-story-builder/writing-driver.js';
 import { exportMaterials } from './exporter.js';
-import { allKnownGenres, listTopicDecisionFiles, parseTopicDecisionGenres, resolveMaterialGenres } from './genres.js';
+import { allKnownGenres } from './genres.js';
 import { buildExistingIndex, countByKind, countKind } from './inventory.js';
 import { KIND_LABELS, MATERIAL_KINDS, focusBlock, renderKindTable, resolveFocus } from './kinds.js';
 import { nextBatchRequest, planMaterialQueue } from './queue.js';
@@ -388,38 +389,27 @@ async function runGenerate(ctx, invocation, session, focusRaw = '') {
     return notify(session, 'error', '❌ 未识别素材类型：' + focusRaw
       + '\n可用示例：地名、人名、姓氏、门派、技能、超能力、武器、颜色、特效、脑洞、人物性格、关系、场景。');
   }
-  // No-arg generation asks which topic_decision report to use when several
-  // exist. Focused runs keep the previous behavior (latest report) so a
-  // targeted one-kind request does not require an extra click.
-  const topicFiles = !focusRaw ? listTopicDecisionFiles(root) : [];
-  let selectedTopicFile = null;
-  if (topicFiles.length > 1) {
-    const options = topicFiles.map((file) => {
-      let genres = [];
-      try { genres = parseTopicDecisionGenres(fs.readFileSync(file, 'utf8')); } catch { /* preview only */ }
-      return {
-        label: path.basename(file),
-        description: genres.length ? genres.join('、') : '未解析到选题方向',
-      };
-    });
+  // 素材题材只认用户选题链路：
+  //   _novel_topic.json > _novel_topic_suggestion.json > 内置全题材。
+  // 不再从 topic_decision 里猜题材，避免素材和用户最终选题脱节。
+  let plan = resolveMaterialTopic(root);
+  if (!plan.mode) {
     const asked = await askUserQuestion(ctx, invocation, [{
-      id: 'material-topic-file',
-      header: '选择选题方向',
-      question: '📊 请选择本次素材库使用的 topic_decision 文件：',
-      detail: '只会读取选中文件里的「选题方向」，不会合并多个文件。',
-      options,
+      id: 'material-builtin-confirm',
+      header: '没有选题记录',
+      question: '当前没有执行过扫榜和 /fancy-topic，将使用内置全题材生成素材（男频 + 女频）。是否继续？',
+      detail: '内置题材共 ' + BUILTIN_GENRES.length + ' 类；确认后所有 kind 都会按全题材生成。',
+      options: [
+        { label: '确认', description: '使用内置全题材生成素材' },
+        { label: '取消', description: '不生成任何素材' },
+      ],
     }]);
     if (!asked.ok) {
       return notify(session, 'error', asked.failure?.message || '❌ 提问失败');
     }
     const selected = asked.answer?.answers?.[0]?.selected?.[0];
-    if (!selected) return notify(session, 'error', '已取消素材生成。');
-    selectedTopicFile = topicFiles.find((file) => path.basename(file) === selected) || null;
-    if (!selectedTopicFile) {
-      return notify(session, 'error', '❌ 未找到选中的选题文件：' + selected);
-    }
-  } else if (topicFiles.length === 1) {
-    selectedTopicFile = topicFiles[0];
+    if (selected !== '确认') return notify(session, 'success', '操作已取消。');
+    plan = { mode: 'builtin', genres: [...BUILTIN_GENRES], topicFile: null };
   }
 
   const config = generationConfig();
@@ -429,10 +419,6 @@ async function runGenerate(ctx, invocation, session, focusRaw = '') {
     return notify(session, 'error', '❌ 部署素材查询脚本失败：\n' + (tools.problems.join('\n') || '未知错误'));
   }
   const database = materialDatabaseName(readWorkspace(root));
-  const plan = resolveMaterialGenres(root, { topicFile: selectedTopicFile || undefined });
-  if (selectedTopicFile && plan.mode !== 'topic_decision') {
-    return notify(session, 'error', '❌ 选中的文件没有解析到「选题方向」：' + path.basename(selectedTopicFile));
-  }
   const counts = await countByKind(root, plan.genres);
   const kinds = [...new Set(focus.kinds.length ? focus.kinds : MATERIAL_KINDS)];
   const planned = planMaterialQueue({ kinds, target: config.targetPerKind });
@@ -791,7 +777,7 @@ export async function apply(ctx) {
           try { root = workspaceOf(session); } catch { /* prompt also works outside a workspace */ }
           const genres = allKnownGenres(root);
           const rendered = renderBasePrompt({
-            mode: 'all_genres',
+            mode: 'builtin',
             genres,
             topicFile: '（prompt 子命令固定输出全题材）',
             existingIndex: '（运行 /fancy-material 时由插件提供）',

package/plugins/fancy-material/templates.js

@@ -17,8 +17,9 @@ export function helpText() {
 说明：
 - 素材是原子积木，每条只有 id / kind / name / tags / genres / note / source。
 - 每次运行：每个 kind 新增 50 条；每批最多 10 条，插件自动分批直到完成。
-- 未指定类型：54 个 kind 全部排队；有多份 topic_decision 文件时先弹窗选择。
-- 指定类型：只生成指定 kind，沿用最新的 topic_decision 文件。
+- 未指定类型：54 个 kind 全部排队。
+- 题材来源：优先 _novel_topic.json，其次 _novel_topic_suggestion.json；都没有时弹框确认后使用内置全题材。
+- 指定类型：只生成指定 kind，题材来源不变。
 - 不设库内上限：运行两次就是每个 kind 累计 100 条；已有素材只用于去重。
 - 中断后重跑会开始新一轮 50 条配额，已经导入的素材不会撤销。
 - 只追加，不覆盖；同 kind 同 name 的素材会被跳过。
@@ -103,7 +104,14 @@ export function generationPrompt({
   lines.push('- 工作区目录：' + workspace);
   lines.push('- 目标文件（**绝对路径**）：`' + target + '`');
   lines.push('- 批次 ID：`' + batchId + '`');
-  lines.push('- 题材模式：' + (mode === 'topic_decision' ? 'topic_decision（选题方向）' : 'all_genres（番茄全题材）'));
+  const modeLabel = mode === 'topic'
+    ? 'topic（_novel_topic.json）'
+    : mode === 'suggestion'
+      ? 'suggestion（_novel_topic_suggestion.json）'
+      : mode === 'builtin'
+        ? 'builtin（内置全题材）'
+        : String(mode || '未指定');
+  lines.push('- 题材模式：' + modeLabel);
   if (Array.isArray(genres) && genres.length) lines.push('- 本次题材：' + genres.join('、'));
   if (focus && focus.query) {
     const kinds = (focus.kinds || []).map((item) => `\`${item}\``).join('、');