koishi-plugin-p-draw 1.3.6 → 1.5.0

package/index.js

@@ -3,7 +3,7 @@ const fs = require('fs')
 const fsp = require('fs/promises')
 const path = require('path')
 const crypto = require('crypto')
-const { pathToFileURL, fileURLToPath } = require('url')
+const { pathToFileURL } = require('url')
 
 exports.name = 'p-draw'
 
@@ -28,14 +28,9 @@ exports.usage = `
 - **联网搜索：** 描述中带 \`联网\` / \`搜索\` / \`查一下\` 等词时，会先联网搜索补充角色设定（需配置 Tavily Key）。
 - **画师组：** \`创建画师组 名称=tags\` \`切换画师组 名称\` \`查看画师组\` \`删除画师组 名称\`
 - **固定角色：** \`添加角色 名称=tags\`
-- **以图生图：** \`p-draw i2i <描述>\`，并在同一条消息里附一张原图（文件/截图/链接均可）。发送后会询问处理模式：
-  - **① 换风格（漫画化）**：保留原图构图，把图片转成二次元画风（用 ControlNet 锁结构）
-  - **② 换装换姿势**：保留角色长相，重新设计服装/姿势/场景（用 IP-Adapter 保脸）
-  - **③ 取消**：不生成
-  - 可加 \`--denoise 0.6\` 单独调整强度；未装 ControlNet/IPAdapter 时自动回退普通 img2img。
-`;
-
-const { zhCN } = require('./lib/i18n')
+ `;
+
+const { zhCN } = require('./lib/i18n')
 exports.Config = Schema.object({
   // ComfyUI 连接
   comfyuiBaseUrl: Schema.string().default('http://127.0.0.1:8188').description('ComfyUI 地址'),
@@ -48,7 +43,6 @@ exports.Config = Schema.object({
 
   // 模型文件
   unetName: Schema.string().default('anima-base-v1.0.safetensors').description('主模型文件名（需与 ComfyUI models/diffusion_models 下的文件名完全一致，含连字符；默认 anima-base-v1.0.safetensors）'),
-  i2iUnetName: Schema.string().default('anima-base-v1.0.safetensors').description('「换风格（漫画化）」工作流专用主模型文件名。LLLite 权重按 block 数逐块训练，当前 LLLite 权重为 28-block，必须搭配 28-block 模型（anima-base-v1.0 / anima-aesthetic-v1.1）；不要用 40-block 的 Anima-2.9B，否则报 depth_embed slices missing。留空则用主模型 unetName'),
   modelParams: Schema.dict(Schema.object({
     samplerName: Schema.string().description('采样器（如 er_sde / res_2s / dpmpp_2m）'),
     scheduler: Schema.string().description('调度器（如 simple / beta57 / normal）'),
@@ -87,6 +81,7 @@ exports.Config = Schema.object({
   activeArtistPreset: Schema.string().default('').description('启用的画师组名称'),
   defaultArtistTags: Schema.string().default('').description('备用画师 tags'),
   styleTags: Schema.string().default('').description('画风 tags'),
+  fixedCharacters: Schema.array(Schema.string()).default([]).description('固定角色（格式：角色名=tags；仅用于兼容旧配置，运行时数据保存在数据库）'),
 
   // 队列
   queueEnabled: Schema.boolean().default(true).description('启用生成队列（逐张顺序执行）'),
@@ -98,20 +93,6 @@ exports.Config = Schema.object({
   multiPrice: Schema.number().default(900).description('多人指令（p-draw 多人）单张消耗的 P 点'),
   couponPrice: Schema.number().default(3000).description('提示词优化券单价（P 点/张，购买询问时显示；可自动读取 data/p-shop.json 里的价格覆盖）'),
   couponAskTimeout: Schema.number().default(60).description('提示词优化券确认等待时间（秒）'),
-  img2imgDenoise: Schema.number().default(0.55).description('普通以图生图（p-draw i2i）的去噪强度，越小越接近原图（建议 0.4-0.7）'),
-  i2iMode: Schema.string().default('ask').description('i2i 模式选择方式：ask=每次询问 / style=直接换风格（漫画化）/ ootd=直接换装换姿势 / plain=普通 img2img'),
-  i2iAskTimeout: Schema.number().default(60).description('i2i 模式询问等待时间（秒）'),
-  seriesAskTimeout: Schema.number().default(60).description('连续图 LLM 使用确认等待时间（秒）'),
-  i2iStyleDenoise: Schema.number().default(0.75).description('换风格模式（漫画化）的去噪强度，越大风格变化越彻底（建议 0.7-0.85）'),
-  i2iOotdDenoise: Schema.number().default(0.55).description('换装换姿势模式（保留角色）的去噪强度（建议 0.5-0.6）'),
-  i2iControlNetStrength: Schema.number().default(0.7).description('换风格模式的 ControlNet-LLLite 强度，越大构图锁得越死（建议 0.5-0.8；需安装 kohya-ss/ComfyUI-Anima-LLLite 节点与权重）'),
-  i2iIPAdapterPath: Schema.string().default('').description('Anima IP-Adapter 模型文件路径（换装换姿势模式保脸用；需安装 comfyui-anima-ipadapter 节点并把模型路径填到这里）'),
-  i2iIPAdapterWeight: Schema.number().default(0.8).description('换装换姿势模式的 IP-Adapter 权重，越大角色特征保留越强（建议 0.6-1.0）'),
-  controlNetModel: Schema.string().default('').description('Anima ControlNet-LLLite 权重文件名（留空自动检测 anima-lllite 系；需放到 ComfyUI/models/controlnet，如 anima-lllite-lineart-test-1.safetensors）'),
-  taggerEnabled: Schema.boolean().default(false).description('i2i 前自动识图（需 ComfyUI 安装 WD14 Tagger 节点与模型；识别出的标签会注入提示词优化）'),
-  taggerModel: Schema.string().default('wd-v1-4-convnext-tagger-v2').description('识图模型名（WD14 Tagger 节点里可选模型）'),
-  taggerThreshold: Schema.number().default(0.35).description('识图标签置信度阈值'),
-  taggerCharacterThreshold: Schema.number().default(0.85).description('识图角色标签置信度阈值'),
   adminUsers: Schema.array(Schema.string()).default([]).description('免 P 点管理员用户 ID 列表'),
   outputLogs: Schema.boolean().default(true).description('是否在控制台输出详细日志'),
 
@@ -134,28 +115,27 @@ exports.Config = Schema.object({
   'zh-CN': zhCN,
 })
 
-// ------------------------------------------------------------------
-// 纯函数库已拆分到 lib/（解析 / tag 清洗 / 工作流 / Comfy 等待 / 多人规划 / HTTP 客户端）
-// ------------------------------------------------------------------
-const {
-  normalizeBaseUrl, escapeRe, parseGenerationSize, parseBatchCount, parseSeed, parseDenoise,
-  stripRawPrefix, splitPositiveNegativePrompt, parseNameTags, parsePresetList, mergeTagText,
-} = require('./lib/parse')
-const {
-  splitTags, canonicalTagText, joinPromptParts, mergeNegativePrompts, cleanContentTags, appendInlineProtectedTags,
-  NO_ARTIST_RE, NO_STYLE_RE,
-} = require('./lib/tags')
-const {
-  animaT2IWorkflow, buildWorkflow, animaI2IWorkflow, animaStyleI2IWorkflow,
-  animaOotdI2IWorkflow, buildI2IWorkflow, customWorkflow,
-} = require('./lib/workflows')
-const { outputImages, waitComfyResult } = require('./lib/comfy')
-const { materializeImageSource } = require('./lib/media')
-const {
-  MULTI_PERSON_NEGATIVE_TAGS, buildMultiPersonPlanPrompt, parseMultiPersonPlan,
-  renderMultiPersonCharacter, multiPersonAutoSize,
-} = require('./lib/multi')
-const { buildComfyClient } = require('./lib/http')
+// ------------------------------------------------------------------
+// 纯函数库已拆分到 lib/（解析 / tag 清洗 / 工作流 / Comfy 等待 / 多人规划 / HTTP 客户端）
+// ------------------------------------------------------------------
+const {
+  normalizeBaseUrl, escapeRe, parseGenerationSize, parseBatchCount, parseSeed,
+  stripRawPrefix, splitPositiveNegativePrompt, parseNameTags, parsePresetList, mergeTagText,
+} = require('./lib/parse')
+const {
+  splitTags, joinPromptParts, mergeNegativePrompts, cleanContentTags, appendInlineProtectedTags,
+  NO_ARTIST_RE, NO_STYLE_RE,
+} = require('./lib/tags')
+const {
+  buildWorkflow,
+} = require('./lib/workflows')
+const { outputImages, waitComfyResult } = require('./lib/comfy')
+const { materializeImageSource } = require('./lib/media')
+const {
+  MULTI_PERSON_NEGATIVE_TAGS, buildMultiPersonPlanPrompt, parseMultiPersonPlan,
+  renderMultiPersonCharacter, multiPersonAutoSize,
+} = require('./lib/multi')
+const { buildComfyClient } = require('./lib/http')
 exports.apply = async function apply(ctx, cfg) {
   // 注意：不在此处 extend p_system 表 —— 该表由 p-qiandao 等 p 系插件创建。
   // 重复声明同一张表可能导致 Koishi 的 schema 迁移冲突，拖垮签到插件。
@@ -163,13 +143,14 @@ exports.apply = async function apply(ctx, cfg) {
   const logger = ctx.logger('p-draw')
   ctx.i18n.define('zh-CN', zhCN)
 
-  // 运行时数据（画师组/固定角色）持久化到 p_draw_config 表，而不是调用 scope.update
+  // 运行时数据持久化到数据库，而不是调用 scope.update
   // 写 koishi.yml：scope.update 会触发插件重载，导致正在生成的图被 dispose（Context has
-  // been disposed），且连续多次写入时配置文件会被冲掉（曾出现配置整体恢复成默认）。
+  // been disposed），且重复写入时配置文件会被冲掉（曾出现配置整体恢复成默认）。
   try {
     ctx.model.extend('p_draw_config', {
       id: 'unsigned',
       fixed_characters: 'json',
+      fixed_characters_migrated: 'boolean',
       artist_presets: 'json',
       active_artist_preset: 'text',
       default_artist_tags: 'text',
@@ -179,6 +160,16 @@ exports.apply = async function apply(ctx, cfg) {
     logger.warn(`p_draw_config 表初始化失败：${e.message}`)
   }
 
+  try {
+    ctx.model.extend('p_draw_fixed_characters', {
+      id: 'unsigned',
+      name: 'string',
+      tags: 'text',
+    }, { autoInc: true, unique: ['name'] })
+  } catch (e) {
+    logger.warn(`p_draw_fixed_characters 表初始化失败：${e.message}`)
+  }
+
   // 用户自选模型偏好（userid -> unet 文件名），持久化在 p_draw_config.user_models
   if (!cfg.userModels || typeof cfg.userModels !== 'object') cfg.userModels = {}
 
@@ -263,12 +254,10 @@ exports.apply = async function apply(ctx, cfg) {
       const vaeList = availableModels(objectInfo, 'VAELoader', 'vae_name')
       payload.unet_available = unetList.includes(cfg.unetName)
       payload.unet_models = unetList
-      payload.i2i_unet_available = unetList.includes(String(cfg.i2iUnetName || '').trim() || cfg.unetName)
       payload.clip_available = clipList.includes(cfg.clipName)
       payload.vae_available = vaeList.includes(cfg.vaeName)
     } else {
       payload.unet_available = undefined
-      payload.i2i_unet_available = undefined
       payload.clip_available = undefined
       payload.vae_available = undefined
     }
@@ -314,7 +303,6 @@ exports.apply = async function apply(ctx, cfg) {
       `版本：${payload.comfyui_version || '未知'}`,
       `GPU：${payload.gpu || '未知'}（显存 ${payload.vram_total_mb}MB / 空闲 ${payload.vram_free_mb}MB）`,
       `主模型：${cfg.unetName} ${modelStatus(cfg.unetName, payload.unet_available)}`,
-      `换风格模型：${cfg.i2iUnetName || cfg.unetName} ${modelStatus(cfg.i2iUnetName || cfg.unetName, payload.i2i_unet_available)}`,
       `文本编码器：${cfg.clipName} ${modelStatus(cfg.clipName, payload.clip_available)}`,
       `VAE：${cfg.vaeName} ${modelStatus(cfg.vaeName, payload.vae_available)}`,
       `可用尺寸：${payload.allowed_sizes.join('、')}`,
@@ -426,7 +414,7 @@ exports.apply = async function apply(ctx, cfg) {
     return String(cfg.styleTags).trim()
   }
 
-  // P 点余额预检（单图/多人/连续共用）
+  // P 点余额预检（单图/多人共用）
   async function precheckPoints(session, USERID, isAdmin, totalPrice) {
     if (isAdmin) return { ok: true }
     const notExists = await isAccountExists(USERID)
@@ -461,56 +449,58 @@ exports.apply = async function apply(ctx, cfg) {
     return { ok: true, tasks, firstPosition }
   }
 
-  // 即时反馈的公共部分。扣费提醒单独返回，随后以引用消息发送。
-  function feedbackBase(session, { firstPosition, count, totalPrice, isAdmin }) {
-    const notices = []
-    if (cfg.queueEnabled) {
-      notices.push(session.text('.queued', [firstPosition, cfg.queueMaxRequests || '∞']))
-      if (count > 1) notices.push(session.text('.batch-count', [count]))
-    } else {
-      notices.push(session.text('.generating'))
-      if (count > 1) notices.push(session.text('.batch-count', [count]))
-    }
-    return {
-      notices,
-      chargeNotice: isAdmin ? '' : session.text('.charged', [totalPrice]),
-    }
-  }
-
-  async function sendNotices(session, notices, opts = {}) {
-    const content = notices.filter(Boolean).join('\n')
-    if (!content) return
-    try {
-      const message = opts.quote && session.messageId ? h.quote(session.messageId) + content : content
-      await session.send(message)
-    } catch (e) {
-      logger.warn(`发送反馈消息失败：${e.message}`)
-    }
-  }
-
-  // 生成图片使用合并转发；每张图后紧跟实际使用的正负面提示词，不附原消息引用。
-  async function sendImagesAsForward(session, outputs) {
-    const nodes = []
-    const fallback = []
-    for (const output of outputs) {
-      const src = typeof output === 'string' ? output : output.src
-      const prompt = typeof output === 'string' ? '' : String(output.prompt || '')
-      const negativePrompt = typeof output === 'string' ? '' : String(output.negativePrompt || '')
-      const materialized = await materializeImageSource(src)
-      const image = Buffer.isBuffer(materialized) ? h.image(materialized) : h.image(src)
-      nodes.push(h('message', image))
-      fallback.push(image)
-      const promptText = `Positive:\n${prompt}\n\nNegative:\n${negativePrompt}`
-      nodes.push(h('message', promptText))
-      fallback.push(promptText)
-    }
-    try {
-      await session.send(h('figure', nodes))
-    } catch (e) {
-      logger.warn(`发送转发图片失败：${e.message}`)
-      await session.send(fallback)
-    }
-  }
+  // 即时反馈的公共部分。扣费提醒在生成完成后使用实际 seed 发送。
+  function feedbackBase(session, { firstPosition, count }) {
+    const notices = []
+    if (cfg.queueEnabled) {
+      notices.push(session.text('.queued', [firstPosition, cfg.queueMaxRequests || '∞']))
+      if (count > 1) notices.push(session.text('.batch-count', [count]))
+    } else {
+      notices.push(session.text('.generating'))
+      if (count > 1) notices.push(session.text('.batch-count', [count]))
+    }
+    return { notices }
+  }
+
+  function buildChargeNotice({ isAdmin, totalPrice, unetName, seeds }) {
+    if (isAdmin || !seeds.length) return ''
+    return `已扣除 ${totalPrice} P 点，当前模型：${unetName}，--seed=${seeds.join(',')}`
+  }
+
+  async function sendNotices(session, notices, opts = {}) {
+    const content = notices.filter(Boolean).join('\n')
+    if (!content) return
+    try {
+      const message = opts.quote && session.messageId ? h.quote(session.messageId) + content : content
+      await session.send(message)
+    } catch (e) {
+      logger.warn(`发送反馈消息失败：${e.message}`)
+    }
+  }
+
+  // 生成图片使用合并转发；每张图后紧跟实际使用的正负面提示词，不附原消息引用。
+  async function sendImagesAsForward(session, outputs) {
+    const nodes = []
+    const fallback = []
+    for (const output of outputs) {
+      const src = typeof output === 'string' ? output : output.src
+      const prompt = typeof output === 'string' ? '' : String(output.prompt || '')
+      const negativePrompt = typeof output === 'string' ? '' : String(output.negativePrompt || '')
+      const materialized = await materializeImageSource(src)
+      const image = Buffer.isBuffer(materialized) ? h.image(materialized) : h.image(src)
+      nodes.push(h('message', image))
+      fallback.push(image)
+      const promptText = `Positive:\n${prompt}\n\nNegative:\n${negativePrompt}`
+      nodes.push(h('message', promptText))
+      fallback.push(promptText)
+    }
+    try {
+      await session.send(h('figure', nodes))
+    } catch (e) {
+      logger.warn(`发送转发图片失败：${e.message}`)
+      await session.send(fallback)
+    }
+  }
 
   // P 点读改写按用户串行化，避免并发指令互相覆盖余额
   const userLocks = new Map()
@@ -522,17 +512,22 @@ exports.apply = async function apply(ctx, cfg) {
   }
 
   // ---------------- 用户自选模型 ----------------
-  // 从 ComfyUI /object_info（10 分钟缓存）读取真实的 UNET 模型列表
+  // 从 ComfyUI /object_info（10 分钟缓存）读取 UNET 和 checkpoint 模型列表
   async function listUnetModels() {
     try {
       const objectInfo = await getObjectInfoCached()
-      const list = availableModels(objectInfo, 'UNETLoader', 'unet_name')
-      if (list.length) return list
+      const list = [
+        ...availableModels(objectInfo, 'UNETLoader', 'unet_name'),
+        ...availableModels(objectInfo, 'CheckpointLoaderSimple', 'ckpt_name')
+          .filter(name => String(name).trim().toLowerCase().replace(/[-_]/g, '~') === 'animagine~xl~3.1.safetensors'),
+      ]
+      const unique = [...new Set(list)]
+      if (unique.length) return unique
     } catch (e) { /* ignore */ }
     return []
   }
 
-  // 解析该用户当前生效的 UNET 模型：有偏好且仍存在于 ComfyUI 时用偏好，否则回落默认
+  // 解析该用户当前生效的模型：有偏好且仍存在于 ComfyUI 时用偏好，否则回落默认
   async function resolveUnet(USERID) {
     const chosen = cfg.userModels && cfg.userModels[USERID]
     if (!chosen || !String(chosen).trim()) return cfg.unetName
@@ -582,12 +577,12 @@ exports.apply = async function apply(ctx, cfg) {
 
   async function runComfyGenerate(prompt, size, overrides) {
     const sizes = parseAllowedSizes()
-    const requestedWidth = (size && size[0]) || overrides.width || cfg.width
-    const requestedHeight = (size && size[1]) || overrides.height || cfg.height
     const unetName = overrides.unet || cfg.unetName
     // 应用该模型的独立参数覆盖（modelParams），再叠加命令级 overrides（overrides.steps/cfg 优先于模型级）
     const modelSpecific = resolveModelParams(unetName)
     const workCfg = Object.assign({}, cfg, modelSpecific, { unetName })
+    const requestedWidth = (size && size[0]) || overrides.width || workCfg.width
+    const requestedHeight = (size && size[1]) || overrides.height || workCfg.height
     // 防御：sampler/scheduler 配置若带尾随空格会导致 ComfyUI 报 "Value not in list"，统一 trim
     if (typeof workCfg.samplerName === 'string') workCfg.samplerName = workCfg.samplerName.trim()
     if (typeof workCfg.scheduler === 'string') workCfg.scheduler = workCfg.scheduler.trim()
@@ -597,14 +592,7 @@ exports.apply = async function apply(ctx, cfg) {
     const cfgVal = Number(overrides.cfg) || workCfg.cfg
     const seed = Number(overrides.seed) || crypto.randomInt(1, 2 ** 32 - 1)
     const negativePrompt = joinPromptParts([overrides.negativePrompt || cfg.negativePrompt || ''])
-    const i2iImage = overrides.i2iImage
-    if (i2iImage && cfg.customWorkflowEnabled && cfg.customWorkflowPath) {
-      return { ok: false, message: 'i2i（以图生图）暂不支持自定义工作流（customWorkflowEnabled），请关闭后再试。' }
-    }
-    const i2iOpts = overrides.i2i || {}
-    const promptBody = i2iImage
-      ? buildI2IWorkflow(workCfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, i2iImage, i2iOpts.mode || 'plain', i2iOpts.denoise != null ? i2iOpts.denoise : null, i2iOpts.caps || null).promptBody
-      : buildWorkflow(workCfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, Boolean(size))
+    const promptBody = buildWorkflow(workCfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, Boolean(size))
 
     const clientId = crypto.randomUUID()
     const submit = await comfyPost('/prompt', { prompt: promptBody, client_id: clientId }, 20000)
@@ -664,10 +652,10 @@ exports.apply = async function apply(ctx, cfg) {
       width,
       height,
       steps,
-      cfg: cfgVal,
-      prompt_id: promptId,
-      negativePrompt,
-    }
+      cfg: cfgVal,
+      prompt_id: promptId,
+      negativePrompt,
+    }
   }
 
   // ---------------- LLM 提示词优化 ----------------
@@ -709,9 +697,14 @@ exports.apply = async function apply(ctx, cfg) {
   }
 
   // 把命中的固定角色 tags 渲染进优化模板的 {character_rule} 占位符。
-  function buildCharacterRule(prompt) {
+  async function fixedCharacterRows(query = {}) {
+    const rows = await ctx.database.get('p_draw_fixed_characters', query)
+    return rows.sort((a, b) => Number(a.id) - Number(b.id))
+  }
+
+  async function buildCharacterRule(prompt) {
     const text = String(prompt || '')
-    for (const [name, tags] of Object.entries(parsePresetList(cfg.fixedCharacters))) {
+    for (const { name, tags } of await fixedCharacterRows()) {
       if (name && text.includes(name)) {
         return `用户提到了固定角色「${name}」，其外观 tags 为：${tags} 请优先保留这些特征。`
       }
@@ -771,7 +764,7 @@ exports.apply = async function apply(ctx, cfg) {
     }
   }
 
-  async function optimizePrompt(session, userPrompt, force = false, img2imgRule = '', precomputedSearch = null) {
+  async function optimizePrompt(session, userPrompt, force = false, precomputedSearch = null) {
     if (!cfg.promptOptimizeEnabled && !force) {
       return { ok: true, prompt: userPrompt, reason: 'optimize_disabled' }
     }
@@ -786,8 +779,8 @@ exports.apply = async function apply(ctx, cfg) {
     } else if (wantsWebSearch(userPrompt)) {
       searchBlock = await webSearch(userPrompt)
     }
-    const characterRule = buildCharacterRule(userPrompt)
-    const defaultTemplate = `你是为图像生成模型编写正面提示词的 AI 画师。\n\n请根据用户的原始要求设计一幅完整、协调、具有视觉吸引力的画面，并将结果输出为英文 Danbooru-style tags。\n\n输出要求：\n- 只输出一行英文 tags，使用英文逗号分隔。\n- 不要输出解释、分析、标题、编号、Markdown、代码块或中文。\n- 不要输出 masterpiece、best quality、score 等质量前缀。\n- 不要输出画师 tags；质量词和画师组会由程序另行拼接。\n- 尽量使用模型容易理解的可见画面描述。\n- 保持用户明确指定的角色、主体、人数、关键服装、动作、表情和道具。\n- 以最终图像协调、精致、有表现力和好看为优先。\n\n角色和动态上下文：\n{character_rule}\n{img2img_rule}\n{search_block}\n\n用户原始要求：\n{theme}`
+    const characterRule = await buildCharacterRule(userPrompt)
+    const defaultTemplate = `你是为图像生成模型编写正面提示词的 AI 画师。\n\n请根据用户的原始要求设计一幅完整、协调、具有视觉吸引力的画面，并将结果输出为英文 Danbooru-style tags。\n\n输出要求：\n- 只输出一行英文 tags，使用英文逗号分隔。\n- 不要输出解释、分析、标题、编号、Markdown、代码块或中文。\n- 不要输出 masterpiece、best quality、score 等质量前缀。\n- 不要输出画师 tags；质量词和画师组会由程序另行拼接。\n- 尽量使用模型容易理解的可见画面描述。\n- 保持用户明确指定的角色、主体、人数、关键服装、动作、表情和道具。\n- 以最终图像协调、精致、有表现力和好看为优先。\n\n角色和动态上下文：\n{character_rule}\n{search_block}\n\n用户原始要求：\n{theme}`
     const template = (cfg.promptOptimizeTemplate || '').trim() || defaultTemplate
     const searchBlockText = searchBlock
       ? `联网搜索参考信息（请尽量依据这些内容补全角色外观与设定）：\n${searchBlock}`
@@ -796,10 +789,6 @@ exports.apply = async function apply(ctx, cfg) {
       .replace(/\{theme\}/g, userPrompt)
       .replace(/\{search_block\}/g, searchBlockText)
       .replace(/\{character_rule\}/g, characterRule)
-      .replace(/\{outfit_transfer_rule\}/g, '')
-      .replace(/\{reference_rule\}/g, '')
-      .replace(/\{img2img_rule\}/g, img2imgRule)
-      .replace(/\{sensual_rule\}/g, '')
       .replace(/[ \t]+\n/g, '\n')
       .replace(/\n{3,}/g, '\n\n')
       .trim()
@@ -849,54 +838,9 @@ exports.apply = async function apply(ctx, cfg) {
     }
   }
 
-  function extractSeriesOptimizeJson(text) {
-    let raw = String(text || '').trim()
-    if (raw.startsWith('```')) raw = (raw.match(/```(?:json)?([\s\S]*?)```/) || [null, raw])[1].trim()
-    const start = raw.indexOf('{')
-    const end = raw.lastIndexOf('}')
-    if (start === -1 || end === -1 || end <= start) return null
-    try { return JSON.parse(raw.slice(start, end + 1)) } catch (e) { return null }
-  }
-
-  function filterFixedTags(tags, drops) {
-    if (!tags) return ''
-    const dropKeys = (drops || []).map(d => canonicalTagText(String(d))).filter(Boolean)
-    if (!dropKeys.length) return tags
-    return splitTags(tags)
-      .filter(t => !dropKeys.some(k => k && canonicalTagText(t).includes(k)))
-      .join(', ')
-  }
-
-  // 连续图专用的阶段优化：LLM 把「角色 + 阶段描述」转成 Danbooru tags，并返回
-  // 要从固定角色 tags 中移除的冲突项（如固定 silver hair、阶段变成 black hair）。
-  async function optimizeSeriesStage(userPrompt, identity) {
-    if (!cfg.llmModel || !cfg.llmBaseUrl) {
-      return { ok: false, prompt: userPrompt, drops: [], reason: 'llm_not_configured' }
-    }
-    const fixedTags = identity && parsePresetList(cfg.fixedCharacters)[identity]
-      ? parsePresetList(cfg.fixedCharacters)[identity]
-      : ''
-    const template = `你是为图像生成模型编写正面提示词的 AI 画师。这是「同一个角色」的连续变化过程中的某一个阶段。\n\n用户给出一行描述：<角色身份>，<本阶段的外貌/状态描述>。\n\n固定角色 tags（身份锚点，包含角色名标签、种族、体型、标志特征，也可能包含发色、瞳色等默认外观）：\n${fixedTags || '（无）'}\n\n输出要求：\n- 只输出一个 JSON 对象，不要 Markdown、不要解释、不要其他任何文字：\n{\n  "stage_tags": "一行英文 Danbooru-style tags，用于本阶段画面，英文逗号分隔；不含 masterpiece/best quality 等质量前缀，不含画师 tags",\n  "drop_fixed": ["要从固定 tags 中移除的标签列表；仅当本阶段描述明确改变了该外观时才列出"]\n}\n- 身份一致性：若用户描述的就是固定角色，stage_tags 必须包含该角色的角色名标签（如 kokkoro_(princess_connect!)），并保留种族、体型、标志特征等「不变的底层身份」。\n- 覆盖规则：本阶段描述明确提到的变化（发色、瞳色、表情、眼神、气质、种族变化等）必须体现在 stage_tags 中，并在 drop_fixed 中列出被替换掉的固定标签（措辞与固定 tags 一致或接近）。\n- 本阶段描述与固定 tags 无冲突时，drop_fixed 为 []。\n\n本阶段描述：\n{theme}`
-    const rendered = template.replace(/\{theme\}/g, userPrompt)
-    try {
-      const text = await llmChat({ system: rendered, user: userPrompt, maxTokens: Math.min(parseInt(cfg.llmMaxTokens) || 700, 900) })
-      const data = extractSeriesOptimizeJson(text)
-      if (data && String(data.stage_tags || '').trim()) {
-        const drops = Array.isArray(data.drop_fixed) ? data.drop_fixed.map(String).filter(Boolean) : []
-        return { ok: true, prompt: String(data.stage_tags).trim(), drops, reason: '' }
-      }
-      // JSON 解析失败：把整段文本当作阶段 tags，不剔除固定标签
-      return { ok: true, prompt: text, drops: [], reason: '' }
-    } catch (e) {
-      const reason = String(e && e.message || e)
-      logger.warn(`连续图阶段优化失败：${reason}`)
-      return { ok: false, prompt: userPrompt, drops: [], reason }
-    }
-  }
-
   // ---------------- 提示词组装 ----------------
   // fixedOverride：undefined=按名称自动匹配固定角色；'skip'=不注入固定角色；字符串=直接使用该字符串作为固定角色 tags
