koishi-plugin-p-draw 1.2.12 → 1.3.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 } = require('url')
+const { pathToFileURL, fileURLToPath } = require('url')
 
 exports.name = 'p-draw'
 
@@ -35,155 +35,7 @@ exports.usage = `
   - 可加 \`--denoise 0.6\` 单独调整强度；未装 ControlNet/IPAdapter 时自动回退普通 img2img。
 `;
 
-const zhCN = {
-  comfyuiBaseUrl: { $description: 'ComfyUI 地址' },
-  workflow: { $description: '工作流类型（内置 anima_t2i）' },
-  customWorkflowEnabled: { $description: '使用自定义 ComfyUI 工作流 JSON' },
-  customWorkflowPath: { $description: '自定义工作流 JSON 路径（相对插件目录）' },
-  customWorkflowOverrideParameters: { $description: '用插件参数覆盖自定义工作流参数' },
-  timeout: { $description: '单次生成超时（秒）' },
-  pollInterval: { $description: '生成状态查询间隔（秒）' },
-  unetName: { $description: '主模型文件名' },
-  clipName: { $description: '文本编码器文件名' },
-  vaeName: { $description: 'VAE 文件名' },
-  width: { $description: '默认宽度' },
-  height: { $description: '默认高度' },
-  allowedSizes: { $description: '可用尺寸列表（宽x高）' },
-  steps: { $description: '采样步数' },
-  cfg: { $description: 'CFG 强度' },
-  samplerName: { $description: '采样器' },
-  scheduler: { $description: '调度器' },
-  qualityPrefix: { $description: '质量词前缀' },
-  negativePrompt: { $description: '负面提示词' },
-  promptOptimizeEnabled: { $description: '启用自然语言优化（需要配置下方 LLM 接口）' },
-  llmBaseUrl: { $description: 'LLM 接口地址（OpenAI 兼容，例如 https://api.deepseek.com/v1）' },
-  llmApiKey: { $description: 'LLM API Key' },
-  llmModel: { $description: 'LLM 模型名（留空则不优化，原样生图）' },
-  llmMaxTokens: { $description: 'LLM 输出上限' },
-  webSearchEnabled: { $description: '启用联网搜索（指令里写“联网/搜索/查一下”等触发）' },
-  tavilyApiKey: { $description: 'Tavily API Key（联网搜索用，https://tavily.com 申请）' },
-  webSearchMaxResults: { $description: '联网搜索结果数量' },
-  webSearchDepth: { $description: '搜索深度（basic / advanced）' },
-  webSearchQueryTemplate: { $description: '搜索词模板（{prompt} 代表用户需求）' },
-  promptOptimizeTemplate: { $description: '自然语言优化模板（支持 {theme} {search_block} 占位符）' },
-  fixedCharacters: { $description: '固定角色（格式：角色名=tags）' },
-  artistPresets: { $description: '画师组（格式：名称=tags）' },
-  activeArtistPreset: { $description: '启用的画师组名称' },
-  defaultArtistTags: { $description: '备用画师 tags' },
-  styleTags: { $description: '画风 tags' },
-  queueEnabled: { $description: '启用生成队列（逐张顺序执行）' },
-  queueMaxRequests: { $description: '队列最大任务数（0 表示不限制）' },
-  batchMax: { $description: '单次指令最多生成的张数（支持 x3 / 3张 / --数量 3 等写法）' },
-  price: { $description: '一张图消耗的 P 点' },
-  multiPrice: { $description: '多人指令（p-draw 多人）单张消耗的 P 点' },
-  couponPrice: { $description: '提示词优化券单价（P 点/张，购买询问时显示）' },
-  couponAskTimeout: { $description: '提示词优化券确认等待时间（秒）' },
-  img2imgDenoise: { $description: '普通以图生图（p-draw i2i）的去噪强度，越小越接近原图（建议 0.4-0.7）' },
-  i2iMode: { $description: 'i2i 模式选择方式：ask=每次询问 / style=直接换风格（漫画化）/ ootd=直接换装换姿势 / plain=普通 img2img' },
-  i2iAskTimeout: { $description: 'i2i 模式询问等待时间（秒）' },
-  seriesAskTimeout: { $description: '连续图 LLM 使用确认等待时间（秒）' },
-  i2iStyleDenoise: { $description: '换风格模式（漫画化）的去噪强度，越大风格变化越彻底（建议 0.7-0.85）' },
-  i2iOotdDenoise: { $description: '换装换姿势模式（保留角色）的去噪强度（建议 0.5-0.6）' },
-  i2iControlNetStrength: { $description: '换风格模式的 ControlNet 强度，越大构图锁得越死（建议 0.5-0.8）' },
-  i2iIPAdapterPath: { $description: 'Anima IP-Adapter 模型文件路径（换装换姿势模式保脸用；需安装 comfyui-anima-ipadapter 节点并把模型路径填到这里）' },
-  i2iIPAdapterWeight: { $description: '换装换姿势模式的 IP-Adapter 权重，越大角色特征保留越强（建议 0.6-1.0）' },
-  controlNetModel: { $description: 'ControlNet 模型文件名（留空自动检测 Qwen/Anima 系 ControlNet；需放到 ComfyUI/models/controlnet）' },
-  taggerEnabled: { $description: 'i2i 前自动识图（需 ComfyUI 安装 WD14 Tagger 节点与模型；识别出的标签会注入提示词优化）' },
-  taggerModel: { $description: '识图模型名（WD14 Tagger 节点里可选模型）' },
-  taggerThreshold: { $description: '识图标签置信度阈值' },
-  taggerCharacterThreshold: { $description: '识图角色标签置信度阈值' },
-  adminUsers: { $description: '免 P 点管理员用户 ID 列表' },
-  outputLogs: { $description: '是否在控制台输出详细日志' },
-  multiVerifyEnabled: { $description: '多人图生成后启用视觉校验（需配置下方视觉模型）' },
-  multiVerifyPassScore: { $description: '多人视觉校验合格分数（0-10）' },
-  multiCandidateCount: { $description: '多人候选采样数量（校验失败时最多重试 候选数-1 次）' },
-  multiSendDegradedCandidate: { $description: '多人候选全部不达标时仍发送最优候选' },
-  verifyLlmBaseUrl: { $description: '视觉校验 LLM 接口地址（OpenAI 兼容；留空则跳过校验）' },
-  verifyLlmApiKey: { $description: '视觉校验 LLM API Key' },
-  verifyLlmModel: { $description: '视觉校验 LLM 模型名（需支持图片输入，如 qwen-vl）' },
-  adminOnly: { $description: '仅管理员可用（adminUsers 中的用户）' },
-  allowedUserIds: { $description: '用户白名单（QQ 号，留空表示不限制）' },
-  blockedUserIds: { $description: '用户黑名单（QQ 号，黑名单优先于白名单）' },
-  allowedGroupIds: { $description: 'QQ 群白名单（群号，留空表示不限制）' },
-  blockedGroupIds: { $description: 'QQ 群黑名单（群号，黑名单优先于白名单）' },
-  commands: {
-    'p-draw': {
-      description: '连接本地 ComfyUI 生图，消耗 P 点',
-      messages: {
-        'not-permitted': 'ComfyUI 助手已关闭，或当前用户没有使用权限。',
-        usage: 'p-draw 帮助（本指令名可自行更换，如 /anm）：\n\n【生成】\n  p-draw <描述>\n  例：p-draw 一个女孩，白色裙子，立绘，简单背景\n  可加 --seed 数字 固定种子（单张 / 批量 / 连续图均支持）\n\n【多人生成】\n  p-draw 多人 <描述>（2-4 人画面）\n  例：p-draw 多人 左边若叶睦抱着吉他，右边千早爱音牵着她的手\n\n【连续图】\n  p-draw 连续 <角色>：<阶段1> → <阶段2> → ...\n  例：p-draw 连续 少女：清纯校服 → 换上晚礼服 → 华丽登场\n  全阶段共用同一 seed，角色外观尽量一致；可加 --seed 数字 固定种子\n  阶段分隔：→ / -> / |\n\n【批量张数】\n  描述后加 x3 / ×3 / 3张 / 三张 / --数量 3，例：p-draw 一个女孩 x3\n  多张按 张数×单价 一次性扣 P 点，余额不足则不生成\n\n【尺寸】\n  竖图 / 横图 / 方图 / 长竖图 / 宽屏，或 1024x1536：描述 / --尺寸 1216x832\n  例：p-draw 竖图：狐莉站在梨花树下\n\n【原样模式】\n  p-draw 无优化 masterpiece, best quality, 1girl, solo\n\n【提示词优化】\n  配置 LLM（llmBaseUrl/llmModel）后：\n  全局优化开启 → 每次自动把中文描述转成 Danbooru tags\n  全局优化关闭 → 生图时询问是否使用「提示词优化券」（p-shop 购买，每张图扣 1 张）：\n    有券 → 确认后消耗券并优化，拒绝则取消本次生图\n    没券 → 询问是否购买（显示价格），确认后购买并消耗、优化生图；\n          拒绝一次会再次警告，再拒绝则直接生图（不优化）；\n          P 点不足买不起券时，会询问是否仍然生图\n  无优化 <tags> 原样生图，不耗券\n  连续图逐阶段强制优化；多人指令依赖 LLM 规划（未配置会提示）\n\n【画师组】\n  创建画师组 名称=tags / 追加画师组 名称=tags / 切换画师组 名称 / 查看画师组 / 删除画师组 名称\n\n【固定角色】\n  添加角色 名称=tags\n\n【以图生图】\n  p-draw i2i <描述>，并在同一条消息里附一张原图（文件/截图/链接均可）\n  例：p-draw i2i 换成晚礼服，背景换成舞台灯光\n  发送后会询问处理模式（可配置 i2iMode 固定模式跳过询问）：\n    ① 换风格（漫画化）：保留原图构图，转成二次元画风（需 ControlNet）\n    ② 换装换姿势：保留角色长相，重新设计服装/姿势/场景（需 Anima IP-Adapter）\n    ③ 取消：不生成\n  可加 --denoise 0.6 单独调整强度；未装 ControlNet/IPAdapter 时自动回退普通 img2img\n\n【模型】\n  p-draw 模型（查看当前与可用模型） / p-draw 模型 名称（切换，支持模糊匹配）/ p-draw 模型 默认（重置）\n  例：p-draw 模型 anima-aesthetic\n\n【状态】\n  p-draw 状态（查看 ComfyUI 连接状态与模型可用性）',
-        'account-notExists': '君现在还没有 p 点，请先签到哦',
-        'no-enough-p': '君的 p 点不够 {0}p 哦，先去签个到吧qwq',
-        'no-prompt': '请提供画面描述，例如：p-draw 一个女孩，白色裙子',
-        generating: '正在生成中，请稍候...',
-        charged: '已扣除 {0} P 点，出图后余额会再核对。',
-        queued: '已加入生成队列，当前第 {0} 位（队列上限 {1}）。',
-        'prompt-degraded': '提示词优化服务不可用{0}，本次已使用原始提示词继续生成；结果可能不符合 Danbooru Tag 预期。',
-        'token-used': '已消耗 {0} 张提示词优化券，本次每张图都会使用 LLM 提示词优化。',
-        'token-short': '提示词优化券不足（需 {0} 张，现有 {1} 张），本次未使用 LLM 优化。',
-        'coupon-ask-use': '你有提示词优化券 {0} 张，本次生图需要消耗 {1} 张。\n是否使用提示词优化券进行 LLM 优化？\n（回复「是」使用 / 回复「否」取消本次生图）',
-        'coupon-use-confirmed': '已消耗 {0} 张提示词优化券，本次每张图都会使用 LLM 优化。',
-        'coupon-use-cancelled': '已取消本次生图（未使用提示词优化券）。',
-        'coupon-cancelled': '未收到有效回复，本次操作已取消。',
-        'coupon-ask-buy': '提示词优化券不足（需 {0} 张，现有 {1} 张）。\n提示词优化券价格：{2} P/张，本次共需 {3} P。\n是否购买并使用？\n（回复「是」购买 / 回复「否」不购买）',
-        'coupon-buy-warn': '不使用提示词优化券的话，生成的图可能不好看。\n是否仍要购买并使用提示词优化券？\n（回复「是」购买 / 回复「否」直接生图）',
-        'coupon-bought-used': '已购买 {0} 张提示词优化券（扣除 {1} P），并消耗 {0} 张用于本次 LLM 优化。',
-        'coupon-buy-cancelled': '好的，本次不使用提示词优化券，直接生图。',
-        'coupon-buy-pshort': 'P 点不足，无法购买提示词优化券（需 {0} P，现有 {1} P）。\n是否仍然生图（不使用 LLM 优化）？\n（回复「是」生图 / 回复「否」取消本次生图）',
-        'coupon-consume-fail': '提示词优化券操作失败，本次未使用 LLM 优化。',
-        'generate-failed': '生成失败：{0}',
-        'generate-ok': '已扣除 {0} P 点，seed={1}',
-        'generate-ok-batch': '已扣除 {0} P 点，共 {1} 张（seed：{2}）',
-        'batch-partial': '本次共生成 {0}/{1} 张，失败 {2} 张：{3}',
-        'batch-limit': '每次最多生成 {0} 张，本次已按 {0} 张处理。',
-        'batch-count': '本次共生成 {0} 张。',
-        'artist-format': '请使用「名称=tags」的格式。例：p-draw 创建画师组 千代风格=@artist_a, @artist_b,',
-        'artist-created': '已保存并启用画师组「{0}」：\n{1}',
-        'artist-appended': '已追加画师组「{0}」：\n{1}',
-        'artist-default-appended': '已追加默认画师 tags：\n{0}',
-        'artist-use-format': '请写要启用的画师组名称。例：p-draw 切换画师组 千代风格',
-        'artist-default': '已切回默认画师 tags。',
-        'artist-not-found': '没有找到画师组「{0}」。',
-        'artist-used': '已启用画师组「{0}」：\n{1}',
-        'artist-deleted': '已删除画师组「{0}」。',
-        'artist-delete-format': '请写要删除的画师组名称。例：p-draw 删除画师组 千代风格',
-        'character-format': '请使用「名称=tags」的格式。例：p-draw 添加角色 狐莉=1girl, solo, fox girl',
-        'character-created': '已保存角色「{0}」：\n{1}',
-        'multi-usage': '多人生图：p-draw 多人 <描述>（2-4 人画面）\n例：p-draw 多人 左边若叶睦抱着吉他，右边千早爱音牵着她的手',
-        'multi-verify-passed': '多人图已通过视觉校验（{0} 分）。',
-        'multi-verify-failed': '多人图未通过视觉校验{0}，已重试 {1} 次。',
-        'multi-verify-degraded': '多人图校验失败，已发送最优候选{0}。',
-        'multi-verify-discarded': '多人图校验失败且未启用降级发送，本次图片不发送。',
-        'multi-degraded': '多人视觉校验不可用{0}，本次已直接发送生成结果。',
-        'multi-verify-error': '多人视觉校验调用失败：{0}',
-        'series-usage': '连续图：p-draw 连续 <角色>：<阶段1> → <阶段2> → ...\n例：p-draw 连续 少女：清纯校服 → 换上晚礼服 → 华丽登场\n或用 | 分隔，可加 --seed 固定种子保证角色一致。',
-        'series-llm-ask': '是否使用 LLM 优化连续图各阶段提示词？\n1. 是（使用 LLM，自动整理成 Danbooru tags）\n2. 否（不使用 LLM，直接用你输入的内容）\n3. 取消（不生成）\n请回复 1 / 2 / 3',
-        'series-llm-invalid': '未识别的回答，请回复 1（使用 LLM）/ 2（不使用 LLM）/ 3（取消）。',
-        'series-no-llm': '本次未使用 LLM 优化，直接使用你输入的描述/tags。',
-        'series-ok': '已扣除 {0} P 点，共 {1} 张连续图（seed={2}）',
-        'model-usage': '当前模型：{0}\n可用模型：\n{1}\n用法：p-draw 模型 <名称>（支持模糊匹配，如 anima-aesthetic）；p-draw 模型 默认 恢复默认。',
-        'model-switched': '已切换为模型「{0}」，对之后的生图生效。',
-        'model-reset': '已恢复默认模型「{0}」。',
-        'model-not-found': '未找到模型「{0}」。可用模型：\n{1}',
-        'model-no-draw': '「模型」只能用来切换/查看模型，不能生图。请先用「p-draw 模型 <名称>」切换，再单独发送要画的内容。',
-        'model-ambiguous': '「{0}」匹配到多个模型，请写得更具体些：\n{1}',
-        'no-optimize': '提示：本次未使用 LLM 优化（{0}）。',
-        'i2i-no-image': 'i2i（以图生图）需要附一张原图。用法：p-draw i2i <描述>，并在同一条消息里带上图片。',
-        'i2i-upload-fail': '原图上传 ComfyUI 失败：{0}',
-        'i2i-no-custom-workflow': 'i2i（以图生图）暂不支持自定义工作流（customWorkflowEnabled），请关闭后再试。',
-        'i2i-mode-ask': '请选择 i2i 处理模式：\n① 换风格（漫画化）——保留原图构图，转成二次元画风\n② 换装换姿势——保留角色长相，重新设计服装/姿势/场景\n③ 取消——不生成\n回复 1 / 2 / 3 或对应名称即可。',
-        'i2i-mode-invalid': '没有理解你的选择。请回复 ①换风格（漫画化） / ②换装换姿势 / ③取消。',
-        'i2i-mode-cancelled': '已取消本次 i2i 生图。',
-        'i2i-mode-style': '已选择【换风格（漫画化）】：保留原图构图，转成二次元画风。',
-        'i2i-mode-ootd': '已选择【换装换姿势】：保留角色长相，重新设计服装/姿势/场景。',
-        'i2i-no-controlnet': '未检测到可用的 Anima ControlNet-LLLite，本次「换风格」将使用普通 img2img，构图保留效果会弱一些。',
-        'i2i-no-ipadapter': '未检测到可用的 Anima IP-Adapter，本次「换装换姿势」将使用普通 img2img，角色保留效果会弱一些。',
-        'multi-no-llm': '多人指令需要 LLM 规划，但当前未配置 llmBaseUrl / llmModel。请管理员在配置中填写后使用。',
-      },
-    },
-  },
-}
-
+const { zhCN } = require('./lib/i18n')
 exports.Config = Schema.object({
   // ComfyUI 连接
   comfyuiBaseUrl: Schema.string().default('http://127.0.0.1:8188').description('ComfyUI 地址'),
@@ -282,1049 +134,27 @@ exports.Config = Schema.object({
   'zh-CN': zhCN,
 })
 
-// ------------------------------------------------------------------
-// 地址规范化
-// ------------------------------------------------------------------
-function normalizeBaseUrl(raw) {
-  let value = String(raw || '').trim()
-  if (!value) value = 'http://127.0.0.1:8188'
-  // 清理重复协议头，例如 http://http://host 或 http://https://host
-  value = value.replace(/^https?:\/\//i, '')
-  if (!/^https?:\/\//i.test(value)) value = 'http://' + value
-  return value.replace(/\/+$/, '')
-}
-
-// ------------------------------------------------------------------
-// 尺寸别名与解析（移植自 anima command_router）
-// ------------------------------------------------------------------
-const SIZE_ALIASES = {
-  '方图': 1.0,
-  '正方形': 1.0,
-  '竖图': 2 / 3,
-  '竖版': 2 / 3,
-  '横图': 3 / 2,
-  '横版': 3 / 2,
-  '长竖图': 9 / 16,
-  '手机竖屏': 9 / 16,
-  '宽屏': 16 / 9,
-  '超宽图': 16 / 9,
-}
-
-const SIZE_VALUE_PATTERN = String.raw`(?<width>\d{2,5})\s*[xX×*＊✕✖хХ]\s*(?<height>\d{2,5})`
-
-function escapeRe(text) {
-  return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-function parseGenerationSize(text, allowed) {
-  const prompt = String(text || '').trim()
-  let sizeMatch = null
-  const patterns = [
-    new RegExp(String.raw`(?<!\S)--(?:尺寸|分辨率)\s*(?:=|＝|:|：)?\s*${SIZE_VALUE_PATTERN}`, 'i'),
-    new RegExp(String.raw`(?:尺寸|分辨率)\s*(?:为|是|=|＝|:|：)?\s*${SIZE_VALUE_PATTERN}`, 'i'),
-    new RegExp(String.raw`^\s*${SIZE_VALUE_PATTERN}\s*[：:,，]`, 'i'),
-  ]
-  for (const pattern of patterns) {
-    sizeMatch = prompt.match(pattern)
-    if (sizeMatch) break
-  }
-
-  let selected = null
-  if (sizeMatch) {
-    selected = [parseInt(sizeMatch.groups.width), parseInt(sizeMatch.groups.height)]
-  } else {
-    const aliases = Object.keys(SIZE_ALIASES)
-      .sort((a, b) => b.length - a.length)
-      .map(escapeRe)
-      .join('|')
-    const aliasPatterns = [
-      new RegExp(String.raw`(?<!\S)--(?:尺寸|分辨率)\s*(?:=|＝|:|：)?\s*(?<alias>${aliases})(?=$|\s|[：:,，])`, 'i'),
-      new RegExp(String.raw`(?:尺寸|分辨率)\s*(?:为|是|=|＝|:|：)?\s*(?<alias>${aliases})(?=$|\s|[：:,，])`, 'i'),
-      new RegExp(String.raw`^\s*(?<alias>${aliases})(?=$|\s|[：:,，])\s*[：:,，]?`, 'i'),
-    ]
-    for (const pattern of aliasPatterns) {
-      sizeMatch = prompt.match(pattern)
-      if (sizeMatch) break
-    }
-    if (sizeMatch && allowed.length) {
-      const targetRatio = SIZE_ALIASES[sizeMatch.groups.alias]
-      selected = allowed.reduce((best, size) => {
-        const a = Math.abs(size[0] / size[1] - targetRatio)
-        const b = Math.abs(size[0] * size[1] - 1024 * 1024)
-        const ba = Math.abs(best[0] / best[1] - targetRatio)
-        const bb = Math.abs(best[0] * best[1] - 1024 * 1024)
-        return a < ba || (a === ba && b < bb) ? size : best
-      })
-    }
-  }
-
-  if (!sizeMatch) return { prompt, size: null, error: null }
-
-  let cleaned = (prompt.slice(0, sizeMatch.index) + ' ' + prompt.slice(sizeMatch.index + sizeMatch[0].length)).trim()
-  cleaned = cleaned.replace(/^[\s,，;；:：]+|[\s,，;；:：]+$/g, '')
-  cleaned = cleaned.replace(/([,，;；])\s*[,，;；]+/g, '$1')
-  cleaned = cleaned.replace(/\s+/g, ' ')
-
-  if (selected && allowed.length && !allowed.some(s => s[0] === selected[0] && s[1] === selected[1])) {
-    return {
-      prompt: cleaned,
-      size: null,
-      error: `尺寸 ${selected[0]}x${selected[1]} 不可用。可用尺寸：${allowed.map(s => `${s[0]}x${s[1]}`).join('、')}`,
-    }
-  }
-  if (selected === null) return { prompt: cleaned, size: null, error: '当前没有配置可用尺寸。' }
-  return { prompt: cleaned, size: selected, error: null }
-}
-
-// 批量张数解析：x3 / ×3 / 3张 / 三张 / --数量 3 / 数量：3
-const BATCH_TOKEN_PATTERNS = [
-  /(?<!\S)(--|——)(?:数量|张数)\s*(?:=|＝|:|：)?\s*(?<num>\d+)/i,
-  /(?:数量|张数)\s*(?:为|是|=|＝|:|：)\s*(?<num>\d+)/i,
-  /(?<!\S)[x×X](?<num>\d+)(?![a-zA-Z0-9])/,
-  /(?<!\S)(?<num>[一二两三四五六七八九十]+)张/,
-  /(?<!\S)(?<num>\d+)张(?:图)?/,
-]
-
-const CN_NUM_MAP = { '一': 1, '两': 2, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9, '十': 10 }
-
-function cnNumValue(text) {
-  if (/^\d+$/.test(text)) return parseInt(text, 10)
-  if (CN_NUM_MAP[text] != null) return CN_NUM_MAP[text]
-  if (/^十[一二三四五六七八九]$/.test(text)) return 10 + CN_NUM_MAP[text.slice(1)]
-  if (text === '十') return 10
-  return 0
-}
-
-function parseBatchCount(text, max) {
-  const prompt = String(text || '').trim()
-  const cap = Math.max(1, parseInt(max) || 1)
-  let requested = 1
-  let matched = false
-  for (const pattern of BATCH_TOKEN_PATTERNS) {
-    const m = prompt.match(pattern)
-    if (!m) continue
-    const numText = m.groups && m.groups.num != null ? m.groups.num : ''
-    const value = cnNumValue(numText)
-    if (value >= 1) {
-      requested = value
-      matched = true
-    }
-    const cleaned = (prompt.slice(0, m.index) + ' ' + prompt.slice(m.index + m[0].length)).trim()
-      .replace(/^[\s,，;；:：]+|[\s,，;；:：]+$/g, '')
-      .replace(/\s+/g, ' ')
-    return { count: Math.min(requested, cap), requested, prompt: cleaned, matched, clamped: requested > cap }
-  }
-  return { count: 1, requested: 1, prompt, matched, clamped: false }
-}
-
-// 固定种子解析：--seed 17021628 / --seed:17021628 / --seed=17021628 / --seed＝123
-// 从提示词里剥离并返回 { seed, prompt }
-function parseSeed(text) {
-  const prompt = String(text || '').trim()
-  const m = prompt.match(/(?<!\S)--seed\s*(?:=|＝|:|：)?\s*(\d+)/i)
-  if (!m) return { seed: null, prompt }
-  const seed = parseInt(m[1], 10) >>> 0
-  const cleaned = (prompt.slice(0, m.index) + ' ' + prompt.slice(m.index + m[0].length)).trim()
-    .replace(/^[\s,，;；:：]+|[\s,，;；:：]+$/g, '')
-    .replace(/\s+/g, ' ')
-  return { seed, prompt: cleaned }
-}
-
-// 去噪强度解析：--denoise 0.3 / --denoise=0.6 / --去噪 0.4，并从提示词里剥离
-function parseDenoise(text) {
-  const prompt = String(text || '').trim()
-  const m = prompt.match(/(?<!\S)--(?:denoise|去噪)\s*(?:=|＝|:|：)?\s*(\d+(?:\.\d+)?)/i)
-  if (!m) return { denoise: null, prompt }
-  const denoise = Math.min(1, Math.max(0, parseFloat(m[1])))
-  const cleaned = (prompt.slice(0, m.index) + ' ' + prompt.slice(m.index + m[0].length)).trim()
-    .replace(/^[\s,，;；:：]+|[\s,，;；:：]+$/g, '')
-    .replace(/\s+/g, ' ')
-  return { denoise, prompt: cleaned }
-}
-
-// ------------------------------------------------------------------
-// 提示词辅助（移植自 anima prompt_presets）
-// ------------------------------------------------------------------
-const RAW_PREFIXES = [
-  '原样', '原样tags', '原样tag', '原样 tags', '原样 tag',
-  '直接画', '直接出图', '直接生图', '直接tags', '直接tag', '直接 tags', '直接 tag',
-  '不优化', '无优化', '无优化tags', '无优化tag', '无优化 tags', '无优化 tag',
-  '不要优化', '跳过优化', '跳过提示词优化', 'raw tags', 'raw tag', 'raw',
-  'no optimize', 'no optimization', '不用优化',
-]
-
-function stripRawPrefix(prompt) {
-  const text = String(prompt || '').trim()
-  const lowered = text.toLowerCase()
-  for (const prefix of RAW_PREFIXES) {
-    if (lowered.startsWith(prefix.toLowerCase())) {
-      return { raw: true, prompt: text.slice(prefix.length).replace(/^[\s,，;；:：]+/, '').trim() }
-    }
-  }
-  return { raw: false, prompt: text }
-}
-
-function mergeTagText(existing, addition) {
-  const tags = []
-  const seen = new Set()
-  for (const source of [existing, addition]) {
-    for (const tag of String(source || '').split(',')) {
-      const text = tag.trim()
-      if (!text) continue
-      const key = text.toLowerCase()
-      if (seen.has(key)) continue
-      tags.push(text)
-      seen.add(key)
-    }
-  }
-  return tags.join(', ') + (tags.length ? ',' : '')
-}
-
-function parseNameTags(text) {
-  const raw = String(text || '').trim()
-  const candidates = []
-  for (const separator of ['=', '＝', '：', ':']) {
-    const index = raw.indexOf(separator)
-    if (index >= 0) candidates.push([index, separator])
-  }
-  candidates.sort((a, b) => a[0] - b[0])
-  for (const [index, separator] of candidates) {
-    const name = raw.slice(0, index).trim()
-    const tags = raw.slice(index + separator.length).trim()
-    if (!name || !tags) continue
-    if (name.includes(',') || name.includes('\n')) continue
-    if (/[@()[\]{}]/.test(name)) continue
-    if (['artist', 'tag', 'tags', 'prompt', 'positive', 'negative'].includes(name.toLowerCase())) continue
-    return { name, tags }
-  }
-  return null
-}
-
-function parsePresetList(list) {
-  const result = {}
-  for (const item of list || []) {
-    const text = String(item || '').trim()
-    if (!text) continue
-    const parsed = parseNameTags(text)
-    if (parsed) result[parsed.name] = parsed.tags
-  }
-  return result
-}
-
-// ------------------------------------------------------------------
-// ComfyUI 工作流构建（移植自 anima comfyui_workflows）
-// ------------------------------------------------------------------
-function animaT2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed) {
-  return {
-    '44': { class_type: 'UNETLoader', inputs: { unet_name: cfg.unetName, weight_dtype: 'fp8_e4m3fn' } },
-    '45': { class_type: 'CLIPLoader', inputs: { clip_name: cfg.clipName, type: 'stable_diffusion', device: 'default' } },
-    '15': { class_type: 'VAELoader', inputs: { vae_name: cfg.vaeName } },
-    '28': { class_type: 'EmptyLatentImage', inputs: { width, height, batch_size: 1 } },
-    '11': { class_type: 'CLIPTextEncode', inputs: { text: prompt, clip: ['45', 0] } },
-    '12': { class_type: 'CLIPTextEncode', inputs: { text: negativePrompt, clip: ['45', 0] } },
-    '19': {
-      class_type: 'KSampler',
-      inputs: {
-        model: ['44', 0],
-        positive: ['11', 0],
-        negative: ['12', 0],
-        latent_image: ['28', 0],
-        seed,
-        steps,
-        cfg: cfgVal,
-        sampler_name: cfg.samplerName,
-        scheduler: cfg.scheduler,
-        denoise: 1,
-      },
-    },
-    '8': { class_type: 'VAEDecodeTiled', inputs: { samples: ['19', 0], vae: ['15', 0], tile_size: 512, overlap: 64, temporal_size: 64, temporal_overlap: 8 } },
-    '9': { class_type: 'SaveImage', inputs: { images: ['8', 0], filename_prefix: 'pdraw/anm' } },
-  }
-}
-
-function buildWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, explicitSize) {
-  if (cfg.customWorkflowEnabled && cfg.customWorkflowPath) {
-    return customWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, explicitSize)
-  }
-  return animaT2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed)
-}
-
-// 以图生图工作流（p-draw i2i）：LoadImage → VAEEncode → KSampler(denoise<1)
-// 输入图编码为 latent 作为起点，尺寸保持原图，去噪强度由 cfg.img2imgDenoise 控制。
-function animaI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, denoise) {
-  return {
-    '44': { class_type: 'UNETLoader', inputs: { unet_name: cfg.unetName, weight_dtype: 'fp8_e4m3fn' } },
-    '45': { class_type: 'CLIPLoader', inputs: { clip_name: cfg.clipName, type: 'stable_diffusion', device: 'default' } },
-    '15': { class_type: 'VAELoader', inputs: { vae_name: cfg.vaeName } },
-    '13': { class_type: 'LoadImage', inputs: { image: inputImage } },
-    '30': { class_type: 'VAEEncode', inputs: { pixels: ['13', 0], vae: ['15', 0] } },
-    '11': { class_type: 'CLIPTextEncode', inputs: { text: prompt, clip: ['45', 0] } },
-    '12': { class_type: 'CLIPTextEncode', inputs: { text: negativePrompt, clip: ['45', 0] } },
-    '19': {
-      class_type: 'KSampler',
-      inputs: {
-        model: ['44', 0],
-        positive: ['11', 0],
-        negative: ['12', 0],
-        latent_image: ['30', 0],
-        seed,
-        steps,
-        cfg: cfgVal,
-        sampler_name: cfg.samplerName,
-        scheduler: cfg.scheduler,
-        denoise,
-      },
-    },
-    '8': { class_type: 'VAEDecodeTiled', inputs: { samples: ['19', 0], vae: ['15', 0], tile_size: 512, overlap: 64, temporal_size: 64, temporal_overlap: 8 } },
-    '9': { class_type: 'SaveImage', inputs: { images: ['8', 0], filename_prefix: 'pdraw/anm_i2i' } },
-  }
-}
-
-// 「换风格（漫画化）」i2i 工作流：LoadImage → 预处理器（LineArt / Canny）→ AnimaLLLiteApply_sdscripts 锁构图，
-// VAEEncode 原图作起点，KSampler 用较高 denoise 整体转二次元风格。
-// 注意：Anima 是 MiniTrainDIT 架构（隐藏层 3584 维），与 Qwen-Image 系 ControlNet 不兼容
-// （InstantX 控制网期望 3584 维文本嵌入，Anima 只给 1024 维 → LayerNorm 崩溃）。
-// 因此这里使用 Anima 原生支持的 ControlNet-LLLite（kohya-ss/ComfyUI-Anima-LLLite），
-// 节点直接对 MODEL 打补丁并返回补丁后的模型，交给 KSampler。
-// 预处理器：comfyui_controlnet_aux 的 AnimeLineArt/LineArt 节点（需安装该自定义节点）；
-// 未安装时回退 ComfyUI 内置 Canny。anima-lllite-lineart 权重是按 lineart 训练的，用 LineArt 比 Canny 更贴。
-function animaStyleI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, controlNetModel, controlNetStrength, denoise, preprocessor) {
-  const detectRes = Math.max(width, height)
-  const preprocessorNode = preprocessor === 'AnimeLineArtPreprocessor' || preprocessor === 'LineArtPreprocessor'
-    ? { class_type: preprocessor, inputs: { image: ['13', 0], detect_resolution: detectRes, resolution: detectRes } }
-    : { class_type: 'Canny', inputs: { image: ['13', 0], low_threshold: 0.4, high_threshold: 0.8 } }
-  return {
-    '44': { class_type: 'UNETLoader', inputs: { unet_name: cfg.i2iUnetName || cfg.unetName, weight_dtype: 'fp8_e4m3fn' } },
-    '45': { class_type: 'CLIPLoader', inputs: { clip_name: cfg.clipName, type: 'stable_diffusion', device: 'default' } },
-    '15': { class_type: 'VAELoader', inputs: { vae_name: cfg.vaeName } },
-    '13': { class_type: 'LoadImage', inputs: { image: inputImage } },
-    '30': { class_type: 'VAEEncode', inputs: { pixels: ['13', 0], vae: ['15', 0] } },
-    '11': { class_type: 'CLIPTextEncode', inputs: { text: prompt, clip: ['45', 0] } },
-    '12': { class_type: 'CLIPTextEncode', inputs: { text: negativePrompt, clip: ['45', 0] } },
-    '70': preprocessorNode,
-    '71': { class_type: 'AnimaLLLiteApply_sdscripts', inputs: { model: ['44', 0], lllite_name: controlNetModel, image: ['70', 0], strength: controlNetStrength, start_percent: 0, end_percent: 1, preserve_wrapper: true } },
-    '19': {
-      class_type: 'KSampler',
-      inputs: {
-        model: ['71', 0],
-        positive: ['11', 0],
-        negative: ['12', 0],
-        latent_image: ['30', 0],
-        seed,
-        steps,
-        cfg: cfgVal,
-        sampler_name: cfg.samplerName,
-        scheduler: cfg.scheduler,
-        denoise,
-      },
-    },
-    '8': { class_type: 'VAEDecodeTiled', inputs: { samples: ['19', 0], vae: ['15', 0], tile_size: 512, overlap: 64, temporal_size: 64, temporal_overlap: 8 } },
-    '9': { class_type: 'SaveImage', inputs: { images: ['8', 0], filename_prefix: 'pdraw/anm_i2i_style' } },
-  }
-}
-
-// 「换装换姿势」i2i 工作流：LoadImage → AnimaSiglipeEncodeImage → AnimaIPAdapterApply 保角色特征，
-// VAEEncode 原图作起点，KSampler 用中等 denoise 重画服装/姿势/场景。
-function animaOotdI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, ipAdapterPath, ipAdapterWeight, denoise) {
-  return {
-    '44': { class_type: 'UNETLoader', inputs: { unet_name: cfg.unetName, weight_dtype: 'fp8_e4m3fn' } },
-    '45': { class_type: 'CLIPLoader', inputs: { clip_name: cfg.clipName, type: 'stable_diffusion', device: 'default' } },
-    '15': { class_type: 'VAELoader', inputs: { vae_name: cfg.vaeName } },
-    '13': { class_type: 'LoadImage', inputs: { image: inputImage } },
-    '30': { class_type: 'VAEEncode', inputs: { pixels: ['13', 0], vae: ['15', 0] } },
-    '11': { class_type: 'CLIPTextEncode', inputs: { text: prompt, clip: ['45', 0] } },
-    '12': { class_type: 'CLIPTextEncode', inputs: { text: negativePrompt, clip: ['45', 0] } },
-    '80': { class_type: 'AnimaIPAdapterLoader', inputs: { ipadapter_path: ipAdapterPath } },
-    '81': { class_type: 'AnimaSiglipeEncodeImage', inputs: { image: ['13', 0] } },
-    '82': { class_type: 'AnimaIPAdapterApply', inputs: { model: ['44', 0], ipadapter: ['80', 0], siglip_features: ['81', 0], start_at: 0, end_at: 1, weight: ipAdapterWeight } },
-    '19': {
-      class_type: 'KSampler',
-      inputs: {
-        model: ['82', 0],
-        positive: ['11', 0],
-        negative: ['12', 0],
-        latent_image: ['30', 0],
-        seed,
-        steps,
-        cfg: cfgVal,
-        sampler_name: cfg.samplerName,
-        scheduler: cfg.scheduler,
-        denoise,
-      },
-    },
-    '8': { class_type: 'VAEDecodeTiled', inputs: { samples: ['19', 0], vae: ['15', 0], tile_size: 512, overlap: 64, temporal_size: 64, temporal_overlap: 8 } },
-    '9': { class_type: 'SaveImage', inputs: { images: ['8', 0], filename_prefix: 'pdraw/anm_i2i_ootd' } },
-  }
-}
-
-// 根据 i2i 模式与已检测到的节点能力，决定最终工作流与去噪强度。
-// mode：style=换风格（漫画化）/ ootd=换装换姿势 / 其他=基础 img2img
-// caps：{ controlNet: { available, model }, ipAdapter: { available } }（由 detectI2ICapabilities 返回）
-// 返回 { promptBody, kind, denoise }，kind 为 plain / controlnet / ipadapter。
-function buildI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, mode, denoiseOverride, caps) {
-  const fallbackDenoise = Number(cfg.img2imgDenoise) || 0.55
-  if (mode === 'style') {
-    if (caps && caps.controlNet && caps.controlNet.available && caps.controlNet.model) {
-      const denoise = denoiseOverride != null ? denoiseOverride : (Number(cfg.i2iStyleDenoise) || 0.75)
-      return {
-        kind: 'controlnet',
-        denoise,
-        promptBody: animaStyleI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, caps.controlNet.model, Number(cfg.i2iControlNetStrength) || 0.7, denoise, caps.controlNet.preprocessor),
-      }
-    }
-    // 没有 ControlNet：换风格又不想崩构图，denoise 自动压到 0.5 以内
-    const denoise = denoiseOverride != null ? denoiseOverride : Math.min(Number(cfg.i2iStyleDenoise) || 0.75, 0.5)
-    return { kind: 'plain', denoise, promptBody: animaI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, denoise) }
-  }
-  if (mode === 'ootd') {
-    if (caps && caps.ipAdapter && caps.ipAdapter.available && String(cfg.i2iIPAdapterPath || '').trim()) {
-      const denoise = denoiseOverride != null ? denoiseOverride : (Number(cfg.i2iOotdDenoise) || 0.55)
-      return {
-        kind: 'ipadapter',
-        denoise,
-        promptBody: animaOotdI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, String(cfg.i2iIPAdapterPath).trim(), Number(cfg.i2iIPAdapterWeight) || 0.8, denoise),
-      }
-    }
-    const denoise = denoiseOverride != null ? denoiseOverride : (Number(cfg.i2iOotdDenoise) || 0.55)
-    return { kind: 'plain', denoise, promptBody: animaI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, denoise) }
-  }
-  const denoise = denoiseOverride != null ? denoiseOverride : fallbackDenoise
-  return { kind: 'plain', denoise, promptBody: animaI2IWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, inputImage, denoise) }
-}
-
-function customWorkflow(cfg, prompt, negativePrompt, width, height, steps, cfgVal, seed, explicitSize) {
-  const rawPath = path.resolve(__dirname, cfg.customWorkflowPath)
-  let raw
-  try {
-    raw = JSON.parse(fs.readFileSync(rawPath, 'utf-8'))
-  } catch (e) {
-    throw new Error(`自定义工作流加载失败：${e.message}`)
-  }
-  const body = raw && typeof raw === 'object' && raw.prompt && typeof raw.prompt === 'object' ? raw.prompt : raw
-  if (!body || typeof body !== 'object') throw new Error('自定义工作流 JSON 无效')
-
-  const workflow = JSON.parse(JSON.stringify(body))
-  const textNodes = []
-  for (const [nodeId, node] of Object.entries(workflow)) {
-    if (!node || typeof node !== 'object') continue
-    const classType = String(node.class_type || '')
-    const inputs = node.inputs
-    if (classType.includes('TextEncode') && inputs && typeof inputs.text === 'string') {
-      textNodes.push(String(nodeId))
-    }
-  }
-  const positiveIds = conditioningTextNodeIds(workflow, 'positive', textNodes)
-  const negativeIds = conditioningTextNodeIds(workflow, 'negative', textNodes)
-  if (!positiveIds.length) throw new Error('自定义工作流中找不到正面提示词节点')
-  if (!negativeIds.length) throw new Error('自定义工作流中找不到负面提示词节点')
-  if (positiveIds.some(id => negativeIds.includes(id))) throw new Error('自定义工作流正负面节点有歧义')
-
-  for (const nodeId of positiveIds) {
-    if (workflow[nodeId] && workflow[nodeId].inputs) workflow[nodeId].inputs.text = prompt
-  }
-  for (const nodeId of negativeIds) {
-    if (workflow[nodeId] && workflow[nodeId].inputs) workflow[nodeId].inputs.text = negativePrompt
-  }
-
-  for (const node of Object.values(workflow)) {
-    if (!node || typeof node !== 'object') continue
-    const classType = String(node.class_type || '')
-    const inputs = node.inputs
-    if (!inputs || typeof inputs !== 'object') continue
-    if (classType === 'SaveImage' && 'filename_prefix' in inputs) {
-      inputs.filename_prefix = 'pdraw/anm'
-    }
-    const override = Boolean(cfg.customWorkflowOverrideParameters)
-    if ((override || explicitSize) && classType === 'EmptyLatentImage') {
-      if ('width' in inputs) inputs.width = width
-      if ('height' in inputs) inputs.height = height
-    }
-    if (override && (classType === 'KSampler' || classType === 'KSamplerAdvanced')) {
-      if ('steps' in inputs) inputs.steps = steps
-      if ('cfg' in inputs) inputs.cfg = cfgVal
-      if (cfg.samplerName && 'sampler_name' in inputs) inputs.sampler_name = cfg.samplerName
-      if (cfg.scheduler && 'scheduler' in inputs) inputs.scheduler = cfg.scheduler
-    }
-    if ('seed' in inputs) inputs.seed = seed
-    if ('noise_seed' in inputs) inputs.noise_seed = seed
-  }
-  return workflow
-}
-
-function conditioningTextNodeIds(workflow, inputName, textNodes) {
-  const pending = []
-  for (const node of Object.values(workflow)) {
-    if (!node || typeof node !== 'object') continue
-    if (!['KSampler', 'KSamplerAdvanced'].includes(String(node.class_type || ''))) continue
-    const link = node.inputs && node.inputs[inputName]
-    if (Array.isArray(link) && link.length) pending.push(String(link[0]))
-  }
-  const found = []
-  const visited = new Set()
-  while (pending.length) {
-    const nodeId = pending.pop()
-    if (visited.has(nodeId)) continue
-    visited.add(nodeId)
-    if (textNodes.includes(nodeId)) {
-      found.push(nodeId)
-      continue
-    }
-    const node = workflow[nodeId]
-    const inputs = node && node.inputs
-    if (!inputs || typeof inputs !== 'object') continue
-    for (const value of Object.values(inputs)) {
-      if (Array.isArray(value) && value.length) {
-        const sourceId = String(value[0])
-        if (workflow[sourceId]) pending.push(sourceId)
-      }
-    }
-  }
-  return found
-}
-
-function outputImages(history) {
-  const images = []
-  const outputs = history.outputs || {}
-  if (outputs && typeof outputs === 'object') {
-    for (const nodeOutput of Object.values(outputs)) {
-      if (!nodeOutput || typeof nodeOutput !== 'object') continue
-      for (const image of nodeOutput.images || []) {
-        if (image && typeof image === 'object') images.push(image)
-      }
-    }
-  }
-  return images
-}
-
-// ------------------------------------------------------------------
-// ComfyUI 结果等待：优先 WebSocket 事件，失败/不可用回退轮询
-// ------------------------------------------------------------------
-function waitViaWebSocket(baseUrl, promptId, clientId, timeoutMs) {
-  return new Promise((resolve) => {
-    let socket
-    let timer = null
-    let settled = false
-    const finish = (ok) => {
-      if (settled) return
-      settled = true
-      if (timer) clearTimeout(timer)
-      try { if (socket) socket.close() } catch (e) { /* ignore */ }
-      resolve(ok)
-    }
-    try {
-      const wsUrl = baseUrl.replace(/^https:/i, 'wss:').replace(/^http:/i, 'ws:') + `/ws?clientId=${encodeURIComponent(clientId)}`
-      socket = new WebSocket(wsUrl)
-    } catch (e) {
-      finish(false)
-      return
-    }
-    timer = setTimeout(() => finish(false), timeoutMs)
-    socket.onmessage = (ev) => {
-      let msg
-      try { msg = JSON.parse(String(ev.data)) } catch (e) { return }
-      if (!msg || typeof msg !== 'object') return
-      if (msg.type === 'execution_success' && msg.data && msg.data.prompt_id === promptId) { finish(true); return }
-      if (msg.type === 'execution_error' || msg.type === 'execution_interrupted') { finish(false) }
-    }
-    socket.onerror = () => finish(false)
-    socket.onclose = () => finish(false)
-  })
-}
-
-async function waitComfyResult(ctx, comfyGet, baseUrl, promptId, clientId, timeoutMs, pollMs) {
-  const deadline = Date.now() + timeoutMs
-  if (typeof WebSocket !== 'undefined') {
-    const remaining = Math.max(0, deadline - Date.now())
-    try {
-      const viaWs = await waitViaWebSocket(baseUrl, promptId, clientId, remaining)
-      if (viaWs) {
-        try {
-          const data = await comfyGet(`/history/${promptId}`, 20000)
-          if (data && data[promptId]) return data[promptId]
-        } catch (e) { /* fall through */ }
-      }
-    } catch (e) { /* fall through to polling */ }
-  }
-  while (Date.now() < deadline) {
-    try {
-      const data = await comfyGet(`/history/${promptId}`, 20000)
-      if (data && data[promptId]) return data[promptId]
-    } catch (e) { /* transient */ }
-    await ctx.sleep(pollMs)
-  }
-  return null
-}
-
-// ------------------------------------------------------------------
-// Tag 清洗（移植自 anima tag_cleaner）
-// ------------------------------------------------------------------
-function splitTags(text) {
-  let cleaned = String(text || '')
-  cleaned = cleaned.replace(/```[\s\S]*?```/g, m => m.slice(3, -3).trim())
-  cleaned = cleaned.replace(/，/g, ',').replace(/、/g, ',').replace(/;/g, ',')
-  cleaned = cleaned.replace(/\n/g, ',')
-  cleaned = cleaned.replace(/^(?:positive|prompt|tags|提示词|正向提示词)\s*[:：]/i, '')
-  const parts = cleaned.split(',').map(p => p.trim().replace(/^[\s,.;:：]+|[\s,.;:：]+$/g, ''))
-  return parts.filter(Boolean)
-}
-
-function normalizeTagKey(tag) {
-  let value = String(tag || '').trim().toLowerCase()
-  if (
-    value.startsWith('(') && value.endsWith(')') &&
-    (value.match(/\(/g) || []).length === 1 &&
-    (value.match(/\)/g) || []).length === 1
-  ) {
-    value = value.slice(1, -1).trim()
-  }
-  value = value.replace(/:\s*[\d.]+$/, '')
-  value = value.replace(/\s+/g, ' ')
-  return value
-}
-
-function stripWrappingBrackets(text) {
-  let value = String(text || '').trim()
-  const pairs = { '(': ')', '[': ']', '{': '}' }
-  let changed = true
-  while (changed && value.length >= 2) {
-    changed = false
-    const left = value[0]
-    const right = pairs[left]
-    if (right && value.endsWith(right)) {
-      value = value.slice(1, -1).trim()
-      changed = true
-    }
-  }
-  return value
-}
-
-const ARTIST_FUNCTION_RE = /^artist\s*:\s*([^:=()[\]{}]+?)\s*(?:[:=]\s*[-+]?(?:\d+(?:\.\d+)?|\.\d+)\s*)?$/i
-
-function normalizeAnimaArtistTag(tag) {
-  const raw = String(tag || '').trim()
-  if (!raw) return ''
-  if (raw.startsWith('@')) {
-    const name = raw.slice(1).trim().replace(/_/g, ' ').replace(/\s+/g, ' ').trim()
-    return name ? `@${name}` : raw
-  }
-  const inner = stripWrappingBrackets(raw)
-  const match = ARTIST_FUNCTION_RE.exec(inner)
-  if (!match) return raw
-  let name = match[1].trim()
-  if (name.startsWith('@')) name = name.slice(1).trim()
-  name = name.replace(/_/g, ' ').replace(/\s+/g, ' ').trim()
-  return name ? `@${name}` : raw
-}
-
-function canonicalTagText(tag) {
-  const artistTag = normalizeAnimaArtistTag(tag)
-  if (artistTag.startsWith('@')) return artistTag
-  const key = normalizeTagKey(tag)
-  if (key === '1 girl') return '1girl'
-  if (key === 'punis') return 'penis'
-  if (['point a sword at the audience', 'point a sword at viewer', 'point sword at the audience', 'point sword at viewer'].includes(key)) return 'sword pointed at viewer'
-  return String(tag || '').trim()
-}
-
-// 内联画师标签（@name / artist:name）与内联质量词（masterpiece / best quality / score_N 等）。
-// 提示词优化会把它们交给 LLM 重写并剥掉，这里在优化后把它们从原始输入中补回，
-// 避免用户直接写在消息里的画师标签 / 质量词丢失。
-const INLINE_QUALITY_RE = /^(masterpiece|best quality|amazing quality|high quality|good quality|score_\d+)$/i
-
-function appendInlineProtectedTags(prompt, original, raw) {
-  if (raw || !original) return prompt
-  if (/(不用我的风格|不要我的风格|不使用我的风格|不要画师词|不用画师词|不加画师词|no artist)/i.test(original)) return prompt
-  const tags = []
-  const seen = new Set(splitTags(prompt).map(t => normalizeTagKey(t)))
-  for (const token of splitTags(original)) {
-    const t = String(token || '').trim()
-    if (!t) continue
-    const artist = normalizeAnimaArtistTag(t)
-    if (artist.startsWith('@')) {
-      const key = normalizeTagKey(artist)
-      if (!seen.has(key)) {
-        seen.add(key)
-        tags.push(artist)
-      }
-      continue
-    }
-    if (INLINE_QUALITY_RE.test(t)) {
-      const key = normalizeTagKey(t)
-      if (!seen.has(key)) {
-        seen.add(key)
-        tags.push(t)
-      }
-    }
-  }
-  if (!tags.length) return prompt
-  return prompt + ', ' + tags.join(', ')
-}
-
-const QUALITY_BLOCKLIST = new Set([
-  'masterpiece', 'best quality', 'score_7', 'score_6', 'score_5', 'score_4', 'score_3', 'score_2', 'score_1',
-  'safe', 'worst quality', 'low quality', 'artist name',
-])
-const CHARACTER_BLOCKLIST = new Set(['1 girl', '1girl', 'solo'])
-const CHARACTER_IDENTITY_EXACT_BLOCKLIST = new Set([
-  'girl', 'boy', 'child', 'teenager', 'young adult', 'adult', 'mature', 'loli', 'shota', 'petite', 'aged down', 'age regression',
-  'vampire', 'angel', 'demon', 'fox girl', 'cat girl', 'animal girl',
-  'ahoge', 'bangs', 'blunt bangs', 'sidelocks', 'hair between eyes', 'long hair', 'short hair', 'medium hair', 'very long hair',
-  'twintails', 'low twintails', 'braids', 'side braid', 'ponytail', 'side ponytail', 'one side up', 'hair bun', 'double bun',
-  'heterochromia', 'blue eyes', 'red eyes', 'green eyes', 'pink eyes', 'purple eyes', 'yellow eyes', 'golden eyes', 'grey eyes',
-  'gray eyes', 'brown eyes', 'black eyes', 'black hair', 'brown hair', 'blonde hair', 'white hair', 'silver hair', 'blue hair',
-  'red hair', 'pink hair', 'purple hair', 'green hair', 'grey hair', 'gray hair',
-  'fox ears', 'cat ears', 'animal ears', 'pointed ears', 'tail', 'fox tail', 'cat tail', 'wings', 'angel wings', 'demon wings',
-  'horns', 'halo', 'fang', 'freckles',
-])
-const CHARACTER_IDENTITY_PATTERNS = [
-  /\b(?:black|brown|blonde|white|silver|blue|red|pink|purple|green|grey|gray|orange|gold|golden|light|dark|ice blue|silver white)\s+hair\b/,
-  /\b(?:black|brown|blue|red|pink|purple|green|grey|gray|gold|golden|light|dark|ice blue|amber)\s+eyes?\b/,
-  /\b(?:ears?|tail|wings?|horns?|halo|fangs?|heterochromia)\b/,
-  /\b(?:vampire|angel|demon|fox girl|cat girl|animal girl)\b/,
-  /\b(?:loli|shota|teenager|young adult|adult|mature|aged down|age regression)\b/,
-]
-const MULTI_CHARACTER_BLOCKLIST = new Set([
-  '2girls', '3girls', '4girls', '5girls', '6+girls', 'multiple girls',
-  '2boys', '3boys', '4boys', '5boys', '6+boys', 'multiple boys',
-  'multiple people', 'crowd', 'group', 'background characters', 'extra girl', 'extra person', 'clone', 'duplicate', 'twins',
-])
-const NON_VISUAL_TAGS = new Set(['holding nothing'])
-const EXCLUSIVE_TAG_GROUPS = {
-  'looking at viewer': 'gaze_target', 'looking away': 'gaze_target',
-  'light rays': 'light_beams', 'sun rays': 'light_beams', 'sunbeams': 'light_beams', 'sunlight rays': 'light_beams',
-  'glowing': 'light_intensity', 'illuminated': 'light_intensity', 'bright': 'light_intensity', 'luminous': 'light_intensity', 'radiant': 'light_intensity',
-  'backlight': 'backlighting', 'backlighting': 'backlighting',
-  'rim light': 'rim_lighting', 'rim lighting': 'rim_lighting',
-  'soft light': 'soft_lighting', 'soft lighting': 'soft_lighting',
-  'floating particles': 'light_particles', 'light particles': 'light_particles', 'glowing particles': 'light_particles',
-  'flowing dress': 'flowing_dress', 'dress flowing': 'flowing_dress',
-  'hair blowing': 'wind_in_hair', 'wind in hair': 'wind_in_hair',
-  'sad expression': 'sad_expression', 'sorrowful expression': 'sad_expression',
-  'teary eyes': 'tearful_eyes', 'watery eyes': 'tearful_eyes', 'wet eyes': 'tearful_eyes',
-}
-const TAG_GROUP_LIMITS = { light_intensity: 2 }
-
-function isCharacterIdentityTag(key) {
-  const compact = normalizeTagKey(key).replace(/_/g, ' ')
-  if (!compact) return false
-  if (CHARACTER_IDENTITY_EXACT_BLOCKLIST.has(compact)) return true
-  return CHARACTER_IDENTITY_PATTERNS.some(pattern => pattern.test(compact))
-}
-
-function cleanContentTags(text, maxTags = 65, stripCharacterTags = true, protectedCoreTags = [], allowMultiCharacter = false) {
-  const tags = splitTags(text)
-  const seen = new Set()
-  const cleaned = []
-  const artistRe = /^@\S+/
-  const protectedSet = new Set(protectedCoreTags.map(t => normalizeTagKey(t)))
-  const parenthesizedCoreRe = /^[a-z0-9_.'-]+_\([a-z0-9_.' -]{2,60}\)$/i
-  for (let tag of tags) {
-    tag = canonicalTagText(tag)
-    const key = normalizeTagKey(tag)
-    if (!key) continue
-    if (seen.has(key)) continue
-    if (QUALITY_BLOCKLIST.has(key)) continue
-    if (stripCharacterTags && CHARACTER_BLOCKLIST.has(key)) continue
-    if (stripCharacterTags && isCharacterIdentityTag(key)) continue
-    if (!allowMultiCharacter && MULTI_CHARACTER_BLOCKLIST.has(key)) continue
-    if (protectedSet.size && parenthesizedCoreRe.test(key) && !protectedSet.has(key)) continue
-    if (artistRe.test(tag.trim())) continue
-    if (tag.length > 80) continue
-    seen.add(key)
-    cleaned.push(tag)
-  }
-  const semanticKeys = cleaned.map(tag => normalizeTagKey(stripWrappingBrackets(tag)))
-  const fullNudityKey = semanticKeys.includes('nude') ? 'nude' : 'naked'
-  const hasFullNudity = semanticKeys.includes(fullNudityKey)
-  const hasSpecificMist = semanticKeys.includes('morning mist')
-  const hasClosedEyes = semanticKeys.some(k => k === 'closed eyes' || k === 'eyes closed')
-  const hasSheerFabric = semanticKeys.includes('sheer fabric')
-  const groupCounts = {}
-  const semanticCleaned = []
-  cleaned.forEach((tag, i) => {
-    const key = semanticKeys[i]
-    if (NON_VISUAL_TAGS.has(key)) return
-    if (hasFullNudity && ['nude', 'naked', 'topless', 'bottomless'].includes(key)) {
-      if (key !== fullNudityKey) return
-    }
-    if (hasSpecificMist && key === 'mist') return
-    if (hasClosedEyes && key.includes('looking') && key.includes('viewer')) return
-    if (hasSheerFabric && key === 'translucent fabric') return
-    const group = EXCLUSIVE_TAG_GROUPS[key.replace(/_/g, ' ')]
-    if (group) {
-      const count = groupCounts[group] || 0
-      if (count >= (TAG_GROUP_LIMITS[group] != null ? TAG_GROUP_LIMITS[group] : 1)) return
-      groupCounts[group] = count + 1
-    }
-    semanticCleaned.push(tag)
-  })
-  return semanticCleaned.slice(0, maxTags).join(', ')
-}
-
-function joinPromptParts(parts) {
-  const tags = []
-  const seen = new Set()
-  for (const part of parts) {
-    for (const tag of splitTags(part)) {
-      const canonical = canonicalTagText(tag)
-      const key = normalizeTagKey(canonical)
-      if (!key || seen.has(key)) continue
-      seen.add(key)
-      tags.push(canonical)
-    }
-  }
-  return tags.join(', ')
-}
-
-// ------------------------------------------------------------------
-// 多人规划（移植自 anima multi_person_prompt）
-// ------------------------------------------------------------------
-const MULTI_PERSON_NEGATIVE_TAGS = [
-  'split screen', 'comic panels', 'multiple views', 'character sheet',
-  'duplicate characters', 'cloned character', 'extra person', 'extra girl', 'extra boy',
-  'twins', 'merged bodies', 'fused characters',
-]
-
-const MULTI_SAFE_SLOTS = new Set(['left', 'right', 'center', 'foreground', 'background', 'far left', 'far right'])
-const MULTI_UNSAFE_COMPOSITION_MARKERS = [
-  'split screen', 'panel', 'multiple views', 'alternate views', 'character sheet',
-  'top left', 'top right', 'bottom left', 'bottom right',
-]
-const MULTI_SAFE_SPATIAL_MODES = new Set(['shared_contact', 'shared_scene', 'explicit_positions'])
-
-function buildMultiPersonPlanPrompt(userPrompt, fixedCharacters = {}) {
-  const fixedNote = Object.keys(fixedCharacters).length
-    ? `Locally saved characters explicitly mentioned by the user:\n${JSON.stringify(fixedCharacters, null, 2)}`
-    : 'No locally saved character name was detected.'
-  return `Plan one coherent Anima image containing 2 to 4 people.
-
-Use the user's requested identities, count, clothing, expressions, props, positions, and relationships. You may freely design compatible mutable details, background, lighting, and atmosphere when the user leaves them open.
-
-Separate every person into an independent semantic block. Position slots are bookkeeping only and must never describe separate regions, panels, views, or sides of the image. Prefer one shared central group. Use explicit positions only when the user directly asks for left/right or foreground/background placement. Never use top_left, top_right, bottom_left, bottom_right, upper, lower, panel, or "side of the image".
-
-For an existing named character, preserve the user's written name in "name" and provide the most likely Danbooru character tag in "danbooru_candidate". For an original or generic person, leave "danbooru_candidate" empty.
-
-When a person matches one of the locally saved characters below, their saved tags are authoritative. Leave "appearance" empty and do not restate or alter their hair, eyes, species, ears, tail, body type, age, or fixed accessories. Only plan mutable clothing, expression, pose, and props.
-
-Return JSON only with this exact shape:
-{
-  "count_tags": ["2girls"],
-  "common_tags": ["medium shot", "outdoors"],
-  "characters": [
-    {
-      "slot": "left",
-      "name": "character name from the user",
-      "danbooru_candidate": "romanized_character_tag",
-      "role": "short semantic role such as rider or supporting girl",
-      "visual_label": "distinctive visible label such as white-haired fox girl",
-      "identity_anchors": ["3 to 6 short appearance tags"],
-      "emphasized_anchors": ["0 to 3 explicitly requested unusual traits"],
-      "appearance": "Visible identity traits for a non-fixed character only; empty for a locally saved character.",
-      "clothing": "One concise English clothing phrase.",
-      "expression": "One concise English expression phrase.",
-      "pose": "One concise English body pose that does not repeat the interaction.",
-      "props": ["visible prop held or worn by this person"]
-    },
-    {
-      "slot": "right",
-      "name": "second character name from the user",
-      "danbooru_candidate": "romanized_character_tag",
-      "appearance": "",
-      "clothing": "One concise English clothing phrase.",
-      "expression": "One concise English expression phrase.",
-      "pose": "One concise English body pose.",
-      "props": []
-    }
-  ],
-  "relationship_tag": "holding hands",
-  "interactions": [
-    "Character A is holding Character B's hand."
-  ],
-  "spatial_mode": "shared_contact",
-  "composition": "A single unified full-frame composition using one camera view."
-}
-
-Rules:
-- Include exactly 2 to 4 character objects.
-- count_tags must agree with the number and genders requested by the user.
-- common_tags contain only shared scene, framing, camera, lighting, atmosphere, and count tags.
-- relationship_tag is one short Danbooru-style relationship or action tag and appears immediately after the count tags in the final prompt.
-- Do not put character names or character-specific appearance in common_tags.
-- role is optional semantic bookkeeping and is not used to identify a person in the final interaction sentence.
-- visual_label must be a unique 2 to 6 word visible description derived from identity_anchors, such as "white-haired fox girl" or "silver-haired vampire girl". Do not use names, ordinal labels, rider, supporter, top, bottom, left, or right as visual_label.
-- identity_anchors must contain only 3 to 6 concise visible identity traits. For locally saved characters, select them only from the saved defining tags.
-- emphasized_anchors may contain at most 3 identity_anchors that the user explicitly requested and that are unusual, contrastive, or likely to be confused between people. Never invent emphasis.
-- For locally saved characters, appearance must be empty and saved defining tags must never be contradicted.
-- Do not output quality tags, safety tags, artist tags, Markdown, or explanations.
-- Keep character fields and relationships visually concrete.
-- Preserve the user's explicit interaction direction and gaze direction.
-- Put the complete directed relationship in exactly one interactions entry. Character pose fields must not repeat the relationship.
-- Refer to people inside interactions exclusively as Character A, Character B, Character C, or Character D. Never use their names, translated names, or Danbooru tags there.
-- spatial_mode must be shared_contact for physical interaction, shared_scene for a non-contact group, or explicit_positions only when the user explicitly requests relative positions.
-- Prefer a single coherent moment rather than multiple competing actions.
-- composition must use affirmative language to request one unified full-frame camera view.
-
-${fixedNote}
-
-User request:
-${userPrompt}
-`
-}
-
-function cleanMultiText(value, limit) {
-  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, limit).trim()
-}
-
-function multiStringTuple(value, limit, itemLimit) {
-  if (!Array.isArray(value)) return []
-  const result = []
-  for (const item of value) {
-    const text = cleanMultiText(item, itemLimit)
-    if (text) result.push(text)
-  }
-  return result.slice(0, limit)
-}
-
-function normalizeMultiSlot(value) {
-  const slot = cleanMultiText(value, 40).toLowerCase().replace(/_/g, ' ').replace(/-/g, ' ').replace(/\s+/g, ' ').trim()
-  return MULTI_SAFE_SLOTS.has(slot) ? slot : ''
-}
-
-function parseMultiPersonPlan(text) {
-  let raw = String(text || '').trim()
-  raw = raw.replace(/^```(?:json)?\s*/i, '')
-  raw = raw.replace(/\s*```$/, '')
-  const match = raw.match(/\{[\s\S]*\}/)
-  if (match) raw = match[0]
-  let data
-  try {
-    data = JSON.parse(raw)
-  } catch (e) {
-    return null
-  }
-  if (!data || typeof data !== 'object') return null
-  const rawCharacters = data.characters
-  if (!Array.isArray(rawCharacters) || rawCharacters.length < 2 || rawCharacters.length > 4) return null
-  if (rawCharacters.some(item => !item || typeof item !== 'object')) return null
-
-  const defaultSlots = {
-    2: ['left', 'right'],
-    3: ['left', 'center', 'right'],
-    4: ['far left', 'left', 'right', 'far right'],
-  }[rawCharacters.length]
-  const proposedSlots = rawCharacters.map(item => normalizeMultiSlot(item.slot))
-  if (
-    proposedSlots.some(slot => !slot) ||
-    new Set(proposedSlots).size !== proposedSlots.length ||
-    (rawCharacters.length === 2 && !(new Set(proposedSlots).size === 2 && ['left', 'right'].every(s => proposedSlots.includes(s)) || ['foreground', 'background'].every(s => proposedSlots.includes(s))))
-  ) {
-    proposedSlots.splice(0, proposedSlots.length, ...defaultSlots)
-  }
-
-  const characters = proposedSlots.map((slot, index) => {
-    const item = rawCharacters[index]
-    return {
-      slot,
-      name: cleanMultiText(item.name, 120),
-      danbooru_candidate: cleanMultiText(item.danbooru_candidate, 160),
-      appearance: cleanMultiText(item.appearance, 500),
-      clothing: cleanMultiText(item.clothing, 400),
-      expression: cleanMultiText(item.expression, 240),
-      pose: cleanMultiText(item.pose, 400),
-      props: multiStringTuple(item.props, 12, 120),
-      role: cleanMultiText(item.role, 80),
-      visual_label: cleanMultiText(item.visual_label, 100),
-      identity_anchors: multiStringTuple(item.identity_anchors, 6, 100),
-      emphasized_anchors: multiStringTuple(item.emphasized_anchors, 3, 100),
-    }
-  })
-
-  const countTags = multiStringTuple(data.count_tags, 8, 80)
-  const commonTags = multiStringTuple(data.common_tags, 50, 100)
-  const interactions = multiStringTuple(data.interactions, 1, 500)
-  const composition = cleanMultiText(data.composition, 700)
-  let spatialMode = cleanMultiText(data.spatial_mode, 40).toLowerCase()
-  const relationshipTag = cleanMultiText(data.relationship_tag, 120)
-  if (!MULTI_SAFE_SPATIAL_MODES.has(spatialMode)) spatialMode = interactions.length ? 'shared_contact' : 'shared_scene'
-  let compositionSafe = composition
-  if (MULTI_UNSAFE_COMPOSITION_MARKERS.some(marker => compositionSafe.toLowerCase().includes(marker))) compositionSafe = ''
-  return {
-    count_tags: countTags.length ? countTags : [`${characters.length}people`],
-    common_tags: commonTags,
-    characters,
-    interactions,
-    composition: compositionSafe,
-    spatial_mode: spatialMode,
-    relationship_tag: relationshipTag,
-  }
-}
-
-function renderMultiPersonCharacter(character, opts = {}) {
-  const {
-    alias = '', resolvedIdentity = '', fixedTags = '', groupedContact = false,
-    explicitPositions = false, identityAnchors = [], includePose = true,
-  } = opts
-  let label = String(alias || character.visual_label || character.role || '').trim()
-  if (explicitPositions && character.slot) label = `${character.slot} ${label}`
-  const identity = String(resolvedIdentity || character.danbooru_candidate || '').trim()
-  const details = []
-  if (identity && !fixedTags) details.push(identity)
-  if (identityAnchors.length) {
-    details.push(...identityAnchors)
-  } else if (fixedTags) {
-    for (const part of fixedTags.split(',')) {
-      const t = part.trim().replace(/^ +| +$/g, '').replace(/^\(|\)$/g, '')
-      if (t) details.push(t)
-    }
-  }
-  if (!identityAnchors.length && !fixedTags && character.appearance) details.push(character.appearance)
-  if (character.clothing) details.push(character.clothing)
-  if (character.expression) details.push(character.expression)
-  if (includePose && character.pose) details.push(character.pose)
-  if (character.props && character.props.length) details.push(...character.props)
-  const joined = details.filter(Boolean).join(', ')
-  return `${label}: ${joined}.`
-}
-
-// ------------------------------------------------------------------
-// 多人尺寸自动选择（移植自 anima command_actions multi_person 分支）
-// ------------------------------------------------------------------
-function multiPersonAutoSize(prompt, allowedSizes) {
-  if (!Array.isArray(allowedSizes) || !allowedSizes.length) return null
-  const promptLower = String(prompt || '').toLowerCase()
-  const threeOrMore = /\b(?:三|四|3|4)\s*(?:人|个|名|girls?|boys?|people)\b|\b(?:3|4)(?:girls?|boys?|people)\b/.test(promptLower)
-  const verticallyStacked = [
-    '骑在肩', '骑肩', '肩膀上', '背着', '抱起', '扑倒', '压在', '上下叠',
-    'on the shoulders', 'piggyback', 'carrying', 'on top of', 'stacked',
-  ].some(marker => promptLower.includes(marker))
-  const physicalContact = [
-    '牵手', '拥抱', '接吻', '搂着', '抱着', '挽着',
-    'holding hands', 'hugging', 'embracing', 'kissing', 'arm around',
-  ].some(marker => promptLower.includes(marker))
-  const target = threeOrMore
-    ? [1216, 832]
-    : verticallyStacked
-      ? [1024, 1536]
-      : physicalContact
-        ? [1024, 1024]
-        : [1152, 896]
-  let best = allowedSizes[0]
-  let bestScore = Infinity
-  for (const size of allowedSizes) {
-    const ratioDiff = Math.abs(size[0] / size[1] - target[0] / target[1])
-    const areaDiff = Math.abs(size[0] * size[1] - target[0] * target[1])
-    const score = ratioDiff * 10000 + areaDiff
-    if (score < bestScore) {
-      bestScore = score
-      best = size
-    }
-  }
-  return best
-}
-
-// ------------------------------------------------------------------
-// 插件主体
-// ------------------------------------------------------------------
+// ------------------------------------------------------------------
+// 纯函数库已拆分到 lib/（解析 / tag 清洗 / 工作流 / Comfy 等待 / 多人规划 / HTTP 客户端）
+// ------------------------------------------------------------------
+const {
+  normalizeBaseUrl, escapeRe, parseGenerationSize, parseBatchCount, parseSeed, parseDenoise,
+  stripRawPrefix, parseNameTags, parsePresetList, mergeTagText,
+} = require('./lib/parse')
+const {
+  splitTags, canonicalTagText, joinPromptParts, 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 {
+  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 迁移冲突，拖垮签到插件。
@@ -1367,83 +197,30 @@ exports.apply = async function apply(ctx, cfg) {
     return sizes
   }
 
-  async function comfyGet(apiPath, timeout = 20000) {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), timeout)
-    try {
-      const res = await fetch(baseUrl() + apiPath, { signal: controller.signal })
-      if (!res.ok) throw new Error(`HTTP ${res.status}`)
-      return await res.json()
-    } finally {
-      clearTimeout(timer)
-    }
-  }
-  async function comfyPost(apiPath, body, timeout = 20000) {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), timeout)
-    try {
-      const res = await fetch(baseUrl() + apiPath, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      })
-      if (!res.ok) {
-        // ComfyUI /prompt 校验失败时会返回 node_errors 等详细错误，尽量带出来便于排查
-        const text = await res.text().catch(() => '')
-        const detail = (() => {
-          try {
-            const data = JSON.parse(text)
-            const nodeErrors = (data && data.node_errors) || (data && data.error && data.error.extra_info && data.error.extra_info.node_errors) || null
-            if (nodeErrors && typeof nodeErrors === 'object') {
-              const lines = Object.entries(nodeErrors).map(([id, e]) => {
-                const cls = (e && e.class_type) || ''
-                const errs = (e && Array.isArray(e.errors) && e.errors.length)
-                  ? e.errors.map(x => `${(x && x.message) || ''}${x && x.details ? ' | ' + x.details : ''}`.trim()).join('; ')
-                  : JSON.stringify(e)
-                return `  #${id} [${cls}]: ${errs}`
-              })
-              if (lines.length) return `\n${lines.join('\n')}`
-            }
-            if (data && data.error) {
-              return `${data.error.message || ''}${data.error.details ? ' ' + data.error.details : ''}`.trim()
-            }
-          } catch (e) { /* ignore */ }
-          return text.slice(0, 800)
-        })()
-        throw new Error(`HTTP ${res.status}${detail ? '：' + detail : ''}`)
-      }
-      return await res.json()
-    } finally {
-      clearTimeout(timer)
-    }
-  }
-  async function comfyGetBytes(apiPath, timeout = 120000) {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), timeout)
-    try {
-      const res = await fetch(baseUrl() + apiPath, { signal: controller.signal })
-      if (!res.ok) throw new Error(`HTTP ${res.status}`)
-      return Buffer.from(await res.arrayBuffer())
-    } finally {
-      clearTimeout(timer)
-    }
-  }
+  // ComfyUI HTTP 客户端（统一超时与错误详情提取，见 lib/http.js）
+  const { get: comfyGet, post: comfyPost, getBytes: comfyGetBytes } = buildComfyClient({ getBaseUrl: baseUrl })
 
   // ---------------- 状态 ----------------
   let objectInfoCache = null
   let objectInfoCacheAt = 0
