✨ feat(content): 新增智能选题引擎、批量创作和图文协同优化

- 新增智能选题引擎 `TopicEngine`，整合热点数据与历史权重，提供多维度评分和创作角度建议 - 新增内容模板系统 `ContentTemplate`，支持从 JSON 文件加载模板并应用于文案生成 - 新增批量创作功能 `batch_generate_copy`，支持串行生成多篇文案并自动入草稿队列 - 升级文案质量流水线：实现 Prompt 分层架构（基础层 + 风格层 + 人设层）、LLM 自检与改写机制、深度去 AI 化后处理 - 优化图文协同：新增封面图策略选择、SD prompt 与文案语义联动、图文匹配度评估 - 集成数据闭环：在文案生成中自动注入 `AnalyticsService` 权重数据，实现发布 → 数据回收 → 优化创作的完整循环 - 更新 UI 组件：新增选题推荐展示区、批量创作折叠面板、封面图策略选择器和图文匹配度评分展示 ♻️ refactor(llm): 重构 Prompt 架构并增强去 AI 化处理 - 将 `PROMPT_COPYWRITING` 拆分为分层架构（基础层 + 风格层 + 人设层），提高维护性和灵活性 - 增强 `_humanize_content` 方法：新增语气词注入、标点不规范化、段落节奏打散和 emoji 密度控制 - 新增 `_self_check` 和 `_self_check_rewrite` 方法，实现文案 AI 痕迹自检与自动改写 - 新增 `evaluate_image_text_match` 方法，支持文案与 SD prompt 的语义匹配度评估（可选，失败不阻塞） - 新增封面图策略配置 `COVER_STRATEGIES` 和情感基调映射 `EMOTION_SD_MAP` 📝 docs(openspec): 归档内容创作优化提案和详细规格 - 新增 `openspec/changes/archive/2026-02-28-optimize-content-creation/` 目录，包含设计文档、提案、规格说明和任务清单 - 新增 `openspec/specs/` 下的批量创作、文案质量流水线、图文协同、服务内容和智能选题引擎规格文档 - 更新 `openspec/specs/services-content/spec.md`，反映新增的批量创作和智能选题入口函数 🔧 chore(config): 更新服务配置和 UI 集成 - 在 `services/content.py` 中集成权重数据自动注入逻辑，实现数据驱动创作 - 在 `ui/app.py` 中新增选题推荐、批量生成和图文匹配度评估的回调函数 - 在 `ui/tab_create.py` 中新增智能选题推荐区、批量创作面板和图文匹配度评估组件 - 修复 `services/sd_service.py` 中的头像文件路径问题，确保目录存在
2026-02-28 21:04:09 +08:00 · 2026-02-28 21:04:09 +08:00 · 1ec520b47e
commit 1ec520b47e
parent 2ba87c8f6e
22 changed files with 1992 additions and 90 deletions
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/.openspec.yaml
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/.openspec.yaml
@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-02-28
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/design.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/design.md
@ -0,0 +1,87 @@
+## Context
+
+当前 autobot 的内容创作流程是单篇串行模式：用户手动输入主题 → LLM 生成文案 → SD 生成图片 → 手动发布/导出。系统已有 `analytics_service.py` 的权重学习和 `hotspot.py` 的热点探测，但两者与创作环节是割裂的——权重数据仅在自动发布时被动使用，热点分析需要用户手动操作后再回到创作 Tab。
+
+核心代码分布：
+- `services/llm_service.py`（964 行）：所有 Prompt 模板和 LLM 调用逻辑
+- `services/content.py`（210 行）：创作入口函数（generate_copy、generate_images、export、publish）
+- `services/analytics_service.py`（666 行）：数据采集 + 权重计算
+- `services/hotspot.py`（191 行）：热点搜索 + 分析
+- `services/publish_queue.py`（630 行）：SQLite 发布队列，已支持草稿/排期/重试
+- `ui/tab_create.py`（183 行）：创作 Tab UI
+
+## Goals / Non-Goals
+
+**Goals:**
+- 让选题从"人工拍脑袋"变成"数据推荐 + 人工确认"
+- 降低文案 AI 痕迹，提高过检率
+- 支持批量创作，一次操作产出多篇内容直接进入草稿队列
+- 打通数据闭环：历史表现 → 权重 → 创作 Prompt → 新内容
+- SD prompt 与文案内容语义对齐，提升图文一致性
+
+**Non-Goals:**
+- 不涉及视频内容生成（仅图文笔记）
+- 不改变 MCP 发布协议和 SD 生成核心逻辑
+- 不引入新的外部依赖（仅内部模块重组）
+- 不改变现有单篇创作的 UI 交互模式（新增批量面板，不替换现有面板）
+
+## Decisions
+
+### Decision 1: 智能选题引擎作为独立模块
+
+**选择**: 新建 `services/topic_engine.py`，不在 `hotspot.py` 或 `analytics_service.py` 中扩展。
+
+**理由**: 选题引擎需要同时聚合热点数据和权重数据，放在任何一方都会造成单向依赖和职责膨胀。独立模块清晰地表达了"整合者"角色。
+
+**替代方案**: 在 `analytics_service.py` 中添加 `recommend_topics()` 方法。弃选原因——`AnalyticsService` 职责已重（采集 + 权重 + 报告），再加选题推荐会让该类过于庞大。
+
+### Decision 2: Prompt 分层而非模板替换
+
+**选择**: 将 `PROMPT_COPYWRITING` 拆为 base + style + persona 三层拼接，而非为每种风格维护完整 Prompt 模板。
+
+**理由**: 当前的完整 Prompt 已有 60+ 行，如果每种风格复制一份，维护成本极高且容易不一致。分层后，基础规则只维护一处，风格层仅包含差异化指导。
+
+**替代方案**: 使用 Jinja2 模板引擎渲染。弃选原因——引入新依赖、过度工程化，字符串拼接足够简单可控。
+
+### Decision 3: 自检用同一 LLM 实例，共享 fallback 机制
+
+**选择**: 文案自检和改写复用 `LLMService._chat()`，共享模型降级和 JSON 回退逻辑。
+
+**理由**: 复用现有的健壮性机制（fallback models、json_mode 回退、超时处理），无需重复实现。自检 Prompt 作为独立方法 `_self_check(content)` 封装即可。
+
+**替代方案**: 使用独立的轻量模型做自检。弃选原因——增加配置复杂度，且当前 fallback 机制已可自动降级。
+
+### Decision 4: 批量创作串行执行 + 队列入草稿
+
+**选择**: `batch_generate()` 串行调用 `generate_copy()`（非并行），结果自动入 `PublishQueue` 的 `draft` 状态。
+
+**理由**: 
+1. LLM API 通常有 rate limit，串行更稳定
+2. 复用现有 `PublishQueue` 的完整草稿管理能力（审核、编辑、排期、重试）
+3. 用户可在批量生成后逐篇审核调整
+
+**替代方案**: 并行调用 + 独立草稿存储。弃选原因——rate limit 风险大，维护两套草稿系统增加复杂度。
+
+### Decision 5: 图文语义联动通过 Prompt 工程实现
+
+**选择**: 在生成文案时把 SD prompt 生成的上下文增强——将文案正文的关键场景词注入 SD prompt 生成指令中，不使用独立的语义匹配模型。
+
+**理由**: 当前 LLM 已具备理解文案并生成对应 SD prompt 的能力，只需优化 Prompt 指令使其更关注文案中的具体场景描述。额外的语义匹配评估作为可选功能，通过 LLM 二次调用实现。
+
+### Decision 6: 封面图策略通过 SD 参数预设实现
+
+**选择**: 在现有 `quality_mode` 机制旁新增 `cover_strategy` 参数，映射为不同的 SD prompt 后缀和尺寸参数，复用 `sd_service.py` 的预设体系。
+
+**理由**: 与现有的"快速/标准/精细"模式选择机制一致，用户理解成本低。
+
+## Risks / Trade-offs
+
+- **[LLM 调用量增加]** → 自检机制每篇多 1 次 LLM 调用，批量创作 N 篇则为 2N 次。缓解：自检设超时上限（10s），失败不阻塞；批量限制 ≤ 10 篇。
+- **[Prompt 分层维护成本]** → 风格层 Prompt 需要针对每种风格单独调优。缓解：初期只提供 3 种核心风格层，其余退回基础层。
+- **[选题推荐质量依赖数据量]** → 新账号/新赛道初期权重数据不足，推荐质量有限。缓解：无权重时退回纯热点推荐，给出"数据不足"提示。
+- **[图文匹配度评估增加延迟]** → 额外 LLM 调用。缓解：评估完全可选，默认关闭，不阻塞创作流程。
+
+## Open Questions
+
+- 风格层 Prompt 的具体数量和优先级——初期先做哪几种风格？（建议："好物种草""日常分享""攻略教程"三种最高频风格）
+- 批量创作的 UI 交互方式——独立 Tab 还是在现有创作 Tab 内新增折叠面板？（建议：同 Tab 内新增折叠面板，降低导航复杂度）
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/proposal.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/proposal.md
@ -0,0 +1,32 @@
+## Why
+
+当前内容创作流程存在几个核心瓶颈：选题依赖人工直觉、文案 AI 痕迹仍有残留、创作只能逐篇操作效率低、数据分析与创作环节割裂、以及 SD 图片 prompt 与文案内容缺乏联动。这些问题导致创作效率低、内容互动率不稳定、人工干预成本高。通过系统性优化，可以让整个创作链路变得更智能、更高效、更数据驱动。
+
+## What Changes
+
+- 新增智能选题引擎：整合热点探测 + 历史表现权重 + 趋势预测，自动推荐高潜力选题并附带推荐理由
+- 升级文案质量流水线：引入 Prompt 分层策略（基础层 + 风格层 + 人设层）、多轮自检机制、更深度的去 AI 化后处理
+- 新增批量创作工作流：支持模板系统、批量主题生成、草稿队列管理，一次操作产出多篇内容
+- 增强数据驱动闭环：将 analytics 权重学习结果自动注入创作 Prompt，实现"发布 → 数据回收 → 优化创作"的完整闭环
+- 优化图文协同：让 SD prompt 与文案内容语义联动、增加封面图策略选择、引入图文匹配度评估
+
+## Capabilities
+
+### New Capabilities
+
+- `smart-topic-engine`: 智能选题引擎——整合热点数据、历史笔记表现权重、内容趋势，自动推荐高潜力选题及创作角度
+- `copy-quality-pipeline`: 文案质量流水线——Prompt 分层架构、LLM 多轮自检/改写、深度去 AI 化后处理管线
+- `batch-creation`: 批量创作工作流——内容模板系统、批量主题生成、草稿队列管理、一键批量导出
+- `image-text-synergy`: 图文协同优化——SD prompt 与文案语义联动生成、封面图策略选择、图文匹配度评估
+
+### Modified Capabilities
+
+- `services-content`: 创作入口函数需适配批量模式、模板注入、智能选题结果传递等新流程
+
+## Impact
+
+- **代码变动**: `services/llm_service.py`（Prompt 重构、新增自检方法）、`services/content.py`（批量创作入口、模板系统）、`services/analytics_service.py`（权重闭环输出接口）、`services/hotspot.py`（选题引擎集成）
+- **UI 变动**: `ui/tab_create.py` 需新增批量创作面板、选题推荐展示区、图文策略选项
+- **新增模块**: 可能需要 `services/topic_engine.py`（选题引擎）、`services/content_template.py`（模板管理）
+- **数据文件**: `xhs_workspace/content_weights.json` 数据结构可能需扩展以支持更细粒度的权重维度
+- **依赖**: 无新增外部依赖，主要是内部模块重组和 Prompt 工程优化
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/batch-creation/spec.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/batch-creation/spec.md
@ -0,0 +1,45 @@
+## ADDED Requirements
+
+### Requirement: 内容模板系统
+系统 SHALL 提供 `ContentTemplate` 类（`services/content_template.py`），支持从 JSON 文件加载和管理内容模板。每个模板包含 `name`、`description`、`topic_pattern`、`style`、`prompt_override`（可选）、`tags_preset`（可选）字段。
+
+#### Scenario: 模板文件加载
+- **WHEN** `ContentTemplate` 初始化时
+- **THEN** SHALL 从 `xhs_workspace/templates.json` 加载模板列表；文件不存在时 SHALL 使用内置默认模板（至少包含"好物种草""日常分享""攻略教程"三个模板）
+
+#### Scenario: 模板应用于文案生成
+- **WHEN** 用户选择模板后点击生成
+- **THEN** 系统 SHALL 将模板的 `prompt_override` 附加到 LLM 系统 prompt 中，`tags_preset` 作为标签默认值
+
+### Requirement: 批量主题生成
+系统 SHALL 支持一次生成多个主题的文案内容，通过 `batch_generate(topics: list, style, template=None)` 方法实现。
+
+#### Scenario: 批量生成返回结果
+- **WHEN** 调用 `batch_generate(["主题A", "主题B", "主题C"], "好物种草")`
+- **THEN** SHALL 返回包含 3 个文案结果的列表，每个结果与 `generate_copy()` 返回结构一致，新增 `batch_index` 字段标识序号
+
+#### Scenario: 批量生成部分失败
+- **WHEN** 批量生成中某篇文案生成失败
+- **THEN** 系统 SHALL 记录该篇的错误信息（`error` 字段），继续生成剩余主题，不中断整个批次
+
+#### Scenario: 批量生成数量限制
+- **WHEN** `topics` 列表长度超过 10
+- **THEN** 系统 SHALL 返回错误提示，拒绝执行（防止 LLM 配额消耗过大）
+
+### Requirement: 草稿队列管理
+批量生成的结果 SHALL 自动存入 `PublishQueue`，状态为 `draft`，用户可在发布队列 UI 中逐篇审核、编辑、排期。
+
+#### Scenario: 批量结果入队
+- **WHEN** `batch_generate()` 成功返回 N 篇文案
+- **THEN** 系统 SHALL 将每篇文案以 `draft` 状态插入 `PublishQueue`，包含 title、content、tags、sd_prompt 字段
+
+#### Scenario: 草稿可独立操作
+- **WHEN** 用户在 UI 中选中某篇草稿
+- **THEN** SHALL 支持编辑标题/正文/标签、单独发布、丢弃等操作，不影响同批次其他草稿
+
+### Requirement: 一键批量导出
+系统 SHALL 支持将多篇文案一次性导出到本地，每篇创建独立文件夹（复用 `one_click_export` 逻辑）。
+
+#### Scenario: 批量导出目录结构
+- **WHEN** 用户点击批量导出并选中 3 篇文案
+- **THEN** 系统 SHALL 在 `xhs_workspace/` 下为每篇创建独立的 `{timestamp}_{title}/` 文件夹，各含 `文案.txt`
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/copy-quality-pipeline/spec.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/copy-quality-pipeline/spec.md
@ -0,0 +1,52 @@
+## ADDED Requirements
+
+### Requirement: Prompt 分层架构
+系统 SHALL 将文案生成 Prompt 拆分为三个独立层，按顺序拼接后发送给 LLM：
+1. **基础层**（`PROMPT_BASE`）：通用的小红书写作规则和反 AI 检测规则
+2. **风格层**（`PROMPT_STYLE_{name}`）：按风格类型（好物种草、日常分享、攻略教程等）定制的写作指导
+3. **人设层**：基于用户选择的人设动态注入视角和语气约束
+
+#### Scenario: 分层 Prompt 拼接
+- **WHEN** 调用 `generate_copy(topic, style, persona=...)` 时
+- **THEN** 系统 SHALL 按 基础层 → 风格层 → 人设层 的顺序拼接 system prompt，各层之间用分隔标记区分
+
+#### Scenario: 风格层缺失时退回基础层
+- **WHEN** 指定的 `style` 没有对应的风格层 Prompt 模板
+- **THEN** 系统 SHALL 仅使用基础层 + 人设层，不报错
+
+### Requirement: LLM 多轮自检机制
+系统 SHALL 在文案生成后调用一次自检 LLM 请求，检查文案的 AI 痕迹程度和质量评分，根据评分决定是否触发改写。
+
+#### Scenario: 自检触发改写
+- **WHEN** 自检返回的 `ai_score`（AI 痕迹评分，0-100）≥ 60
+- **THEN** 系统 SHALL 将原始文案连同自检反馈一起发送给 LLM 进行改写，最多改写 1 次
+
+#### Scenario: 自检通过直接返回
+- **WHEN** 自检返回的 `ai_score` < 60
+- **THEN** 系统 SHALL 直接返回原始文案，不触发改写
+
+#### Scenario: 自检超时不阻塞
+- **WHEN** 自检 LLM 请求超时或失败
+- **THEN** 系统 SHALL 跳过自检，直接返回原始文案并记录警告日志
+
+### Requirement: 深度去 AI 化后处理管线
+系统 SHALL 在 `_humanize_content()` 方法中新增以下后处理步骤：
+1. **语气词注入**：在合适位置随机添加"嘿""诶""啊"等真人语气词
+2. **标点不规范化**：随机删除部分逗号/句号，模拟手机打字习惯
+3. **段落节奏打散**：确保连续段落字数差异 ≥ 30%
+4. **emoji 密度控制**：全文 emoji 数量控制在 6-12 个，分布不均匀
+
+#### Scenario: 后处理不改变语义
+- **WHEN** 对文案进行后处理
+- **THEN** 处理后的文案 SHALL 保留原始语义和关键信息（标签、核心观点），仅改变表达风格
+
+#### Scenario: 段落节奏检测
+- **WHEN** 后处理完成后
+- **THEN** 相邻段落的字数差异 SHALL 至少有 30% 的概率满足 ≥ 30% 的差异要求（基于随机化）
+
+### Requirement: 文案质量评分输出
+`generate_copy()` 方法 SHALL 在返回的 JSON 中新增 `quality_meta` 字段，包含 `ai_score`（AI 痕迹评分）、`self_check_passed`（是否通过自检）、`rewritten`（是否经过改写）。
+
+#### Scenario: 质量元数据完整
+- **WHEN** 文案生成成功返回
+- **THEN** 返回的字典 SHALL 包含 `quality_meta` 字段，其中 `ai_score` 为 0-100 整数，`self_check_passed` 和 `rewritten` 为布尔值
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/image-text-synergy/spec.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/image-text-synergy/spec.md
@ -0,0 +1,42 @@
+## ADDED Requirements
+
+### Requirement: SD Prompt 与文案语义联动
+系统 SHALL 在生成 SD 绘图提示词时，基于文案正文的核心关键词和情感基调生成更匹配的 prompt，而非仅依赖主题词。
+
+#### Scenario: 语义提取驱动 SD prompt
+- **WHEN** 文案正文包含特定场景描述（如"在咖啡馆里翻书""海边散步"）
+- **THEN** 生成的 `sd_prompt` SHALL 包含对应的场景元素（如 "cozy cafe, reading book" / "beach walking, seaside"），与文案描述保持一致
+
+#### Scenario: 情感基调映射
+- **WHEN** 文案整体基调为温柔/治愈
+- **THEN** `sd_prompt` SHALL 倾向使用 soft lighting、warm tone、gentle atmosphere 等对应氛围词
+
+### Requirement: 封面图策略选择
+系统 SHALL 支持用户选择封面图策略，影响 SD prompt 的构图和风格指导。策略包括：
+1. **人物特写**：以人物面部/半身为主体
+2. **场景展示**：以环境/产品为主体，人物为辅
+3. **对比图**：适合前后对比、测评类内容
+4. **文字卡片**：纯文字/简约背景，适合干货类笔记
+
+#### Scenario: 策略影响 SD prompt
+- **WHEN** 用户选择"人物特写"策略
+- **THEN** SD prompt SHALL 自动追加 portrait、face close-up、shallow depth of field 等构图关键词
+
+#### Scenario: 策略影响图片尺寸
+- **WHEN** 用户选择"文字卡片"策略
+- **THEN** SD 生成参数 SHALL 使用 3:4 竖版比例（小红书推荐封面比例）
+
+### Requirement: 图文匹配度评估
+系统 SHALL 提供 `evaluate_image_text_match(content, sd_prompt)` 方法，通过 LLM 评估文案与 SD prompt 的语义匹配度。
+
+#### Scenario: 匹配度评分返回
+- **WHEN** 调用 `evaluate_image_text_match()` 时
+- **THEN** SHALL 返回 `match_score`（0-100 整数）和 `suggestions`（改进建议字符串列表）
+
+#### Scenario: 低匹配度提示
+- **WHEN** `match_score` < 50
+- **THEN** 系统 SHALL 在 UI 中显示警告提示和改进建议，建议用户重新生成图片 prompt
+
+#### Scenario: 评估可选不阻塞
+- **WHEN** 图文匹配度评估失败或超时
+- **THEN** 系统 SHALL 跳过评估，不影响正常创作流程，记录警告日志
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/services-content/spec.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/services-content/spec.md
@ -0,0 +1,24 @@
+## MODIFIED Requirements
+
+### Requirement: 内容生成函数迁移至独立模块
+系统 SHALL 将内容生成、图片生成、发布及导出相关函数从 `main.py` 提取至 `services/content.py`，包括：`generate_copy`、`generate_images`、`one_click_export`、`publish_to_xhs`。新增 `batch_generate_copy` 和 `generate_copy_with_topic_engine` 入口函数。
+
+#### Scenario: 模块导入成功
+- **WHEN** `main.py` 执行 `from services.content import generate_copy, generate_images, publish_to_xhs, one_click_export, batch_generate_copy, generate_copy_with_topic_engine`
+- **THEN** 所有函数可正常调用，原有函数行为不变
+
+#### Scenario: 智能选题创作入口
+- **WHEN** 调用 `generate_copy_with_topic_engine(model, style, sd_model_name, persona_text)` 时（不传 topic）
+- **THEN** 函数 SHALL 自动调用 `TopicEngine.recommend_topics(count=1)` 获取最佳选题，再调用 `generate_copy()` 生成文案，返回结果中新增 `recommended_topic` 字段
+
+#### Scenario: 批量创作入口
+- **WHEN** 调用 `batch_generate_copy(model, topics, style, sd_model_name, persona_text, template=None)` 时
+- **THEN** 函数 SHALL 按 `batch-creation` spec 的要求逐个生成文案，并将结果存入 `PublishQueue` 的 `draft` 状态
+
+#### Scenario: 内容生成保留现有验证逻辑
+- **WHEN** 调用 `publish_to_xhs` 时标题超过 20 字或图片数量不合法
+- **THEN** 函数 SHALL 返回与迁移前相同的错误提示，不改变验证行为
+
+#### Scenario: 临时文件清理逻辑保留
+- **WHEN** `publish_to_xhs` 执行完毕（成功或失败）
+- **THEN** `finally` 块中的 AI 临时文件清理逻辑 SHALL 正常执行
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/smart-topic-engine/spec.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/specs/smart-topic-engine/spec.md
@ -0,0 +1,41 @@
+## ADDED Requirements
+
+### Requirement: 智能选题推荐入口
+系统 SHALL 提供 `TopicEngine` 类（`services/topic_engine.py`），暴露 `recommend_topics(count=5)` 方法，整合热点数据、历史权重、内容趋势，返回排序后的推荐选题列表。
+
+#### Scenario: 有历史权重数据时推荐
+- **WHEN** `content_weights.json` 中存在至少 5 篇笔记的权重数据
+- **THEN** `recommend_topics()` SHALL 返回融合了热点分析和历史表现权重的推荐列表，每项包含 `topic`、`score`、`reason`、`source`（"hotspot" / "weight" / "trend"）字段
+
+#### Scenario: 无历史数据时退回热点推荐
+- **WHEN** `content_weights.json` 为空或不存在
+- **THEN** `recommend_topics()` SHALL 仅基于热点探测结果返回推荐，`source` 全部为 "hotspot"
+
+#### Scenario: 推荐结果去重
+- **WHEN** 热点数据和权重数据中存在语义相近的主题（如"春季穿搭"和"早春穿搭"）
+- **THEN** 系统 SHALL 合并为一个推荐项，取较高分数，避免重复推荐
+
+### Requirement: 多维度选题评分
+系统 SHALL 为每个候选主题计算综合评分，评分维度包括：热点热度（0-40 分）、历史互动权重（0-30 分）、内容稀缺度（0-20 分）、时效性（0-10 分）。
+
+#### Scenario: 评分维度完整
+- **WHEN** 调用 `score_topic(topic)` 方法
+- **THEN** 返回的字典 SHALL 包含 `total_score`、`hotspot_score`、`weight_score`、`scarcity_score`、`timeliness_score` 五个字段，各分项之和等于 `total_score`
+
+#### Scenario: 已有高赞笔记的主题稀缺度降低
+- **WHEN** 某主题在最近 7 天内已发布过 2 篇以上笔记
+- **THEN** 该主题的 `scarcity_score` SHALL 不超过 5 分
+
+### Requirement: 选题附带创作角度
+系统 SHALL 为每个推荐选题生成 1-3 个具体的创作角度建议（`angles` 字段），帮助用户快速进入创作状态。
+
+#### Scenario: 角度建议格式
+- **WHEN** `recommend_topics()` 返回推荐列表
+- **THEN** 每项的 `angles` 字段 SHALL 为字符串列表，每个角度不超过 30 字，描述具体的切入点（如"从预算角度对比三款产品"）
+
+### Requirement: 热点数据整合
+`TopicEngine` SHALL 通过调用 `hotspot.py` 的搜索功能获取实时热点数据，并通过 `analytics_service.py` 获取历史权重数据，不直接访问 MCP 或 LLM。
+
+#### Scenario: 依赖注入
+- **WHEN** 初始化 `TopicEngine` 时
+- **THEN** 构造函数 SHALL 接受 `analytics_service: AnalyticsService` 参数，不在内部直接实例化依赖
--- a/openspec/changes/archive/2026-02-28-optimize-content-creation/tasks.md
+++ b/openspec/changes/archive/2026-02-28-optimize-content-creation/tasks.md
@ -0,0 +1,64 @@
+## 1. Prompt 分层架构重构
+
+- [x] 1.1 从 `PROMPT_COPYWRITING` 中提取通用写作规则和反 AI 检测规则为 `PROMPT_BASE`
+- [x] 1.2 创建风格层 Prompt 模板：`PROMPT_STYLE_GOODS`（好物种草）、`PROMPT_STYLE_DAILY`（日常分享）、`PROMPT_STYLE_GUIDE`（攻略教程）
+- [x] 1.3 在 `LLMService.generate_copy()` 中实现三层 Prompt 拼接逻辑（base → style → persona），风格层缺失时退回基础层
+- [x] 1.4 确保 `PROMPT_WEIGHTED_COPYWRITING` 和 `PROMPT_COPY_WITH_REFERENCE` 也使用分层架构
+
+## 2. LLM 自检与改写机制
+
+- [x] 2.1 在 `LLMService` 中新增 `_self_check(content: str) -> dict` 方法，返回 `ai_score`（0-100）和 `feedback` 字段
+- [x] 2.2 新增自检 Prompt 模板 `PROMPT_SELF_CHECK`，指导 LLM 评估文案的 AI 痕迹程度
+- [x] 2.3 在 `generate_copy()` 流程中集成自检：ai_score ≥ 60 时触发改写（最多 1 次），超时/失败时跳过
+- [x] 2.4 `generate_copy()` 返回的 JSON 中新增 `quality_meta` 字段（ai_score、self_check_passed、rewritten）
+
+## 3. 深度去 AI 化后处理增强
+
+- [x] 3.1 在 `_humanize_content()` 中新增语气词注入步骤（随机在合适位置添加“嘿”“诶”“啊”等）
+- [x] 3.2 增强标点不规范化处理（提高随机删除逗号/句号的概率，模拟手机打字）
+- [x] 3.3 新增段落节奏打散逻辑（检测并调整连续段落的字数差异）
+- [x] 3.4 新增 emoji 密度控制（全文 6-12 个，分布不均匀，避免堆叠）
+
+## 4. 智能选题引擎
+
+- [x] 4.1 创建 `services/topic_engine.py`，定义 `TopicEngine` 类，构造函数接受 `AnalyticsService` 实例
+- [x] 4.2 实现 `score_topic(topic)` 方法：计算热点热度（0-40）、历史权重（0-30）、稀缺度（0-20）、时效性（0-10）四维评分
+- [x] 4.3 实现 `recommend_topics(count=5)` 方法：聚合热点 + 权重数据，返回排序后的推荐列表（含 topic、score、reason、source、angles）
+- [x] 4.4 实现推荐结果去重逻辑（语义相近主题合并）
+- [x] 4.5 实现稀缺度计算：近 7 天已发布 ≥2 篇的主题 scarcity_score ≤5
+
+## 5. 内容模板系统
+
+- [x] 5.1 创建 `services/content_template.py`，定义 `ContentTemplate` 类
+- [x] 5.2 实现模板加载逻辑：从 `xhs_workspace/templates.json` 加载，文件不存在时使用内置默认模板
+- [x] 5.3 实现模板应用逻辑：将 `prompt_override` 附加到 LLM prompt，`tags_preset` 作为标签默认值
+
+## 6. 批量创作工作流
+
+- [x] 6.1 在 `services/content.py` 中新增 `batch_generate_copy()` 函数，支持串行生成多篇文案
+- [x] 6.2 实现部分失败容错：单篇失败记录 error 字段，继续生成剩余主题
+- [x] 6.3 实现数量限制：topics 列表 > 10 时拒绝执行
+- [x] 6.4 批量结果自动以 `draft` 状态插入 `PublishQueue`
+- [x] 6.5 在 `services/content.py` 中新增 `generate_copy_with_topic_engine()` 函数，自动选题后生成文案
+
+## 7. 图文协同优化
+
+- [x] 7.1 优化 SD prompt 生成 Prompt 指令，增加“从文案正文提取场景关键词”的指导
+- [x] 7.2 增加情感基调 → SD 氛围词映射逻辑
+- [x] 7.3 新增封面图策略参数 `cover_strategy`，实现 4 种策略的 SD prompt 后缀和尺寸映射
+- [x] 7.4 在 `LLMService` 中新增 `evaluate_image_text_match(content, sd_prompt)` 方法
+- [x] 7.5 图文匹配度评估设为可选，超时/失败时跳过并记录警告
+
+## 8. UI 集成
+
+- [x] 8.1 在 `ui/tab_create.py` 中新增选题推荐展示区（显示推荐主题列表，点击可填充到主题输入框）
+- [x] 8.2 新增封面图策略选择 Radio 组件（人物特写 / 场景展示 / 对比图 / 文字卡片）
+- [x] 8.3 新增批量创作折叠面板：多主题输入框 + 模板选择 + 批量生成按钮
+- [x] 8.4 新增图文匹配度评分展示（可选，在图片生成后显示）
+- [x] 8.5 连接 `generate_copy_with_topic_engine` 到“智能选题”按钮事件
+
+## 9. 数据闭环与集成测试
+
+- [x] 9.1 在 `content.py` 的创作入口中集成 `AnalyticsService` 权重数据自动注入（加权文案生成路径）
+- [x] 9.2 验证完整闭环：选题推荐 → 文案生成 → 自检 → 图片生成 → 草稿入队 → 发布
+- [x] 9.3 验证批量创作端到端流程：多主题输入 → 批量生成 → 草稿队列 → 逐篇审核发布
--- a/openspec/specs/batch-creation/spec.md
+++ b/openspec/specs/batch-creation/spec.md
@ -0,0 +1,45 @@
+## Requirements
+
+### Requirement: 内容模板系统
+系统 SHALL 提供 `ContentTemplate` 类（`services/content_template.py`），支持从 JSON 文件加载和管理内容模板。每个模板包含 `name`、`description`、`topic_pattern`、`style`、`prompt_override`（可选）、`tags_preset`（可选）字段。
+
+#### Scenario: 模板文件加载
+- **WHEN** `ContentTemplate` 初始化时
+- **THEN** SHALL 从 `xhs_workspace/templates.json` 加载模板列表；文件不存在时 SHALL 使用内置默认模板（至少包含"好物种草""日常分享""攻略教程"三个模板）
+
+#### Scenario: 模板应用于文案生成
+- **WHEN** 用户选择模板后点击生成
+- **THEN** 系统 SHALL 将模板的 `prompt_override` 附加到 LLM 系统 prompt 中，`tags_preset` 作为标签默认值
+
+### Requirement: 批量主题生成
+系统 SHALL 支持一次生成多个主题的文案内容，通过 `batch_generate(topics: list, style, template=None)` 方法实现。
+
+#### Scenario: 批量生成返回结果
+- **WHEN** 调用 `batch_generate(["主题A", "主题B", "主题C"], "好物种草")`
+- **THEN** SHALL 返回包含 3 个文案结果的列表，每个结果与 `generate_copy()` 返回结构一致，新增 `batch_index` 字段标识序号
+
+#### Scenario: 批量生成部分失败
+- **WHEN** 批量生成中某篇文案生成失败
+- **THEN** 系统 SHALL 记录该篇的错误信息（`error` 字段），继续生成剩余主题，不中断整个批次
+
+#### Scenario: 批量生成数量限制
+- **WHEN** `topics` 列表长度超过 10
+- **THEN** 系统 SHALL 返回错误提示，拒绝执行（防止 LLM 配额消耗过大）
+
+### Requirement: 草稿队列管理
+批量生成的结果 SHALL 自动存入 `PublishQueue`，状态为 `draft`，用户可在发布队列 UI 中逐篇审核、编辑、排期。
+
+#### Scenario: 批量结果入队
+- **WHEN** `batch_generate()` 成功返回 N 篇文案
+- **THEN** 系统 SHALL 将每篇文案以 `draft` 状态插入 `PublishQueue`，包含 title、content、tags、sd_prompt 字段
+
+#### Scenario: 草稿可独立操作
+- **WHEN** 用户在 UI 中选中某篇草稿
+- **THEN** SHALL 支持编辑标题/正文/标签、单独发布、丢弃等操作，不影响同批次其他草稿
+
+### Requirement: 一键批量导出
+系统 SHALL 支持将多篇文案一次性导出到本地，每篇创建独立文件夹（复用 `one_click_export` 逻辑）。
+
+#### Scenario: 批量导出目录结构
+- **WHEN** 用户点击批量导出并选中 3 篇文案
+- **THEN** 系统 SHALL 在 `xhs_workspace/` 下为每篇创建独立的 `{timestamp}_{title}/` 文件夹，各含 `文案.txt`
--- a/openspec/specs/copy-quality-pipeline/spec.md
+++ b/openspec/specs/copy-quality-pipeline/spec.md
@ -0,0 +1,52 @@
+## Requirements
+
+### Requirement: Prompt 分层架构
+系统 SHALL 将文案生成 Prompt 拆分为三个独立层，按顺序拼接后发送给 LLM：
+1. **基础层**（`PROMPT_BASE`）：通用的小红书写作规则和反 AI 检测规则
+2. **风格层**（`PROMPT_STYLE_{name}`）：按风格类型（好物种草、日常分享、攻略教程等）定制的写作指导
+3. **人设层**：基于用户选择的人设动态注入视角和语气约束
+
+#### Scenario: 分层 Prompt 拼接
+- **WHEN** 调用 `generate_copy(topic, style, persona=...)` 时
+- **THEN** 系统 SHALL 按 基础层 → 风格层 → 人设层 的顺序拼接 system prompt，各层之间用分隔标记区分
+
+#### Scenario: 风格层缺失时退回基础层
+- **WHEN** 指定的 `style` 没有对应的风格层 Prompt 模板
+- **THEN** 系统 SHALL 仅使用基础层 + 人设层，不报错
+
+### Requirement: LLM 多轮自检机制
+系统 SHALL 在文案生成后调用一次自检 LLM 请求，检查文案的 AI 痕迹程度和质量评分，根据评分决定是否触发改写。
+
+#### Scenario: 自检触发改写
+- **WHEN** 自检返回的 `ai_score`（AI 痕迹评分，0-100）≥ 60
+- **THEN** 系统 SHALL 将原始文案连同自检反馈一起发送给 LLM 进行改写，最多改写 1 次
+
+#### Scenario: 自检通过直接返回
+- **WHEN** 自检返回的 `ai_score` < 60
+- **THEN** 系统 SHALL 直接返回原始文案，不触发改写
+
+#### Scenario: 自检超时不阻塞
+- **WHEN** 自检 LLM 请求超时或失败
+- **THEN** 系统 SHALL 跳过自检，直接返回原始文案并记录警告日志
+
+### Requirement: 深度去 AI 化后处理管线
+系统 SHALL 在 `_humanize_content()` 方法中新增以下后处理步骤：
+1. **语气词注入**：在合适位置随机添加"嘿""诶""啊"等真人语气词
+2. **标点不规范化**：随机删除部分逗号/句号，模拟手机打字习惯
+3. **段落节奏打散**：确保连续段落字数差异 ≥ 30%
+4. **emoji 密度控制**：全文 emoji 数量控制在 6-12 个，分布不均匀
+
+#### Scenario: 后处理不改变语义
+- **WHEN** 对文案进行后处理
+- **THEN** 处理后的文案 SHALL 保留原始语义和关键信息（标签、核心观点），仅改变表达风格
+
+#### Scenario: 段落节奏检测
+- **WHEN** 后处理完成后
+- **THEN** 相邻段落的字数差异 SHALL 至少有 30% 的概率满足 ≥ 30% 的差异要求（基于随机化）
+
+### Requirement: 文案质量评分输出
+`generate_copy()` 方法 SHALL 在返回的 JSON 中新增 `quality_meta` 字段，包含 `ai_score`（AI 痕迹评分）、`self_check_passed`（是否通过自检）、`rewritten`（是否经过改写）。
+
+#### Scenario: 质量元数据完整
+- **WHEN** 文案生成成功返回
+- **THEN** 返回的字典 SHALL 包含 `quality_meta` 字段，其中 `ai_score` 为 0-100 整数，`self_check_passed` 和 `rewritten` 为布尔值
--- a/openspec/specs/image-text-synergy/spec.md
+++ b/openspec/specs/image-text-synergy/spec.md
@ -0,0 +1,42 @@
+## Requirements
+
+### Requirement: SD Prompt 与文案语义联动
+系统 SHALL 在生成 SD Image Prompt 时，解析文案中的核心视觉元素（场景词、物品词、情绪词），并将其映射为 SD Prompt 的画面描述词，确保图片内容与文案主题语义一致。
+
+#### Scenario: 文案关键词提取
+- **WHEN** 传入文案文本至图片生成流程
+- **THEN** 系统 SHALL 使用 LLM 提取文案中的视觉关键词（不超过 5 个），并将其注入 SD Prompt 的主体描述段
+
+#### Scenario: 视觉关键词映射失败
+- **WHEN** LLM 提取视觉关键词失败或超时
+- **THEN** 系统 SHALL 退回使用 `style_tag + topic` 拼接的默认 Prompt，不中断图片生成流程
+
+### Requirement: 封面图策略选择
+系统 SHALL 支持 4 种封面图策略，用户可在创作时选择：
+1. **AI 写真**（`ai_portrait`）：生成人物写真封面
+2. **产品特写**（`product_close`）：生成产品/物品近景
+3. **场景氛围**（`scene_mood`）：生成场景氛围图
+4. **文字海报**（`text_poster`）：生成带有文字排版的海报图
+
+#### Scenario: 策略路由
+- **WHEN** 用户选择封面策略 `strategy` 并调用图片生成
+- **THEN** 系统 SHALL 根据 `strategy` 值路由至对应的 Prompt 模板和 SD 参数配置，不使用其他策略的模板
+
+#### Scenario: 策略参数默认值
+- **WHEN** 用户未指定封面策略时
+- **THEN** 系统 SHALL 默认使用 `ai_portrait` 策略
+
+### Requirement: 图文匹配度评估
+系统 SHALL 提供 `evaluate_image_text_match(copy_text, image_path)` 方法，使用 VL 模型（vision-language）分析图片内容与文案之间的语义匹配程度，返回 0-100 的匹配度评分和改进建议。
+
+#### Scenario: 匹配度评估成功
+- **WHEN** 传入有效的文案文本和图片路径
+- **THEN** 系统 SHALL 返回包含 `match_score`（0-100 整数）和 `suggestions`（字符串列表，可为空）的字典
+
+#### Scenario: VL 模型不可用
+- **WHEN** VL 模型调用失败或未配置
+- **THEN** 系统 SHALL 返回 `{"match_score": -1, "suggestions": [], "error": "VL model unavailable"}`，不抛出异常
+
+#### Scenario: 低匹配度触发建议
+- **WHEN** `match_score` < 60
+- **THEN** `suggestions` 字段 SHALL 包含至少 1 条具体的图片改进建议文本
--- a/openspec/specs/services-content/spec.md
+++ b/openspec/specs/services-content/spec.md
@ -1,10 +1,10 @@
-## ADDED Requirements
+## Requirements

 ### Requirement: 内容生成函数迁移至独立模块