-  function composePrompt(userPrompt, raw, fixedOverride) {
+  async function composePrompt(userPrompt, raw, fixedOverride) {
     if (raw) return { prompt: userPrompt, degraded: false }
     const parts = []
     if (cfg.qualityPrefix) parts.push(String(cfg.qualityPrefix).trim())
@@ -905,7 +849,7 @@ exports.apply = async function apply(ctx, cfg) {
     } else if (typeof fixedOverride === 'string') {
       if (String(fixedOverride).trim()) parts.push(String(fixedOverride).trim())
     } else {
-      for (const [name, tags] of Object.entries(parsePresetList(cfg.fixedCharacters))) {
+      for (const { name, tags } of await fixedCharacterRows()) {
         if (name && userPrompt.includes(name)) {
           parts.push(tags)
           break
@@ -965,7 +909,7 @@ exports.apply = async function apply(ctx, cfg) {
   // 多人规划：让 LLM 输出结构化场景 JSON（2-4 人）。
   async function generateMultiPersonPlan(prompt) {
     const mentioned = {}
-    for (const [name, tags] of Object.entries(parsePresetList(cfg.fixedCharacters))) {
+    for (const { name, tags } of await fixedCharacterRows()) {
       if (name && prompt.includes(name)) mentioned[name] = tags
     }
     const planPrompt = buildMultiPersonPlanPrompt(prompt, mentioned)
@@ -1011,7 +955,7 @@ exports.apply = async function apply(ctx, cfg) {
   }
 
   // 多人最终提示词组装：count/common tags + 角色块 + 互动 + 构图。
-  function buildMultiPersonFinalPrompt(plan, prompt) {
+  async function buildMultiPersonFinalPrompt(plan, prompt) {
     const aliases = ['Character A', 'Character B', 'Character C', 'Character D']
     const characterCount = plan.characters.length
     const characterRoles = []
@@ -1027,7 +971,7 @@ exports.apply = async function apply(ctx, cfg) {
 
     const usedFixedNames = new Set()
     const fixedGenders = []
-    const configuredChars = parsePresetList(cfg.fixedCharacters)
+    const configuredChars = Object.fromEntries((await fixedCharacterRows()).map(({ name, tags }) => [name, tags]))
     for (let index = 0; index < plan.characters.length; index++) {
       const character = plan.characters[index]
       let fixedName = ''
@@ -1196,11 +1140,11 @@ exports.apply = async function apply(ctx, cfg) {
 
   // 视觉校验（anima_verify + generation_verifier 移植）：对生成的图片跑视觉 LLM，
   // 不合格则用相同提示词重试（最多 multiCandidateCount 张），按多候选规则挑选并返回结果。
-  async function verifyGeneratedImages(session, images, userRequest, prompt, size, planCount, unet, negativePrompt) {
+  async function verifyGeneratedImages(session, images, userRequest, prompt, size, planCount, unet, negativePrompt) {
     const verifyBaseUrl = String(cfg.verifyLlmBaseUrl || '').trim()
     const verifyModel = String(cfg.verifyLlmModel || '').trim()
     if (!verifyBaseUrl || !verifyModel) {
-      return { ok: true, degraded: true, message: '', verdict: null, outputs: images, prompt, negativePrompt }
+      return { ok: true, degraded: true, message: '', verdict: null, outputs: images, prompt, negativePrompt }
     }
     const passScore = Math.max(0, Math.min(10, parseInt(cfg.multiVerifyPassScore) || 6))
     const candidateCount = Math.max(1, Math.min(3, parseInt(cfg.multiCandidateCount) || 2))
@@ -1208,10 +1152,10 @@ exports.apply = async function apply(ctx, cfg) {
     const systemPrompt = buildVerifySystemPrompt(true, planCount)
     const candidates = []
     let lastVerdict = null
-    let retries = 0
-    let currentImages = images
-    let currentPrompt = prompt
-    let currentNegativePrompt = negativePrompt
+    let retries = 0
+    let currentImages = images
+    let currentPrompt = prompt
+    let currentNegativePrompt = negativePrompt
 
     async function verifyOnce(imgs, userReq) {
       const controller = new AbortController()
@@ -1309,15 +1253,15 @@ exports.apply = async function apply(ctx, cfg) {
         data = extractVerifyJson(reply)
       } catch (e) {
         logger.warn(`多人视觉校验失败：${e.message}`)
-        return { ok: true, degraded: true, message: session.text('.multi-verify-error', [String(e && e.message || e)]), verdict: null, outputs: images, prompt: currentPrompt, negativePrompt: currentNegativePrompt }
+        return { ok: true, degraded: true, message: session.text('.multi-verify-error', [String(e && e.message || e)]), verdict: null, outputs: images, prompt: currentPrompt, negativePrompt: currentNegativePrompt }
       }
       if (!data) {
         logger.warn(`多人视觉校验返回无法解析：${reply.slice(0, 200)}`)
-        return { ok: true, degraded: true, message: '', verdict: null, outputs: images, prompt: currentPrompt, negativePrompt: currentNegativePrompt }
+        return { ok: true, degraded: true, message: '', verdict: null, outputs: images, prompt: currentPrompt, negativePrompt: currentNegativePrompt }
       }
       const verdict = verdictFromData(data)
       verdict.skipped = false
-      candidates.push({ outputs: currentImages, verdict, prompt: currentPrompt, negativePrompt: currentNegativePrompt })
+      candidates.push({ outputs: currentImages, verdict, prompt: currentPrompt, negativePrompt: currentNegativePrompt })
       selectedOutputs = currentImages
       selectedVerdict = verdict
 
@@ -1331,13 +1275,13 @@ exports.apply = async function apply(ctx, cfg) {
       if (hint) {
         currentPrompt = `${userRequest}\n【上次问题，请修正】${hint}`
       }
-      const regen = await runComfyGenerate(currentPrompt, size, { unet, negativePrompt: currentNegativePrompt })
+      const regen = await runComfyGenerate(currentPrompt, size, { unet, negativePrompt: currentNegativePrompt })
       if (!regen.ok) {
         logger.warn(`多人校验重试生成失败：${regen.message}`)
         break
       }
-      currentImages = regen.outputs
-      currentNegativePrompt = regen.negativePrompt || currentNegativePrompt
+      currentImages = regen.outputs
+      currentNegativePrompt = regen.negativePrompt || currentNegativePrompt
     }
 
     // 多候选挑选
@@ -1348,7 +1292,7 @@ exports.apply = async function apply(ctx, cfg) {
     selectedOutputs = best.outputs
     selectedVerdict = best.verdict
     if (!multiAccepted && !cfg.multiSendDegradedCandidate) {
-      return { ok: false, discarded: true, message: session.text('.multi-verify-discarded'), verdict: selectedVerdict, outputs: [], prompt: best.prompt, negativePrompt: best.negativePrompt }
+      return { ok: false, discarded: true, message: session.text('.multi-verify-discarded'), verdict: selectedVerdict, outputs: [], prompt: best.prompt, negativePrompt: best.negativePrompt }
     }
     const noteParts = []
     if (multiAccepted) {
@@ -1357,7 +1301,7 @@ exports.apply = async function apply(ctx, cfg) {
       noteParts.push(session.text('.multi-verify-degraded', selectedVerdict.issues.length ? '（' + selectedVerdict.issues.join('；').slice(0, 80) + '）' : ''))
     }
     if (retries) noteParts.push(session.text('.multi-verify-failed', [selectedVerdict.issues.length ? '：' + selectedVerdict.issues.join('；').slice(0, 80) : '', retries]))
-    return { ok: true, degraded: false, message: noteParts.join('\n'), verdict: selectedVerdict, outputs: selectedOutputs, prompt: best.prompt, negativePrompt: best.negativePrompt }
+    return { ok: true, degraded: false, message: noteParts.join('\n'), verdict: selectedVerdict, outputs: selectedOutputs, prompt: best.prompt, negativePrompt: best.negativePrompt }
   }
 
   function buildVerifySystemPrompt(multiPerson, planCount) {
@@ -1370,7 +1314,7 @@ exports.apply = async function apply(ctx, cfg) {
   }
 
   // 共享批量执行器：一次性扣除总价，逐张生成，单张失败只退该张单价。
-  // runOne(i) 需返回 { ok, outputs, seed, prompt, negativePrompt, message? }；返回数组为多张输出（如视觉校验候选）。
+  // runOne(i) 需返回 { ok, outputs, seed, prompt, negativePrompt, message? }；返回数组为多张输出（如视觉校验候选）。
   async function executeBatch(USERID, isAdmin, count, unitPrice, runOne) {
     const results = []
     let successCount = 0
@@ -1384,7 +1328,7 @@ exports.apply = async function apply(ctx, cfg) {
       const outputs = Array.isArray(item.outputs) ? item.outputs : (item.outputs ? [item.outputs] : [])
       if (item.ok && outputs.length) {
         successCount += 1
-        results.push({ i, ok: true, outputs, seed: item.seed, prompt: item.prompt || '', negativePrompt: item.negativePrompt || '', note: item.note || '' })
+        results.push({ i, ok: true, outputs, seed: item.seed, prompt: item.prompt || '', negativePrompt: item.negativePrompt || '', note: item.note || '' })
       } else {
         if (!isAdmin) await refundP(USERID, unitPrice)
         if (cfg.outputLogs) logger.warn(`批量第 ${i + 1} 张生成失败（${USERID}）：${item.message || '无输出'}`)
@@ -1441,7 +1385,7 @@ exports.apply = async function apply(ctx, cfg) {
     const plan = planResult.plan
 
     // 组装最终提示词
-    const built = buildMultiPersonFinalPrompt(plan, text)
+    const built = await buildMultiPersonFinalPrompt(plan, text)
     if (!built.ok) {
       return session.text('.multi-usage') + '\n（多人规划失败：' + built.error + '）'
     }
@@ -1465,10 +1409,9 @@ exports.apply = async function apply(ctx, cfg) {
     // 即时反馈
     const notice = []
     if (parsedBatch.clamped) notice.push(session.text('.batch-limit', [count]))
-    const feedback = feedbackBase(session, { firstPosition, count, totalPrice: count * price, isAdmin })
-    notice.push(...feedback.notices)
-    await sendNotices(session, notice)
-    await sendNotices(session, [feedback.chargeNotice], { quote: true })
+    const feedback = feedbackBase(session, { firstPosition, count })
+    notice.push(...feedback.notices)
+    await sendNotices(session, notice)
 
     // 单张生成 +（可选）视觉校验
     const runOne = async (i) => {
@@ -1478,27 +1421,27 @@ exports.apply = async function apply(ctx, cfg) {
       } else {
         try { result = await runComfyGenerate(finalPrompt, size, { negativePrompt: multiNegative, unet }) } catch (e) { result = { ok: false, message: `生成失败：${e.message}` } }
       }
-      if (!result.ok || !result.outputs || !result.outputs.length) return result
-      if (!cfg.multiVerifyEnabled) {
-        return { ok: true, outputs: result.outputs, seed: result.seed, prompt: finalPrompt, negativePrompt: result.negativePrompt, note: session.text('.multi-degraded', ['（未启用校验或未配置视觉模型）']) }
-      }
-      const verified = await verifyGeneratedImages(session, result.outputs, text, finalPrompt, size, plan.characters.length, unet, result.negativePrompt || multiNegative)
-      if (!verified.ok) return { ok: false, message: verified.message }
-      return { ok: true, outputs: verified.outputs, seed: result.seed, prompt: verified.prompt || finalPrompt, negativePrompt: verified.negativePrompt || result.negativePrompt || multiNegative, note: verified.message || '' }
+      if (!result.ok || !result.outputs || !result.outputs.length) return result
+      if (!cfg.multiVerifyEnabled) {
+        return { ok: true, outputs: result.outputs, seed: result.seed, prompt: finalPrompt, negativePrompt: result.negativePrompt, note: session.text('.multi-degraded', ['（未启用校验或未配置视觉模型）']) }
+      }
+      const verified = await verifyGeneratedImages(session, result.outputs, text, finalPrompt, size, plan.characters.length, unet, result.negativePrompt || multiNegative)
+      if (!verified.ok) return { ok: false, message: verified.message }
+      return { ok: true, outputs: verified.outputs, seed: result.seed, prompt: verified.prompt || finalPrompt, negativePrompt: verified.negativePrompt || result.negativePrompt || multiNegative, note: verified.message || '' }
     }
 
     const { results, successCount } = await executeBatch(USERID, isAdmin, count, price, runOne)
 
-    // 汇总
-    const allOutputs = []
-    const forwardOutputs = []
-    const notes = []
+    // 汇总
+    const allOutputs = []
+    const forwardOutputs = []
+    const notes = []
     const seeds = []
     const failures = []
     for (const item of results) {
-      if (item.ok) {
-        allOutputs.push(...item.outputs)
-        forwardOutputs.push(...item.outputs.map(src => ({ src, prompt: item.prompt || finalPrompt, negativePrompt: item.negativePrompt })))
+      if (item.ok) {
+        allOutputs.push(...item.outputs)
+        forwardOutputs.push(...item.outputs.map(src => ({ src, prompt: item.prompt || finalPrompt, negativePrompt: item.negativePrompt })))
         if (item.seed != null) seeds.push(item.seed)
         if (item.note) notes.push(item.note)
       } else {
@@ -1506,6 +1449,14 @@ exports.apply = async function apply(ctx, cfg) {
       }
     }
 
+    const chargeNotice = buildChargeNotice({
+      isAdmin,
+      totalPrice: successCount * price,
+      unetName: unet,
+      seeds,
+    })
+    await sendNotices(session, [chargeNotice], { quote: true })
+
     if (!allOutputs.length) {
       if (cfg.outputLogs) logger.warn(`多人生成全部失败（${USERID}），已按张退款`)
       return session.text('.generate-failed', ['全部失败（已按张退款）'])
@@ -1513,8 +1464,8 @@ exports.apply = async function apply(ctx, cfg) {
 
     if (cfg.outputLogs) logger.success(`${USERID} 多人生成成功 ${successCount}/${count} 张`)
 
-    // 发图：合并转发，不引用原指令
-    await sendImagesAsForward(session, forwardOutputs)
+    // 发图：合并转发，不引用原指令
+    await sendImagesAsForward(session, forwardOutputs)
 
     const reply = []
     if (count > 1) {
@@ -1527,174 +1478,6 @@ exports.apply = async function apply(ctx, cfg) {
     return reply.filter(Boolean).join('\n')
   }
 
-  // 连续图/过程图主流程：同一角色多阶段（固定身份 + 阶段描述 + 全阶段共用同一 seed 保证一致性）
-  // 语法：连续 <角色>：<阶段1> → <阶段2> → ...  或  连续 <角色>：<阶段1>|<阶段2>|...
-  // 询问是否使用 LLM 优化，返回 'yes' / 'no' / 'cancel' / null（无法交互或超时）
-  async function askSeriesLLMUse(session) {
-    if (typeof session.prompt !== 'function') return null
-    await session.send(session.text('.series-llm-ask'))
-    const reply = await session.prompt((cfg.seriesAskTimeout || 60) * 1000).catch(() => null)
-    const ans = String((reply && (reply.content != null ? reply.content : reply)) || '').trim()
-    if (/^(是|1|①|用|使用|使用llm|yes|y)$/i.test(ans)) return 'yes'
-    if (/^(否|2|②|不用|不使用|不使用llm|不优化|不用llm|no|n)$/i.test(ans)) return 'no'
-    if (/^(取消|3|③|算了|不生成|cancel|c)$/i.test(ans)) return 'cancel'
-    if (!ans) return null
-    await session.send(session.text('.series-llm-invalid'))
-    return askSeriesLLMUse(session)
-  }
-
-  async function handleGenerateSeries(session, rawText) {
-    const USERID = session.userId
-    const isAdmin = isAdminUser(session)
-    const unet = await resolveUnet(USERID)
-    const price = Math.max(0, parseInt(cfg.price) || 500)
-
-    // 阶段分隔符：箭头 / 管道
-    const STAGE_SEP = /→|➔|➜|←|↔|=>|->|⇒|\|/
-
-    // 尺寸解析（连续图默认横图）；固定 seed：全阶段共用，支持 --seed 覆盖（含 --seed: 冒号形式）
-    const seedInfo = parseSeed(String(rawText || ''))
-    const seed = seedInfo.seed != null ? seedInfo.seed : crypto.randomInt(1, 2 ** 32 - 1)
-    const allowed = parseAllowedSizes()
-    const parsedSize = parseGenerationSize(seedInfo.prompt, allowed)
-    if (parsedSize.error) return parsedSize.error
-    let size = parsedSize.size
-    if (!size && allowed.length) {
-      size = allowed.reduce((best, s) => {
-        const a = Math.abs(s[0] / s[1] - 16 / 9)
-        const b = Math.abs(best[0] / best[1] - 16 / 9)
-        return a < b ? s : best
-      })
-    }
-    const sizeCleanedPrompt = parsedSize.prompt
-
-    // 提取身份与阶段文本（角色：阶段1 → 阶段2）
-    let identity = ''
-    let stageText = String(sizeCleanedPrompt || '').trim()
-    const colonMatch = stageText.match(/^(.+?)[：:]\s*(.+)$/)
-    if (colonMatch) {
-      identity = colonMatch[1].trim()
-      stageText = colonMatch[2].trim()
-    }
-    const stages = stageText
-      .split(STAGE_SEP)
-      .map(s => s.trim().replace(/^[\s,，、;；:：]+|[\s,，、;；:：]+$/g, '').replace(/\s+/g, ' '))
-      .filter(Boolean)
-    if (!stages.length) return session.text('.series-usage')
-
-    const maxStages = Math.max(1, parseInt(cfg.batchMax) || 4)
-    const count = Math.min(stages.length, maxStages)
-    const clamped = stages.length > count
-    const stageList = stages.slice(0, count)
-
-    // P 点校验（按总价）
-    const pcheck = await precheckPoints(session, USERID, isAdmin, count * price)
-    if (!pcheck.ok) return pcheck.message
-
-    // ComfyUI 就绪
-    const ready = await ensureComfyuiReady()
-    if (!ready.ok) return ready.message
-
-    // 询问是否使用 LLM 优化：是=用 LLM / 否=直接使用原始描述 / 取消=不生成。
-    // 未配置 LLM 或平台不支持交互式询问时，沿用原有「配置了 LLM 就逐阶段优化」行为。
-    let useLLM = true
-    if (cfg.llmModel && cfg.llmBaseUrl && typeof session.prompt === 'function') {
-      const choice = await askSeriesLLMUse(session)
-      if (choice === 'cancel') return ''
-      if (choice === 'no') useLLM = false
-    }
-
-    // 组装各阶段提示词：身份（含固定角色 tags）+ 阶段描述。
-    // 使用 LLM 时逐阶段优化（不受 promptOptimizeEnabled 限制），因为 anima 是
-    // Danbooru-tag 模型，中文阶段描述必须转成 tags 才能体现在画面里；
-    // 用户选择「否」或未配置 LLM 时，直接使用各阶段原始描述（不注入身份前缀）。
-    const fixedChars = parsePresetList(cfg.fixedCharacters)
-    const stagePrompts = []
-    let degradedStages = 0
-    for (const st of stageList) {
-      const base = identity ? `${identity}，${st}` : st
-      const result = useLLM
-        ? await optimizeSeriesStage(base, identity)
-        : { ok: true, prompt: st, drops: [], reason: 'user_skipped_llm' }
-      if (!result.ok) degradedStages += 1
-      const stageTags = result.prompt || base
-      const drops = result.drops || []
-      // 始终注入固定角色 tags 作为身份锚点（保证角色名/种族/尖耳朵出现），
-      // 阶段描述里被明确改变的外观由 drop 列表剔除，避免被固定默认值拉回。
-      const identityTags = identity ? filterFixedTags(fixedChars[identity] || '', drops) : ''
-      const anchor = stageTags
-      const composed = composePrompt(anchor, false, identityTags)
-      stagePrompts.push(composed.prompt)
-    }
-
-    // 扣 P 点（一次性扣除总价）
-    if (!isAdmin) {
-      const saving = await deductP(USERID, count * price)
-      if (cfg.outputLogs) logger.info(`[p-draw] ${USERID} 连续图已扣除 ${count * price} P 点（${count} 阶段 × ${price}，seed=${seed}），余额 ${saving - count * price}`)
-    }
-
-    // 队列：预排队全部阶段（先查容量再入队）
-    const queued = await enqueueBatch(count, (i) => runComfyGenerate(stagePrompts[i], size, { seed, unet }), { USERID, isAdmin, totalPrice: count * price })
-    if (!queued.ok) return queued.message
-    const queuedTasks = queued.tasks
-    const firstPosition = queued.firstPosition
-
-    // 即时反馈
-    const notice = []
-    if (clamped) notice.push(session.text('.batch-limit', [count]))
-    if (identity && fixedChars[identity]) notice.push(`已固定角色「${identity}」的身份 tags，各阶段外观将保持一致。`)
-    if (!useLLM) notice.push(session.text('.series-no-llm'))
-    if (degradedStages) notice.push(session.text('.prompt-degraded', ['（连续图阶段优化失败，已使用原始描述）']))
-    const feedback = feedbackBase(session, { firstPosition, count, totalPrice: count * price, isAdmin })
-    notice.push(...feedback.notices)
-    await sendNotices(session, notice)
-    await sendNotices(session, [feedback.chargeNotice], { quote: true })
-
-    // 单阶段生成（共用 seed）
-    const runOne = async (i) => {
-      let result
-      if (cfg.queueEnabled) {
-        try { result = await queuedTasks[i] } catch (e) { result = { ok: false, message: `生成失败：${e.message}` } }
-      } else {
-        try { result = await runComfyGenerate(stagePrompts[i], size, { seed, unet }) } catch (e) { result = { ok: false, message: `生成失败：${e.message}` } }
-      }
-      result.prompt = stagePrompts[i]
-      return result
-    }
-
-    const { results, successCount } = await executeBatch(USERID, isAdmin, count, price, runOne)
-
-    // 汇总
-    const allOutputs = []
-    const forwardOutputs = []
-    const seeds = []
-    const failures = []
-    for (const item of results) {
-      if (item.ok) {
-        allOutputs.push(...item.outputs)
-        forwardOutputs.push(...item.outputs.map(src => ({ src, prompt: item.prompt || stagePrompts[item.i] || '', negativePrompt: item.negativePrompt })))
-        if (item.seed != null) seeds.push(item.seed)
-      } else {
-        failures.push(`第 ${item.i + 1} 阶段：${item.message}`)
-      }
-    }
-
-    if (!allOutputs.length) {
-      if (cfg.outputLogs) logger.warn(`连续图全部失败（${USERID}），已按阶段退款`)
-      return session.text('.generate-failed', ['全部失败（已按阶段退款）'])
-    }
-
-    if (cfg.outputLogs) logger.success(`${USERID} 连续图生成成功 ${successCount}/${count} 阶段（seed=${seed}）`)
-
-    // 发图：合并转发，不引用原指令
-    await sendImagesAsForward(session, forwardOutputs)
-
-    const reply = []
-    reply.push(session.text('.series-ok', [count * price, successCount, seed]))
-    if (failures.length) reply.push(session.text('.batch-partial', [successCount, count, failures.length, failures.join('；')]))
-    return reply.filter(Boolean).join('\n')
-  }
-
   // ---------------- 权限 ----------------
   function readableOptimizeReason(reason) {
     if (!reason) return ''
@@ -1776,7 +1559,6 @@ exports.apply = async function apply(ctx, cfg) {
   // 注意：更新数据里不能带主键 id，否则数据库驱动会报 cannot modify primary key
   function runtimeState() {
     return {
-      fixed_characters: cfg.fixedCharacters || [],
       artist_presets: cfg.artistPresets || [],
       active_artist_preset: cfg.activeArtistPreset || '',
       default_artist_tags: cfg.defaultArtistTags || '',
@@ -1784,20 +1566,25 @@ exports.apply = async function apply(ctx, cfg) {
     }
   }
 
-  // 启动时把数据库里保存的画师组/固定角色合并进 cfg（数据库覆盖配置，保证运行时新增不被重启丢失）
+  let legacyRuntimeFixedCharacters = []
+  let fixedCharactersMigrated = false
+
+  // 启动时加载 p_draw_config 中仍归属该表的运行时数据。
+  // fixed_characters 只作为旧版本迁移输入，运行时不再覆盖 cfg.fixedCharacters。
   async function loadRuntimeState() {
     try {
       const rows = await ctx.database.get('p_draw_config', { id: 1 })
       const row = rows && rows[0]
       if (!row) return
-      if (Array.isArray(row.fixed_characters)) cfg.fixedCharacters = row.fixed_characters
+      if (Array.isArray(row.fixed_characters)) legacyRuntimeFixedCharacters = row.fixed_characters
+      fixedCharactersMigrated = row.fixed_characters_migrated === true
       if (Array.isArray(row.artist_presets)) cfg.artistPresets = row.artist_presets
       if (row.active_artist_preset) cfg.activeArtistPreset = row.active_artist_preset
       if (row.default_artist_tags != null) cfg.defaultArtistTags = row.default_artist_tags
       if (row.user_models && typeof row.user_models === 'object') cfg.userModels = row.user_models
-      if (cfg.outputLogs) logger.info(`[p-draw] 已加载运行时配置（画师组 ${(cfg.artistPresets || []).length} 个，固定角色 ${(cfg.fixedCharacters || []).length} 个，模型偏好 ${Object.keys(cfg.userModels || {}).length} 个）`)
+      if (cfg.outputLogs) logger.info(`[p-draw] 已加载运行时配置（画师组 ${(cfg.artistPresets || []).length} 个，模型偏好 ${Object.keys(cfg.userModels || {}).length} 个）`)
     } catch (e) {
-      logger.warn(`读取运行时配置失败（画师组/固定角色可能未持久化）：${e.message}`)
+      logger.warn(`读取运行时配置失败（画师组或模型偏好可能未持久化）：${e.message}`)
     }
   }
 
@@ -1816,6 +1603,29 @@ exports.apply = async function apply(ctx, cfg) {
     }
   }
 
+  async function migrateFixedCharacters() {
+    if (fixedCharactersMigrated) return
+    const existingRows = await fixedCharacterRows()
+    const existingNames = new Set(existingRows.map(row => row.name))
+    const legacyEntries = [...(cfg.fixedCharacters || []), ...legacyRuntimeFixedCharacters]
+    for (const entry of legacyEntries) {
+      const parsed = parseNameTags(entry)
+      if (!parsed || existingNames.has(parsed.name)) continue
+      await ctx.database.create('p_draw_fixed_characters', {
+        name: parsed.name,
+        tags: parsed.tags,
+      })
+      existingNames.add(parsed.name)
+    }
+    const existingConfig = await ctx.database.get('p_draw_config', { id: 1 })
+    if (existingConfig && existingConfig[0]) {
+      await ctx.database.set('p_draw_config', { id: 1 }, { fixed_characters_migrated: true })
+    } else {
+      await ctx.database.create('p_draw_config', { id: 1, ...runtimeState(), fixed_characters_migrated: true })
+    }
+    fixedCharactersMigrated = true
+  }
+
   function normalizeTagText(text) {
     const tags = []
     for (const tag of String(text || '').split(',')) {
@@ -1848,18 +1658,6 @@ exports.apply = async function apply(ctx, cfg) {
         return await diagnoseText(session)
       }
 
-      // 连续图指令：p-draw 连续 <角色>：<阶段1> → <阶段2>
-      const seriesMatch = text.match(/^连续\s*(.*)$/)
-      if (seriesMatch) {
-        return await handleGenerateSeries(session, seriesMatch[1].trim())
-      }
-
-      // 以图生图指令：p-draw i2i <描述>（需同一条消息附带原图）
-      const i2iMatch = text.match(/^i2i\s*(.*)$/i)
-      if (i2iMatch) {
-        return await handleGenerateI2I(session, i2iMatch[1].trim())
-      }
-
       // 多人指令：p-draw 多人 <描述>
       const multiMatch = text.match(/^(?:多人|多人生图|双人|三人|群像)\s*(.*)$/)
       if (multiMatch) {
@@ -1945,12 +1743,27 @@ exports.apply = async function apply(ctx, cfg) {
       if (addCharacter) {
         const parsed = parseNameTags(addCharacter[1])
         if (!parsed) return session.text('.character-format')
-        const chars = parsePresetList(cfg.fixedCharacters)
-        chars[parsed.name] = normalizeTagText(parsed.tags)
-        await persistConfig('fixedCharacters', Object.entries(chars).map(([n, t]) => `${n}=${t}`))
+        const tags = normalizeTagText(parsed.tags)
+        const existing = (await fixedCharacterRows({ name: parsed.name }))[0]
+        if (existing) await ctx.database.set('p_draw_fixed_characters', { id: existing.id }, { name: parsed.name, tags })
+        else await ctx.database.create('p_draw_fixed_characters', { name: parsed.name, tags })
         if (cfg.outputLogs) logger.success(`${USERID} 添加固定角色 ${parsed.name}`)
         return session.text('.character-created', [parsed.name, parsed.tags])
       }
+      if (text.match(/^(?:查看|列出|显示)\s*(?:固定)?\s*角色$|^(?:固定)?\s*角色列表$/)) {
+        const rows = await fixedCharacterRows()
+        if (!rows.length) return '固定角色：无'
+        return ['固定角色：', ...rows.map(row => `- ${row.name}：${row.tags}`)].join('\n')
+      }
+      const deleteCharacter = text.match(/^(?:删除|移除)\s*(?:固定)?\s*角色\s*(.*)$/)
+      if (deleteCharacter) {
+        const name = String(deleteCharacter[1]).trim()
+        if (!name) return session.text('.character-delete-format')
+        const existing = (await fixedCharacterRows({ name }))[0]
+        if (!existing) return session.text('.character-not-found', [name])
+        await ctx.database.remove('p_draw_fixed_characters', { id: existing.id })
+        return session.text('.character-deleted', [name])
+      }
 
       // 模型切换：p-draw 模型 <名称>（查看）/ p-draw 模型 默认（重置）
       const modelMatch = text.match(/^(?:切换)?\s*模型\s*(.*)$/)
@@ -1985,230 +1798,10 @@ exports.apply = async function apply(ctx, cfg) {
       return await handleGenerate(session, text)
     })
 
-  // ---------------- 以图生图（p-draw i2i） ----------------
-  async function handleGenerateI2I(session, rawText) {
-    if (cfg.customWorkflowEnabled && cfg.customWorkflowPath) {
-      return session.text('.i2i-no-custom-workflow')
-    }
-    const image = await extractImageFromSession(session)
-    if (!image) return session.text('.i2i-no-image')
-    let uploadName
-    try {
-      uploadName = await uploadImageToComfyui(image)
-    } catch (e) {
-      logger.warn(`上传原图失败：${e.message}`)
-      return session.text('.i2i-upload-fail', [e.message])
-    }
-    if (cfg.outputLogs) logger.info(`[p-draw] i2i ${session.userId} 原图已上传：${uploadName}`)
-
-    // 能力检测（ControlNet / Anima IP-Adapter）
-    const caps = await detectI2ICapabilities()
-
-    // 处理模式：i2iMode=ask 时交互询问；style/ootd/plain 直接固定
-    let mode = 'plain'
-    const cfgMode = String(cfg.i2iMode || 'ask').toLowerCase()
-    if (cfgMode === 'style' || cfgMode === 'ootd') {
-      mode = cfgMode
-    } else if (cfgMode === 'ask' && typeof session.prompt === 'function') {
-      const chosen = await askI2IMode(session)
-      if (chosen === 'cancel') return session.text('.i2i-mode-cancelled')
-      if (chosen === null) {
-        await session.send(session.text('.i2i-mode-cancelled'))
-        return ''
-      }
-      mode = chosen
-      if (mode === 'style') await session.send(session.text('.i2i-mode-style'))
-      if (mode === 'ootd') await session.send(session.text('.i2i-mode-ootd'))
-    }
-    if (cfg.outputLogs) logger.info(`[p-draw] i2i ${session.userId} 模式=${mode} ControlNet=${caps.controlNet.available ? caps.controlNet.model : '-'} IPAdapter=${caps.ipAdapter.available ? 'on' : 'off'}`)
-
-    // 所选模式依赖的节点缺失时给出提示（仍会回退普通 img2img，不中断）
-    const notices = []
-    if (mode === 'style' && (!caps.controlNet.available || !caps.controlNet.model)) {
-      notices.push(session.text('.i2i-no-controlnet'))
-    }
-    if (mode === 'ootd' && (!caps.ipAdapter.available || !String(cfg.i2iIPAdapterPath || '').trim())) {
-      notices.push(session.text('.i2i-no-ipadapter'))
-    }
-    if (notices.length) {
-      try { await session.send(notices.join('\n')) } catch (e) { logger.warn(`发送 i2i 提示失败：${e.message}`) }
-    }
-
-    // 识图：仅当启用、非无优化模式、且已配置 LLM（识图结果会注入提示词优化）时才执行
-    let taggerTags = ''
-    if (cfg.taggerEnabled && cfg.llmModel && cfg.llmBaseUrl && !stripRawPrefix(rawText).raw) {
-      try {
-        taggerTags = await taggerImage(uploadName)
-        if (cfg.outputLogs) logger.info(`[p-draw] i2i ${session.userId} 识图完成：${taggerTags.slice(0, 120)}${taggerTags.length > 120 ? '...' : ''}`)
-      } catch (e) {
-        logger.warn(`识图失败（继续生图）：${e.message}`)
-      }
-    }
-    return await handleGenerate(session, rawText, uploadName, taggerTags, { mode, caps })
-  }
-
-  // 识图预工作流：LoadImage → WD14Tagger|pysssss，读回原图 tags
-  async function taggerImage(uploadName) {
-    const model = String(cfg.taggerModel || 'wd-v1-4-convnext-tagger-v2').trim()
-    const taggerNodeId = '61'
-    const promptBody = {
-      '60': { class_type: 'LoadImage', inputs: { image: uploadName } },
-      [taggerNodeId]: {
-        class_type: 'WD14Tagger|pysssss',
-        inputs: {
-          image: ['60', 0],
-          model,
-          threshold: Number(cfg.taggerThreshold) || 0.35,
-          character_threshold: Number(cfg.taggerCharacterThreshold) || 0.85,
-          replace_underscore: true,
-          trailing_comma: false,
-          exclude_tags: '',
-        },
-      },
-    }
-    const clientId = crypto.randomUUID()
-    const submit = await comfyPost('/prompt', { prompt: promptBody, client_id: clientId }, 20000)
-    const promptId = submit && submit.prompt_id
-    if (!promptId) throw new Error('识图工作流提交失败')
-    const timeoutMs = Math.max(1, parseInt(cfg.timeout) || 300) * 1000
-    const pollMs = Math.max(1, parseInt(cfg.pollInterval) || 2) * 1000
-    const history = await waitComfyResult(ctx, comfyGet, baseUrl(), promptId, clientId, timeoutMs, pollMs)
-    if (!history) throw new Error('识图超时')
-    const nodeOutput = history.outputs && history.outputs[taggerNodeId]
-    const tags = (nodeOutput && Array.isArray(nodeOutput.tags) ? nodeOutput.tags : []).filter(Boolean)
-    const first = String(tags[0] || '').trim()
-    if (!first) throw new Error('识图未返回标签')
-    return first
-  }
-
-  // 从会话消息里取第一张图片并下载为内存 Buffer
-  async function extractImageFromSession(session) {
-    const elements = session.elements || []
-    const img = elements.find((e) => e.type === 'img' || e.type === 'image')
-    if (!img) return null
-    const attrs = img.attrs || img.data || {}
-    const src = String(attrs.src || '')
-    if (!src) return null
-    try {
-      if (/^file:\/\//i.test(src)) {
-        // 修复：Windows 下 file:///K:/... 用 replace 会得到 /K:/...（无法读取），用 fileURLToPath 解析
-        let filePath
-        try {
-          filePath = fileURLToPath(src)
-        } catch (e) {
-          filePath = src.replace(/^file:\/\//i, '')
-        }
-        const buffer = await fsp.readFile(filePath)
-        return { buffer, ext: path.extname(filePath) || '.png' }
-      }
-      if (/^data:/i.test(src)) {
-        const m = src.match(/^data:image\/([a-zA-Z0-9+]+);base64,(.+)$/)
-        if (!m) return null
-        const kind = m[1].toLowerCase()
-        const ext = kind === 'jpeg' ? '.jpg' : kind === 'webp' ? '.webp' : kind === 'png' ? '.png' : '.' + (kind || 'png')
-        return { buffer: Buffer.from(m[2], 'base64'), ext }
-      }
-      const res = await fetch(src)
-      if (!res.ok) return null
-      const buffer = Buffer.from(await res.arrayBuffer())
-      const mime = String(res.headers.get('content-type') || '')
-      const ext = mime.includes('jpeg') ? '.jpg' : mime.includes('webp') ? '.webp' : '.png'
-      return { buffer, ext }
-    } catch (e) {
-      logger.warn(`读取原图失败：${e.message}`)
-      return null
-    }
-  }
-
-  // 上传图片到 ComfyUI input 目录，返回 ComfyUI 使用的文件名
-  async function uploadImageToComfyui(image) {
-    const filename = `pdraw_i2i_${Date.now()}_${crypto.randomBytes(4).toString('hex')}${image.ext || '.png'}`
-    const form = new FormData()
-    form.append('image', new Blob([image.buffer]), filename)
-    form.append('overwrite', 'true')
-    form.append('type', 'input')
-    const res = await fetch(baseUrl() + '/upload/image', { method: 'POST', body: form })
-    if (!res.ok) throw new Error(`HTTP ${res.status}`)
-    const data = await res.json().catch(() => ({}))
-    if (!data || !data.name) throw new Error('ComfyUI 未返回上传文件名')
-    return data.name
-  }
-
-  // 检测 i2i 可用能力：Anima ControlNet-LLLite 节点与权重（comfyui-anima-lllite / kohya-ss/ComfyUI-Anima-LLLite）、
-  // LineArt 预处理器（comfyui_controlnet_aux，可选）与 Anima IP-Adapter 专用节点（comfyui-anima-ipadapter）。
-  // 检测失败全部视为不可用（回退普通 img2img）。
-  // 注意：Qwen-Image InstantX ControlNet 与 Anima（MiniTrainDIT，3584 维）架构不兼容，这里只认 LLLite 权重。
-  async function detectI2ICapabilities() {
-    const caps = { controlNet: { available: false, model: null, preprocessor: 'Canny' }, ipAdapter: { available: false } }
-    let info
-    try {
-      info = await getObjectInfoCached()
-    } catch (e) {
-      return caps
-    }
-    if (!info || typeof info !== 'object') return caps
-    // LineArt 预处理器（comfyui_controlnet_aux）：AnimeLineArt 更贴近漫画线条，优先；LineArt 次之；都没有则回退 Canny
-    if (info.AnimeLineArtPreprocessor) {
-      caps.controlNet.preprocessor = 'AnimeLineArtPreprocessor'
-    } else if (info.LineArtPreprocessor) {
-      caps.controlNet.preprocessor = 'LineArtPreprocessor'
-    }
-    // Anima ControlNet-LLLite：lllite_name 从 models/controlnet 目录读取，只挑 anima-lllite 系权重
-    if (info.AnimaLLLiteApply_sdscripts) {
-      const llliteModels = availableModels(info, 'AnimaLLLiteApply_sdscripts', 'lllite_name')
-      if (cfg.outputLogs) logger.info(`[p-draw] i2i LLLite 节点存在，models/controlnet 文件列表=${JSON.stringify(llliteModels)}`)
-      if (llliteModels.length) {
-        const configured = String(cfg.controlNetModel || '').trim()
-        const norm = (s) => String(s).toLowerCase().replace(/[-_ ]/g, '')
-        const prefers = ['anima-lllite-lineart', 'anima-lllite', 'lllite-lineart', 'lllite']
-        const pool = llliteModels.filter((m) => /lllite/i.test(String(m)))
-        const scored = pool.map((m) => ({ m, s: prefers.reduce((acc, p, i) => acc + (norm(m) === norm(p) ? prefers.length - i : 0), 0) }))
-        scored.sort((a, b) => b.s - a.s)
-        const best = (scored[0] && scored[0].m) || null
-        caps.controlNet.model = configured && llliteModels.includes(configured) ? configured : best
-        caps.controlNet.available = !!caps.controlNet.model
-      }
-      // 换风格专用主模型必须是 28-block（与 LLLite 权重匹配），检测它是否已安装
-      const styleModel = String(cfg.i2iUnetName || '').trim() || cfg.unetName
-      const unetList = availableModels(info, 'UNETLoader', 'unet_name')
-      if (unetList.length && !unetList.includes(styleModel)) {
-        logger.warn(`[p-draw] i2i 换风格专用主模型 ${styleModel} 不在 models/diffusion_models 中（现有：${JSON.stringify(unetList)}）。LLLite 权重为 28-block，请安装 anima-base-v1.0 或修改 i2iUnetName 配置，否则换风格会报 depth_embed slices missing`)
-        caps.controlNet.modelMismatch = true
-      }
-    } else if (cfg.outputLogs) {
-      logger.info('[p-draw] i2i 未检测到 AnimaLLLiteApply_sdscripts 节点（请确认已安装 kohya-ss/ComfyUI-Anima-LLLite 并重启 ComfyUI）')
-    }
-    if (info.AnimaIPAdapterLoader && info.AnimaIPAdapterApply && info.AnimaSiglipeEncodeImage) {
-      caps.ipAdapter.available = true
-    }
-    if (cfg.outputLogs) logger.info(`[p-draw] i2i 能力检测：ControlNet(LLLite)=${JSON.stringify(caps.controlNet)} IPAdapter=${JSON.stringify(caps.ipAdapter)}`)
-    return caps
-  }
-
-  // 交互式询问 i2i 处理模式，返回 'style' / 'ootd' / 'cancel' / null（超时或无法询问时 null）
-  async function askI2IMode(session, i18nAsk) {
-    if (typeof session.prompt !== 'function') return null
-    await session.send(i18nAsk || session.text('.i2i-mode-ask'))
-    const reply = await session.prompt((cfg.i2iAskTimeout || 60) * 1000).catch(() => null)
-    const ans = String((reply && (reply.content != null ? reply.content : reply)) || '').trim()
-    if (/^(1|①|换风格|风格|漫画|漫画化|style|stylechange)$/i.test(ans)) return 'style'
-    if (/^(2|②|换装|换装换姿势|换衣服|换姿势|ootd|outfit)$/i.test(ans)) return 'ootd'
-    if (/^(3|③|取消|不生成|不要|算了|cancel|no)$/i.test(ans)) return 'cancel'
-    if (!ans) return null
-    await session.send(session.text('.i2i-mode-invalid'))
-    return askI2IMode(session, i18nAsk)
-  }
-
-  async function handleGenerate(session, rawText, i2iImage = null, taggerTags = '', i2iOpts = null) {
+  async function handleGenerate(session, rawText) {
     const USERID = session.userId
     const isAdmin = isAdminUser(session)
     const unet = await resolveUnet(USERID)
-    const i2iRule = i2iImage
-      ? '这是以图生图（img2img）：原图的构图、主体与色调会被保留。请主要描述你希望发生的变化（风格、服装、表情、场景改造、细节调整等），不要重复描述原图已有的细节。'
-        + (taggerTags
-          ? `\n\n原图内容参考（本地识图自动识别出的标签，用于了解原图已包含的内容；不要照抄全部标签，只参考与用户改动需求相关的部分）：\n${taggerTags}`
-          : '')
-      : ''
     if (cfg.outputLogs) {
       logger.info(`[p-draw] 请求 userId=${USERID} isAdmin=${isAdmin} adminUsers=${JSON.stringify(cfg.adminUsers || [])} normalizeId=${normalizeId(USERID)}`)
     }
@@ -2222,11 +1815,8 @@ exports.apply = async function apply(ctx, cfg) {
     const parsedBatch = parseBatchCount(parsedSize.prompt, cfg.batchMax)
     // 固定种子解析（--seed:xxx / --seed xxx / --seed=xxx），并从提示词中剥离
     const parsedSeed = parseSeed(parsedBatch.prompt)
-    // i2i 去噪强度解析（--denoise 0.6 / --去噪 0.4），并从提示词中剥离
-    const parsedDenoise = i2iImage ? parseDenoise(parsedSeed.prompt) : { denoise: null, prompt: parsedSeed.prompt }
-    const text = parsedDenoise.prompt
+    const text = parsedSeed.prompt
     const seed = parsedSeed.seed
-    const denoise = parsedDenoise.denoise
     const count = parsedBatch.count
 
     // P 点校验（按总价 = 张数 × 单价）
@@ -2234,12 +1824,12 @@ exports.apply = async function apply(ctx, cfg) {
     const pcheck = await precheckPoints(session, USERID, isAdmin, count * cfg.price)
     if (!pcheck.ok) return pcheck.message
 
-    // 原样模式
-    const stripped = stripRawPrefix(text)
-    const raw = stripped.raw
-    const promptSections = splitPositiveNegativePrompt(stripped.prompt)
-    const userPrompt = promptSections.positive
-    const userNegativePrompt = promptSections.negative
+    // 原样模式
+    const stripped = stripRawPrefix(text)
+    const raw = stripped.raw
+    const promptSections = splitPositiveNegativePrompt(stripped.prompt)
+    const userPrompt = promptSections.positive
+    const userNegativePrompt = promptSections.negative
     if (!userPrompt) return session.text('.no-prompt')
 
     // ComfyUI 就绪
@@ -2261,13 +1851,13 @@ exports.apply = async function apply(ctx, cfg) {
       const tokenOpt = !globalOpt && !isAdmin && cfg.llmModel && cfg.llmBaseUrl
       if (globalOpt) {
         // 全局优化开启：一次优化，整批复用同一提示词
-        const optimized = await optimizePrompt(session, userPrompt, false, i2iRule)
+        const optimized = await optimizePrompt(session, userPrompt, false)
         finalPrompt = optimized.prompt
         degraded = !optimized.ok
         optimizedReason = optimized.reason || ''
       } else if (adminOpt) {
         // 管理员在全局关闭时也免费优化（不耗券）
-        const optimized = await optimizePrompt(session, userPrompt, true, i2iRule)
+        const optimized = await optimizePrompt(session, userPrompt, true)
         finalPrompt = optimized.prompt
         degraded = !optimized.ok
         optimizedReason = optimized.reason || ''
@@ -2308,7 +1898,7 @@ exports.apply = async function apply(ctx, cfg) {
     }
     // 非按张优化模式：直接拼好整批复用的提示词
     if (!perImageOptimize) {
-      const composed = composePrompt(finalPrompt, raw)
+      const composed = await composePrompt(finalPrompt, raw)
       finalPrompt = appendInlineProtectedTags(composed.prompt, userPrompt, raw)
       degraded = degraded || composed.degraded
     }
@@ -2319,16 +1909,11 @@ exports.apply = async function apply(ctx, cfg) {
       if (cfg.outputLogs) logger.info(`[p-draw] ${USERID} 已扣除 ${count * cfg.price} P 点（${count} 张 × ${cfg.price}），余额 ${saving - count * cfg.price}`)
     }
 
-    // i2i 运行参数：模式（style/ootd/plain）、--denoise 覆盖值、检测到的能力
-    const i2iRun = i2iImage
-      ? { i2iImage, i2i: { mode: (i2iOpts && i2iOpts.mode) || 'plain', denoise: denoise != null ? denoise : null, caps: (i2iOpts && i2iOpts.caps) || null } }
-      : {}
-    // 用户手写了 negative: 区块时，默认负面词仍保留；用户 tag 只补充未出现的部分。
-    const generationOverrides = Object.assign(
-      { unet, seed },
-      i2iRun,
-      userNegativePrompt ? { negativePrompt: mergeNegativePrompts(cfg.negativePrompt, userNegativePrompt) } : {},
-    )
+    // 用户手写了 negative: 区块时，默认负面词仍保留；用户 tag 只补充未出现的部分。
+    const generationOverrides = Object.assign(
+      { unet, seed },
+      userNegativePrompt ? { negativePrompt: mergeNegativePrompts(cfg.negativePrompt, userNegativePrompt) } : {},
+    )
 
     // 性能：按张优化（perImageOptimize）时联网搜索只做一次，各图复用同一份结果
     const searchCache = perImageOptimize && wantsWebSearch(userPrompt) ? await webSearch(userPrompt) : null
@@ -2337,11 +1922,11 @@ exports.apply = async function apply(ctx, cfg) {
     const queued = await enqueueBatch(count, async (i) => {
       let p = finalPrompt
       if (perImageOptimize) {
-        const optimized = await optimizePrompt(session, userPrompt, true, i2iRule, searchCache)
-        p = appendInlineProtectedTags(composePrompt(optimized.prompt || userPrompt, raw).prompt, userPrompt, raw)
+        const optimized = await optimizePrompt(session, userPrompt, true, searchCache)
+        p = appendInlineProtectedTags((await composePrompt(optimized.prompt || userPrompt, raw)).prompt, userPrompt, raw)
       }
-      const generated = await runComfyGenerate(p, parsedSize.size, generationOverrides)
-      return { ...generated, prompt: p }
+      const generated = await runComfyGenerate(p, parsedSize.size, generationOverrides)
+      return { ...generated, prompt: p }
     }, { USERID, isAdmin, totalPrice: count * cfg.price })
     if (!queued.ok) return queued.message
     const queuedTasks = queued.tasks
@@ -2364,45 +1949,52 @@ exports.apply = async function apply(ctx, cfg) {
       notice.push(session.text('.no-optimize', [reasons[noOptimizeReason] || noOptimizeReason]))
     }
     if (parsedBatch.clamped) notice.push(session.text('.batch-limit', [count]))
-    const feedback = feedbackBase(session, { firstPosition, count, totalPrice: count * cfg.price, isAdmin })
-    notice.push(...feedback.notices)
-    await sendNotices(session, notice)
-    await sendNotices(session, [feedback.chargeNotice], { quote: true })
+    const feedback = feedbackBase(session, { firstPosition, count })
+    notice.push(...feedback.notices)
+    await sendNotices(session, notice)
 
     // 单张生成
     const runOne = async (i) => {
       let p = finalPrompt
       if (perImageOptimize) {
-        const optimized = await optimizePrompt(session, userPrompt, true, i2iRule, searchCache)
-        p = appendInlineProtectedTags(composePrompt(optimized.prompt || userPrompt, raw).prompt, userPrompt, raw)
+        const optimized = await optimizePrompt(session, userPrompt, true, searchCache)
+        p = appendInlineProtectedTags((await composePrompt(optimized.prompt || userPrompt, raw)).prompt, userPrompt, raw)
       }
       let result
       if (cfg.queueEnabled) {
         try { result = await queuedTasks[i] } catch (e) { result = { ok: false, message: `生成失败：${e.message}` } }
-      } else {
-        try { result = await runComfyGenerate(p, parsedSize.size, generationOverrides) } catch (e) { result = { ok: false, message: `生成失败：${e.message}` } }
-      }
-      if (!result.prompt) result.prompt = p
-      return result
+      } else {
+        try { result = await runComfyGenerate(p, parsedSize.size, generationOverrides) } catch (e) { result = { ok: false, message: `生成失败：${e.message}` } }
+      }
+      if (!result.prompt) result.prompt = p
+      return result
     }
 
     const { results, successCount } = await executeBatch(USERID, isAdmin, count, cfg.price, runOne)
 
-    // 汇总
-    const allOutputs = []
-    const forwardOutputs = []
-    const seeds = []
-    const failures = []
-    for (const item of results) {
-      if (item.ok) {
-        allOutputs.push(...item.outputs)
-        forwardOutputs.push(...item.outputs.map(src => ({ src, prompt: item.prompt || finalPrompt, negativePrompt: item.negativePrompt })))
-        if (item.seed != null) seeds.push(item.seed)
+    // 汇总
+    const allOutputs = []
+    const forwardOutputs = []
+    const seeds = []
+    const failures = []
+    for (const item of results) {
+      if (item.ok) {
+        allOutputs.push(...item.outputs)
+        forwardOutputs.push(...item.outputs.map(src => ({ src, prompt: item.prompt || finalPrompt, negativePrompt: item.negativePrompt })))
+        if (item.seed != null) seeds.push(item.seed)
       } else {
         failures.push(`第 ${item.i + 1} 张：${item.message}`)
       }
     }
 
+    const chargeNotice = buildChargeNotice({
+      isAdmin,
+      totalPrice: successCount * cfg.price,
+      unetName: unet,
+      seeds,
+    })
+    await sendNotices(session, [chargeNotice], { quote: true })
+
     if (!allOutputs.length) {
       if (cfg.outputLogs) logger.warn(`生成全部失败（${USERID}），已按张退款`)
       return session.text('.generate-failed', ['全部失败（已按张退款）'])
@@ -2410,8 +2002,8 @@ exports.apply = async function apply(ctx, cfg) {
 
     if (cfg.outputLogs) logger.success(`${USERID} 生成成功 ${successCount}/${count} 张`)
 
-    // 发图：合并转发，不引用原指令
-    await sendImagesAsForward(session, forwardOutputs)
+    // 发图：合并转发，不引用原指令
+    await sendImagesAsForward(session, forwardOutputs)
 
     const reply = []
     if (count > 1) {
@@ -2550,8 +2142,9 @@ exports.apply = async function apply(ctx, cfg) {
     return price
   }
 
-  // 启动时合并数据库里保存的运行时配置（画师组/固定角色）
+  // 启动时加载配置表，并将旧 fixedCharacters 数据迁入专用表。
   await loadRuntimeState()
+  await migrateFixedCharacters()
 
   ctx.on('dispose', () => {
     // 清理临时文件
@@ -2564,5 +2157,5 @@ exports.apply = async function apply(ctx, cfg) {
   })
 
   // 暴露内部接口供自动化测试调用（Koishi 忽略 apply 返回值，不影响生产行为）
-  return { couponConfirmFlow, buyCouponsAndConsume, normalizeConfirm, resolveCouponPrice, handleGenerateI2I, extractImageFromSession, uploadImageToComfyui, taggerImage, animaI2IWorkflow, animaStyleI2IWorkflow, animaOotdI2IWorkflow, buildI2IWorkflow, detectI2ICapabilities, parseDenoise, sendNotices, sendImagesAsForward, executeBatch }
-}
+  return { couponConfirmFlow, buyCouponsAndConsume, normalizeConfirm, resolveCouponPrice, buildChargeNotice, sendNotices, sendImagesAsForward, executeBatch }
+}