+  let objectInfoInFlight = null
 
   // /object_info 可能返回体巨大或接口本身很慢（自定义节点多），
   // 用短超时 + 10 分钟缓存，避免每次状态检查都干等。
+  // 并发请求共用同一个 in-flight promise，避免同一时刻重复请求 /object_info。
   async function getObjectInfoCached() {
     if (objectInfoCache && Date.now() - objectInfoCacheAt < 10 * 60 * 1000) {
       return objectInfoCache
     }
-    const data = await comfyGet('/object_info', 5000)
-    objectInfoCache = data
-    objectInfoCacheAt = Date.now()
-    return data
+    if (objectInfoInFlight) return objectInfoInFlight
+    objectInfoInFlight = comfyGet('/object_info', 5000)
+      .then((data) => {
+        objectInfoCache = data
+        objectInfoCacheAt = Date.now()
+        return data
+      })
+      .finally(() => { objectInfoInFlight = null })
+    return objectInfoInFlight
   }
 
   async function statusPayload() {
@@ -1626,6 +403,107 @@ exports.apply = async function apply(ctx, cfg) {
     return { ok: true }
   }
 
+  // ---------------- 共享辅助（三大 handler 共用骨架，去重） ----------------
+
+  // 画师 tags 解析 + no artist 守卫（用户明确「不要画师/不要风格」时跳过）。
+  // 语义：与负面词里的 artist name（去签名/水印）无关，只响应用户的显式拒绝。
+  function resolveArtistTags(userPrompt, opts = {}) {
+    const presets = parsePresetList(cfg.artistPresets)
+    let artistTags = ''
+    if (cfg.activeArtistPreset && presets[cfg.activeArtistPreset]) {
+      artistTags = presets[cfg.activeArtistPreset]
+    } else if (cfg.defaultArtistTags) {
+      artistTags = String(cfg.defaultArtistTags).trim()
+    }
+    if (artistTags && !opts.skipGuard && NO_ARTIST_RE.test(String(userPrompt || ''))) return ''
+    return artistTags
+  }
+
+  function resolveStyleTags(userPrompt, opts = {}) {
+    if (!cfg.styleTags) return ''
+    if (!opts.skipGuard && NO_STYLE_RE.test(String(userPrompt || ''))) return ''
+    return String(cfg.styleTags).trim()
+  }
+
+  // P 点余额预检（单图/多人/连续共用）
+  async function precheckPoints(session, USERID, isAdmin, totalPrice) {
+    if (isAdmin) return { ok: true }
+    const notExists = await isAccountExists(USERID)
+    if (!notExists) return { ok: false, message: session.text('.account-notExists') }
+    const usersdata = await getPUser(USERID)
+    const saving = usersdata?.p || 0
+    if (saving < totalPrice) return { ok: false, message: session.text('.no-enough-p', [totalPrice]) }
+    return { ok: true }
+  }
+
+  // 预排队整批任务：先检查队列容量再入队，杜绝「部分入队后满、退款但任务仍执行」。
+  // 任一失败路径都按原逻辑退款（P 已在入队前扣除）。
+  async function enqueueBatch(count, work, { USERID, isAdmin, totalPrice }) {
+    const tasks = []
+    let firstPosition = null
+    if (!cfg.queueEnabled) return { ok: true, tasks, firstPosition }
+    const maxQueue = queueMax()
+    // 容量预检与入队循环之间没有 await，单线程内是原子的
+    if (maxQueue && queueInFlight + queueSize + count > maxQueue) {
+      if (!isAdmin) await refundP(USERID, totalPrice)
+      return { ok: false, message: `生成队列已满（最多 ${maxQueue} 个），本次请求已丢弃，请稍后再试。` }
+    }
+    for (let i = 0; i < count; i++) {
+      const q = enqueue(() => work(i))
+      if (!q.ok) {
+        if (!isAdmin) await refundP(USERID, totalPrice)
+        return { ok: false, message: q.message }
+      }
+      tasks.push(q.task)
+      if (firstPosition == null) firstPosition = q.position
+    }
+    return { ok: true, tasks, firstPosition }
+  }
+
+  // 即时反馈的公共部分（队列/生成中 + 张数 + 扣费），返回待发送的行
+  function feedbackBase(session, { firstPosition, count, totalPrice, isAdmin }) {
+    const rows = []
+    if (cfg.queueEnabled) {
+      rows.push(session.text('.queued', [firstPosition, cfg.queueMaxRequests || '∞']))
+      if (count > 1) rows.push(session.text('.batch-count', [count]))
+      if (!isAdmin) rows.push(session.text('.charged', [totalPrice]))
+    } else {
+      rows.push(session.text('.generating'))
+      if (count > 1) rows.push(session.text('.batch-count', [count]))
+      if (!isAdmin) rows.push(session.text('.charged', [totalPrice]))
+    }
+    return rows
+  }
+
+  async function sendNotices(session, notices) {
+    if (!notices.length) return
+    try {
+      await session.send(notices.filter(Boolean).join('\n'))
+    } catch (e) {
+      logger.warn(`发送反馈消息失败：${e.message}`)
+    }
+  }
+
+  // 发图：引用用户触发指令的原消息，失败回退普通发送
+  async function sendImagesWithQuote(session, outputs) {
+    const imageElements = outputs.map(src => h.image(src))
+    try {
+      await session.send(h.quote(session.messageId) + imageElements.join(''))
+    } catch (e) {
+      logger.warn(`发送图片失败（引用）：${e.message}`)
+      await session.send(imageElements)
+    }
+  }
+
+  // P 点读改写按用户串行化，避免并发指令互相覆盖余额
+  const userLocks = new Map()
+  function withUserLock(USERID, fn) {
+    const prev = userLocks.get(USERID) || Promise.resolve()
+    const next = prev.then(fn, fn)
+    userLocks.set(USERID, next.catch(() => {}))
+    return next
+  }
+
   // ---------------- 用户自选模型 ----------------
   // 从 ComfyUI /object_info（10 分钟缓存）读取真实的 UNET 模型列表
   async function listUnetModels() {
@@ -1875,7 +753,7 @@ exports.apply = async function apply(ctx, cfg) {
     }
   }
 
-  async function optimizePrompt(session, userPrompt, force = false, img2imgRule = '') {
+  async function optimizePrompt(session, userPrompt, force = false, img2imgRule = '', precomputedSearch = null) {
     if (!cfg.promptOptimizeEnabled && !force) {
       return { ok: true, prompt: userPrompt, reason: 'optimize_disabled' }
     }
@@ -1884,7 +762,10 @@ exports.apply = async function apply(ctx, cfg) {
       return { ok: false, prompt: userPrompt, reason: 'llm_not_configured' }
     }
     let searchBlock = ''
-    if (wantsWebSearch(userPrompt)) {
+    if (precomputedSearch != null) {
+      // 批量按张优化时由调用方复用同一份搜索结果，避免重复请求 Tavily
+      searchBlock = precomputedSearch
+    } else if (wantsWebSearch(userPrompt)) {
       searchBlock = await webSearch(userPrompt)
     }
     const characterRule = buildCharacterRule(userPrompt)
@@ -2013,19 +894,10 @@ exports.apply = async function apply(ctx, cfg) {
         }
       }
     }
-    const presets = parsePresetList(cfg.artistPresets)
-    let artistTags = ''
-    if (cfg.activeArtistPreset && presets[cfg.activeArtistPreset]) {
-      artistTags = presets[cfg.activeArtistPreset]
-    } else if (cfg.defaultArtistTags) {
-      artistTags = String(cfg.defaultArtistTags).trim()
-    }
-    if (artistTags && !/(不用我的风格|不要我的风格|不使用我的风格|不要画师词|不用画师词|不加画师词|no artist)/i.test(userPrompt)) {
-      parts.push(artistTags)
-    }
-    if (cfg.styleTags && !/(不用我的风格|不要我的风格|不使用我的风格)/i.test(userPrompt)) {
-      parts.push(String(cfg.styleTags).trim())
-    }
+    const artistTags = resolveArtistTags(userPrompt)
+    if (artistTags) parts.push(artistTags)
+    const styleTags = resolveStyleTags(userPrompt)
+    if (styleTags) parts.push(styleTags)
     parts.push(userPrompt)
     return { prompt: joinPromptParts(parts), degraded: false }
   }
@@ -2125,7 +997,7 @@ exports.apply = async function apply(ctx, cfg) {
     const aliases = ['Character A', 'Character B', 'Character C', 'Character D']
     const characterCount = plan.characters.length
     const characterRoles = []
-    const characterBlocks = []
+    const characterTagStream = []
     const characterEntityNames = []
     let groupedContact = plan.spatial_mode === 'shared_contact'
     const explicitPositionRequested = /左边|右边|左侧|右侧|前景|后方|前后站位|\bon\s+the\s+(?:left|right)\b|\bforeground\b|\bbackground\b/i.test(prompt)
@@ -2193,7 +1065,7 @@ exports.apply = async function apply(ctx, cfg) {
       )
 
       characterEntityNames.push(new Set([character.name, character.danbooru_candidate, fixedName, resolvedIdentity].filter(Boolean)))
-      characterBlocks.push(renderMultiPersonCharacter(character, {
+      characterTagStream.push(renderMultiPersonCharacter(character, {
         alias: visualLabel,
         resolvedIdentity,
         fixedTags: fixedName ? fixedTags : '',
@@ -2201,6 +1073,7 @@ exports.apply = async function apply(ctx, cfg) {
         explicitPositions: spatialMode === 'explicit_positions',
         identityAnchors: renderedIdentityTags,
         includePose: !groupedContact,
+        asTagStream: true,
       }))
     }
 
@@ -2274,7 +1147,6 @@ exports.apply = async function apply(ctx, cfg) {
       return displayed
     })
 
-    const sceneGuard = 'The composition shows one shared continuous moment.'
     let relativePosition = ''
     if (spatialMode === 'explicit_positions' && characterCount === 2) {
       const slotAliases = {}
@@ -2286,22 +1158,19 @@ exports.apply = async function apply(ctx, cfg) {
       }
     }
 
-    const narrativeBlocks = [...characterBlocks, ...displayInteractions, relativePosition, sceneGuard].filter(Boolean)
+    const narrativeBlocks = [...displayInteractions, relativePosition].filter(Boolean)
 
-    // 组装最终提示词：质量词 + 画师组 + content + narrative 块
+    // 组装最终提示词：质量词 + 画师组 + 主 tag 流（含角色外观）+ narrative 块（仅互动/站位）
     const contentClean = cleanContentTags(commonContent, 65, false, [], true)
     const parts = []
     if (cfg.qualityPrefix) parts.push(String(cfg.qualityPrefix).trim())
-    const presets = parsePresetList(cfg.artistPresets)
-    let artistTags = ''
-    if (cfg.activeArtistPreset && presets[cfg.activeArtistPreset]) {
-      artistTags = presets[cfg.activeArtistPreset]
-    } else if (cfg.defaultArtistTags) {
-      artistTags = String(cfg.defaultArtistTags).trim()
-    }
+    // 多人同样遵守 no artist 守卫（与单图一致）：用户说「不要画师」时跳过画师 tags
+    const artistTags = resolveArtistTags(prompt)
     if (artistTags) parts.push(artistTags)
-    if (cfg.styleTags) parts.push(String(cfg.styleTags).trim())
+    const styleTags = resolveStyleTags(prompt)
+    if (styleTags) parts.push(styleTags)
     parts.push(contentClean || commonContent)
+    if (characterTagStream.length) parts.push(characterTagStream.join(', '))
     let finalPrompt = joinPromptParts(parts)
     if (narrativeBlocks.length) finalPrompt += '\n\n' + narrativeBlocks.join('\n\n')
     return { ok: true, prompt: finalPrompt }
@@ -2449,7 +1318,6 @@ exports.apply = async function apply(ctx, cfg) {
         break
       }
       currentImages = regen.outputs
-      currentPrompt = regen.finalPrompt || currentPrompt
     }
 
     // 多候选挑选
@@ -2527,13 +1395,8 @@ exports.apply = async function apply(ctx, cfg) {
     const count = parsedBatch.count
 
     // P 点校验（按总价 = 张数 × 单价）
-    if (!isAdmin) {
-      const notExists = await isAccountExists(USERID)
-      if (!notExists) return session.text('.account-notExists')
-      const usersdata = await getPUser(USERID)
-      const saving = usersdata?.p || 0
-      if (saving < count * price) return session.text('.no-enough-p', [count * price])
-    }
+    const pcheck = await precheckPoints(session, USERID, isAdmin, count * price)
+    if (!pcheck.ok) return pcheck.message
 
     // 未指定尺寸时按人数/接触关系自动选横图
     let size = parsedSize.size
@@ -2573,40 +1436,17 @@ exports.apply = async function apply(ctx, cfg) {
       if (cfg.outputLogs) logger.info(`[p-draw] ${USERID} 多人已扣除 ${count * price} P 点（${count} 张 × ${price}），余额 ${saving - count * price}`)
     }
 
-    // 队列：预排队全部任务，占满即退回总价
-    const queuedTasks = []
-    let firstPosition = null
-    if (cfg.queueEnabled) {
-      for (let i = 0; i < count; i++) {
-        const q = enqueue(() => runComfyGenerate(finalPrompt, size, { negativePrompt: multiNegative, unet }))
-        if (!q.ok) {
-          if (!isAdmin) await refundP(USERID, count * price)
-          return q.message
-        }
-        queuedTasks.push(q.task)
-        if (firstPosition == null) firstPosition = q.position
-      }
-    }
+    // 队列：预排队全部任务（先查容量再入队，占满整体退回总价）
+    const queued = await enqueueBatch(count, (i) => runComfyGenerate(finalPrompt, size, { negativePrompt: multiNegative, unet }), { USERID, isAdmin, totalPrice: count * price })
+    if (!queued.ok) return queued.message
+    const queuedTasks = queued.tasks
+    const firstPosition = queued.firstPosition
 
     // 即时反馈
     const notice = []
     if (parsedBatch.clamped) notice.push(session.text('.batch-limit', [count]))
-    if (cfg.queueEnabled) {
-      notice.push(session.text('.queued', [firstPosition, cfg.queueMaxRequests || '∞']))
-      if (count > 1) notice.push(session.text('.batch-count', [count]))
-      if (!isAdmin) notice.push(session.text('.charged', [count * price]))
-    } else {
-      notice.push(session.text('.generating'))
-      if (count > 1) notice.push(session.text('.batch-count', [count]))
-      if (!isAdmin) notice.push(session.text('.charged', [count * price]))
-    }
-    if (notice.length) {
-      try {
-        await session.send(notice.filter(Boolean).join('\n'))
-      } catch (e) {
-        logger.warn(`发送反馈消息失败：${e.message}`)
-      }
-    }
+    notice.push(...feedbackBase(session, { firstPosition, count, totalPrice: count * price, isAdmin }))
+    await sendNotices(session, notice)
 
     // 单张生成 +（可选）视觉校验
     const runOne = async (i) => {
@@ -2650,13 +1490,7 @@ exports.apply = async function apply(ctx, cfg) {
     if (cfg.outputLogs) logger.success(`${USERID} 多人生成成功 ${successCount}/${count} 张`)
 
     // 发图：引用用户触发指令的原消息
-    const imageElements = allOutputs.map(src => h.image(src))
-    try {
-      await session.send(h.quote(session.messageId) + imageElements.join(''))
-    } catch (e) {
-      logger.warn(`发送多人图片失败：${e.message}`)
-      await session.send(imageElements)
-    }
+    await sendImagesWithQuote(session, allOutputs)
 
     const reply = []
     if (count > 1) {
@@ -2730,13 +1564,8 @@ exports.apply = async function apply(ctx, cfg) {
     const stageList = stages.slice(0, count)
 
     // P 点校验（按总价）
-    if (!isAdmin) {
-      const notExists = await isAccountExists(USERID)
-      if (!notExists) return session.text('.account-notExists')
-      const usersdata = await getPUser(USERID)
-      const saving = usersdata?.p || 0
-      if (saving < count * price) return session.text('.no-enough-p', [count * price])
-    }
+    const pcheck = await precheckPoints(session, USERID, isAdmin, count * price)
+    if (!pcheck.ok) return pcheck.message
 
     // ComfyUI 就绪
     const ready = await ensureComfyuiReady()
@@ -2780,20 +1609,11 @@ exports.apply = async function apply(ctx, cfg) {
       if (cfg.outputLogs) logger.info(`[p-draw] ${USERID} 连续图已扣除 ${count * price} P 点（${count} 阶段 × ${price}，seed=${seed}），余额 ${saving - count * price}`)
     }
 
-    // 队列：预排队全部阶段
-    const queuedTasks = []
-    let firstPosition = null
-    if (cfg.queueEnabled) {
-      for (let i = 0; i < count; i++) {
-        const q = enqueue(() => runComfyGenerate(stagePrompts[i], size, { seed, unet }))
-        if (!q.ok) {
-          if (!isAdmin) await refundP(USERID, count * price)
-          return q.message
-        }
-        queuedTasks.push(q.task)
-        if (firstPosition == null) firstPosition = q.position
-      }
-    }
+    // 队列：预排队全部阶段（先查容量再入队）
+    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 = []
@@ -2801,22 +1621,8 @@ exports.apply = async function apply(ctx, cfg) {
     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', ['（连续图阶段优化失败，已使用原始描述）']))
-    if (cfg.queueEnabled) {
-      notice.push(session.text('.queued', [firstPosition, cfg.queueMaxRequests || '∞']))
-      if (count > 1) notice.push(session.text('.batch-count', [count]))
-      if (!isAdmin) notice.push(session.text('.charged', [count * price]))
-    } else {
-      notice.push(session.text('.generating'))
-      if (count > 1) notice.push(session.text('.batch-count', [count]))
-      if (!isAdmin) notice.push(session.text('.charged', [count * price]))
-    }
-    if (notice.length) {
-      try {
-        await session.send(notice.filter(Boolean).join('\n'))
-      } catch (e) {
-        logger.warn(`发送反馈消息失败：${e.message}`)
-      }
-    }
+    notice.push(...feedbackBase(session, { firstPosition, count, totalPrice: count * price, isAdmin }))
+    await sendNotices(session, notice)
 
     // 单阶段生成（共用 seed）
     const runOne = async (i) => {
@@ -2852,13 +1658,7 @@ exports.apply = async function apply(ctx, cfg) {
     if (cfg.outputLogs) logger.success(`${USERID} 连续图生成成功 ${successCount}/${count} 阶段（seed=${seed}）`)
 
     // 发图：引用用户触发指令的原消息
-    const imageElements = allOutputs.map(src => h.image(src))
-    try {
-      await session.send(h.quote(session.messageId) + imageElements.join(''))
-    } catch (e) {
-      logger.warn(`发送连续图失败：${e.message}`)
-      await session.send(imageElements)
-    }
+    await sendImagesWithQuote(session, allOutputs)
 
     const reply = []
     reply.push(session.text('.series-ok', [count * price, successCount, seed]))
@@ -2927,16 +1727,20 @@ exports.apply = async function apply(ctx, cfg) {
   }
 
   async function deductP(USERID, amount) {
-    const user = await getPUser(USERID)
-    const current = user?.p || 0
-    await ctx.database.set('p_system', { userid: USERID }, { p: Math.max(0, current - amount) })
-    return current
+    return withUserLock(USERID, async () => {
+      const user = await getPUser(USERID)
+      const current = user?.p || 0
+      await ctx.database.set('p_system', { userid: USERID }, { p: Math.max(0, current - amount) })
+      return current
+    })
   }
 
   async function refundP(USERID, amount) {
-    const user = await getPUser(USERID)
-    const current = user?.p || 0
-    await ctx.database.set('p_system', { userid: USERID }, { p: current + amount })
+    return withUserLock(USERID, async () => {
+      const user = await getPUser(USERID)
+      const current = user?.p || 0
+      await ctx.database.set('p_system', { userid: USERID }, { p: current + amount })
+    })
   }
 
   // ---------------- 画师组/角色管理（持久化到数据库，避免 scope.update 触发重载） ----------------
@@ -3258,7 +2062,13 @@ exports.apply = async function apply(ctx, cfg) {
     if (!src) return null
     try {
       if (/^file:\/\//i.test(src)) {
-        const filePath = src.replace(/^file:\/\//i, '')
+        // 修复：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' }
       }
@@ -3391,13 +2201,9 @@ exports.apply = async function apply(ctx, cfg) {
     const count = parsedBatch.count
 
     // P 点校验（按总价 = 张数 × 单价）
-    if (!isAdmin) {
-      const notExists = await isAccountExists(USERID)
-      if (!notExists) return session.text('.account-notExists')
-      const usersdata = await getPUser(USERID)
-      const saving = usersdata?.p || 0
-      if (saving < count * cfg.price) return session.text('.no-enough-p', [count * cfg.price])
-    }
+    // P 点校验（按总价 = 张数 × 单价）
+    const pcheck = await precheckPoints(session, USERID, isAdmin, count * cfg.price)
+    if (!pcheck.ok) return pcheck.message
 
     // 原样模式
     const stripped = stripRawPrefix(text)
@@ -3487,27 +2293,21 @@ exports.apply = async function apply(ctx, cfg) {
       ? { i2iImage, i2i: { mode: (i2iOpts && i2iOpts.mode) || 'plain', denoise: denoise != null ? denoise : null, caps: (i2iOpts && i2iOpts.caps) || null } }
       : {}
 
-    // 队列：预排队全部任务，占满即退回总价
-    const queuedTasks = []
-    let firstPosition = null
-    if (cfg.queueEnabled) {
-      for (let i = 0; i < count; i++) {
-        const q = enqueue(async () => {
-          let p = finalPrompt
-          if (perImageOptimize) {
-            const optimized = await optimizePrompt(session, userPrompt, true, i2iRule)
-            p = appendInlineProtectedTags(composePrompt(optimized.prompt || userPrompt, raw).prompt, userPrompt, raw)
-          }
-          return runComfyGenerate(p, parsedSize.size, Object.assign({ unet, seed }, i2iRun))
-        })
-        if (!q.ok) {
-          if (!isAdmin) await refundP(USERID, count * cfg.price)
-          return q.message
-        }
-        queuedTasks.push(q.task)
-        if (firstPosition == null) firstPosition = q.position
+    // 性能：按张优化（perImageOptimize）时联网搜索只做一次，各图复用同一份结果
+    const searchCache = perImageOptimize && wantsWebSearch(userPrompt) ? await webSearch(userPrompt) : null
+
+    // 队列：预排队全部任务（先查容量再入队，占满整体退回总价）
+    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)
       }
-    }
+      return runComfyGenerate(p, parsedSize.size, Object.assign({ unet, seed }, i2iRun))
+    }, { USERID, isAdmin, totalPrice: count * cfg.price })
+    if (!queued.ok) return queued.message
+    const queuedTasks = queued.tasks
+    const firstPosition = queued.firstPosition
 
     // 先发一条即时反馈（扣费结果 / 队列位置 / 降级提示），
     // 确保用户不会以为指令没反应。
@@ -3526,28 +2326,14 @@ 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]))
-    if (cfg.queueEnabled) {
-      notice.push(session.text('.queued', [firstPosition, cfg.queueMaxRequests || '∞']))
-      if (count > 1) notice.push(session.text('.batch-count', [count]))
-      if (!isAdmin) notice.push(session.text('.charged', [count * cfg.price]))
-    } else {
-      notice.push(session.text('.generating'))
-      if (count > 1) notice.push(session.text('.batch-count', [count]))
-      if (!isAdmin) notice.push(session.text('.charged', [count * cfg.price]))
-    }
-    if (notice.length) {
-      try {
-        await session.send(notice.filter(Boolean).join('\n'))
-      } catch (e) {
-        logger.warn(`发送反馈消息失败：${e.message}`)
-      }
-    }
+    notice.push(...feedbackBase(session, { firstPosition, count, totalPrice: count * cfg.price, isAdmin }))
+    await sendNotices(session, notice)
 
     // 单张生成
     const runOne = async (i) => {
       let p = finalPrompt
       if (perImageOptimize) {
-        const optimized = await optimizePrompt(session, userPrompt, true, i2iRule)
+        const optimized = await optimizePrompt(session, userPrompt, true, i2iRule, searchCache)
         p = appendInlineProtectedTags(composePrompt(optimized.prompt || userPrompt, raw).prompt, userPrompt, raw)
       }
       let result
@@ -3581,14 +2367,8 @@ exports.apply = async function apply(ctx, cfg) {
 
     if (cfg.outputLogs) logger.success(`${USERID} 生成成功 ${successCount}/${count} 张`)
 
-    const imageElements = allOutputs.map(src => h.image(src))
-    // 引用用户触发指令的原消息
-    try {
-      await session.send(h.quote(session.messageId) + imageElements.join(''))
-    } catch (e) {
-      logger.warn(`发送图片失败（引用）：${e.message}`)
-      await session.send(imageElements)
-    }
+    // 发图：引用用户触发指令的原消息
+    await sendImagesWithQuote(session, allOutputs)
 
     const reply = []
     if (count > 1) {
@@ -3629,13 +2409,13 @@ exports.apply = async function apply(ctx, cfg) {
       // 没券/券不足：问是否购买（显示价格）；拒绝一次再警告并问第二次，再拒绝直接生图
       const askBuy = async () => {
         await session.send(session.text('.coupon-ask-buy', [count, tokens, couponPrice, count * couponPrice]))
-        const reply = await session.prompt(cfg.couponAskTimeout * 1000)
+        const reply = await session.prompt(cfg.couponAskTimeout * 1000).catch(() => null)
         return normalizeConfirm(reply)
       }
       let ans = await askBuy()
       if (ans === false) {
         await session.send(session.text('.coupon-buy-warn'))
-        const reply = await session.prompt(cfg.couponAskTimeout * 1000)
+        const reply = await session.prompt(cfg.couponAskTimeout * 1000).catch(() => null)
         ans = normalizeConfirm(reply)
         if (ans !== true) {
           await session.send(session.text('.coupon-buy-cancelled'))
@@ -3693,8 +2473,15 @@ exports.apply = async function apply(ctx, cfg) {
     return null
   }
 
-  // 提示词优化券单价：优先读 data/p-shop.json 里覆盖的价格，否则用配置 couponPrice
+  // 提示词优化券单价：优先读 data/p-shop.json 里覆盖的价格，否则用配置 couponPrice。
+  // 加 60 秒 TTL 缓存，避免每次购买询问都同步读盘。
+  let couponPriceCache = null
+  let couponPriceCacheAt = 0
   async function resolveCouponPrice() {
+    if (couponPriceCache != null && Date.now() - couponPriceCacheAt < 60 * 1000) {
+      return couponPriceCache
+    }
+    let price = cfg.couponPrice
     const candidates = [
       path.join(ctx.baseDir, 'data', 'p-shop.json'),
       path.join(process.cwd(), 'data', 'p-shop.json'),
@@ -3705,14 +2492,19 @@ exports.apply = async function apply(ctx, cfg) {
           const data = JSON.parse(fs.readFileSync(f, 'utf-8'))
           if (data && typeof data === 'object') {
             const item = data['提示词优化券']
-            if (item && typeof item.price === 'number' && item.price > 0) return item.price
+            if (item && typeof item.price === 'number' && item.price > 0) {
+              price = item.price
+              break
+            }
           }
         }
       } catch (e) {
         logger.warn(`读取 p-shop.json 价格失败：${e.message}`)
       }
     }
-    return cfg.couponPrice
+    couponPriceCache = price
+    couponPriceCacheAt = Date.now()
+    return price
   }
 
   // 启动时合并数据库里保存的运行时配置（画师组/固定角色）