-系统 SHALL 将内容生成、图片生成、发布及导出相关函数从 `main.py` 提取至 `services/content.py`，包括：`generate_copy`、`generate_images`、`one_click_export`、`publish_to_xhs`。
+系统 SHALL 将内容生成、图片生成、发布及导出相关函数从 `main.py` 提取至 `services/content.py`，包括：`generate_copy`、`generate_images`、`one_click_export`、`publish_to_xhs`、`batch_generate_copy`、`generate_copy_with_topic_engine`。

 #### Scenario: 模块导入成功
- **WHEN** `main.py` 执行 `from services.content import generate_copy, generate_images, publish_to_xhs, one_click_export`
+- **WHEN** `main.py` 执行 `from services.content import generate_copy, generate_images, publish_to_xhs, one_click_export, batch_generate_copy, generate_copy_with_topic_engine`
 - **THEN** 所有函数可正常调用，行为与迁移前完全一致

 #### Scenario: 内容生成保留现有验证逻辑
@ -14,3 +14,11 @@
 #### Scenario: 临时文件清理逻辑保留
 - **WHEN** `publish_to_xhs` 执行完毕（成功或失败）
 - **THEN** `finally` 块中的 AI 临时文件清理逻辑 SHALL 正常执行
+
+#### Scenario: 智能选题创作入口
+- **WHEN** 调用 `generate_copy_with_topic_engine(count=N)` 时
+- **THEN** 系统 SHALL 先通过 `TopicEngine().recommend(count=N)` 获取推荐选题，再对排名第一的选题自动调用 `generate_copy()`，返回文案结果和使用的选题信息
+
+#### Scenario: 批量创作入口
+- **WHEN** 调用 `batch_generate_copy(topics: list, style: str, persona=None)` 时
+- **THEN** 系统 SHALL 对列表中的每个 `topic` 依次调用 `generate_copy(topic, style, persona)`，并将所有结果以列表形式返回，单个 topic 失败时记录错误并继续处理后续项，不中断整体流程
--- a/openspec/specs/smart-topic-engine/spec.md
+++ b/openspec/specs/smart-topic-engine/spec.md
@ -0,0 +1,49 @@
+## Requirements
+
+### Requirement: 智能选题推荐入口
+系统 SHALL 提供 `TopicEngine` 类，封装选题推荐的完整逻辑，通过 `recommend(count=5)` 方法返回推荐选题列表。
+
+#### Scenario: 推荐选题返回
+- **WHEN** 调用 `TopicEngine().recommend(count=N)` 时
+- **THEN** 系统 SHALL 返回包含 N 个选题字典的列表，每个字典包含 `topic`（选题名称）、`score`（综合评分）、`angles`（创作角度列表）字段
+
+#### Scenario: 推荐数量边界
+- **WHEN** `count` 小于 1 或大于 20
+- **THEN** 系统 SHALL 将 `count` 强制修正至合法范围 [1, 20]，不抛出异常
+
+### Requirement: 多维度选题评分
+每个候选选题 SHALL 从 4 个维度进行评分，各维度满分如下，合计 100 分：
+1. **热点相关度**（`hotspot_relevance`）：满分 30 分，与当前热点话题的关联程度
+2. **账号契合度**（`account_fit`）：满分 30 分，与账号人设和内容风格的契合程度
+3. **内容稀缺度**（`content_scarcity`）：满分 20 分，在账号历史内容中的稀缺程度（越少发过越高）
+4. **互动潜力**（`engagement_potential`）：满分 20 分，预估点赞/评论/收藏的综合表现
+
+#### Scenario: 评分维度完整
+- **WHEN** 选题推荐返回结果
+- **THEN** 每个选题字典 SHALL 包含 `score_detail` 字段，其中包含上述 4 个子维度的分值
+
+#### Scenario: 账号历史影响稀缺度评分
+- **WHEN** 账号近 30 天内已发布过相同或极相似选题（语义相似度 ≥ 80%）
+- **THEN** 该选题的 `content_scarcity` 评分 SHALL 不超过 5 分
+
+### Requirement: 选题附带创作角度
+每个推荐选题 SHALL 附带 2-4 个差异化的创作角度（`angles`），每个角度包含`angle_name`（角度名称）和 `hook`（开头 hook 句）。
+
+#### Scenario: 创作角度多样性
+- **WHEN** 同一选题返回多个创作角度
+- **THEN** 每个角度 SHALL 采用不同的叙事视角（如：亲身体验 vs 对比测评 vs 干货攻略）
+
+#### Scenario: Hook 句格式
+- **WHEN** 返回 `hook` 字段
+- **THEN** hook 句 SHALL 为 15-30 字的小红书风格开头，包含至少一个情绪词或疑问词
+
+### Requirement: 热点数据整合
+`TopicEngine` SHALL 调用 `HotspotService` 获取当日热点数据，并将热点话题权重纳入选题评分的 `hotspot_relevance` 维度。
+
+#### Scenario: 热点服务可用
+- **WHEN** `HotspotService` 正常返回热点数据
+- **THEN** 系统 SHALL 将热点话题与候选选题做语义匹配，高匹配选题的 `hotspot_relevance` 评分加成不低于 10 分
+
+#### Scenario: 热点服务不可用
+- **WHEN** `HotspotService` 调用失败或返回空数据
+- **THEN** 系统 SHALL `hotspot_relevance` 维度评分统一设为 15 分（满分 50%），不因热点数据缺失而中断选题推荐流程
--- a/services/connection.py
+++ b/services/connection.py
@ -7,6 +7,7 @@ import re
 import logging

 import gradio as gr
+from PIL import Image

 from .config_manager import ConfigManager
 from .llm_service import LLMService
--- a/services/content.py
+++ b/services/content.py
@ -22,14 +22,39 @@ logger = logging.getLogger("autobot")
 cfg = ConfigManager()

 def generate_copy(model, topic, style, sd_model_name, persona_text):
-    """生成文案（自动适配 SD 模型的 prompt 风格，支持人设）"""
+    """生成文案（自动适配 SD 模型，支持人设，自动注入权重数据）"""
    api_key, base_url, _ = _get_llm_config()
    if not api_key:
        return "", "", "", "", "❌ 请先配置并连接 LLM 提供商"
    try:
        svc = LLMService(api_key, base_url, model)
        persona = _resolve_persona(persona_text) if persona_text else None
-        data = svc.generate_copy(topic, style, sd_model_name=sd_model_name, persona=persona)
+
+        # 尝试自动注入权重数据（数据闭环 9.1）
+        data = None
+        try:
+            from .analytics_service import AnalyticsService
+            analytics = AnalyticsService()
+            if analytics.has_weights:
+                weight_insights = analytics.weights_summary
+                title_advice = analytics.get_title_advice()
+                hot_tags = ", ".join(analytics.get_top_tags(8))
+                data = svc.generate_weighted_copy(
+                    topic, style,
+                    weight_insights=weight_insights,
+                    title_advice=title_advice,
+                    hot_tags=hot_tags,
+                    sd_model_name=sd_model_name,
+                    persona=persona,
+                )
+                logger.info("使用加权文案生成路径（权重数据已注入）")
+        except Exception as e:
+            logger.debug("权重数据注入跳过: %s", e)
+
+        # 无权重或权重路径失败时，退回基础生成
+        if data is None:
+            data = svc.generate_copy(topic, style, sd_model_name=sd_model_name, persona=persona)
+
        cfg.set("model", model)
        tags = data.get("tags", [])
        return (
@ -207,3 +232,177 @@ def publish_to_xhs(title, content, tags_str, images, local_images, mcp_url, sche
                logger.warning("临时文件清理失败 %s: %s", tmp_path, cleanup_err)


+# ========== 批量创作 ==========
+
+def batch_generate_copy(
+    model: str,
+    topics: list[str],
+    style: str,
+    sd_model_name: str = "",
+    persona_text: str = "",
+    template_name: str = "",
+    publish_queue=None,
+) -> tuple[list[dict], str]:
+    """
+    批量生成多篇文案（串行），自动插入发布队列草稿
+
+    Args:
+        model: LLM 模型名
+        topics: 主题列表 (最多 10 个)
+        style: 写作风格
+        sd_model_name: SD 模型名
+        persona_text: 人设文本
+        template_name: 可选的模板名
+        publish_queue: 可选的 PublishQueue 实例
+
+    Returns:
+        (results_list, status_msg)
+    """
+    if not topics:
+        return [], "❌ 请输入至少一个主题"
+    if len(topics) > 10:
+        return [], "❌ 批量生成最多支持 10 个主题，请减少数量"
+
+    api_key, base_url, _ = _get_llm_config()
+    if not api_key:
+        return [], "❌ 请先配置并连接 LLM 提供商"
+
+    # 加载模板覆盖
+    prompt_override = ""
+    tags_preset = []
+    if template_name:
+        try:
+            from .content_template import ContentTemplate
+            ct = ContentTemplate()
+            override = ct.apply_template(template_name)
+            style = override.get("style") or style
+            prompt_override = override.get("prompt_override", "")
+            tags_preset = override.get("tags_preset", [])
+        except Exception as e:
+            logger.warning("模板加载失败，使用默认参数: %s", e)
+
+    svc = LLMService(api_key, base_url, model)
+    persona = _resolve_persona(persona_text) if persona_text else None
+
+    results = []
+    success_count = 0
+    fail_count = 0
+
+    for idx, topic in enumerate(topics):
+        topic = topic.strip()
+        if not topic:
+            continue
+
+        try:
+            data = svc.generate_copy(
+                topic, style,
+                sd_model_name=sd_model_name,
+                persona=persona,
+            )
+
+            # 如有模板 prompt_override，它已通过风格参数间接生效
+            # 合并模板标签
+            tags = data.get("tags", [])
+            if tags_preset:
+                existing = set(tags)
+                for t in tags_preset:
+                    if t not in existing:
+                        tags.append(t)
+                data["tags"] = tags
+
+            data["batch_index"] = idx
+            results.append(data)
+            success_count += 1
+
+            # 自动入队为草稿
+            if publish_queue:
+                try:
+                    publish_queue.add(
+                        title=data.get("title", ""),
+                        content=data.get("content", ""),
+                        sd_prompt=data.get("sd_prompt", ""),
+                        tags=data.get("tags", []),
+                        topic=topic,
+                        style=style,
+                        persona=persona_text if persona_text else "",
+                        status="draft",
+                    )
+                except Exception as e:
+                    logger.warning("批量草稿入队失败 #%d: %s", idx, e)
+
+            logger.info("批量生成 %d/%d 完成: %s", idx + 1, len(topics), topic[:20])
+
+        except Exception as e:
+            logger.error("批量生成 %d/%d 失败 [%s]: %s", idx + 1, len(topics), topic[:20], e)
+            results.append({
+                "batch_index": idx,
+                "topic": topic,
+                "error": str(e),
+            })
+            fail_count += 1
+
+    status = f"✅ 批量生成完成: {success_count} 成功"
+    if fail_count:
+        status += f", {fail_count} 失败"
+    if publish_queue and success_count:
+        status += f" | {success_count} 篇已入草稿队列"
+
+    return results, status
+
+
+def generate_copy_with_topic_engine(
+    model: str,
+    style: str,
+    sd_model_name: str = "",
+    persona_text: str = "",
+    count: int = 1,
+    hotspot_data: dict = None,
+    publish_queue=None,
+) -> tuple[list[dict], str]:
+    """
+    使用智能选题引擎自动选题 + 生成文案
+
+    Args:
+        model: LLM 模型名
+        style: 写作风格
+        sd_model_name: SD 模型名
+        persona_text: 人设文本
+        count: 生成篇数
+        hotspot_data: 可选的热点分析数据
+        publish_queue: 可选的 PublishQueue 实例
+
+    Returns:
+        (results_list, status_msg)
+    """
+    try:
+        from .analytics_service import AnalyticsService
+        from .topic_engine import TopicEngine
+
+        analytics = AnalyticsService()
+        engine = TopicEngine(analytics)
+        recommendations = engine.recommend_topics(count=count, hotspot_data=hotspot_data)
+
+        if not recommendations:
+            return [], "❌ 选题引擎未找到推荐主题，请先进行热点搜索或积累数据"
+
+        topics = [r["topic"] for r in recommendations]
+        results, status = batch_generate_copy(
+            model=model,
+            topics=topics,
+            style=style,
+            sd_model_name=sd_model_name,
+            persona_text=persona_text,
+            publish_queue=publish_queue,
+        )
+
+        # 把选题推荐信息附加到结果
+        for result in results:
+            idx = result.get("batch_index", -1)
+            if 0 <= idx < len(recommendations):
+                result["topic_recommendation"] = recommendations[idx]
+
+        return results, status
+
+    except Exception as e:
+        logger.error("智能选题生成失败: %s", e)
+        return [], f"❌ 智能选题生成失败: {e}"
--- a/services/content_template.py
+++ b/services/content_template.py
@ -0,0 +1,132 @@
+"""
+services/content_template.py
+内容模板系统 — 管理和应用创作模板
+"""
+import json
+import os
+import logging
+
+logger = logging.getLogger("autobot")
+
+TEMPLATES_FILE = "templates.json"
+
+# 内置默认模板 (templates.json 不存在时使用)
+DEFAULT_TEMPLATES = [
+    {
+        "name": "好物种草",
+        "description": "适合分享好用的产品和购物推荐",
+        "topic_pattern": "",
+        "style": "好物种草",
+        "prompt_override": "请以真实使用者的口吻分享产品体验，突出个人感受和使用前后对比，避免像广告文案。",
+        "tags_preset": ["好物推荐", "真实测评", "分享好物"],
+    },
+    {
+        "name": "日常分享",
+        "description": "记录日常生活点滴、感悟和心情",
+        "topic_pattern": "",
+        "style": "日常分享",
+        "prompt_override": "请以轻松随意的语气记录生活日常，像发朋友圈那样自然，多用短句和口语化表达。",
+        "tags_preset": ["日常", "生活记录", "碎碎念"],
+    },
+    {
+        "name": "攻略教程",
+        "description": "分享经验技巧、教程和攻略指南",
+        "topic_pattern": "",
+        "style": "攻略教程",
+        "prompt_override": "请以过来人的身份分享干货经验，用分步骤的方式让读者易懂，加入踩坑经历增加可信度。",
+        "tags_preset": ["干货分享", "经验", "保姆级教程"],
+    },
+]
+
+
+class ContentTemplate:
+    """
+    内容模板管理器
+
+    从 xhs_workspace/templates.json 加载模板，
+    文件不存在时使用内置默认模板。
+    """
+
+    def __init__(self, workspace_dir: str = "xhs_workspace"):
+        self.workspace_dir = workspace_dir
+        self.templates_path = os.path.join(workspace_dir, TEMPLATES_FILE)
+        self._templates: list[dict] = self._load_templates()
+
+    def _load_templates(self) -> list[dict]:
+        """加载模板列表"""
+        if os.path.exists(self.templates_path):
+            try:
+                with open(self.templates_path, "r", encoding="utf-8") as f:
+                    templates = json.load(f)
+                if isinstance(templates, list) and templates:
+                    logger.info("已从 %s 加载 %d 个模板", self.templates_path, len(templates))
+                    return templates
+            except (json.JSONDecodeError, IOError) as e:
+                logger.warning("模板文件加载失败，使用默认模板: %s", e)
+
+        logger.info("使用内置默认模板 (%d 个)", len(DEFAULT_TEMPLATES))
+        return list(DEFAULT_TEMPLATES)
+
+    def save_templates(self):
+        """将当前模板保存到文件"""
+        try:
+            os.makedirs(self.workspace_dir, exist_ok=True)
+            with open(self.templates_path, "w", encoding="utf-8") as f:
+                json.dump(self._templates, f, ensure_ascii=False, indent=2)
+            logger.info("模板已保存到 %s", self.templates_path)
+        except IOError as e:
+            logger.error("模板保存失败: %s", e)
+
+    @property
+    def templates(self) -> list[dict]:
+        """获取所有模板"""
+        return self._templates
+
+    def get_template_names(self) -> list[str]:
+        """获取模板名称列表"""
+        return [t.get("name", "未命名") for t in self._templates]
+
+    def get_template(self, name: str) -> dict | None:
+        """按名称获取模板"""
+        for t in self._templates:
+            if t.get("name") == name:
+                return t
+        return None
+
+    def apply_template(self, template_name: str) -> dict:
+        """
+        应用模板，返回用于文案生成的参数覆盖
+
+        Returns:
+            dict with keys:
+              - style: str
+              - prompt_override: str (附加到 LLM prompt 的额外指令)
+              - tags_preset: list[str] (标签默认值)
+        """
+        template = self.get_template(template_name)
+        if not template:
+            logger.warning("模板 '%s' 不存在，返回空覆盖", template_name)
+            return {"style": "", "prompt_override": "", "tags_preset": []}
+
+        return {
+            "style": template.get("style", ""),
+            "prompt_override": template.get("prompt_override", ""),
+            "tags_preset": template.get("tags_preset", []),
+        }
+
+    def add_template(self, template: dict):
+        """添加新模板"""
+        required_fields = {"name", "description", "style"}
+        if not required_fields.issubset(template.keys()):
+            raise ValueError(f"模板缺少必要字段: {required_fields - template.keys()}")
+        self._templates.append(template)
+        self.save_templates()
+
+    def remove_template(self, name: str) -> bool:
+        """删除模板"""
+        before = len(self._templates)
+        self._templates = [t for t in self._templates if t.get("name") != name]
+        if len(self._templates) < before:
+            self.save_templates()
+            return True
+        return False
--- a/services/llm_service.py
+++ b/services/llm_service.py
@ -12,7 +12,9 @@ logger = logging.getLogger(__name__)

 # ================= Prompt 模板 =================

-PROMPT_COPYWRITING = """
+# ---- 分层 Prompt 架构：基础层 + 风格层 + 人设层 ----
+
+PROMPT_BASE = """
 你是一个真实的小红书博主，正在用手机编辑一篇笔记。你不是内容专家，你只是一个想认真分享的普通人。

 【你的写作状态】：
@ -55,14 +57,128 @@ PROMPT_COPYWRITING = """
 6. 避免完美的逻辑链条：不要每段都工工整整地推进论点，真人笔记是跳跃式的
 7. 偶尔口语化到"学渣"程度："就 很那个 你懂的" "属于是" "多少有点" "怎么说呢"
 8. 绝对不要用"然而" "此外" "因此" "尽管" "虽然...但是..."这些书面连接词
+"""

+# ---- 风格层 Prompt ----
+
+PROMPT_STYLE_GOODS = """
+【风格：好物种草】：
+你在分享一个让你很惊喜的东西。重点是真实体验感受，不是产品说明书。
+- 写出"发现宝藏"的兴奋感，但别太夸张
+- 可以先说你怎么发现/入手的（"刷到好多人推 忍不住下单了"）
+- 重点说使用感受，别罗列参数配置
+- 适当提一两个小缺点增加可信度
+- 价格相关的要自然带出（"百元价位能有这效果 我真的服"）
+"""
+
+PROMPT_STYLE_DAILY = """
+【风格：日常分享】：
+你在分享生活中一个有意思/有感触的瞬间。核心是情绪共鸣。
+- 写得像发朋友圈，随意自然
+- 不需要有"干货"，纯粹分享感受就好
+- 可以碎碎念、跑题、突然感叹
+- 配图描述偏生活化场景（自拍、日常环境、随手拍）
+"""
+
+PROMPT_STYLE_GUIDE = """
+【风格：攻略教程】：
+你在分享一个你研究了很久/踩了很多坑之后总结的经验。
+- 用"过来人"的语气，不是老师讲课
+- 开头可以用痛点引入（"之前踩了好多坑""终于搞明白了"）
+- 信息量要足但别太结构化，穿插个人经历和小吐槽
+- 可以用简单的分段，但别用"第一步、第二步"这种死板格式
+- 结尾可以加"有问题评论区问我"之类的互动引导
+"""
+
+# 风格层映射
+PROMPT_STYLES = {
+    "好物种草": PROMPT_STYLE_GOODS,
+    "日常分享": PROMPT_STYLE_DAILY,
+    "攻略教程": PROMPT_STYLE_GUIDE,
+    "真实分享": PROMPT_STYLE_DAILY,
+    "经验分享": PROMPT_STYLE_GUIDE,
+    "种草安利": PROMPT_STYLE_GOODS,
+}
+
+PROMPT_COPYWRITING_SUFFIX = """
 【绘图 Prompt】：
 {sd_prompt_guide}

+【重要 - 图文语义联动】：
+生成 sd_prompt 时，必须从文案正文中提取具体的场景描述和关键词：
+- 如文案提到"咖啡馆翻书"，sd_prompt 必须包含 cozy cafe, reading book 等对应元素
+- 如文案提到"海边散步"，sd_prompt 必须包含 beach walking, seaside 等
+- 如文案是温柔/治愈风，sd_prompt 加入 soft lighting, warm tone, gentle atmosphere
+- 如文案是活力/运动风，sd_prompt 加入 bright colors, dynamic pose, energetic mood
+- 如文案是酷飒/高级风，sd_prompt 加入 cool tone, dramatic lighting, editorial style
+- 文案→图片的场景一致性是最重要的，不要凭空编造与文案无关的场景
+
 返回 JSON 格式：
 {{"title": "...", "content": "...", "sd_prompt": "...", "tags": ["标签1", "标签2", ...]}}
 """

+# 保留旧变量名兼容（组合基础层 + 默认后缀）
+PROMPT_COPYWRITING = PROMPT_BASE + PROMPT_COPYWRITING_SUFFIX
+
+PROMPT_SELF_CHECK = """
+你是一个专业的AI内容检测专家。请评估以下小红书笔记文案的"AI痕迹程度"。
+
+【评估维度】（每项0-20分，总分0-100）：
+1. **书面化程度** (0-20)：是否使用了"然而""此外""综上所述"等书面连接词？句式是否过于规整？
+2. **逻辑完美度** (0-20)：段落逻辑是否过于顺畅完美？真人写作会有跳跃和碎片化
+3. **用词规范度** (0-20)：用词是否过于"正确"？真人会用网络语、口语、不规范表达
+4. **结构工整度** (0-20)：是否有明显的分点罗列、排比对仗？段落长度是否过于均匀？
+5. **情感自然度** (0-20)：情感表达是否像真人？还是像AI在"模拟"情感？
+
+【待评估文案】：
+{content}
+
+返回 JSON 格式：
+{{"ai_score": 总分(0-100), "feedback": "具体哪些地方暴露了AI痕迹，以及改进建议", "dimension_scores": {{"书面化": x, "逻辑完美": x, "用词规范": x, "结构工整": x, "情感自然": x}}}}
+"""
+
+PROMPT_SELF_CHECK_REWRITE = """
+你是一个小红书文案优化专家。以下文案被检测出AI痕迹，请根据反馈进行改写，让它更像真人写的。
+
+【原始文案】：
+{original_content}
+
+【AI检测反馈】：
+{feedback}
+
+【改写要求】：
+- 保留原始内容的核心信息和观点
+- 针对反馈中指出的AI痕迹进行修改
+- 不要改变标题和标签
+- 改写后的文案长度保持在 400-600 字
+- 让文案读起来更像一个真人在手机上随手写的
+
+直接返回改写后的正文，不要有任何解释。
+"""
+
+PROMPT_IMAGE_TEXT_MATCH = """
+你是一个图文内容质量评审专家。请评估以下小红书笔记文案与其配图 SD 绘图提示词之间的语义匹配度。
+
+【文案正文】：
+{content}
+
+【SD 绘图 Prompt】：
+{sd_prompt}
+
+【评估维度】：
+1. 场景一致性：文案描述的场景是否在图片中有体现？
+2. 情感基调匹配：文案的情绪与图片氛围是否一致？
+3. 关键元素覆盖：文案中的核心事物（产品、地点、人物状态）是否在 prompt 中有对应描述？
+
+返回 JSON 格式：
+{{"match_score": 0-100分, "suggestions": ["改进建议1", "改进建议2"]}}
+
+评分标准：
+- 80-100: 高度匹配，图文呼应好
+- 50-79: 基本匹配，有可改进空间
+- 0-49: 匹配度低，建议重新生成
+"""
+
 PROMPT_PERFORMANCE_ANALYSIS = """
 你是一个有实战经验的小红书运营数据分析师。下面是一个博主已发布的笔记数据，按互动量从高到低排列：

@ -89,38 +205,22 @@ PROMPT_PERFORMANCE_ANALYSIS = """
 {{"high_perform_features": "...", "low_perform_issues": "...", "user_preference": "...", "content_suggestions": [{{"topic": "...", "reason": "...", "priority": 1-5}}], "title_templates": ["模板1", "模板2", "模板3"], "recommended_tags": ["标签1", "标签2", ...]}}
 """

-PROMPT_WEIGHTED_COPYWRITING = """
-你是一个真实的小红书博主，正在用手机编辑一篇笔记。
-
+PROMPT_WEIGHTED_COPYWRITING_EXTRA = """
 【智能学习洞察——基于你过去笔记的数据分析】：
 {weight_insights}

 【创作要求】：
 基于以上数据洞察，请创作一篇更容易获得高互动的笔记。要把数据分析的结论融入创作中，但写出来的内容要自然，不能看出是"为了数据而写"。

-【标题规则】(严格执行)：
-1. 长度限制：必须控制在 18 字以内（含Emoji），绝对不能超过 20 字！
-2. 参考高互动标题的模式：{title_advice}
-3. 口语化，有情绪感，像发朋友圈
-4. 禁止广告法违禁词
-
-【正文规则——像说话一样写】：
-1. 想象你在跟闺蜜/朋友面对面聊天
-2. 正文控制在 400-600 字
-3. 自然展开，不要分点罗列
-4. 可以有小情绪：吐槽、感叹、自嘲、开心炸裂
-5. emoji穿插在情绪高点，不要每句都有
-6. 绝对禁止 AI 痕迹书面用语
+【补充标题规则】：
+参考高互动标题的模式：{title_advice}

 【推荐标签】：优先使用这些高权重标签 → {hot_tags}
-
-【绘图 Prompt】：
-{sd_prompt_guide}
-
-返回 JSON 格式：
-{{"title": "...", "content": "...", "sd_prompt": "...", "tags": ["标签1", "标签2", ...]}}
 """

+# 保留旧变量名兼容（加权创作也使用分层基础）
+PROMPT_WEIGHTED_COPYWRITING = PROMPT_BASE + PROMPT_WEIGHTED_COPYWRITING_EXTRA + PROMPT_COPYWRITING_SUFFIX
+
 PROMPT_HOTSPOT_ANALYSIS = """
 你是一个有实战经验的小红书运营人。下面是搜索到的热门笔记信息：

@ -237,45 +337,24 @@ PROMPT_PROACTIVE_COMMENT = """
 请直接输出一条评论，不要有任何解释或前缀。记住：你是一个真人，不是AI。
 """

-PROMPT_COPY_WITH_REFERENCE = """
-你是一个真实的小红书博主，正在参考一些热门笔记来写一篇自己的原创内容。
-你不是在写营销文案，你只是觉得这些笔记写得不错，想借鉴思路写一篇自己的体验分享。
-
+PROMPT_COPY_WITH_REFERENCE_EXTRA = """
 【参考笔记】：
 {reference_notes}

 【创作主题】：{topic}
 【风格要求】：{style}

-【标题规则】：
-1. 长度限制：必须控制在 18 字以内（含Emoji），绝对不能超过 20 字！
-2. 学习参考笔记标题的情绪感和口语感，但内容完全原创
-3. 写得像你发给朋友看的那种，不要像广告
-
-【正文规则——写得像真人】：
-1. 想象你是刚体验完然后打开小红书写笔记，把你的真实感受和过程写出来
-2. 正文控制在 400-600 字
-3. 真人写法：
-   - 开头可以直接说事，不需要"嗨大家好"之类的开场白
-   - 中间夹杂一些个人感受和小吐槽（"一开始还在犹豫 结果用了之后真香"）
-   - 不要面面俱到什么优点都说一遍，挑2-3个最有感触的重点说
-   - 可以适当说一两个小缺点，让内容更真实（"唯一的缺点就是xxx 但瑕不掩瑜"）
-   - 段落自然分割，有的段一两句，有的段稍长
-4. emoji 穿插在情绪高点，不要每句都有，整篇 6-10 个足够
-5. 绝对禁止：
-   ❌ 排比句、对仗句（"不仅...而且..." "既...又..."）
-   ❌ "值得一提" "需要注意" "总结一下" 等总结性书面用语
-   ❌ 每个段落都很工整的1234结构
-   ❌ 面面俱到地罗列所有优点
-6. 结尾加 5-8 个话题标签(#)
-
-【绘图 Prompt】：
-{sd_prompt_guide}
-
-返回 JSON 格式：
-{{"title": "...", "content": "...", "sd_prompt": "...", "tags": ["标签1", "标签2", ...]}}
+【参考笔记创作指导】：
+- 学习参考笔记标题的情绪感和口语感，但内容完全原创
+- 开头可以直接说事，不需要"嗨大家好"之类的开场白
+- 中间夹杂个人感受和小吐槽
+- 挑2-3个最有感触的重点说，不要面面俱到
+- 可以适当提一两个小缺点增加可信度
 """

+# 保留旧变量名兼容（参考创作也使用分层基础）
+PROMPT_COPY_WITH_REFERENCE = PROMPT_BASE + PROMPT_COPY_WITH_REFERENCE_EXTRA + PROMPT_COPYWRITING_SUFFIX
+

 class LLMService:
    """LLM API 服务封装"""
@ -419,6 +498,80 @@ class LLMService:

        return base + chinese_aesthetic_guide + anti_detect_tips + persona_guide

+    # ========== 封面图策略 ==========
+
+    # 情感基调 → SD 氛围词映射
+    EMOTION_SD_MAP = {
+        "温柔": "soft lighting, warm color palette, gentle atmosphere, cozy mood",
+        "治愈": "warm tone, soft focus, peaceful, comforting light, serene mood",
+        "活力": "bright vivid colors, dynamic angle, energetic mood, sunlight",
+        "酷飒": "cool tone, dramatic lighting, sharp contrast, cinematic, editorial",
+        "甜美": "pastel colors, soft pink tone, dreamy, cute, romantic lighting",
+        "高级": "neutral tone, minimalist, luxury, muted colors, sophisticated",
+        "搞笑": "bright cheerful colors, exaggerated expression, fun, playful",
+        "文艺": "film grain, muted vintage tone, nostalgic, soft natural light",
+    }
+
+    # 封面图策略 → SD prompt 后缀 + 尺寸
+    COVER_STRATEGIES = {
+        "人物特写": {
+            "sd_suffix": "portrait, face close-up, shallow depth of field, bokeh background, upper body shot",
+            "width": 768,
+            "height": 1024,
+        },
+        "场景展示": {
+            "sd_suffix": "wide angle, environmental shot, product in context, lifestyle scene, natural setting",
+            "width": 1024,
+            "height": 768,
+        },
+        "对比图": {
+            "sd_suffix": "before and after, side by side comparison, split view, clean background, product showcase",
+            "width": 1024,
+            "height": 1024,
+        },
+        "文字卡片": {
+            "sd_suffix": "minimal background, clean simple design, solid color backdrop, text space, magazine layout",
+            "width": 768,
+            "height": 1024,
+        },
+    }
+
+    @staticmethod
+    def get_cover_strategy(strategy_name: str) -> dict:
+        """获取封面图策略配置"""
+        return LLMService.COVER_STRATEGIES.get(
+            strategy_name,
+            LLMService.COVER_STRATEGIES.get("人物特写")
+        )
+
+    @staticmethod
+    def get_emotion_atmosphere(emotion: str) -> str:
+        """根据情感基调获取 SD 氛围词"""
+        return LLMService.EMOTION_SD_MAP.get(emotion, "")
+
+    # ========== 图文匹配度评估 ==========
+
+    def evaluate_image_text_match(self, content: str, sd_prompt: str) -> dict:
+        """
+        评估文案与 SD prompt 的语义匹配度（可选，失败不阻塞）
+
+        Returns:
+            dict with match_score (0-100), suggestions (list[str])
+            失败时返回 {"match_score": -1, "suggestions": [], "skipped": True}
+        """
+        prompt = PROMPT_IMAGE_TEXT_MATCH.format(content=content, sd_prompt=sd_prompt)
+        try:
+            raw = self._chat(prompt, "请评估图文匹配度", json_mode=True)
+            result = self._parse_json(raw)
+            return {
+                "match_score": int(result.get("match_score", 0)),
+                "suggestions": result.get("suggestions", []),
+                "skipped": False,
+            }
+        except Exception as e:
+            logger.warning("图文匹配度评估失败（已跳过）: %s", e)
+            return {"match_score": -1, "suggestions": [], "skipped": True}
+
    def _chat(self, system_prompt: str, user_message: str,
              json_mode: bool = True, temperature: float = 0.8) -> str:
        """底层聊天接口（含空返回检测、json_mode 回退、模型降级）"""
@ -592,13 +745,55 @@ class LLMService:
            logger.warning("获取模型列表失败 (%s): %s", url, e)
            return []

-    def generate_copy(self, topic: str, style: str, sd_model_name: str = None, persona: str = None) -> dict:
-        """生成小红书文案（含重试逻辑，自动适配SD模型，支持人设）"""
-        sd_guide = self.get_sd_prompt_guide(sd_model_name, persona=persona)
-        system_prompt = PROMPT_COPYWRITING.format(sd_prompt_guide=sd_guide)
-        user_msg = f"主题：{topic}\n风格：{style}"
+    @staticmethod
+    def _build_layered_prompt(style: str, sd_guide: str, persona: str = None) -> str:
+        """构建分层 Prompt：基础层 → 风格层 → 人设层 → 后缀"""
+        parts = [PROMPT_BASE]
+        # 风格层（缺失时退回基础层）
+        style_prompt = PROMPT_STYLES.get(style, "")
+        if style_prompt:
+            parts.append(style_prompt)
+        # 人设层
        if persona:
-            user_msg = f"【博主人设】：{persona}\n请以此人设的视角和风格创作。\n\n{user_msg}"
+            parts.append(f"\n【博主人设】：{persona}\n请以此人设的视角和风格创作。\n")
+        # 后缀（SD prompt 指导 + JSON 格式要求）
+        parts.append(PROMPT_COPYWRITING_SUFFIX.format(sd_prompt_guide=sd_guide))
+        return "\n".join(parts)
+
+    def _self_check(self, content: str) -> dict:
+        """对文案进行 AI 痕迹自检，返回 {ai_score, feedback, dimension_scores}"""
+        try:
+            prompt = PROMPT_SELF_CHECK.format(content=content)
+            raw = self._chat(prompt, "请评估以上文案的AI痕迹程度",
+                             json_mode=True, temperature=0.3)
+            result = self._parse_json(raw)
+            # 确保字段完整
+            return {
+                "ai_score": int(result.get("ai_score", 50)),
+                "feedback": result.get("feedback", ""),
+                "dimension_scores": result.get("dimension_scores", {}),
+            }
+        except Exception as e:
+            logger.warning("文案自检失败（跳过）: %s", e)
+            return {"ai_score": 0, "feedback": "", "dimension_scores": {}}
+
+    def _self_check_rewrite(self, original_content: str, feedback: str) -> str:
+        """根据自检反馈改写文案"""
+        try:
+            prompt = PROMPT_SELF_CHECK_REWRITE.format(
+                original_content=original_content, feedback=feedback
+            )
+            rewritten = self._chat(prompt, "请改写文案", json_mode=False, temperature=0.9)
+            return rewritten.strip() if rewritten and rewritten.strip() else original_content
+        except Exception as e:
+            logger.warning("文案改写失败（使用原始文案）: %s", e)
+            return original_content
+
+    def generate_copy(self, topic: str, style: str, sd_model_name: str = None, persona: str = None) -> dict:
+        """生成小红书文案（分层 Prompt 架构，含重试逻辑，自动适配SD模型，支持人设）"""
+        sd_guide = self.get_sd_prompt_guide(sd_model_name, persona=persona)
+        system_prompt = self._build_layered_prompt(style, sd_guide, persona=persona)
+        user_msg = f"主题：{topic}\n风格：{style}"
        last_error = None
        for attempt in range(2):
            try:
@ -618,10 +813,30 @@ class LLMService:
                    title = title[:20]
                    data["title"] = title

+                # 自检机制：检测 AI 痕迹
+                quality_meta = {"ai_score": 0, "self_check_passed": True, "rewritten": False}
+                raw_content = data.get("content", "")
+                if raw_content:
+                    check_result = self._self_check(raw_content)
+                    ai_score = check_result.get("ai_score", 0)
+                    quality_meta["ai_score"] = ai_score
+                    if ai_score >= 60:
+                        # AI 痕迹较重，触发改写
+                        quality_meta["self_check_passed"] = False
+                        feedback = check_result.get("feedback", "")
+                        rewritten = self._self_check_rewrite(raw_content, feedback)
+                        if rewritten != raw_content:
+                            data["content"] = rewritten
+                            quality_meta["rewritten"] = True
+                            logger.info("文案自检未通过 (ai_score=%d)，已改写", ai_score)
+                        else:
+                            logger.info("文案自检未通过 (ai_score=%d)，改写无变化", ai_score)
+
                # 去 AI 化后处理
                if "content" in data:
                    data["content"] = self._humanize_content(data["content"])

+                data["quality_meta"] = quality_meta
                return data

            except (json.JSONDecodeError, ValueError) as e:
@ -636,15 +851,22 @@ class LLMService:

    def generate_copy_with_reference(self, topic: str, style: str,
                                     reference_notes: str, sd_model_name: str = None, persona: str = None) -> dict:
-        """参考热门笔记生成文案（含重试逻辑，自动适配SD模型，支持人设）"""
+        """参考热门笔记生成文案（分层 Prompt，含重试逻辑，自动适配SD模型，支持人设）"""
        sd_guide = self.get_sd_prompt_guide(sd_model_name, persona=persona)
-        prompt = PROMPT_COPY_WITH_REFERENCE.format(
+        # 分层构建：基础层 + 风格层 + 参考笔记层 + 后缀
+        ref_extra = PROMPT_COPY_WITH_REFERENCE_EXTRA.format(
            reference_notes=reference_notes, topic=topic, style=style,
-            sd_prompt_guide=sd_guide,
        )
-        user_msg = f"请创作关于「{topic}」的小红书笔记"
+        style_prompt = PROMPT_STYLES.get(style, "")
+        parts = [PROMPT_BASE]
+        if style_prompt:
+            parts.append(style_prompt)
+        parts.append(ref_extra)
        if persona:
-            user_msg = f"【博主人设】：{persona}\n请以此人设的视角和风格创作。\n\n{user_msg}"
+            parts.append(f"\n【博主人设】：{persona}\n请以此人设的视角和风格创作。\n")
+        parts.append(PROMPT_COPYWRITING_SUFFIX.format(sd_prompt_guide=sd_guide))
+        prompt = "\n".join(parts)
+        user_msg = f"请创作关于「{topic}」的小红书笔记"
        last_error = None
        for attempt in range(2):
            try:
@ -769,7 +991,7 @@ class LLMService:
            if t.startswith(prefix):
                t = t[len(prefix):].strip()

-        # ========== 第四层: 标点符号真人化 ==========
+        # ========== 第四层: 标点符号真人化（增强版） ==========
        # AI 特征: 每句话都有完整标点 → 真人经常不加标点或只用逗号
        sentences = t.split('\n')
        humanized_lines = []
@ -777,16 +999,22 @@ class LLMService:
            if not line.strip():
                humanized_lines.append(line)
                continue
-            # 随机去掉句末句号 (真人经常不打句号)
-            if line.rstrip().endswith('。') and random.random() < 0.35:
+            # 随机去掉句末句号 (真人经常不打句号) — 概率提高到 50%
+            if line.rstrip().endswith('。') and random.random() < 0.50:
                line = line.rstrip()[:-1]
-            # 随机把部分逗号替换成空格或什么都不加 (模拟打字不加标点)
-            if random.random() < 0.15:
-                # 只替换一个逗号
+            # 随机把部分逗号替换成空格或什么都不加 (模拟打字不加标点) — 概率提高到 25%
+            if random.random() < 0.25:
                comma_positions = [m.start() for m in re.finditer(r'[，,]', line)]
                if comma_positions:
                    pos = random.choice(comma_positions)
-                    line = line[:pos] + ' ' + line[pos+1:]
+                    replacement = random.choice([' ', '', ' '])
+                    line = line[:pos] + replacement + line[pos+1:]
+            # 随机把感叹号降级为句号 (AI 爱用感叹号)
+            if line.rstrip().endswith('！') and random.random() < 0.20:
+                line = line.rstrip()[:-1] + '。'
+            # 随机删除句末标点 (真人有时就不加)
+            if line.rstrip() and line.rstrip()[-1] in '。，,' and random.random() < 0.10:
+                line = line.rstrip()[:-1]
            humanized_lines.append(line)
        t = '\n'.join(humanized_lines)

@ -807,7 +1035,30 @@ class LLMService:
                    paragraphs[idx] = connector + paragraphs[idx].lstrip()
            t = '\n\n'.join(paragraphs)

-        # ========== 第六层: 句子长度打散 ==========
+        # ========== 第六层: 语气词注入 ==========
+        # 真人说话带语气词 → AI 生成文本通常没有
+        tone_particles_end = ['啊', '呢', '吧', '嘛', '呀', '哦', '啦', '噢']
+        tone_particles_mid = ['嘿', '诶', '哈', '唉']
+        lines = t.split('\n')
+        particle_budget = random.randint(2, 4)  # 全文最多注入 2-4 个
+        injected = 0
+        for i in range(len(lines)):
+            if injected >= particle_budget:
+                break
+            line = lines[i].strip()
+            if not line or len(line) < 6:
+                continue
+            # 句末语气词: 在没有标点或句号结尾的句子加语气词
+            if random.random() < 0.15 and line[-1] not in '。！？!?~～…':
+                lines[i] = lines[i].rstrip() + random.choice(tone_particles_end)
+                injected += 1
+            # 句首感叹词: 在段落开头偶尔加
+            elif random.random() < 0.08 and not any(line.startswith(p) for p in tone_particles_mid):
+                lines[i] = random.choice(tone_particles_mid) + ' ' + lines[i].lstrip()
+                injected += 1
+        t = '\n'.join(lines)
+
+        # ========== 第七层: 句子长度打散 ==========
        # AI 特征: 句子长度高度均匀 → 真人笔记长短参差不齐
        # 随机把一些长句用换行打散
        lines = t.split('\n')
@ -832,7 +1083,7 @@ class LLMService:
            final_lines.append(line)
        t = '\n'.join(final_lines)

-        # ========== 第七层: 随机注入微小不完美 ==========
+        # ========== 第八层: 随机注入微小不完美 ==========
        # 真人打字偶尔有重复字、多余空格等
        if random.random() < 0.2:
            # 随机在某处加一个波浪号或省略号
@ -844,9 +1095,73 @@ class LLMService:
                    lines[target] = lines[target].rstrip() + random.choice(insert_chars)
                t = '\n'.join(lines)

-        # ========== 第八层: 清理 ==========
-        # 去掉连续3个以上的 emoji
-        t = re.sub(r'([\U0001F600-\U0001F9FF\u2600-\u27BF])\1{2,}', r'\1\1', t)
+        # ========== 第九层: 段落节奏打散 ==========
+        # AI 特征: 连续段落字数接近 → 真人笔记长短参差不齐
+        paragraphs = t.split('\n\n')
+        if len(paragraphs) >= 3:
+            para_lens = [len(p.strip()) for p in paragraphs]
+            for i in range(1, len(paragraphs) - 1):
+                if para_lens[i] == 0:
+                    continue
+                prev_len = para_lens[i - 1] if para_lens[i - 1] > 0 else 1
+                # 如果连续两段字数差异 < 30%，尝试打散
+                ratio = abs(para_lens[i] - prev_len) / max(para_lens[i], prev_len)
+                if ratio < 0.30 and para_lens[i] > 20 and random.random() < 0.40:
+                    # 策略: 在中间段落找标点断开，制造长短不一
+                    p = paragraphs[i].strip()
+                    cut_pos = -1
+                    mid = len(p) // 3  # 在 1/3 处截断，制造不均匀
+                    for offset in range(0, mid):
+                        for check in [mid + offset, mid - offset]:
+                            if 0 < check < len(p) and p[check] in '，。！？、,!?':
+                                cut_pos = check
+                                break
+                        if cut_pos > 0:
+                            break
+                    if cut_pos > 0:
+                        paragraphs[i] = p[:cut_pos + 1] + '\n\n' + p[cut_pos + 1:].lstrip()
+            t = '\n\n'.join(paragraphs)
+
+        # ========== 第十层: emoji 密度控制 ==========
+        # 目标: 全文 6-12 个 emoji，分布不均匀，避免堆叠
+        emoji_pattern = re.compile(
+            r'[\U0001F300-\U0001F9FF\u2600-\u27BF\u2702-\u27B0'
+            r'\U0001FA00-\U0001FA6F\U0001FA70-\U0001FAFF'
+            r'\u231A-\u231B\u23E9-\u23F3\u23F8-\u23FA'
+            r'\u25AA-\u25AB\u25B6\u25C0\u25FB-\u25FE'
+            r'\u2614-\u2615\u2648-\u2653\u267F\u2693'
+            r'\u26A1\u26AA-\u26AB\u26BD-\u26BE\u26C4-\u26C5'
+            r'\u26D4\u26EA\u26F2-\u26F3\u26F5\u26FA\u26FD\u2934-\u2935]'
+        )
+        emojis_found = emoji_pattern.findall(t)
+        emoji_count = len(emojis_found)
+        target_min, target_max = 6, 12
+
+        if emoji_count > target_max:
+            # 太多: 随机删除多余的
+            excess = emoji_count - random.randint(target_min, target_max)
+            if excess > 0:
+                # 找到所有 emoji 位置，随机选择 excess 个删除
+                positions = [m.start() for m in emoji_pattern.finditer(t)]
+                remove_positions = set(random.sample(positions, min(excess, len(positions))))
+                t = ''.join(c for idx, c in enumerate(t) if idx not in remove_positions)
+        elif emoji_count < target_min and emoji_count > 0:
+            # 太少: 在随机位置复制现有 emoji
+            shortage = random.randint(target_min, target_min + 2) - emoji_count
+            lines = t.split('\n')
+            non_empty_lines = [i for i, l in enumerate(lines) if l.strip() and len(l.strip()) > 4]
+            if non_empty_lines and emojis_found:
+                for _ in range(min(shortage, len(non_empty_lines))):
+                    idx = random.choice(non_empty_lines)
+                    emoji_to_add = random.choice(emojis_found)
+                    # 在行末添加
+                    lines[idx] = lines[idx].rstrip() + emoji_to_add
+                t = '\n'.join(lines)
+
+        # 去掉连续相同的 emoji 堆叠（超过 2 个相同的只保留 1 个）
+        t = re.sub(r'([\U0001F300-\U0001F9FF\u2600-\u27BF])\1{1,}', r'\1', t)
+
+        # ========== 第十一层: 清理 ==========
        # 清理多余空行
        t = re.sub(r'\n{3,}', '\n\n', t)
        # 清理行首多余空格 (手机打字不会缩进)
@ -925,17 +1240,24 @@ class LLMService:
    def generate_weighted_copy(self, topic: str, style: str,
                               weight_insights: str, title_advice: str,
                               hot_tags: str, sd_model_name: str = None, persona: str = None) -> dict:
-        """基于权重学习生成高互动潜力的文案（自动适配SD模型，支持人设）"""
+        """基于权重学习生成高互动潜力的文案（分层 Prompt，自动适配SD模型，支持人设）"""
        sd_guide = self.get_sd_prompt_guide(sd_model_name, persona=persona)
-        prompt = PROMPT_WEIGHTED_COPYWRITING.format(
+        # 分层构建：基础层 + 风格层 + 权重洞察层 + 后缀
+        weighted_extra = PROMPT_WEIGHTED_COPYWRITING_EXTRA.format(
            weight_insights=weight_insights,
            title_advice=title_advice,
            hot_tags=hot_tags,
-            sd_prompt_guide=sd_guide,
        )
-        user_msg = f"主题：{topic}\n风格：{style}\n请创作一篇基于数据洞察的高质量小红书笔记"
+        style_prompt = PROMPT_STYLES.get(style, "")
+        parts = [PROMPT_BASE]
+        if style_prompt:
+            parts.append(style_prompt)
+        parts.append(weighted_extra)
        if persona:
-            user_msg = f"【博主人设】：{persona}\n请以此人设的视角和风格创作。\n\n{user_msg}"
+            parts.append(f"\n【博主人设】：{persona}\n请以此人设的视角和风格创作。\n")
+        parts.append(PROMPT_COPYWRITING_SUFFIX.format(sd_prompt_guide=sd_guide))
+        prompt = "\n".join(parts)
+        user_msg = f"主题：{topic}\n风格：{style}\n请创作一篇基于数据洞察的高质量小红书笔记"
        last_error = None
        for attempt in range(2):
            try:
--- a/services/sd_service.py
+++ b/services/sd_service.py
@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 SD_TIMEOUT = 1800  # 图片生成可能需要较长时间

 # 头像文件默认保存路径
-FACE_IMAGE_PATH = os.path.join(os.path.dirname(__file__), "assets", "faces", "my_face.png")
+FACE_IMAGE_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "assets", "faces", "my_face.png")

 # ==================== 多模型配置系统 ====================
 # 每个模型的最优参数、prompt 增强词、负面提示词、三档预设
@ -739,6 +739,7 @@ class SDService:
    def save_face_image(img: Image.Image, path: str = None) -> str:
        """保存头像图片，返回保存路径"""
        path = path or FACE_IMAGE_PATH
+        os.makedirs(os.path.dirname(path), exist_ok=True)
        img = img.convert("RGB")
        img.save(path, format="PNG")
        logger.info("头像已保存: %s", path)
--- a/services/topic_engine.py
+++ b/services/topic_engine.py
@ -0,0 +1,462 @@
+"""
+services/topic_engine.py
+智能选题引擎 — 聚合热点数据 + 历史权重，推荐高潜力选题
+"""
+import logging
+import os
+import json
+import re
+from datetime import datetime, timedelta
+
+logger = logging.getLogger("autobot")
+
+
+class TopicEngine:
+    """
+    智能选题推荐引擎
+
+    职责: 聚合热点探测结果与历史互动权重，为用户推荐高潜力选题。
+    不直接访问 MCP / LLM，通过注入的 AnalyticsService 获取数据。
+    """
+
+    def __init__(self, analytics_service):
+        """
+        Args:
+            analytics_service: AnalyticsService 实例，提供权重和笔记数据
+        """
+        self.analytics = analytics_service
+
+    # ========== 核心: 多维度评分 ==========
+
+    def score_topic(self, topic: str, hotspot_data: dict = None) -> dict:
+        """
+        为单个候选主题计算综合评分
+
+        维度:
+          - hotspot_score (0-40): 热点热度
+          - weight_score  (0-30): 历史互动权重
+          - scarcity_score(0-20): 内容稀缺度
+          - timeliness_score(0-10): 时效性
+
+        Args:
+            topic: 候选主题文本
+            hotspot_data: 可选的热点分析数据（包含 hot_topics, suggestions 等）
+
+        Returns:
+            dict with total_score, hotspot_score, weight_score, scarcity_score, timeliness_score
+        """
+        hotspot_score = self._calc_hotspot_score(topic, hotspot_data)
+        weight_score = self._calc_weight_score(topic)
+        scarcity_score = self._calc_scarcity_score(topic)
+        timeliness_score = self._calc_timeliness_score(topic)
+
+        total = hotspot_score + weight_score + scarcity_score + timeliness_score
+
+        return {
+            "total_score": total,
+            "hotspot_score": hotspot_score,
+            "weight_score": weight_score,
+            "scarcity_score": scarcity_score,
+            "timeliness_score": timeliness_score,
+        }
+
+    # ========== 推荐主题列表 ==========
+
+    def recommend_topics(self, count: int = 5, hotspot_data: dict = None) -> list[dict]:
+        """
+        推荐排序后的选题列表
+
+        逻辑:
+          1. 收集候选主题 (热点 + 权重主题)
+          2. 对每个主题评分
+          3. 去重 (语义相近合并)
+          4. 按总分降序取 top-N
+          5. 为每个主题生成创作角度建议
+
+        Args:
+            count: 返回推荐数量 (默认 5)
+            hotspot_data: 可选的热点分析数据
+
+        Returns:
+            list of dict, 每项包含:
+              topic, score, reason, source, angles,
+              score_detail (各维度分数)
+        """
+        candidates = self._collect_candidates(hotspot_data)
+
+        if not candidates:
+            logger.warning("选题引擎: 无候选主题可推荐")
+            return []
+
+        # 评分
+        scored = []
+        for topic, source in candidates:
+            detail = self.score_topic(topic, hotspot_data)
+            scored.append({
+                "topic": topic,
+                "score": detail["total_score"],
+                "source": source,
+                "score_detail": detail,
+            })
+
+        # 去重
+        scored = self._deduplicate(scored)
+
+        # 排序
+        scored.sort(key=lambda x: x["score"], reverse=True)
+        scored = scored[:count]
+
+        # 生成 reason 和 angles
+        for item in scored:
+            item["reason"] = self._generate_reason(item)
+            item["angles"] = self._generate_angles(item["topic"], item["source"])
+
+        return scored
+
+    # ========== 候选收集 ==========
+
+    def _collect_candidates(self, hotspot_data: dict = None) -> list[tuple[str, str]]:
+        """
+        收集所有候选主题，返回 [(topic, source), ...]
+
+        source: "hotspot" | "weight" | "trend"
+        """
+        candidates = []
+        seen = set()
+
+        # 1. 从热点数据收集
+        if hotspot_data:
+            for topic in hotspot_data.get("hot_topics", []):
+                topic_clean = self._clean_topic(topic)
+                if topic_clean and topic_clean not in seen:
+                    candidates.append((topic_clean, "hotspot"))
+                    seen.add(topic_clean)
+
+            for suggestion in hotspot_data.get("suggestions", []):
+                topic_clean = self._clean_topic(suggestion.get("topic", ""))
+                if topic_clean and topic_clean not in seen:
+                    candidates.append((topic_clean, "hotspot"))
+                    seen.add(topic_clean)
+
+        # 2. 从权重数据收集
+        topic_weights = self.analytics._weights.get("topic_weights", {})
+        for topic, info in topic_weights.items():
+            topic_clean = self._clean_topic(topic)
+            if topic_clean and topic_clean not in seen:
+                candidates.append((topic_clean, "weight"))
+                seen.add(topic_clean)
+
+        # 3. 从分析历史提取趋势主题
+        history = self.analytics._weights.get("analysis_history", [])
+        for entry in history[-5:]:
+            top_topic = entry.get("top_topic", "")
+            if top_topic and top_topic not in seen:
+                candidates.append((top_topic, "trend"))
+                seen.add(top_topic)
+
+        return candidates
+
+    # ========== 评分子模块 ==========
+
+    def _calc_hotspot_score(self, topic: str, hotspot_data: dict = None) -> int:
+        """热点热度评分 (0-40)"""
+        if not hotspot_data:
+            return 0
+
+        score = 0
+
+        # 检查是否在热门主题中
+        hot_topics = hotspot_data.get("hot_topics", [])
+        for i, ht in enumerate(hot_topics):
+            if self._topic_similar(topic, ht):
+                # 排名越靠前分越高
+                score = max(score, 40 - i * 5)
+                break
+
+        # 检查是否在推荐建议中
+        suggestions = hotspot_data.get("suggestions", [])
+        for suggestion in suggestions:
+            if self._topic_similar(topic, suggestion.get("topic", "")):
+                score = max(score, 30)
+                break
+
+        return min(40, score)
+
+    def _calc_weight_score(self, topic: str) -> int:
+        """历史互动权重评分 (0-30)"""
+        topic_weights = self.analytics._weights.get("topic_weights", {})
+        if not topic_weights:
+            return 0
+
+        # 精确匹配
+        if topic in topic_weights:
+            weight = topic_weights[topic].get("weight", 0)
+            # weight 原始范围 0-100，映射到 0-30
+            return min(30, int(weight * 0.3))
+
+        # 模糊匹配
+        best_score = 0
+        for existing_topic, info in topic_weights.items():
+            if self._topic_similar(topic, existing_topic):
+                weight = info.get("weight", 0)
+                best_score = max(best_score, min(30, int(weight * 0.3)))
+
+        return best_score
+
+    def _calc_scarcity_score(self, topic: str) -> int:
+        """
+        内容稀缺度评分 (0-20)
+
+        近 7 天已发布 >= 2 篇的主题: scarcity_score <= 5
+        """
+        notes = self.analytics._analytics_data.get("notes", {})
+        seven_days_ago = (datetime.now() - timedelta(days=7)).isoformat()
+
+        recent_count = 0
+        for nid, note in notes.items():
+            collected = note.get("collected_at", "")
+            if collected >= seven_days_ago:
+                note_topic = note.get("topic", "")
+                if self._topic_similar(topic, note_topic):
+                    recent_count += 1
+
+        if recent_count >= 2:
+            return min(5, max(0, 5 - recent_count))  # 发的越多越低
+        elif recent_count == 1:
+            return 12  # 有一篇，中等稀缺
+        else:
+            return 20  # 完全空白，高稀缺
+
+    def _calc_timeliness_score(self, topic: str) -> int:
+        """
+        时效性评分 (0-10)
+
+        基于主题是否包含时效性关键词（季节、节日等）
+        """
+        now = datetime.now()
+        month = now.month
+
+        # 季节关键词
+        season_keywords = {
+            "春": [2, 3, 4, 5],
+            "夏": [5, 6, 7, 8],
+            "秋": [8, 9, 10, 11],
+            "冬": [11, 12, 1, 2],
+            "早春": [2, 3],
+            "初夏": [5, 6],
+            "初秋": [8, 9],
+        }
+
+        # 节日关键词
+        festival_windows = {
+            "情人节": (2, 10, 2, 18),
+            "三八": (3, 1, 3, 12),
+            "妇女节": (3, 1, 3, 12),
+            "母亲节": (5, 5, 5, 15),
+            "618": (6, 1, 6, 20),
+            "七夕": (7, 20, 8, 15),
+            "中秋": (9, 1, 9, 30),
+            "国庆": (9, 25, 10, 10),
+            "双十一": (10, 20, 11, 15),
+            "双11": (10, 20, 11, 15),
+            "双十二": (12, 1, 12, 15),
+            "圣诞": (12, 15, 12, 28),
+            "元旦": (12, 25, 1, 5),
+            "年货": (1, 5, 2, 10),
+            "春节": (1, 10, 2, 10),
+            "开学": (8, 20, 9, 15),
+        }
+
+        score = 5  # 基础分
+
+        # 季节匹配
+        for keyword, months in season_keywords.items():
+            if keyword in topic and month in months:
+                score = max(score, 8)
+                break
+
+        # 节日窗口匹配
+        for keyword, (m1, d1, m2, d2) in festival_windows.items():
+            if keyword in topic:
+                start = datetime(now.year, m1, d1)
+                end = datetime(now.year, m2, d2)
+                # 处理跨年
+                if start > end:
+                    if now >= start or now <= end:
+                        score = 10
+                        break
+                elif start <= now <= end:
+                    score = 10
+                    break
+                else:
+                    score = max(score, 3)  # 不在窗口期但有时效关键词
+
+        return score
+
+    # ========== 去重 ==========
+
+    def _deduplicate(self, scored: list[dict]) -> list[dict]:
+        """
+        去重: 语义相近的主题合并，保留分数较高者
+
+        例: "春季穿搭" 和 "早春穿搭" 合并为高分项
+        """
+        if len(scored) <= 1:
+            return scored
+
+        result = []
+        merged_indices = set()
+
+        for i in range(len(scored)):
+            if i in merged_indices:
+                continue
+            best = scored[i]
+            for j in range(i + 1, len(scored)):
+                if j in merged_indices:
+                    continue
+                if self._topic_similar(scored[i]["topic"], scored[j]["topic"]):
+                    merged_indices.add(j)
+                    if scored[j]["score"] > best["score"]:
+                        best = scored[j]
+            result.append(best)
+
+        return result
+
+    # ========== 辅助方法 ==========
+
+    @staticmethod
+    def _clean_topic(topic: str) -> str:
+        """清理主题文本"""
+        if not topic:
+            return ""
+        # 去除序号、emoji、多余空格
+        t = re.sub(r'^[\d.、)\]】]+\s*', '', topic.strip())
+        t = re.sub(r'[•·●]', '', t)
+        return t.strip()
+
+    @staticmethod
+    def _topic_similar(a: str, b: str) -> bool:
+        """
+        判断两个主题是否语义相近 (简单规则匹配)
+
+        策略:
+          1. 完全相同 → True
+          2. 一方包含另一方 → True
+          3. 去除修饰词后相同 → True
+          4. 共享核心词比例 > 60% → True
+        """
+        if not a or not b:
+            return False
+
+        a_clean = a.strip().lower()
+        b_clean = b.strip().lower()
+
+        # 完全相同
+        if a_clean == b_clean:
+            return True
+
+        # 包含关系
+        if a_clean in b_clean or b_clean in a_clean:
+            return True
+
+        # 去修饰词
+        modifiers = ["早", "初", "晚", "新", "最", "超", "巨", "真的", "必看"]
+        a_core = a_clean
+        b_core = b_clean
+        for mod in modifiers:
+            a_core = a_core.replace(mod, "")
+            b_core = b_core.replace(mod, "")
+        if a_core and b_core and a_core == b_core:
+            return True
+
+        # 核心词重叠
+        # 按字分词 (中文简单分词)
+        a_chars = set(a_clean)
+        b_chars = set(b_clean)
+        if len(a_chars) >= 2 and len(b_chars) >= 2:
+            intersection = a_chars & b_chars
+            union = a_chars | b_chars
+            if len(intersection) / len(union) > 0.6:
+                return True
+
+        return False
+
+    @staticmethod
+    def _generate_reason(item: dict) -> str:
+        """根据评分生成推荐理由"""
+        detail = item.get("score_detail", {})
+        parts = []
+
+        if detail.get("hotspot_score", 0) >= 25:
+            parts.append("当前热点话题")
+        if detail.get("weight_score", 0) >= 15:
+            parts.append("历史互动表现好")
+        if detail.get("scarcity_score", 0) >= 15:
+            parts.append("内容空白可抢占")
+        if detail.get("timeliness_score", 0) >= 8:
+            parts.append("时效性强")
+
+        source = item.get("source", "")
+        if source == "hotspot" and not parts:
+            parts.append("热点趋势推荐")
+        elif source == "weight" and not parts:
+            parts.append("基于历史表现推荐")
+        elif source == "trend" and not parts:
+            parts.append("持续趋势主题")
+
+        if not parts:
+            parts.append("综合推荐")
+
+        return "，".join(parts)
+
+    @staticmethod
+    def _generate_angles(topic: str, source: str) -> list[str]:
+        """
+        为主题生成 1-3 个创作角度建议
+
+        注意: 这里用规则生成，不调用 LLM
+        """
+        angles = []
+
+        # 通用角度模板
+        templates_by_type = {
+            "穿搭": [
+                f"从预算角度分享{topic}的平替选择",
+                f"身材不同如何驾驭{topic}",
+                f"一周{topic}不重样的实穿记录",
+            ],
+            "美食": [
+                f"零失败的{topic}详细做法",
+                f"外卖 vs 自己做{topic}的对比",
+                f"{topic}的隐藏吃法",
+            ],
+            "护肤": [
+                f"不同肤质的{topic}选择指南",
+                f"踩雷vs回购：{topic}真实体验",
+                f"平价替代大牌{topic}推荐",
+            ],
+            "好物": [
+                f"用了半年的{topic}真实测评",
+                f"后悔没早买的{topic}清单",
+                f"从使用场景出发推荐{topic}",
+            ],
+        }
+
+        # 根据主题关键词匹配模板
+        matched = False
+        for keyword, templates in templates_by_type.items():
+            if keyword in topic:
+                angles = templates[:3]
+                matched = True
+                break
+
+        if not matched:
+            # 通用角度
+            angles = [
+                f"个人真实体验分享{topic}",
+                f"新手入门{topic}的详细攻略",
+                f"关于{topic}的冷知识和避坑指南",
+            ]
+
+        # 限制每个角度不超过 30 字
+        return [a[:30] for a in angles]
--- a/ui/app.py
+++ b/ui/app.py
@ -52,11 +52,46 @@ from services.queue_ops import (
    queue_format_table, queue_format_calendar,
 )
 from services.autostart import is_autostart_enabled, toggle_autostart
-from services.content import generate_copy, generate_images, one_click_export, publish_to_xhs
-from services.publish_queue import STATUS_LABELS
+from services.content import generate_copy, generate_images, one_click_export, publish_to_xhs, batch_generate_copy
+from services.publish_queue import PublishQueue, STATUS_LABELS
+from services.topic_engine import TopicEngine

 logger = logging.getLogger("autobot")

+
+# ========== 新增回调: 选题推荐 / 批量创作 / 图文匹配 ==========
+
+def _fn_topic_recommend(model_name):
+    """获取智能选题推荐列表"""
+    analytics = AnalyticsService()
+    engine = TopicEngine(analytics)
+    return engine.recommend_topics(count=5)
+
+
+def _fn_batch_generate(model_name, topics, style, sd_model_name, persona_text, template_name):
+    """批量生成文案并入草稿队列"""
+    pq = PublishQueue()
+    return batch_generate_copy(
+        model=model_name,
+        topics=topics,
+        style=style,
+        sd_model_name=sd_model_name,
+        persona_text=persona_text,
+        template_name=template_name,
+        publish_queue=pq,
+    )
+
+
+def _fn_evaluate_match(model_name, content, sd_prompt):
+    """评估图文匹配度"""
+    from services.llm_service import LLMService
+    from services.connection import _get_llm_config
+    api_key, base_url, _ = _get_llm_config()
+    if not api_key:
+        return {"match_score": -1, "suggestions": [], "skipped": True}
+    svc = LLMService(api_key, base_url, model_name)
+    return svc.evaluate_image_text_match(content, sd_prompt)
+
 _GRADIO_CSS = """
 /* ── Autobot 主题层 ── */
 body, .gradio-container {
@ -238,6 +273,9 @@ def build_app(cfg: "ConfigManager", analytics: "AnalyticsService") -> gr.Blocks:
                fn_get_sd_preset=get_sd_preset,
                fn_cfg_set=cfg.set,
                fn_cfg_update=cfg.update,
+                fn_batch_generate=_fn_batch_generate,
+                fn_topic_recommend=_fn_topic_recommend,
+                fn_evaluate_match=_fn_evaluate_match,
            )
            res_title = _tab1["res_title"]
            res_content = _tab1["res_content"]
--- a/ui/tab_create.py
+++ b/ui/tab_create.py
@ -2,8 +2,11 @@
 内容创作 Tab UI 模块
 包含 Tab 1「✨ 内容创作」的所有 Gradio 组件定义和事件绑定
 """
+import logging
 import gradio as gr

+logger = logging.getLogger("autobot")
+

 def build_tab(
    config: dict,
@ -27,6 +30,10 @@ def build_tab(
    fn_get_sd_preset,
    fn_cfg_set,
    fn_cfg_update,
+    # 新增: 批量创作 & 选题推荐回调
+    fn_batch_generate=None,
+    fn_topic_recommend=None,
+    fn_evaluate_match=None,
 ):
    """
    构建「✨ 内容创作」Tab，注册所有事件绑定。
@ -52,6 +59,15 @@ def build_tab(
            # ---- 左栏：输入 ----
            with gr.Column(scale=3):
                gr.Markdown("### 💡 构思")
+
+                # === 智能选题推荐 ===
+                with gr.Accordion("🧠 智能选题推荐", open=False):
+                    btn_recommend = gr.Button("🔍 获取推荐选题", variant="secondary", size="sm")
+                    topic_recommendations = gr.Markdown(
+                        value="点击上方按钮获取推荐选题",
+                        label="推荐选题",
+                    )
+
                topic = gr.Textbox(label="笔记主题", placeholder="例如：优衣库早春穿搭")
                style = gr.Dropdown(
                    styles,
@ -61,6 +77,13 @@ def build_tab(

                gr.Markdown("---")
                gr.Markdown("### 🎨 绘图参数")
+                # 封面图策略选择
+                cover_strategy = gr.Radio(
+                    ["人物特写", "场景展示", "对比图", "文字卡片"],
+                    label="封面图策略",
+                    value="人物特写",
+                    info="影响 SD 构图和尺寸",
+                )
                quality_mode = gr.Radio(
                    sd_preset_names,
                    label="生成模式",
@ -123,6 +146,30 @@ def build_tab(
                    btn_publish = gr.Button("🚀 发布到小红书", variant="primary")
                publish_msg = gr.Markdown("")

+                # === 图文匹配度评分 ===
+                with gr.Accordion("📊 图文匹配度", open=False):
+                    btn_eval_match = gr.Button("评估匹配度", variant="secondary", size="sm")
+                    match_score_display = gr.Markdown("点击按钮评估文案与图片的匹配度")
+
+        # === 批量创作面板 ===
+        with gr.Accordion("📦 批量创作", open=False):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    batch_topics = gr.TextArea(
+                        label="批量主题 (每行一个，最多10个)",
+                        placeholder="优衣库早春穿搭\n百元床品测评\n新手养宠攻略",
+                        lines=5,
+                    )
+                with gr.Column(scale=1):
+                    batch_template = gr.Dropdown(
+                        choices=["(不使用模板)", "好物种草", "日常分享", "攻略教程"],
+                        value="(不使用模板)",
+                        label="内容模板",
+                    )
+                    btn_batch_gen = gr.Button("🚀 批量生成", variant="primary")
+                    btn_smart_gen = gr.Button("🧠 智能选题+生成", variant="secondary")
+            batch_result = gr.Markdown("")
+
        # ---- 事件绑定 ----

        btn_gen_copy.click(
@ -168,6 +215,120 @@ def build_tab(
            outputs=[publish_msg],
        )

+        # ---- 新增事件绑定 ----
+
+        # 智能选题推荐
+        def _on_recommend(model_name):
+            if not fn_topic_recommend:
+                return "⚠️ 选题推荐功能未连接"
+            try:
+                recommendations = fn_topic_recommend(model_name)
+                if not recommendations:
+                    return "暂无推荐选题，请先搜索热点或积累数据"
+                lines = []
+                for i, r in enumerate(recommendations, 1):
+                    angles_str = "、".join(r.get("angles", [])[:2])
+                    lines.append(
+                        f"**{i}. {r['topic']}** (评分: {r['score']})\n"
+                        f"   {r.get('reason', '')}\n"
+                        f"   💡 角度: {angles_str}"
+                    )
+                return "\n\n".join(lines)
+            except Exception as e:
+                logger.error("选题推荐失败: %s", e)
+                return f"❌ 推荐失败: {e}"
+
+        btn_recommend.click(
+            fn=_on_recommend,
+            inputs=[llm_model],
+            outputs=[topic_recommendations],
+        )
+
+        # 图文匹配度评估
+        def _on_eval_match(model_name, content, sd_prompt):
+            if not fn_evaluate_match:
+                return "⚠️ 图文匹配度评估功能未连接"
+            if not content or not sd_prompt:
+                return "请先生成文案和图片后再评估"
+            try:
+                result = fn_evaluate_match(model_name, content, sd_prompt)
+                if result.get("skipped"):
+                    return "⚠️ 评估超时或失败，已跳过"
+                score = result.get("match_score", 0)
+                suggestions = result.get("suggestions", [])
+                icon = "🟢" if score >= 80 else ("🟡" if score >= 50 else "🔴")
+                text = f"{icon} 匹配度: **{score}/100**"
+                if suggestions:
+                    text += "\n\n改进建议:\n" + "\n".join(f"- {s}" for s in suggestions)
+                if score < 50:
+                    text += "\n\n⚠️ 匹配度较低，建议重新生成图片提示词"
+                return text
+            except Exception as e:
+                return f"评估失败: {e}"
+
+        btn_eval_match.click(
+            fn=_on_eval_match,
+            inputs=[llm_model, res_content, res_prompt],
+            outputs=[match_score_display],
+        )
+
+        # 批量生成
+        def _on_batch_generate(model_name, topics_text, style_val, sd_model_name, persona_text, template):
+            if not fn_batch_generate:
+                return "⚠️ 批量创作功能未连接"
+            topics = [t.strip() for t in topics_text.strip().split("\n") if t.strip()]
+            if not topics:
+                return "❌ 请输入至少一个主题（每行一个）"
+            template_name = template if template != "(不使用模板)" else ""
+            try:
+                results, status = fn_batch_generate(
+                    model_name, topics, style_val, sd_model_name, persona_text, template_name
+                )
+                lines = [f"### {status}\n"]
+                for r in results:
+                    if "error" in r:
+                        lines.append(f"❌ **{r.get('topic', '未知')}**: {r['error']}")
+                    else:
+                        lines.append(f"✅ **{r.get('title', '无标题')}** — {r.get('topic', '')}")
+                return "\n\n".join(lines)
+            except Exception as e:
+                return f"❌ 批量生成失败: {e}"
+
+        btn_batch_gen.click(
+            fn=_on_batch_generate,
+            inputs=[llm_model, batch_topics, style, sd_model, persona, batch_template],
+            outputs=[batch_result],
+        )
+
+        # 智能选题+生成
+        def _on_smart_generate(model_name, style_val, sd_model_name, persona_text):
+            if not fn_topic_recommend or not fn_batch_generate:
+                return "⚠️ 智能选题功能未连接"
+            try:
+                recommendations = fn_topic_recommend(model_name)
+                if not recommendations:
+                    return "❌ 选题引擎未找到推荐主题"
+                # 取前 3 个推荐
+                topics = [r["topic"] for r in recommendations[:3]]
+                results, status = fn_batch_generate(
+                    model_name, topics, style_val, sd_model_name, persona_text, ""
+                )
+                lines = [f"### {status}\n", "**使用推荐选题:**"]
+                for r in results:
+                    if "error" in r:
+                        lines.append(f"❌ **{r.get('topic', '未知')}**: {r['error']}")
+                    else:
+                        lines.append(f"✅ **{r.get('title', '无标题')}**")
+                return "\n\n".join(lines)
+            except Exception as e:
+                return f"❌ 智能生成失败: {e}"
+
+        btn_smart_gen.click(
+            fn=_on_smart_generate,
+            inputs=[llm_model, style, sd_model, persona],
+            outputs=[batch_result],
+        )
+
    # 返回可能被其他 Tab 引用的组件
    return {
        "res_title": res_title,
@ -179,4 +340,5 @@ def build_tab(
        "cfg_scale": cfg_scale,
        "neg_prompt": neg_prompt,
        "enhance_level": enhance_level,
+        "cover_strategy": cover_strategy,
    }