add compute_coverage_score and cleanup script

agent/llm/claude.py

@@ -111,7 +111,8 @@ async def anthropic_native_llm_call(
     last_exception = None
     
     for attempt in range(max_retries):
-        async with httpx.AsyncClient(timeout=300.0) as client:
+        # 将默认 5 分钟超时延迟加长至 15 分钟，防止长文本输出（如 strategy.json 合成）时引发 ReadTimeout
+        async with httpx.AsyncClient(timeout=900.0) as client:
             try:
                 response = await client.post(endpoint, json=payload, headers=headers)
                 response.raise_for_status()

examples/process_pipeline/run_pipeline.py

@@ -316,10 +316,11 @@ async def main():
     # Instantiate two distinct LLM orchestrators
     qwen_model = "qwen3.5-plus"  # maps to qwen3.5-plus via Qwen interface
     
-    # 当前使用原生 Claude 接口 (走 ANTHROPIC_API_KEY)，而非 OpenRouter
-    claude_model = "claude-sonnet-4-5"  # 切换回 4-5 模型别名
-    from agent.llm.claude import create_claude_llm_call
-    claude_llm_call = create_claude_llm_call(model=claude_model)
+    # 用户指示使用 OpenRouter 代理的 Claude 4.5
+    claude_model = "anthropic/claude-4.5-sonnet"
+    args.use_claude_sdk = False  # 禁用纯 Native SDK 模式，走内部通用 AgentRunner (即可对接 OpenRouter)
+    from agent.llm.openrouter import create_openrouter_llm_call
+    claude_llm_call = create_openrouter_llm_call(model=claude_model)
     
     runner_qwen = AgentRunner(
         trace_store=store,
@@ -440,10 +441,12 @@ async def main():
             
             task_a = None
             task_b = None
+            force_strategy_rerun = False
             
             if Path(blueprint_file).exists():
                 print(f"⏭️  [Skip P2] blueprint.json already exists. Skipping P2_FilterBlueprint.")
             else:
+                force_strategy_rerun = True
                 if args.use_claude_sdk:
                     print("   > Using [Anthropic SDK Core] for P2_FilterBlueprint")
                     task_a = run_anthropic_sdk_task("filter_and_blueprint", {
@@ -462,6 +465,7 @@ async def main():
             if Path(capabilities_file).exists():
                 print(f"⏭️  [Skip P2] capabilities_extracted.json already exists. Skipping P2_ExtractCaps.")
             else:
+                force_strategy_rerun = True
                 if args.use_claude_sdk:
                     print("   > Using [Anthropic SDK Core] for P2_ExtractCaps")
                     task_b = run_anthropic_sdk_task("extract_capabilities", {
@@ -497,9 +501,12 @@ async def main():
             print(f"\n--- Phase 3: Final Strategy Assembly ({claude_model}) ---")
             strategy_file = str(output_dir / "strategy.json")
             
-            if Path(strategy_file).exists():
+            if Path(strategy_file).exists() and not force_strategy_rerun:
                 print(f"⏭️  [Skip P3] strategy.json already exists. Skipping P3_Assembler.")
             else:
+                if Path(strategy_file).exists():
+                    print(f"⚠️  [Force P3] Upstream dependencies were regenerated. Forcing re-run of P3_Assembler...")
+                
                 if args.use_claude_sdk:
                     print("   > Using [Anthropic SDK Core]")
                     phase3_cost, phase3_errs = await run_anthropic_sdk_task("assemble_strategy", {

examples/process_pipeline/script/compute_coverage_scores.py

@@ -0,0 +1,210 @@
+import json
+import sys
+import asyncio
+from pathlib import Path
+repo_root = str(Path(__file__).parent.parent.parent.parent)
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from knowhub.knowhub_db.pg_strategy_store import PostgreSQLStrategyStore
+from knowhub.knowhub_db.pg_requirement_store import PostgreSQLRequirementStore
+from agent.llm.openrouter import openrouter_llm_call
+
+OUTPUT_JSON = Path("examples/process_pipeline/script/coverage_scores.json")
+
+EVAL_PROMPT = """
+You are an expert system architecture and pipeline evaluator.
+You will be provided with a User Requirement and multiple alternative Proposed Pipeline Workflows created to resolve that requirement.
+Your task is to evaluate how well each workflow semantically covers and resolves the user's needs.
+
+User Requirement:
+{req_desc}
+
+Proposed Workflows:
+{workflows_json}
+
+For each workflow, assign a `coverage_score` between 0.00 and 1.00 (1.00 = completely and deeply resolves the core requirement).
+Return your result STRICTLY as a JSON array of objects, one for each workflow evaluated, containing:
+[
+  {{
+    "strategy_id": "<exact strategy_id from the input>",
+    "coverage_score": 0.85,
+    "explanation": "<1-2 sentence justification on what it covers well and what it might be missing>"
+  }}
+]
+DO NOT output any thinking, markdown wrapping (```json), or conversational text. Output ONLY the raw JSON array.
+"""
+
+async def process_requirement(req_desc: str, group_strats: list) -> dict:
+    # Prepare payload to send to LLM
+    workflows_payload = []
+    for s in group_strats:
+        body_data = s.get("body") or {}
+        if isinstance(body_data, str):
+            try:
+                body_data = json.loads(body_data)
+            except:
+                body_data = {}
+                
+        workflows_payload.append({
+            "strategy_id": s["id"],
+            "workflow": body_data.get("workflow", [])
+        })
+        
+    prompt = EVAL_PROMPT.format(
+        req_desc=req_desc,
+        workflows_json=json.dumps(workflows_payload, ensure_ascii=False, indent=2)
+    )
+    
+    try:
+        resp = await openrouter_llm_call(
+            messages=[{"role": "user", "content": prompt}],
+            model="anthropic/claude-sonnet-4.5",  # OpenRouter uses this to route to latest 3.5 Sonnet
+            max_tokens=4096,
+            temperature=0.1
+        )
+        content = resp["content"].strip()
+        if content.startswith("```json"):
+            content = content.replace("```json", "").replace("```", "").strip()
+        elif content.startswith("```"):
+            content = content.replace("```", "").strip()
+            
+        return json.loads(content)
+    except Exception as e:
+        print(f"  [Error] LLM Call failed for a requirement: {e}")
+        return []
+
+async def main(dry_run: bool = False, force: bool = False):
+    print("Connecting to DB...")
+    strat_store = PostgreSQLStrategyStore()
+    req_store = PostgreSQLRequirementStore()
+    
+    requirements = req_store.list_all(limit=10000)
+    strategies = strat_store.list_all(limit=10000)
+    
+    strat_map = {s["id"]: s for s in strategies}
+    
+    output_data = {}
+    if OUTPUT_JSON.exists() and not force:
+        try:
+            with open(OUTPUT_JSON, "r", encoding="utf-8") as f:
+                output_data = json.load(f)
+            print(f"Loaded existing coverage scores for {len(output_data)} requirements. Resuming...")
+        except:
+            print("Failed to load existing JSON, starting fresh.")
+    elif force:
+        print("Force run enabled. Discarding existing records and starting completely fresh.")
+            
+    processed_req_ids = set(output_data.keys())
+    
+    total_reqs = len(output_data)
+
+    # Filter out already processed requirements
+    pending_requirements = [r for r in requirements if r["id"] not in processed_req_ids]
+    
+    print(f"Starting LLM coverage semantic evaluation using Sonnet 4.5 via OpenRouter...")
+    print(f"Total Requirements remaining to evaluate: {len(pending_requirements)} (out of {len(requirements)})")
+    
+    # Process in batches of 10 concurrent requests
+    batch_size = 10
+    
+    for i in range(0, len(pending_requirements), batch_size):
+        batch_reqs = pending_requirements[i:i+batch_size]
+        tasks = []
+        
+        print(f"Evaluating Batch {i//batch_size + 1} (Reqs {i+1} to min({i+batch_size}, {len(pending_requirements)}))")
+        
+        for req in batch_reqs:
+            req_id = req["id"]
+            req_desc = req.get("description", "Unknown Description")
+            req_strat_ids = req.get("strategy_ids") or []
+            
+            group_strats = [strat_map[sid] for sid in req_strat_ids if sid in strat_map]
+            if not group_strats:
+                continue
+                
+            tasks.append((req_id, req_desc, process_requirement(req_desc, group_strats)))
+            
+        if not tasks:
+            continue
+            
+        # Execute batch concurrently
+        results = await asyncio.gather(*(t[2] for t in tasks))
+        
+        # Map results back
+        for idx, (req_id, req_desc, _) in enumerate(tasks):
+            evaluations = results[idx]
+            if not evaluations:
+                continue
+                
+            strat_results = []
+            for ev in evaluations:
+                sid = ev.get("strategy_id")
+                if sid in strat_map:
+                    strat_info = strat_map[sid]
+                    is_selected = (strat_info.get("status") == "published")
+                    strat_results.append({
+                        "strategy_id": sid,
+                        "strategy_name": strat_info.get("name", ""),
+                        "is_selected": is_selected,
+                        "coverage_score": ev.get("coverage_score", 0),
+                        "explanation": ev.get("explanation", "")
+                    })
+            
+            if strat_results:
+                strat_results.sort(key=lambda x: x["coverage_score"], reverse=True)
+                output_data[req_id] = {
+                    "requirement_desc": req_desc,
+                    "strategies": strat_results
+                }
+                total_reqs += 1
+                
+                # Write the calculated score and explanation directly back to the database body
+                updated_count = 0
+                for ev in strat_results:
+                    sid = ev["strategy_id"]
+                    if sid in strat_map:
+                        strat_info = strat_map[sid]
+                        body_data = strat_info.get("body") or {}
+                        if isinstance(body_data, str):
+                            try:
+                                body_data = json.loads(body_data)
+                            except:
+                                body_data = {}
+                        
+                        body_data.setdefault("coverage_evaluations", {})
+                        body_data["coverage_evaluations"][req_id] = {
+                            "score": ev["coverage_score"],
+                            "explanation": ev["explanation"]
+                        }
+                        
+                        if not dry_run:
+                            try:
+                                strat_store.update(sid, {"body": json.dumps(body_data, ensure_ascii=False)})
+                                strat_map[sid]["body"] = body_data  # Update local map cache
+                                updated_count += 1
+                            except Exception as e:
+                                print(f"  [Error] Failed to update body for strategy {sid}: {e}")
+                        else:
+                            updated_count += 1
+                            
+                tag_word = "[DRY-RUN] Simulated updating" if dry_run else "Updated"
+                print(f"  -> Processed requirement {req_id}: {tag_word} DB body for {updated_count} strategies.")
+                
+        # Save incrementally after every batch to prevent data loss
+        with open(OUTPUT_JSON, "w", encoding="utf-8") as f:
+            json.dump(output_data, f, ensure_ascii=False, indent=2)
+
+    print(f"Evaluated {total_reqs} requirements overall.")
+    print(f"Results {"simulated (DB untouched)" if dry_run else "and DB updates"} successfully saved to: {OUTPUT_JSON}")
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dry-run", action="store_true", help="Calculate scores and save to JSON only, do not write to DB")
+    parser.add_argument("--force", action="store_true", help="Discard existing JSON and rerun all requirements from scratch")
+    args = parser.parse_args()
+    asyncio.run(main(args.dry_run, args.force))

examples/process_pipeline/script/coverage_scores.json

@@ -0,0 +1,1489 @@
+{
+  "REQ_001": {
+    "requirement_desc": "生成人物在不同场景下呈现丰富面部表情的图片，例如夸张的痛苦、无奈、开心、困倦等神态，表情要生动传神、情绪感强烈",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-2c12f52d",
+        "strategy_name": "3D 卡通风情绪矩阵路线（皮克斯/九宫格/表情包）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求，通过四个阶段系统性地实现了角色生成、多情绪表情批量生成、场景融合和风格精调，特别强调了情绪标注驱动机制和场景道具设计，能够生成夸张痛苦、无奈、开心、困倦等丰富表情。唯一轻微不足是流程较复杂，可能增加执行时间。"
+      },
+      {
+        "strategy_id": "STRAT-0902410f",
+        "strategy_name": "锁主体身份 + 情绪 Prompt 矩阵批量路线",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过三个阶段有效实现了角色生成、六种表情一致性生成和场景融合，核心能力覆盖了用户对丰富面部表情的需求（开心、悲伤、愤怒、惊讶、委屈、无奈）。相比第一个方案，缺少了情绪标注驱动和道具设计等增强情绪表现力的机制，但流程更简洁高效。"
+      }
+    ]
+  },
+  "REQ_002": {
+    "requirement_desc": "生成人物与道具、环境或其他角色发生互动的画面，例如人物摆弄物品、与道具合影、在特定场景中做出配合动作等，画面要体现人物和周围元素之间的关联感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-96e19b67",
+        "strategy_name": "人物×场景深度融合路线",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流深度覆盖了用户需求的核心要素：通过多主体场景合成、人景融合提示词公式和光影匹配技术，系统性地实现了人物与道具/环境/角色的互动画面生成，强调关联感（光影交互、物理接触、视线呼应）和故事叙事感。唯一轻微不足是在单纯的'人物摆弄物品'这一具体动作细节控制上，可以进一步补充手部姿态精准控制的能力模块。"
+      },
+      {
+        "strategy_id": "STRAT-f84e9426",
+        "strategy_name": "MJ Omni Reference 锁主体 + Prompt 批量变体路线",
+        "is_selected": false,
+        "coverage_score": 0.38,
+        "explanation": "该工作流专注于近景人像肖像生成，核心能力集中在人脸一致性、浅景深背景虚化、表情控制和光影氛围渲染，适合生成'人物与道具合影'中的特写肖像部分。但缺乏对'人物与道具/环境互动'的核心场景合成能力，无法体现人物摆弄物品、在特定场景中做出配合动作等关联感需求，仅能满足静态合影类场景的部分需求。"
+      }
+    ]
+  },
+  "REQ_003": {
+    "requirement_desc": "生成将动物（如猫咪）拟人化扮演特定角色或情境的图片，赋予其人类的表情、姿态和道具，用来传达幽默或情感共鸣的视觉效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-38fbb4e1",
+        "strategy_name": "精品单图拟人化角色生成流派",
+        "is_selected": false,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了拟人化动物图像生成的核心需求，从角色人设构建、分层提示词工程、AI生成与一致性保持到高分辨率输出，系统性地解决了赋予动物人类表情、姿态、道具以传达幽默或情感共鸣的全流程。唯一轻微不足是未涉及动态化或视频化扩展。"
+      },
+      {
+        "strategy_id": "STRAT-4914537c",
+        "strategy_name": "文生图底帧 + 图生视频动态化路线（首尾帧/多镜头/Hailuo-Seedance-Kling）",
+        "is_selected": true,
+        "coverage_score": 0.25,
+        "explanation": "该工作流专注于非常规摄像机视角（虫眼仰拍、鸟瞰俯视、POV等）和镜头运动的生成，核心能力在于视角控制和图生视频，但完全未涉及用户需求的核心要素：动物拟人化、角色扮演、人类表情姿态赋予、道具配置等，语义覆盖度极低。"
+      }
+    ]
+  },
+  "REQ_005": {
+    "requirement_desc": "生成婚礼或节日庆典场景，背景需包含大量花卉装饰、定制发光字牌、喜字等布景元素，整体氛围感强烈，道具与场景协调统一",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-e4e136f7",
+        "strategy_name": "沉浸式花卉穹顶婚礼场景——三层立体空间叙事流派",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了婚礼场景的核心需求：通过三阶段流程系统性地生成花卉装饰底图、强化多层次花卉密度、精确植入定制发光字牌和喜字元素，并通过全局光效增强确保氛围感强烈和道具场景协调统一。唯一轻微不足是对节日庆典（如春节等中式场景）的覆盖相对较弱。"
+      },
+      {
+        "strategy_id": "STRAT-b775c852",
+        "strategy_name": "中式节日庆典喜庆场景——红金配色书法字牌流派",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流专注于中式节日庆典场景，完整覆盖了红金色调、喜字福字、花艺装饰和灯笼等传统元素的生成与植入，氛围感强烈且道具协调。但对婚礼场景（特别是西式浪漫婚礼）的覆盖不如第一个工作流全面，且缺少对多色系花卉穹顶等现代婚礼元素的深度处理。"
+      }
+    ]
+  },
+  "REQ_007": {
+    "requirement_desc": "生成真实人物在户外或特定场景中的生活记录照片，画面自然真实，包含儿童在公园、农场等户外环境中玩耍的多角度抓拍效果，光线自然，氛围温馨",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6b8ca29b",
+        "strategy_name": "专属 LoRA 精细化控制生图路线（人像/产品）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流精准覆盖用户需求的所有核心要素：使用写实模型生成真实儿童人物、明确户外场景（公园/农场）与自然光线设定、通过去油腻感处理实现自然真实效果、最终批量生成多角度抓拍组图。唯一微小不足是未明确提及温馨氛围的情感化描述，但整体技术路径完整且高度匹配需求。"
+      },
+      {
+        "strategy_id": "STRAT-f84e9426",
+        "strategy_name": "MJ Omni Reference 锁主体 + Prompt 批量变体路线",
+        "is_selected": false,
+        "coverage_score": 0.45,
+        "explanation": "该工作流专注于近景人像特写、面部表情控制和浅景深背景虚化，技术能力强大但与需求核心偏离：用户需要儿童在户外场景中玩耍的多角度生活记录照片，而该方案主要解决商业肖像、面部特写和情绪表达，缺少户外场景构建、儿童动态抓拍、多角度全身/半身构图等关键要素。"
+      }
+    ]
+  },
+  "REQ_008": {
+    "requirement_desc": "制作将真实人物照片合成到趣味场景中的创意图片，例如把人物缩小放入超市肉类托盘包装内、或与冰雕翅膀等道具结合形成视觉错位的幽默效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-1c15a66b",
+        "strategy_name": "纯 AI 一键合成路线：人物照片 → 微缩场景融合",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了人物特征保留、场景构建、比例缩放、视觉错位效果生成和细节优化的完整流程，特别强调了面部特征锁定和多工具协同（Gemini + nano banana pro），并提供了具体的提示词参数指导。唯一不足是缺少多版本生成对比机制，可能需要多次迭代才能获得最优效果。"
+      },
+      {
+        "strategy_id": "STRAT-7008f9b3",
+        "strategy_name": "场景定制增强路线：人物照片 → 指定趣味场景精准合成",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过模板化设计和多版本生成机制提供了系统化的创意图片制作方案，特别强调了氛围增强和特效叠加（如保鲜膜反光、星空背景、飘雪特效）以增强视觉冲击力。相比STRAT-1c15a66b，该方案在技术实现细节（如比例缩放参数、材质质感控制）的描述上略显简略，但在创意场景多样性和氛围营造上更具优势。"
+      }
+    ]
+  },
+  "REQ_009": {
+    "requirement_desc": "生成真实场景的多图拼贴展示图，将同一地点或主题的多张实拍照片拼合为一张图文并茂的内容图，适合用于地点打卡、产品展示或生活记录类帖子",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-d8340a6a",
+        "strategy_name": "实拍照片 + 模板工具拼贴叙事路线（Canva/醒图/ProCCD/CapCut）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了真实场景多图拼贴的核心需求，包括批量导入实拍照片、智能抠图、叙事排序、布局排版、文字标注、装饰元素等全流程，特别适合地点打卡、产品展示和生活记录类帖子。唯一轻微不足是对AI自动化程度的描述较少，更多依赖用户手动操作现有工具。"
+      },
+      {
+        "strategy_id": "STRAT-425a984a",
+        "strategy_name": "结构化 Prompt 一次直出多格/网格路线",
+        "is_selected": true,
+        "coverage_score": 0.35,
+        "explanation": "该工作流主要聚焦于AI模型一次性生成网格布局图像，适用于虚拟角色分镜、多姿态展示等AI生成场景，但不符合用户需求中'将同一地点或主题的多张实拍照片拼合'这一核心要求。该方案缺少对真实照片导入、预处理、叙事排序、图文叠加等关键环节的支持。"
+      }
+    ]
+  },
+  "REQ_010": {
+    "requirement_desc": "制作多格宫格式信息图，将同类内容（如多种食材搭配方案）拆分为统一风格的小卡片，每格包含标题、食材图片和文字说明，整体排列整齐、色块鲜明，适合一图展示多个并列条目",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-494cc29c",
+        "strategy_name": "Coze 工作流端到端批量生成路线（宫格/长图/信息可视化）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了多格宫格信息图的核心需求：从内容拆解、批量图像生成、文字渲染到网格排版和切割输出，每个阶段都针对'统一风格小卡片'和'整齐排列'的要求提供了专门工具和流程。唯一微小不足是阶段1的AI脚本生成更偏向叙事分镜，对于纯信息展示类（如食材搭配）的结构化模板支持描述不够明确。"
+      },
+      {
+        "strategy_id": "STRAT-425a984a",
+        "strategy_name": "结构化 Prompt 一次直出多格/网格路线",
+        "is_selected": true,
+        "coverage_score": 0.78,
+        "explanation": "该工作流通过AI模型一次性直出完整网格大图的方式实现了多宫格布局，并提供了网格切割和局部精修能力，基本满足整齐排列和统一风格的需求。但缺少针对'每格包含标题、食材图片和文字说明'这一核心要素的专门文字渲染阶段，且更侧重于分镜叙事场景而非信息图卡片的结构化内容组织。"
+      }
+    ]
+  },
+  "REQ_011": {
+    "requirement_desc": "在图片上叠加标注元素，如用红色圆点、箭头或emoji符号指向图中特定位置，配合说明文字，实现在真实照片上直观标记关键信息的视觉效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-805daf9b",
+        "strategy_name": "多模态AI指令驱动路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：通过自然语言指令驱动图像编辑实现标注需求解析，利用AI矢量图形生成能力精确创建箭头、圆点等标注元素，并通过图像内文字渲染实现说明文字叠加。智能标注规划阶段特别考虑了布局优化和避免遮挡，完全符合'直观标记关键信息'的视觉效果要求。"
+      },
+      {
+        "strategy_id": "STRAT-b7aa114e",
+        "strategy_name": "AI视觉理解 + 自动标注生成路线",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流同样覆盖了用户需求的主要功能点：图像理解与定位阶段实现了对特定位置的识别，标注元素生成阶段支持圆点、箭头、emoji等多种标注类型，图层合成输出阶段确保标注清晰可见。相比STRAT-805daf9b，该方案在智能布局规划和批量处理能力方面描述较少，但整体流程逻辑清晰且实用。"
+      }
+    ]
+  },
+  "REQ_012": {
+    "requirement_desc": "制作图文混排的长图文内容，将大段文字与人物照片、数据表格、流程图等多种视觉元素组合排布在同一版面中，形成类似杂志或报告的专业排版风格",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6f1bf38a",
+        "strategy_name": "杂志报告风格图文混排全流程（通用四阶段主线）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了图文混排长图的核心需求，包括多类型视觉元素生成（人物照片、数据表格、流程图）、文字精准渲染、风格统一、信息层级控制和版面自动布局合成，形成完整的端到端解决方案。唯一轻微不足是对实际杂志/报告排版中的网格系统和模块化设计规范的显式支持描述较少。"
+      },
+      {
+        "strategy_id": "STRAT-48f04a9c",
+        "strategy_name": "产品展示型长图生成（电商场景优化备选）",
+        "is_selected": false,
+        "coverage_score": 0.45,
+        "explanation": "该工作流主要聚焦于电商产品展示场景，强调产品多角度视图生成和背景替换，但缺少用户需求中核心的数据表格、流程图等多种视觉元素的生成能力，也未涉及大段文字与多元素的复杂版面布局合成，不完全匹配杂志或报告式的专业图文混排需求。"
+      }
+    ]
+  },
+  "REQ_013": {
+    "requirement_desc": "生成以暖黄/米棕色为背景底色的图文排版内容，整体画面呈现温暖、复古的暖色调氛围，适合健康养生、生活方式类主题",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-dda4228c",
+        "strategy_name": "AI图文生成+色调控制路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了暖黄/米棕色背景底色生成、图文排版、色调统一等核心需求，系统性地实现了温暖复古氛围的营造。唯一略显不足的是在主题元素和装饰风格上相对通用化，对健康养生、生活方式类主题的针对性表达稍弱。"
+      },
+      {
+        "strategy_id": "STRAT-0006cf28",
+        "strategy_name": "AI插画生成+排版合成路线",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过手绘插画、书法字体、东方美学等元素深度契合健康养生主题，复古氛围渲染到位。但工作流程从插画生成开始而非背景底色构建，在强调'背景底色'这一核心要求的优先级和系统性上略有偏差。"
+      }
+    ]
+  },
+  "REQ_014": {
+    "requirement_desc": "生成以深色（黑色/深蓝/深紫）为背景底色的海报，搭配霓虹感彩色光效（橙、紫、青等），营造出科技感强烈的冷暖对比配色效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-e5fde1dc",
+        "strategy_name": "分层精控路线",
+        "is_selected": false,
+        "coverage_score": 0.94,
+        "explanation": "该工作流通过四阶段精细化流程，将深色背景与霓虹光效分层生成并独立迭代，确保冷暖对比达到最佳视觉张力，完全契合用户对科技感强烈配色效果的需求。色彩系统搭建阶段提供了精确的配色规范和比例控制，覆盖深度和执行细节均优于另一方案。"
+      },
+      {
+        "strategy_id": "STRAT-d073b214",
+        "strategy_name": "提示词直出路线",
+        "is_selected": true,
+        "coverage_score": 0.82,
+        "explanation": "该工作流完整覆盖了深色背景、霓虹光效、冷暖对比配色的核心需求，并通过三阶段流程实现从配色方案到最终海报的完整输出。但在光效层的精细控制和迭代优化方面略显简化，可能影响冷暖对比的最佳视觉张力。"
+      }
+    ]
+  },
+  "REQ_015": {
+    "requirement_desc": "生成整体色调偏粉紫、薄荷绿、浅蓝等低饱和度冷色系的插画或场景图，画面呈现出梦幻、静谧的冷色调氛围，颜色搭配柔和克制",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-33acc2f0",
+        "strategy_name": "多阶段精准控制流派：构图生成 → 色调锁定 → 氛围增强",
+        "is_selected": true,
+        "coverage_score": 0.94,
+        "explanation": "该方案采用三阶段渐进式流程，从基础构图、精准色调锁定到梦幻氛围增强，全面覆盖了用户需求的所有维度：低饱和度冷色系（粉紫/薄荷绿/浅蓝）、梦幻静谧氛围、柔和克制的色彩搭配。通过多种能力组合（风格控制、全向参考、光照转换、柔光效果、装饰元素）实现了对色调、氛围、质感的精细化控制，能够稳定输出高质量的目标风格插画。"
+      },
+      {
+        "strategy_id": "STRAT-91477a0a",
+        "strategy_name": "单阶段精准提示词文生图路线",
+        "is_selected": false,
+        "coverage_score": 0.72,
+        "explanation": "该方案通过精准色彩语义提示词和个人化风格持久化能力，能够直接生成符合粉紫、薄荷绿、浅蓝等低饱和度冷色系的插画，并保持风格一致性。但缺少对梦幻静谧氛围的深度控制手段（如柔光效果、装饰元素等），仅依赖提示词可能在氛围营造的精准度和层次感上有所不足。"
+      }
+    ]
+  },
+  "REQ_016": {
+    "requirement_desc": "生成手部持握或展示物品的特写画面，手势自然，物品清晰呈现，如用手托举饺子、手持卡片、手握手机等，突出手与物品的互动关系",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-3b0052f8",
+        "strategy_name": "结构化提示词直接生成路线",
+        "is_selected": false,
+        "coverage_score": 0.0,
+        "explanation": "The workflow is empty and contains no steps or components to address the requirement of generating close-up images of hands holding or displaying objects with natural gestures and clear item presentation."
+      },
+      {
+        "strategy_id": "STRAT-6ada0f7a",
+        "strategy_name": "双图垫图融合路线（推荐首选）",
+        "is_selected": false,
+        "coverage_score": 0.0,
+        "explanation": "The workflow is empty and provides no pipeline or processing steps to fulfill the user's need for generating hand-object interaction imagery with emphasis on natural gestures and clear object visibility."
+      }
+    ]
+  },
+  "REQ_017": {
+    "requirement_desc": "生成多人或多只动物同框的协同姿态画面，如两只猫并排躺着穿睡衣、两人一起摆造型抱花束，呈现出同步、对称或互动的视觉效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-76111aad",
+        "strategy_name": "OpenPose + ControlNet 姿态迁移路线（多人/服装）",
+        "is_selected": true,
+        "coverage_score": 0.15,
+        "explanation": "该工作流专注于将单个人物嵌入场景容器（如托盘）的创意合成，强调人物、服装、场景三要素融合及光影一致性，但完全未涉及用户核心需求中的'多人或多只动物同框'、'协同姿态'、'同步/对称/互动效果'等多主体协同生成能力，语义覆盖严重不足。"
+      }
+    ]
+  },
+  "REQ_018": {
+    "requirement_desc": "生成创意性的嘴部动作特写，如用嘴唇衔住花朵茎部形成'嘴唇花'的视觉效果，将身体部位与物品结合产生趣味创意画面",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-0ea1c8bc",
+        "strategy_name": "精准嘴唇衔花特写生成流派（参数锚定 × 接触关系精控 × 氛围精修）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过全向参考和主体一致性锁定花朵与嘴唇的视觉目标，通过结构控制和新增的'人体与物品接触关系精准生成'能力精确实现嘴唇衔花的物理接触效果，通过局部特写构图能力聚焦嘴部动作，最后通过局部重绘、细节增强、光照转换和风格控制完成氛围优化。唯一微小不足是对表情情绪层面的控制描述相对较少。"
+      },
+      {
+        "strategy_id": "STRAT-f84e9426",
+        "strategy_name": "MJ Omni Reference 锁主体 + Prompt 批量变体路线",
+        "is_selected": false,
+        "coverage_score": 0.42,
+        "explanation": "该工作流聚焦于人像面部表情、构图、光影和胶片质感的精准控制，适合生成高质量近景人像肖像，但完全未涉及用户需求的核心创意元素——'嘴唇衔住花朵茎部'这一身体部位与物品结合的趣味创意画面，缺少对物品道具（花朵）及其与嘴部接触关系的生成能力支持。"
+      }
+    ]
+  },
+  "REQ_019": {
+    "requirement_desc": "将人物照片与中国传统吉祥符号（如双喜字、红玫瑰、金色祝福文字）融合，生成具有强烈喜庆氛围的定制化图案，人物面孔清晰嵌入红色喜庆背景中",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-505c2718",
+        "strategy_name": "直接融合生成路线",
+        "is_selected": true,
+        "coverage_score": 0.72,
+        "explanation": "该工作流覆盖了提示词构建、AI生成融合图像和细节优化三个核心阶段，能够实现人物与喜庆元素的融合生成。但缺少对用户提供的真实人物照片的直接处理能力（如人脸提取、特征保持），主要依赖文本描述而非真实照片输入，可能导致生成人物与原照片相似度不足。"
+      }
+    ]
+  },
+  "REQ_020": {
+    "requirement_desc": "制作统一模板风格的系列信息卡片，每张卡片包含固定的图标符号（如皇冠等级图标）、彩色标题文字和配图，整体视觉风格一致、可批量复用",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-441008e2",
+        "strategy_name": "LLM + Canva 模板驱动批量合成路线",
+        "is_selected": true,
+        "coverage_score": 0.72,
+        "explanation": "该工作流覆盖了批量生成、统一视觉风格、图标符号叠加、彩色标题文字等核心需求，特别是通过Canva Bulk Create实现了模板复用和批量产出。但工作流过于复杂，包含了多图拼贴、信息分区等用户需求中未明确要求的功能，且聚焦于复杂海报制作而非简洁的系列信息卡片，部分阶段（如多图网格拼贴）偏离了'固定图标+彩色标题+配图'的简单卡片结构核心诉求。"
+      }
+    ]
+  },
+  "REQ_022": {
+    "requirement_desc": "生成宠物或动物穿戴人类服饰配件（如帽子、围巾）的画面，让动物看起来像在过节或扮演某种角色，整体效果可爱又有趣",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-e1903c78",
+        "strategy_name": "IP-Adapter 主体/风格迁移路线（动画/换装/风格统一）",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过阶段1的角色扮演场景生成能力直接实现动物穿戴服饰配件的可爱有趣效果，阶段2的姿态控制确保服饰配件与动物身体自然契合，阶段3的动画生成提供了超出基础需求的增强价值。唯一轻微不足是阶段3的动画能力虽然增值明显但对于静态画面生成的核心需求来说属于可选扩展而非必需。"
+      }
+    ]
+  },
+  "REQ_023": {
+    "requirement_desc": "生成将普通服装或日常物品以夸张搞怪方式穿戴的人物画面，比如把超大号短裤当长袍穿、用篮球短裤模仿古希腊长袍，产生强烈的视觉反差和幽默效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-f921299a",
+        "strategy_name": "纯图像超现实错位穿戴路线",
+        "is_selected": false,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完全覆盖用户需求的核心要素：通过精准提示词构建'日常物品错位穿戴'的荒诞场景（阶段1），使用文生图直接生成夸张穿搭人物画面（阶段2），并通过光影色彩强化视觉反差和幽默效果（阶段3）。工作流直接针对'超大号短裤当长袍'等具体场景设计，能够产生强烈视觉反差，唯一微小不足是未涉及动态视频生成。"
+      },
+      {
+        "strategy_id": "STRAT-4914537c",
+        "strategy_name": "文生图底帧 + 图生视频动态化路线（首尾帧/多镜头/Hailuo-Seedance-Kling）",
+        "is_selected": true,
+        "coverage_score": 0.25,
+        "explanation": "该工作流专注于非常规摄像机角度和POV视角生成（虫眼仰拍、鸟瞰俯视、第一人称视角等），虽然技术能力强大，但与用户需求'夸张搞怪方式穿戴日常物品产生幽默效果'的核心诉求严重不匹配。工作流重点在于视角转换而非服装穿戴的创意错位，仅在极少数情况下可能间接辅助呈现夸张穿搭效果。"
+      }
+    ]
+  },
+  "REQ_024": {
+    "requirement_desc": "生成具有超现实风格的创意合成画面，将人物头部替换为宇宙星云、太极图、粒子爆炸等抽象元素，配合深蓝红色调背景，营造出哲学感或科幻感的视觉冲击",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-d41e55b3",
+        "strategy_name": "分步合成路线",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该方案采用分阶段流程，通过独立生成人物身体、抽象元素素材库，再使用局部重绘精准替换头部，最后统一色调和氛围渲染，完整覆盖用户需求的所有关键要素。分步控制使头部替换更精准、融合更自然，且能灵活调整各抽象元素，唯一不足是流程相对复杂需要多步操作。"
+      },
+      {
+        "strategy_id": "STRAT-5a38e3fc",
+        "strategy_name": "直接生成路线",
+        "is_selected": true,
+        "coverage_score": 0.75,
+        "explanation": "该方案通过单次精细提示词生成完整画面，能够直接实现头部抽象元素替换、深蓝红色调背景和超现实风格，效率高且风格统一。但依赖AI模型一次性理解复杂提示词，对头部替换的精准控制和边缘融合效果可能不如分阶段处理稳定。"
+      }
+    ]
+  },
+  "REQ_025": {
+    "requirement_desc": "生成穿着完整冬季搭配的人物形象，展示黑色羽绒服、红色围巾、红色手套、宽腿裤等单品的组合穿搭效果，呈现从全身到局部细节的多角度造型展示",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-795a1faa",
+        "strategy_name": "提示词工程直接生成路线",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过结构化提示词精准生成黑色羽绒服、红色围巾、红色手套、宽腿裤等单品组合，材质物理属性模拟确保羽绒服蓬松度和围巾纹理真实呈现，冬季场景氛围构建提供完整视觉语境，多景别构图生成实现从全身到局部细节的15张多角度展示。唯一微小不足是未明确提及换装流程的灵活性控制。"
+      },
+      {
+        "strategy_id": "STRAT-e3232f37",
+        "strategy_name": "人物固定+多角度换装路线",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流采用分阶段生成策略，通过基础人物模板+服装层替换+多角度扩展的流程实现需求，能够生成目标冬季搭配并保持人物一致性，最终输出15张多角度展示图。但相比第一个方案，在材质物理属性模拟（羽绒服蓬松度、围巾纹理）和冬季氛围场景构建方面的技术深度和系统性描述略显不足，可能影响冬季服装质感的最终呈现效果。"
+      }
+    ]
+  },
+  "REQ_026": {
+    "requirement_desc": "生成宠物穿着服装的可爱造型图，展示猫咪穿上印花连体衣的整体穿着效果，需要清晰呈现服装的图案、版型与宠物身体的贴合细节",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-f5c616fe",
+        "strategy_name": "AI文生图路线(从零生成)",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流直接针对宠物穿着服装效果图生成，明确包含服装印花图案精准还原能力和版型贴合控制，通过精准提示词构建和姿态控制实现清晰呈现服装细节的核心需求；唯一不足是缺少对连体衣特定版型（如袖口、裤腿贴合）的专项优化说明。"
+      },
+      {
+        "strategy_id": "STRAT-86d1256a",
+        "strategy_name": "主体一致性 + Inpaint 局部换装/换景路线",
+        "is_selected": true,
+        "coverage_score": 0.65,
+        "explanation": "该工作流专注于多职业造型批量生成，通过局部重绘和道具叠加实现多样化输出，但核心需求是单一印花连体衣的穿着效果展示，而非多职业场景；工作流在服装图案精准还原和版型贴合细节方面缺乏针对性能力支撑。"
+      }
+    ]
+  },
+  "REQ_027": {
+    "requirement_desc": "生成创意合成图，将人物穿搭形象嵌入特定场景容器中（如超市生鲜托盘），使人物服装与场景产生趣味性视觉对比，同时保留服装细节的清晰可见",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-76111aad",
+        "strategy_name": "OpenPose + ControlNet 姿态迁移路线（多人/服装）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过三要素分层准备实现人物、服装、场景容器的精确控制；使用ControlNet OpenPose确保姿态和透视关系正确；通过FLORA AI和ComfyUI Redux实现高质量融合合成；特别强调了服装细节保留和光影一致性处理。唯一微小不足是未明确提及最终输出的趣味性视觉对比效果的验证机制。"
+      }
+    ]
+  },
+  "REQ_028": {
+    "requirement_desc": "将猫咪表情包图片与各种场景素材（办公室、食物、产品、背景环境等）合成拼贴在一起，让猫咪看起来自然地处于这些场景中，形成多格并排的拼贴版式",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-e9ec0dad",
+        "strategy_name": "AI人宠合照专业模型路线（高质量型）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流更贴近用户需求的核心场景，通过双素材准备（猫咪+场景背景图）直接进行AI合成，流程更直观高效。覆盖了抠图、透视光影校正、批量迭代和多格拼贴的完整链路，且强调了场景素材的多样性准备，与用户要求的'与各种场景素材合成'高度契合。"
+      },
+      {
+        "strategy_id": "STRAT-7fd1acde",
+        "strategy_name": "AI图生图场景融合路线（通用型）",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流完整覆盖了从猫咪抠图、场景提示词构建、AI批量合成到多格拼贴的全流程，特别强调了批量生成和自动化处理。略微不足在于阶段2构建提示词矩阵的方式相对间接，需要用户自行准备场景描述而非直接使用现成场景素材。"
+      }
+    ]
+  },
+  "REQ_029": {
+    "requirement_desc": "把猫咪图片与各类装扮道具（帽子、眼镜、服装、假发等）或其他卡通/玩具素材叠加合成，让不同来源的素材无缝融合成一张完整的搞笑图",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-86d1256a",
+        "strategy_name": "主体一致性 + Inpaint 局部换装/换景路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该方案完整覆盖了用户需求的核心：保持原始猫咪图片不变，通过局部重绘技术在指定区域精准添加帽子、眼镜、服装等道具，实现真正的素材叠加合成。支持批量处理和多道具分步叠加，完美契合'不同来源素材无缝融合'的要求。"
+      },
+      {
+        "strategy_id": "STRAT-e1903c78",
+        "strategy_name": "IP-Adapter 主体/风格迁移路线（动画/换装/风格统一）",
+        "is_selected": false,
+        "coverage_score": 0.65,
+        "explanation": "该方案侧重于AI生成完整的角色扮演场景，通过提示词和模型生成猫咪穿戴装扮的整体图像，但不是真正的素材叠加合成。缺少对用户提供的原始猫咪图片与外部道具素材进行无缝融合的核心能力，更多是重新生成而非合成。"
+      }
+    ]
+  },
+  "REQ_030": {
+    "requirement_desc": "在同一张图中将多只猫咪或同一只猫咪的不同姿态照片拼接组合，配合文字标注形成对话或对比效果的多格拼图",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-425a984a",
+        "strategy_name": "结构化 Prompt 一次直出多格/网格路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了多猫咪拼图的核心需求：通过AI模型一次性生成网格大图，支持角色一致性保持（同一只猫的不同姿态），提供网格切割和高清输出。唯一不足是文字标注功能未明确提及专门的文字渲染工具，可能需要在提示词中实现或后期添加。"
+      },
+      {
+        "strategy_id": "STRAT-494cc29c",
+        "strategy_name": "Coze 工作流端到端批量生成路线（宫格/长图/信息可视化）",
+        "is_selected": true,
+        "coverage_score": 0.88,
+        "explanation": "该工作流提供了完整的端到端解决方案，特别强调了文字标注（阶段3专门的图像内文字渲染）和网格布局排版，完全满足对话或对比效果需求。但其侧重于AI脚本生成和批量处理流程，对于用户已有猫咪照片的拼接场景（非AI生成）的支持不如STRAT-425a984a直接。"
+      }
+    ]
+  },
+  "REQ_033": {
+    "requirement_desc": "在真实物体照片上叠加手绘风格的简笔画元素，例如在猕猴桃切片上添加卡通五官和小触角，让照片呈现出实物与手绘结合的趣味效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-10a9da66",
+        "strategy_name": "双工具协作精细化策略（Nano Banana + Adobe Firefly）",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过图像局部重绘保留真实物体照片底图，通过手绘笔触生成和卡通拟人化元素生成实现简笔画叠加（五官、触角等），并通过风格控制确保手绘与照片融合的趣味效果。唯一轻微不足是阶段1的语义分析描述较为抽象，实际实现路径可更具体化。"
+      }
+    ]
+  },
+  "REQ_034": {
+    "requirement_desc": "生成真实户外场景中的人物活动照片，画面要呈现自然光线下的街道、公园、游乐场等具体地点环境，人物动作自然生动，背景环境细节丰富真实",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6881b31c",
+        "strategy_name": "混合素材增强路线（有实景素材）",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过实景素材采集、光照分析、物理真实性关键词注入和运动关键帧设置，能够生成高度真实的户外场景人物活动内容，背景环境细节来自真实素材保证了丰富性和真实性，但流程较复杂且依赖实景素材的前期准备。"
+      },
+      {
+        "strategy_id": "STRAT-a5b959a8",
+        "strategy_name": "纯提示词驱动路线（从零生成）",
+        "is_selected": true,
+        "coverage_score": 0.82,
+        "explanation": "该工作流通过构建包含7大核心要素的精准提示词框架，系统性地覆盖了地点、光线、环境细节、人物动作等所有需求维度，能够直接生成高质量户外人物活动照片，但完全依赖提示词工程可能在极端真实感和物理准确性上略逊于混合实景素材的方案。"
+      },
+      {
+        "strategy_id": "STRAT-59a75d98",
+        "strategy_name": "参考图复刻路线（有参考素材）",
+        "is_selected": false,
+        "coverage_score": 0.72,
+        "explanation": "该工作流通过参考图复刻和详细提示词工程能够生成具有自然光线和丰富环境细节的户外人物照片，但其核心依赖参考图上传，限制了从零开始创作多样化场景的灵活性，且缺少对真实物理光照和景深的深度控制。"
+      }
+    ]
+  },
+  "REQ_035": {
+    "requirement_desc": "生成多人聚集的活动现场图，如会议、展览、户外聚会等场景，画面中需要呈现多个人物同框、有组织的群体互动氛围，背景有明显的活动标识或场地特征",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-ce4ef3f5",
+        "strategy_name": "草图布局驱动路线：ControlNet + 分区控制精准生成流",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流从草图布局设计开始，通过姿态与分区控制、细节生成与风格统一，全面覆盖了多人位置关系、群体互动氛围、活动标识和场地特征的所有核心需求，并提供可选的动态化与合成能力，语义覆盖度最高且流程更加系统化。"
+      },
+      {
+        "strategy_id": "STRAT-5fe35cac",
+        "strategy_name": "参数公式直出路线：模型优选 + 可视化分区 + 批量筛选流",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流通过模型选择、可视化分区固定和批量生成筛选三个阶段，完整覆盖了多人同框、群体互动氛围和人脸修复的核心需求，但对活动标识和场地特征的生成控制较为隐含，缺少明确的背景细节控制步骤。"
+      }
+    ]
+  },
+  "REQ_036": {
+    "requirement_desc": "生成真实物品的特写或陈列展示图，物品摆放清晰、细节可辨，适合用于产品展示或场景道具呈现，画面构图干净突出主体",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-744c86a3",
+        "strategy_name": "摄影级产品特写路线（微距/材质/工作室布光）",
+        "is_selected": false,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过三阶段流程系统性地实现了产品特写生成（材质定义、构图控制）、光影质感强化（精准光照、无景深全画面清晰）、细节层次叠加（8K输出、微观纹理），特别强调了'细节可辨'和'构图干净突出主体'的要求。唯一微小不足是部分能力（如爆炸分解图）超出了基础产品陈列展示的范畴，但不影响核心需求的完整实现。"
+      },
+      {
+        "strategy_id": "STRAT-d37d2be3",
+        "strategy_name": "高端产品爆炸图信息图流派",
+        "is_selected": false,
+        "coverage_score": 0.72,
+        "explanation": "该工作流能够生成高质量的产品特写图（阶段1覆盖了8K分辨率、超写实质感、清晰边缘等核心要求），但后续阶段（爆炸图、动态效果）偏离了用户'真实物品陈列展示'的静态特写需求。工作流重点放在了产品分解和动态展示上，而非单纯的'摆放清晰、细节可辨'的静态陈列，导致整体语义覆盖度降低。"
+      }
+    ]
+  },
+  "REQ_037": {
+    "requirement_desc": "生成同一人物在同一场景中多角度、多姿态的即时抓拍效果图，画面呈现自然随意的动态感，如行走、转身、低头、仰望等非摆拍状态，整体风格真实生活化",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-3c6df37a",
+        "strategy_name": "Nano Banana Pro 参数化多视角/多姿态批量路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过JSON结构化提示词确保人物一致性，系统化设计多姿态（行走、转身、低头、仰望等非摆拍状态）和多角度方案，并通过拼贴生成实现同场景多视角输出，最后进行人脸修复保证真实生活化效果。唯一可能的改进空间在于场景一致性的显式控制机制未单独强调，但整体方案已通过背景参数锁定解决。"
+      }
+    ]
+  },
+  "REQ_038": {
+    "requirement_desc": "生成动物（如马）在运动瞬间被捕捉的高动态画面，鬃毛飞扬、肢体伸展，呈现出强烈的瞬间张力和动感，背景简洁以突出主体动态",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-9b4cae79",
+        "strategy_name": "静态高动态图像流派：专业摄影级瞬间张力捕捉",
+        "is_selected": true,
+        "coverage_score": 0.98,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过阶段1-2精确构建高动态运动瞬间（鬃毛飞扬、肢体伸展）和专业摄影参数模拟实现瞬间张力捕捉，阶段3的光线氛围定调和阶段4的毛发动态及粒子特效强化完美呈现动感，阶段1明确的简洁背景策略突出主体，阶段5的高分辨率输出和全向参考确保最终质量。唯一微小不足是未明确提及后期微调迭代机制，但整体语义覆盖极其完整且具备可执行性。"
+      }
+    ]
+  },
+  "REQ_039": {
+    "requirement_desc": "生成人物在真实日常场景（街头、公园、机场等）中被随手拍下的多张图片拼贴效果，画面构图不刻意、视角多变（含俯拍脚部、镜中自拍、远景抓拍等），整体呈现出碎片化的生活记录感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-07cdf8b9",
+        "strategy_name": "多视角生活拼贴自动化流派",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：真实日常场景库（街头、公园、机场等）、多变视角（俯拍脚部、镜中自拍、远景抓拍）、非刻意构图（candid/unposed）、碎片化拼贴布局（不对称、尺寸随机）以及胶片质感增强。唯一微小不足是未明确提及镜中自拍等特定视角的技术实现细节，但整体语义覆盖极为完整且具备可执行性。"
+      }
+    ]
+  },
+  "REQ_040": {
+    "requirement_desc": "制作图文卡片时，需要让插图与文字在语义上高度呼应——比如用可爱小驴的不同表情和动作配合对应的幽默文字，每张小卡片中图在上、文字在下，插图内容直接反映文字含义，形成一眼就能看懂的图文配合效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-23d50376",
+        "strategy_name": "全自动批量语义驱动图文卡片流水线（Lovart + Nano Banana）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：通过元提示词规范确保风格一致性，批量生成多情绪小驴表情集建立可复用资产，利用Lovart的语义驱动能力实现文案与插图的精准呼应，并通过AI辅助排版自动完成'图上文下'布局合成与批量导出。唯一微小不足是阶段划分较细，可能增加初学者理解成本。"
+      },
+      {
+        "strategy_id": "STRAT-fd507b56",
+        "strategy_name": "精品单卡语义匹配路线（Midjourney 图集 + 逐张情绪匹配）",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流同样覆盖了核心需求：建立小驴情绪图集、实现图文语义匹配、完成AI辅助排版合成。但相比STRAT-23d50376，缺少了阶段1的元提示词规范设计环节，在风格一致性保障和批量自动化流程的系统性描述上略显不足，更依赖人工标注情绪标签进行匹配。"
+      }
+    ]
+  },
+  "REQ_041": {
+    "requirement_desc": "制作多图拼贴帖子时，需要将多张照片或截图按照叙事顺序排列在一张大图中，并在关键图片上叠加说明性文字标注，让图片和文字共同讲述一个完整故事，文字起到补充说明和情感点评的作用",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-d8340a6a",
+        "strategy_name": "实拍照片 + 模板工具拼贴叙事路线（Canva/醒图/ProCCD/CapCut）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：多图按叙事顺序排列（阶段2的叙事排序规划和布局排版）、关键图片上叠加说明性文字标注（阶段3的文字叠加与情感标注）、文字起到补充说明和情感点评作用（碎碎念式标注）。工作流还额外提供了抠图、色调调整、装饰元素等增强功能，使最终输出更专业。唯一微小不足是阶段1的抠图预处理对于某些简单拼贴场景可能是可选而非必需的。"
+      }
+    ]
+  },
+  "REQ_042": {
+    "requirement_desc": "制作信息图文海报时，需要将大标题、分类小标题与正文段落按照清晰的层级排布在版面上，标题用大字醒目展示，正文紧跟其下，整体版面分区明确、图文对应，让读者能快速扫读获取信息",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-c5ac801a",
+        "strategy_name": "参考图引导生成路线（版式迁移·稳定可控）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了信息图文海报制作的核心需求，包括层级排布、标题醒目展示、版面分区明确和图文对应等关键要素，并通过五个阶段系统性地实现从生成到精修的完整流程。唯一轻微不足是对快速扫读的视觉引导路径设计可以更明确地体现在具体执行步骤中。"
+      }
+    ]
+  },
+  "REQ_043": {
+    "requirement_desc": "在图片上叠加标题文字，文字大小、粗细、颜色各异，形成层次感强的排版效果——例如大标题用粗体醒目字体，副标题用细体小字，整体风格统一（如深色系商务风或简约设计风）",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-941dc269",
+        "strategy_name": "蓝图A：纯AI自动生成路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过AI自动化实现多层次文字排版（大标题粗体、副标题细体）、自动匹配字体颜色大小形成层次感、并支持统一风格（商务风/简约风）。唯一轻微不足是对手动精细调整参数（如具体字距、行距数值）的控制粒度描述较少。"
+      },
+      {
+        "strategy_id": "STRAT-6d8e64bb",
+        "strategy_name": "蓝图B：智能修复增强路线",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流详细覆盖了文字叠加的参数化实现（字体选择、字重、字距、行距等具体数值），并通过阴影、透明度等技术强化层次感，满足统一风格需求。相比第一个方案，其依赖更多手动操作而非AI自动化，在智能化程度上略逊一筹，但在精细控制方面更具优势。"
+      }
+    ]
+  },
+  "REQ_044": {
+    "requirement_desc": "在AI生成的卡通角色图片上叠加幽默吐槽文案，文字直接覆盖在图片上方，字体简洁白色，与画面情绪呼应，形成图文结合的表情包风格内容",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-ff13853b",
+        "strategy_name": "路线A：提示词驱动的图文一体化生成（推荐）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流通过精准提示词工程实现AI一次性生成图文结合内容，完整覆盖了卡通角色生成、幽默文案创作、文字叠加和情绪匹配等核心需求，且强调文字与画面的视觉互动关系。唯一的潜在风险是依赖AI模型的文字渲染能力，可能在中文字体精准控制上存在局限性。"
+      },
+      {
+        "strategy_id": "STRAT-ff97a911",
+        "strategy_name": "路线B：AI智能后处理叠加",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流采用分阶段方法，先生成角色底图，再通过多模态AI识别情绪并生成文案，最后使用专业工具叠加文字，流程清晰且可控性强。相比一次性生成方案，该方法在文字渲染质量和位置精准度上更有保障，但增加了工作流复杂度和人工介入环节。"
+      }
+    ]
+  },
+  "REQ_045": {
+    "requirement_desc": "制作多宫格拼图帖子，每格图片配有对应的标题文字或字幕说明，文字风格统一，整体排列整齐，适合用于周记、日历、流程说明等系列内容展示",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-494cc29c",
+        "strategy_name": "Coze 工作流端到端批量生成路线（宫格/长图/信息可视化）",
+        "is_selected": true,
+        "coverage_score": 0.98,
+        "explanation": "该工作流完整覆盖了多宫格拼图帖子制作的所有核心需求：从主题拆解、批量图像生成、统一风格控制、文字渲染嵌入、网格布局排版到最终切割输出，形成完整闭环，特别适合周记、日历、流程说明等系列内容展示。唯一微小不足是未明确提及用户自定义文字样式的灵活性调整接口。"
+      }
+    ]
+  },
+  "REQ_047": {
+    "requirement_desc": "制作数据报告类图文内容：包含柱状图、饼图、折线图、词云图、环形图等多种数据可视化图表，配合标题、要点文字说明，整体呈现专业研究报告的视觉风格，色彩搭配统一（如蓝紫色系或橙色系）",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-ce0c37dd",
+        "strategy_name": "数据驱动 AI 图表/报告生成路线（多图表 + 词云 + 美化重构）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：多种图表类型生成（柱状图、饼图、折线图、词云图、环形图）、统一色彩配色方案（蓝紫色系/橙色系）、标题与要点文字说明、以及专业研究报告的整体视觉风格排版。工作流结构清晰，从数据分析、图表生成、文字配套到最终排版输出形成完整闭环，且提供了多种工具实现路径（DeepSeek/ChatGPT、Nano Banana、镝数图表等），具备很强的可操作性。唯一微小不足是在环形图的具体生成细节上着墨较少，但整体能力已充分满足需求。"
+      }
+    ]
+  },
+  "REQ_048": {
+    "requirement_desc": "制作流程图/架构示意图：用箭头、方框、层级结构或立体堆叠图形展示系统架构、业务流程或概念层级关系，配合文字标注说明各模块功能，视觉上清晰呈现逻辑关系",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-360e072f",
+        "strategy_name": "参考图逆向复刻流派：草图/截图→AI识别→可编辑数字图表",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "This workflow directly addresses the core requirement of creating flowcharts/architecture diagrams with arrows, boxes, hierarchical structures through AI-powered diagram recognition and iterative editing. It excels at converting sketches to editable diagrams and enabling conversational refinement, though it focuses more on diagram editing than initial creation from scratch."
+      },
+      {
+        "strategy_id": "STRAT-cde98036",
+        "strategy_name": "LLM 生成代码 → 渲染为图路线（HTML/SVG/Code Interpreter）",
+        "is_selected": true,
+        "coverage_score": 0.45,
+        "explanation": "This workflow is designed for creating magazine-style infographics with fantasy illustrations and long-form content layouts, which diverges significantly from the requirement of creating technical flowcharts/architecture diagrams with arrows, boxes, and hierarchical structures. While it produces visual content with text annotations, it does not address system architecture visualization or business process flowcharts."
+      }
+    ]
+  },
+  "REQ_049": {
+    "requirement_desc": "将整个帖子内容拆分为多个独立小格子并排列成网格或矩阵布局，每个格子承载一个独立的场景或信息单元，格子之间有明显的分隔边界，整体看起来像一张由多张小图拼合而成的大图",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-425a984a",
+        "strategy_name": "结构化 Prompt 一次直出多格/网格路线",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过阶段1明确网格布局和内容拆分逻辑，阶段2使用AI模型一次性生成完整网格大图（多个独立场景单元、清晰分隔边界），阶段3进行质检和局部精修，阶段4支持高清输出和可选的网格拆解。唯一轻微不足是对于非AI直出场景（如手动拼接多张独立图片）的覆盖较少，但整体已深度满足'多个独立小格子排列成网格、格子间有明显分隔边界、像多张小图拼合成大图'的核心诉求。"
+      }
+    ]
+  },
+  "REQ_050": {
+    "requirement_desc": "在同一张图中混合使用多种内容载体形式，例如将真实照片、插画角色、产品图、文字说明、图表等不同类型的视觉元素组合排布在同一个版面内，形成图文混排的丰富视觉层次",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6aeb80a1",
+        "strategy_name": "QA Agent 闭环信息图/海报自动化路线",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了多种内容载体混排的核心需求，从版面信息架构规划、多类型视觉元素分区生成、品牌化约束注入到质量校验与批量输出，形成完整的端到端流程。特别是通过AI版面自动排布、多主体场景合成、图像内文字渲染等能力，能够在单一版面内有效整合真实照片、插画、产品图、文字说明、图表等多种视觉元素，并通过QA代理机制确保输出质量。唯一微小不足是对手工精修环节的描述相对较少。"
+      },
+      {
+        "strategy_id": "STRAT-1b504a8e",
+        "strategy_name": "AI提示词驱动混合媒体拼贴创意流派",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流通过内容载体清单化、多载体混排核心提示词构建、风格参考锚定和局部元素精修四个阶段，有效实现了多种视觉元素的混合排布。特别强调了混合媒体拼贴美学和分层叙事构图生成能力，能够在单次生成中融合照片、插画、几何图形、文字等多种载体。相比第一个工作流，该方案更侧重提示词工程和风格控制，但在自动化版面规划、品牌化约束注入和系统性质量校验方面的覆盖深度略显不足。"
+      }
+    ]
+  },
+  "REQ_051": {
+    "requirement_desc": "以统一的视觉主角（如同一个卡通角色、同一个人物、同一主题场景）贯穿多个分格画面，每个格子呈现该主角在不同场景或状态下的样子，配合文字说明形成系列感强的多格叙事版式",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-1d3bf349",
+        "strategy_name": "工业化路线：角色资产先行 + 分镜批量生成",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：通过角色设定卡生成统一视觉主角，多格叙事分镜版式自动编排实现系列感强的叙事结构，批量生成保持角色一致性，并配合文字说明和对话气泡形成完整多格叙事版式。六个阶段从角色锁定、分镜规划、批量生成、场景连贯、文字排版到质检修复形成完整闭环，深度解决了统一主角贯穿多格的技术难点。"
+      },
+      {
+        "strategy_id": "STRAT-007e744f",
+        "strategy_name": "轻量直出路线：单Prompt多格叙事一次成型",
+        "is_selected": false,
+        "coverage_score": 0.78,
+        "explanation": "该工作流覆盖了核心需求的主要环节：通过结构化prompt实现单次多格生成，保持角色一致性和文字叙事排版。但相比第一个方案，缺少专门的角色设定卡生成阶段和跨格场景连贯性约束机制，且没有批量自动化工作流支持，在处理复杂多格叙事（如25宫格）时的系统性和可扩展性较弱。"
+      }
+    ]
+  },
+  "REQ_052": {
+    "requirement_desc": "将多张图片按网格或分区方式拼贴成一张图，每个区域展示不同角度或不同场景，整体画面有清晰的分割感和节奏感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-13eb963a",
+        "strategy_name": "叙事性场景拼贴流派（Bento-grid 不规则布局）",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该方案深度覆盖了用户需求的核心要素：通过bento-grid不规则布局实现清晰分割感，通过Hero Cell和Feature Cell的大小差异化创造视觉节奏，通过色调统一和风格一致性保证整体协调。唯一轻微不足是对传统规则网格（如3x3）的支持描述相对较少，更侧重不规则布局。"
+      },
+      {
+        "strategy_id": "STRAT-425a984a",
+        "strategy_name": "结构化 Prompt 一次直出多格/网格路线",
+        "is_selected": true,
+        "coverage_score": 0.88,
+        "explanation": "该方案完整覆盖了网格拼贴的技术实现路径，特别强调了3x3/5x5等规则网格的一次性生成能力和角色一致性保持，符合用户对多角度/多场景展示的需求。但在'清晰分割感和节奏感'的设计层面（如不规则布局、视觉层级强化）的阐述不如STRAT-13eb963a深入。"
+      }
+    ]
+  },
+  "REQ_054": {
+    "requirement_desc": "生成包含多个独立小格子的图文排版画面，每个格子内有图片和文字说明，格子之间疏密有致、整齐排列，整体呈现信息图表或内容合集的视觉效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-cde98036",
+        "strategy_name": "LLM 生成代码 → 渲染为图路线（HTML/SVG/Code Interpreter）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过LLM进行内容结构化拆解为多个独立板块，AI生成HTML实现多格子布局和疏密排列，奇幻风格插画生成确保每个格子内有图片和文字说明，QA评分保证视觉质量，最终导出PNG长图呈现信息图表效果。唯一小缺陷是案例更侧重心理学科普长图，但技术能力完全适用于通用信息图表和内容合集场景。"
+      },
+      {
+        "strategy_id": "STRAT-74369213",
+        "strategy_name": "AI分镜逻辑驱动的多格子视频生成路线",
+        "is_selected": false,
+        "coverage_score": 0.45,
+        "explanation": "该工作流主要针对视频分镜和动态场景生成，使用9宫格/25宫格布局实现视觉统一，但核心是AI视频生成而非静态图文排版。虽然提到格子布局和场景说明，但缺少文字排版、信息图表设计、静态图文混排等用户需求的核心要素，更适合短片制作而非信息图表生成。"
+      }
+    ]
+  },
+  "REQ_055": {
+    "requirement_desc": "生成人物局部特写画面，如放大呈现嘴巴咬食物、手持物品、耳朵佩戴饰品、鼻子、指甲等身体局部细节，画面填充感强，细节清晰可见",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6b8ca29b",
+        "strategy_name": "专属 LoRA 精细化控制生图路线（人像/产品）",
+        "is_selected": true,
+        "coverage_score": 0.15,
+        "explanation": "该工作流专注于生成儿童户外全身/半身照片，强调自然光线、场景氛围和多角度抓拍，但完全未涉及用户核心需求——身体局部特写（嘴巴、手部、耳朵、鼻子、指甲等）的放大呈现和细节填充，语义方向偏离严重。"
+      },
+      {
+        "strategy_id": "STRAT-c2bf1271",
+        "strategy_name": "提示词驱动极端特写路线",
+        "is_selected": false,
+        "coverage_score": 0.0,
+        "explanation": "该工作流为空，未提供任何阶段或工具配置，完全无法满足用户需求。"
+      }
+    ]
+  },
+  "REQ_056": {
+    "requirement_desc": "生成人物近景半身或胸部以上的画面，突出人物面部表情和情绪，背景适当虚化，让观看者能清楚看到人物的神态与互动感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6b3e3450",
+        "strategy_name": "情绪驱动型近景肖像策略",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流语义覆盖度最高，完美匹配用户需求：阶段1明确情绪基调与近景构图框架，阶段2构建光线与背景虚化参数直接对应'背景适当虚化'需求，阶段3注入情绪细节与皮肤质感深度实现'突出面部表情和情绪、清楚看到神态'，阶段4质检兜底确保商业级输出。流程逻辑清晰且每个阶段都紧扣用户核心诉求。"
+      },
+      {
+        "strategy_id": "STRAT-f84e9426",
+        "strategy_name": "MJ Omni Reference 锁主体 + Prompt 批量变体路线",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过阶段1锁定人脸一致性，阶段2精准控制近景构图和背景虚化，阶段3细化面部表情和光影氛围，完整实现了'突出人物面部表情和情绪、背景适当虚化、清楚看到人物神态与互动感'的要求。唯一轻微不足是阶段1的人脸一致性保持对于单次生成场景可能是过度设计。"
+      }
+    ]
+  },
+  "REQ_057": {
+    "requirement_desc": "生成产品或物品的极近距离特写图，如食物截面、商品细节、小物件放大展示，画面主体占满画幅，质感和纹理清晰突出",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-744c86a3",
+        "strategy_name": "摄影级产品特写路线（微距/材质/工作室布光）",
+        "is_selected": false,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过三阶段流程实现了产品特写的材质质感控制、微距构图与画幅填充、精准光影强化，以及食物截面、商品细节、小物件放大等具体场景的生成能力，并明确支持8K高分辨率输出。唯一微小不足是对某些极端材质（如液体、透明物体）的特殊处理描述相对较少。"
+      }
+    ]
+  },
+  "REQ_058": {
+    "requirement_desc": "生成具有强烈透视纵深感的室内空间图，画面中窗框、拱门、地板线条等建筑元素形成明显的空间层次，光线从远处窗口射入，营造出由近到远的视觉延伸效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-c61ec3cc",
+        "strategy_name": "结构化Prompt五维度直出路线",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：通过一点透视精确控制建筑元素（窗框、拱门、地板线条）形成空间层次，远处窗口光源注入配合体积光效营造由近到远的视觉延伸，分层空间元素叠加强化透视纵深感，并提供高分辨率输出。唯一微小不足是未明确提及对输入图像结构的锁定能力。"
+      },
+      {
+        "strategy_id": "STRAT-728a2e72",
+        "strategy_name": "Depth/白模 ControlNet 结构锁定 + 风格迁移室内渲染路线",
+        "is_selected": true,
+        "coverage_score": 0.72,
+        "explanation": "该工作流通过ControlNet Depth锁定空间结构、IPAdapter Plus风格迁移和光影优化，能够生成具有透视感的室内空间图，但其核心聚焦于风格迁移（奶油色调、地中海/法式风格）而非透视纵深感的精确控制。对于窗框、拱门、地板线条形成明显空间层次和光线从远处射入的视觉延伸效果的描述不够明确和系统化。"
+      }
+    ]
+  },
+  "REQ_059": {
+    "requirement_desc": "生成采用夸张变形构图的图片，例如鱼眼镜头效果将人物或场景扭曲成球形全景、仰拍使近处物体极度放大而远处极度缩小，或通过搞怪角度让画面产生强烈的视觉冲击感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-0919d3e6",
+        "strategy_name": "极端视角 Prompt 路线（鱼眼/广角/球形/仰拍）",
+        "is_selected": true,
+        "coverage_score": 0.98,
+        "explanation": "该工作流全面覆盖了用户需求的三大核心场景：鱼眼镜头球形畸变（阶段1）、仰拍/俯拍透视变形（阶段2）、搞怪角度视觉冲击（阶段3荷兰角），并提供了详细的提示词实现方案和多平台工具支持。唯一微小不足是对某些极端创意角度（如360度环绕畸变）的探索深度可以进一步扩展，但已充分满足实际应用需求。"
+      }
+    ]
+  },
+  "REQ_060": {
+    "requirement_desc": "生成画面中存在嵌套框架效果的图片，如在沙漠场景中用一个悬空的矩形框将主体框住形成画中画，或利用水面倒影与实景上下对称形成嵌套镜像构图，制造超现实的空间突破感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-fafdbef0",
+        "strategy_name": "悬空矩形框画中画流派",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的两个核心场景：阶段2专门针对'沙漠场景悬空矩形框'的画中画效果，阶段1和3提供了完整的场景构建和细节强化流程。虽然对水面倒影镜像构图的描述相对简略，但通过'画中画嵌套框架构图生成'能力和多个相关案例充分证明了对核心需求的深度理解和实现路径。"
+      },
+      {
+        "strategy_id": "STRAT-e06aec89",
+        "strategy_name": "水面倒影嵌套镜像流派",
+        "is_selected": true,
+        "coverage_score": 0.75,
+        "explanation": "该工作流深度覆盖了水面倒影嵌套镜像构图的生成，提供了详细的prompt工程和专项工具（Midjourney Editor水面反射功能），但对用户需求中明确提到的'沙漠场景中悬空矩形框'这类画中画框架构图覆盖不足，主要聚焦于对称镜像而非框架嵌套。"
+      }
+    ]
+  },
+  "REQ_061": {
+    "requirement_desc": "生成具有强烈色彩对比的艺术插画，整体画面以高饱和度的红色与蓝色为主色调，两种颜色形成鲜明的冷暖对撞，背景大面积纯色铺底，视觉冲击力极强",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-0de66146",
+        "strategy_name": "风格锁定直出路线：--sref 参数锚定 × 双色调构图精控 × 批量优选",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "全面覆盖用户需求的所有核心要素：红蓝高饱和度主色调、冷暖对撞、大面积纯色铺底、强烈视觉冲击力。通过双色调构图控制、风格参考码锁定、饱和度精准控制、波普纹理与光效增强等多层次能力，系统性地实现了从构图到色彩到视觉增强的完整流程，且提供批量生成与风格持久化能力支持系列化产出。"
+      },
+      {
+        "strategy_id": "STRAT-fdfe1caa",
+        "strategy_name": "多风格分层融合路线：风格基底选择 × 双色分层结构 × 饱和度校验微调",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "有效覆盖核心需求，通过风格基底选择、红蓝双色分层结构、饱和度校验等阶段实现红蓝冷暖对撞与高饱和度效果。相比第一个方案，缺少风格参考码锁定和波普纹理/光效增强等高级视觉冲击力强化手段，但通过双重曝光与剪影融合提供了独特的叙事深度维度。"
+      }
+    ]
+  },
+  "REQ_062": {
+    "requirement_desc": "在以暗色或单色为主的画面中，用局部的高饱和亮色（如红色心脏、橙色暖光窗口、金黄色星光）作为点睛之笔，让视线自然聚焦到这个色彩亮点上，形成强烈的视觉引导",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-94f4e98d",
+        "strategy_name": "Prompt 驱动全自动暗调点睛生成流（文生图/AI视频一体化路线）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的三个核心要素：暗色基调建立、高饱和亮色点睛、视觉引导强化。通过系统化的三阶段流程，结合暗调长调配色、选择性色彩保留、暖光点睛、发光效果等多种能力，全面实现了从暗色底图到局部亮色焦点的视觉引导效果，且提供了丰富的风格扩展选项（赛博朋克、金色粒子等）。"
+      },
+      {
+        "strategy_id": "STRAT-a856d593",
+        "strategy_name": "ComfyUI 节点化工作流路线（精准控制版）",
+        "is_selected": false,
+        "coverage_score": 0.55,
+        "explanation": "该工作流覆盖了暗色底图生成和发光效果增强两个环节，但关键的阶段2（局部色彩注入）被完全截断丢弃，导致缺失了实现'局部高饱和亮色点睛'这一核心需求的关键步骤。虽然阶段1和阶段3的能力本身有效，但工作流的完整性和可执行性存在重大缺陷。"
+      }
+    ]
+  },
+  "REQ_063": {
+    "requirement_desc": "生成整体色调统一、饱和度偏高的场景图，例如全画面笼罩在深蓝色夜光氛围或浓郁的赤红土地色调中，让单一主色调主导整个画面，营造出沉浸式的强烈色彩氛围感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-2b07a94f",
+        "strategy_name": "主色调锚定 + 色彩脚本分层 + 胶片氛围强化流派",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过主色调锚定直接生成单一色调主导的画面，配合色彩脚本分区域控制实现深度层次，再通过光照氛围和胶片效果强化沉浸式色彩氛围感。四个阶段层层递进，从色调统一、高饱和度到沉浸式氛围营造，完整解决了'让单一主色调主导整个画面'的核心诉求，且提供了丰富的案例支撑（深蓝夜光、赤红土地等典型场景）。"
+      },
+      {
+        "strategy_id": "STRAT-f13bb636",
+        "strategy_name": "HEX 色板精准定调 + LUT 风格模板跨模型复用流派",
+        "is_selected": false,
+        "coverage_score": 0.78,
+        "explanation": "该工作流通过HEX色板提取、LUT风格提示词和风格参考代码三个阶段，提供了精准的色调控制方法，能够实现色调统一和高饱和度效果。但其侧重于色彩提取和风格复现的技术流程，对于如何直接生成单一主色调主导整个画面的沉浸式氛围感描述相对间接，需要依赖参考图或预设风格，缺少从零开始直接生成目标色调场景的能力。"
+      }
+    ]
+  },
+  "REQ_064": {
+    "requirement_desc": "生成具有强烈氛围感的插画风场景图，整体画面以深蓝色调为主，室内外场景都笼罩在宁静的夜色中，窗户透出暖黄色灯光形成冷暖对比，画面质感接近油画或数字绘画风格，传达出静谧、沉思、略带忧郁的情绪氛围",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-000f9272",
+        "strategy_name": "高水准氛围插画路线：色调建立→光源植入→质感收敛",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：深蓝色调夜景底图构建、冷暖对比光源设计（暖黄窗灯）、油画质感强化与情绪氛围后处理，三阶段逻辑清晰且每个阶段都有精确的技术实现路径和案例支撑。唯一微小不足是批量变体生成环节未明确提及，但整体语义覆盖度极高。"
+      },
+      {
+        "strategy_id": "STRAT-61e0f069",
+        "strategy_name": "快速全自动管线路线：提示词模板→ComfyUI节点管线→批量优选",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流通过预设模板+ComfyUI自动化管线+批量变体生成，实现了用户需求的核心视觉元素（深蓝夜景、暖黄窗灯、油画风格、静谧情绪），且强调自动化效率。但在油画质感强化的具体后处理步骤描述上不如STRAT-000f9272详细，缺少渐变映射等精细调色环节的明确说明。"
+      }
+    ]
+  },
+  "REQ_065": {
+    "requirement_desc": "制作色彩鲜艳、视觉冲击力强的宣传海报，背景使用渐变色块（蓝紫、橙红等高饱和度色彩），搭配几何抽象图形装饰，文字排版醒目大气，整体呈现出热烈、充满活力的欢庆氛围",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-419e9ab1",
+        "strategy_name": "极速直出路线：精准配色锚点 × AI一键生成 × 多轮收敛",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过精准配色库选定高饱和度蓝紫/橙红渐变色组，使用几何抽象图形装饰，配备电影级光效和8K商业级渲染，并通过多轮迭代优化文字排版和视觉冲击力。唯一微小不足是文字排版的具体实现细节相对较少，但整体方案完整且有大量案例验证支撑。"
+      },
+      {
+        "strategy_id": "STRAT-fa2fe44f",
+        "strategy_name": "参考图驱动路线：GPT反向读图 × AI主图生成 × 版式合成",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过参考图反向解析和GPT关键词提取实现了精准的风格控制，覆盖了渐变背景、几何装饰和色彩饱和度控制等核心需求，并在阶段3专门处理文字排版与版式合成。相比第一个方案，其在色彩方案的预设库和多轮迭代优化方面略显不足，但参考图驱动的方式在风格还原度上有独特优势。"
+      }
+    ]
+  },
+  "REQ_067": {
+    "requirement_desc": "生成具有强烈视觉冲击力的超现实主义风格图像：画面以大地色系（深红、赭石、深蓝）为主调，将白马、牛仔等元素置于极简的荒漠/盐湖场景中，营造出孤寂、神秘、如油画般的电影感氛围",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-4914537c",
+        "strategy_name": "文生图底帧 + 图生视频动态化路线（首尾帧/多镜头/Hailuo-Seedance-Kling）",
+        "is_selected": true,
+        "coverage_score": 0.35,
+        "explanation": "该工作流专注于非常规摄像机角度（虫眼仰拍、鸟瞰俯视、POV等）和视角转换技术，虽然可以提供视觉冲击力和电影感，但用户需求的核心是超现实主义风格、大地色系、荒漠场景和特定元素（白马、牛仔），而非摄像机角度实验。工作流缺少色调风格化、场景氛围营造和超现实主义美学控制能力。"
+      },
+      {
+        "strategy_id": "STRAT-f84e9426",
+        "strategy_name": "MJ Omni Reference 锁主体 + Prompt 批量变体路线",
+        "is_selected": false,
+        "coverage_score": 0.25,
+        "explanation": "该工作流专注于人像面部特写、表情控制、浅景深和胶片质感，但用户需求是超现实主义风格的荒漠/盐湖场景中的白马、牛仔等元素，两者在主题、构图和场景类型上完全不匹配。工作流缺少场景构建、色调控制（大地色系）和超现实主义风格渲染能力。"
+      }
+    ]
+  },
+  "REQ_068": {
+    "requirement_desc": "生成3D卡通风格的拟人化动物角色，角色具有毛绒质感和丰富的表情神态，能够在不同生活场景（办公室、卧室、户外）中呈现出喜怒哀乐等情绪状态，整体风格类似皮克斯动画",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-071a27d4",
+        "strategy_name": "快速批量出图流派（场景×情绪矩阵变量公式）",
+        "is_selected": false,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过结构化提示词实现3D卡通风格和毛绒质感，系统化生成多场景多情绪组合，并通过角色一致性机制和统一渲染参数确保皮克斯风格的整体性。唯一微小不足是未明确提及动画或动态表情的可能性，但对于静态角色生成需求已完全满足。"
+      }
+    ]
+  },
+  "REQ_071": {
+    "requirement_desc": "将动物（如猫咪）与各种食物、道具进行创意合成，给动物添加配饰（帽子、假发、领带等）并嵌入食物场景中，搭配谐音梗或双关文字，制作出拟人化角色扮演的趣味表情包图片",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-46ca5644",
+        "strategy_name": "统一IP系列化批量生产流派",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：动物配饰穿戴、食物场景合成、谐音梗文案生成、批量系列化输出，并通过IP一致性保持实现系列化品牌效果。唯一轻微不足是流程分为三个阶段，操作步骤相对复杂，但这也带来了更高的质量控制和系列化能力。"
+      },
+      {
+        "strategy_id": "STRAT-d6cb776f",
+        "strategy_name": "单图精品直出流派",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过精细prompt工程一步直出完整合成图，覆盖了动物配饰、食物场景、拟人化和谐音梗文字的核心需求，流程更简洁高效。相比第一个方案，缺少了IP角色一致性保持和批量生成能力，更适合单图精品路线而非系列化生产，在系列化表情包制作方面略显不足。"
+      }
+    ]
+  },
+  "REQ_072": {
+    "requirement_desc": "给同一张猫咪照片批量添加不同职业的帽子、道具和配件（如厨师帽、安全帽、眼镜、画板等），让猫咪看起来像在扮演各种职业角色",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-86d1256a",
+        "strategy_name": "主体一致性 + Inpaint 局部换装/换景路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流通过IP-Adapter保持猫咪主体一致性，使用Flux-kontext局部重绘精准添加不同职业道具，支持多道具叠加和批量处理，完整覆盖了用户需求的核心要素（同一张猫咪照片+批量添加不同职业道具）。唯一不足是流程相对复杂，需要手动构建遮罩和分步执行。"
+      },
+      {
+        "strategy_id": "STRAT-a0341ba4",
+        "strategy_name": "轻量级文生图批量生成路线",
+        "is_selected": false,
+        "coverage_score": 0.68,
+        "explanation": "该工作流通过AI文生图工具（豆包AI/小云雀AI）批量生成职业场景，操作简便且支持批量处理，但核心缺陷是无法保证每次生成使用的是'同一张猫咪照片'——AI每次会重新生成猫咪形象，导致不同职业图中的猫咪外观可能存在差异，不完全符合用户'同一张照片'的严格要求。"
+      }
+    ]
+  },
+  "REQ_073": {
+    "requirement_desc": "将真实照片转换成具有统一色调风格的插画效果，整体呈现蓝紫色调的复古油画或动画风格，让风景场景看起来像艺术插图",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-581b4a18",
+        "strategy_name": "高精度全自动路线：ComfyUI Flux深度控制 × 蓝紫色调插画转换",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流通过深度图提取保留场景结构，结合Flux Redux风格迁移和专门的蓝紫色调LoRA/提示词，系统性地实现了照片到统一蓝紫色调插画的转换，并包含光照氛围强化和超分辨率输出。技术路径更完整，对结构保留、色调统一、批量处理和高清输出的控制更精确，全面覆盖用户需求。"
+      },
+      {
+        "strategy_id": "STRAT-8d447fff",
+        "strategy_name": "轻量快速路线：Midjourney提示词驱动蓝紫色调油画转换",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过Midjourney niji 6模型和详细的蓝紫色调提示词体系（Blue Hour/Nordic Noir/Very light purple等）直接实现照片到插画的风格转换，完整覆盖了蓝紫色调、复古油画/动画风格、批量统一处理等核心需求。略微不足在于依赖Midjourney平台，对结构保留的精确控制相对较弱。"
+      }
+    ]
+  },
+  "REQ_074": {
+    "requirement_desc": "制作图文排版信息图，将多张食材产品图片抠出后整齐排列在统一背景上，配合文字说明组合成内容丰富的科普海报",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-494cc29c",
+        "strategy_name": "Coze 工作流端到端批量生成路线（宫格/长图/信息可视化）",
+        "is_selected": true,
+        "coverage_score": 0.45,
+        "explanation": "该工作流专注于多宫格分镜图文内容生成和排版，但用户需求核心是「食材产品图片抠图后排列+文字说明」，该流程缺少关键的图像抠图/背景移除能力，且从文本生成图像而非处理已有产品图片，语义匹配度较低。"
+      }
+    ]
+  },
+  "REQ_075": {
+    "requirement_desc": "生成具有强烈光影对比的场景图，画面中光源明显（如阳光折射、水面反光、彩虹色光晕），暗部极深、亮部极亮，整体呈现出戏剧性的明暗反差和光线质感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-62b34455",
+        "strategy_name": "戏剧性体积光四阶段流派（自然场景主线）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过阶段1建立明确光源（阳光折射、体积光），阶段2实现水面反光和彩虹色光晕（焦散、色散），阶段3强化极致明暗对比（Chiaroscuro、负补光），阶段4精修光线质感。四阶段递进式结构系统性地解决了光源明显、光影对比、彩虹光晕和戏剧性质感的全部要求，实现路径清晰且技术覆盖完整。"
+      },
+      {
+        "strategy_id": "STRAT-c2977647",
+        "strategy_name": "冷暖双极对立光晕流派（城市/人造场景备选）",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流通过冷暖双极光源设定（阶段1）有效建立戏剧性明暗反差，阶段2的光晕与折射特效叠加精准实现了阳光折射、彩虹色光晕需求，阶段3整合场景氛围强化了整体光线质感。相比STRAT-62b34455，该方案在体积光/丁达尔效应的系统性处理上略显不足，且缺少对光源架构和介质注入的独立阶段规划，但核心需求覆盖度仍然很高。"
+      }
+    ]
+  },
+  "REQ_076": {
+    "requirement_desc": "生成带有明显颗粒感或纸张纹理的插画风格图片，画面整体像是印刷在粗糙介质上，物体表面有细腻的颗粒噪点或手工绘制的笔触肌理",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-9c64803f",
+        "strategy_name": "路线A：MidJourney 颗粒质感直接生成法 + 纸张底图双层叠加",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过CAP-GRAIN实现明显颗粒感和噪点纹理，通过CAP-STIPPLE模拟手工绘制的点画笔触肌理，通过CAP-WATERCOLOR和CAP-PAPER生成纸张纹理和粗糙介质效果，并提供了多种实现路径（Flux/MidJourney/ComfyUI）和丰富的案例支撑。唯一微小不足是部分能力（如个人化风格持久化）与核心需求关联度较弱。"
+      },
+      {
+        "strategy_id": "STRAT-5e02cd3f",
+        "strategy_name": "路线B：Risograph 孔版印刷风格模拟法",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流聚焦于Risograph孔版印刷风格，通过CAP-HALFTONE和CAP-GRAIN有效实现了颗粒感和粗糙介质质感，特别适合复古印刷品风格。但相比需求中强调的'细腻的颗粒噪点或手工绘制的笔触肌理'，该路线更侧重半色调网点和色彩叠印效果，对水彩笔触、点彩等手绘肌理的覆盖相对较弱，且缺少纸张纹理素材生成等能力。"
+      }
+    ]
+  },
+  "REQ_078": {
+    "requirement_desc": "在图片上叠加对话气泡或多行说明文字，用于讲述故事背景或补充情节说明，文字带有描边或阴影效果以确保在复杂背景上清晰可读",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-54878602",
+        "strategy_name": "在线工具自动化文字叠加路线（Canva/CapCut）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：对话气泡生成与定位、多行文字添加、描边/阴影效果实现、复杂背景可读性保证，并提供了Canva/CapCut/ComfyUI等多种实现路径和丰富案例支撑。唯一轻微不足是部分高级特效（如文字与主体深度融合）超出了基础需求范畴，但整体语义覆盖度极高。"
+      }
+    ]
+  },
+  "REQ_079": {
+    "requirement_desc": "制作图文并茂的科普说明卡片，每张卡片包含标题、编号、插图和详细文字说明，整体排版整齐统一，适合分步骤展示教程或知识点",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-c44e2daa",
+        "strategy_name": "DeepSeek + MD2Card 文本生成排版流派",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：通过DeepSeek生成结构化内容，MD2Card自动转换为图文并茂的卡片并支持自动编号和拆分，提供多种统一风格主题选择，最终导出标准格式。唯一的小缺陷是插图部分依赖MD2Card的自动配图，可能在插图定制化方面略有限制。"
+      },
+      {
+        "strategy_id": "STRAT-4d502039",
+        "strategy_name": "豆包Seedream提示词生图流派",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流通过AI图像生成直接产出图文并茂的知识卡片，支持多种风格和版式布局，能够满足标题、插图、文字说明等基本需求。但在编号的自动化管理、系列卡片的批量统一排版方面不如专门的卡片工具，且需要多次抽卡选优增加了不确定性和时间成本。"
+      }
+    ]
+  },
+  "REQ_080": {
+    "requirement_desc": "在多图拼贴海报上为每个区域叠加带图标的标签（如勾选符号+地点名称），并在整体画面上方添加大标题和副标题文字，形成图文结合的内容合集展示效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-441008e2",
+        "strategy_name": "LLM + Canva 模板驱动批量合成路线",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的所有核心要素：多图拼贴排版（阶段1）、区域图标标签叠加（阶段2）、大标题和副标题添加（阶段4），并通过信息层级分区（阶段3）实现图文结合的内容合集展示效果。额外提供的AI智能填充（阶段5）和批量生成（阶段6）能力进一步增强了实用性和效率，唯一微小不足是部分实现细节依赖特定工具（Canva）可能限制通用性。"
+      }
+    ]
+  },
+  "REQ_081": {
+    "requirement_desc": "为多人物展示海报中的每个人物添加姓名和职位标签，并在画面顶部叠加活动主题、专场名称等层级分明的标题文字，整体风格统一、信息密度高",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-4a3f7b3e",
+        "strategy_name": "AI全自动图层合成流派（信息结构→底图→布局→文字叠加→批量输出）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流从信息结构预处理开始，系统性覆盖了底图生成、人物布局排版、文字层级叠加、标签渲染和批量输出全链路，完整解决用户需求中的所有关键点（多人物、姓名职位标签、顶部标题、风格统一、高信息密度）。流程逻辑清晰、层次分明，且在阶段4专门强调了文字层级叠加与标签渲染的精细化处理，覆盖度极高。"
+      },
+      {
+        "strategy_id": "STRAT-17d5d5e5",
+        "strategy_name": "模板驱动批量生成流派（预设框架→素材注入→标签渲染→风格统一输出）",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流完整覆盖了模板框架设计、人物素材注入、姓名职位标签批量渲染、顶部标题层叠加和风格统一输出全流程，直接对应用户需求的所有核心要素（多人物展示、姓名职位标签、顶部标题文字、风格统一、信息密度高）。唯一轻微不足是阶段划分偏向模板预设，对动态人数适配的灵活性描述略少。"
+      }
+    ]
+  },
+  "REQ_082": {
+    "requirement_desc": "对同一场景或主体生成多个不同距离和景别的画面，包括远景展示整体环境、中景呈现主体与环境关系、近景突出细节，形成一组视角丰富的图片集合",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-04934b67",
+        "strategy_name": "结构化提示词路线（专业分镜术语驱动）",
+        "is_selected": false,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了用户需求的核心要素：通过结构化镜头列表精确控制远景/中景/近景等多景别生成，批量生成功能实现多距离画面集合，景别递进组合形成视角丰富的图片序列。唯一微小不足是对同一主体一致性保持的技术细节描述相对较少。"
+      },
+      {
+        "strategy_id": "STRAT-3c6df37a",
+        "strategy_name": "Nano Banana Pro 参数化多视角/多姿态批量路线",
+        "is_selected": true,
+        "coverage_score": 0.72,
+        "explanation": "该工作流重点聚焦于人物主体一致性保持和多姿态多角度生成，能够实现不同距离和角度的画面集合。但对用户需求中明确提到的'远景展示整体环境、中景呈现主体与环境关系、近景突出细节'等景别层次化控制缺乏专门设计，更侧重于人物姿态变化而非景别距离的系统化覆盖。"
+      }
+    ]
+  },
+  "REQ_083": {
+    "requirement_desc": "生成采用非常规拍摄角度的图片，如从低角度仰拍、从高处俯视、或模拟第一人称主观视角看向场景，让画面产生独特的视觉冲击感",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-4914537c",
+        "strategy_name": "文生图底帧 + 图生视频动态化路线（首尾帧/多镜头/Hailuo-Seedance-Kling）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖用户需求，从专业摄像机角度术语库（42种词汇）构建提示词，到主流模型生成非常规视角底图，再到专项POV沉浸式视角生成和图生视频动态化，完整实现低角度仰拍、高处俯视、第一人称主观视角等所有要求的非常规拍摄角度，并通过鱼眼/广角畸变效果进一步增强视觉冲击感。唯一微小不足是流程较长，对初学者可能存在一定学习曲线。"
+      },
+      {
+        "strategy_id": "STRAT-94288ec5",
+        "strategy_name": "LoRA精确角度控制路线：坐标系量化控制 × 96角度批量生成 × 可选动态输出",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流通过准备高质量基础锚点图像，结合Qwen Multi-Angle LoRA坐标系统精确控制96种角度组合（-30°仰拍到60°俯视），高效批量生成非常规视角并保持主体一致性，完全满足用户对低角度仰拍、高处俯视、POV视角的需求。相比STRAT-4914537c，该方案更侧重图像转换而非从零生成，在POV沉浸式视角的专项处理上略显不足，但在批量生成效率和精确控制方面更具优势。"
+      }
+    ]
+  },
+  "REQ_084": {
+    "requirement_desc": "生成能展示宽广空间感的室内或室外全景图，画面中包含完整的环境纵深，让观看者感受到场景的整体规模和空间层次",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-108fb2c7",
+        "strategy_name": "文本直驱全景生成路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流通过DiT360/混元3D等专用全景生成模型直接输出360°等距矩形全景图，完整覆盖了宽广空间感、环境纵深和整体规模的核心需求，并通过Gaussian Splat技术进一步增强沉浸式体验。唯一不足是对室内外场景的差异化处理策略描述较少。"
+      },
+      {
+        "strategy_id": "STRAT-aa34c436",
+        "strategy_name": "超宽画幅空间营造路线",
+        "is_selected": false,
+        "coverage_score": 0.78,
+        "explanation": "该工作流通过超宽画幅、精确的透视控制和体积大气效果有效展现空间感和纵深层次，特别在Prompt工程和光照控制方面有深入设计。但相比真正的360°全景图，21:9画幅在展示完整环境和整体规模方面存在视角局限性。"
+      }
+    ]
+  },
+  "REQ_086": {
+    "requirement_desc": "生成色彩鲜艳、多色并置的视觉冲击画面，画面中同时出现多种高饱和度的颜色搭配（如复古拼贴风格中的粉色、蓝色、橙色并置，或彩色条纹波浪地形），让整体色彩浓烈饱满、视觉张力强烈",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-cdc95b7e",
+        "strategy_name": "风格化拼贴构图路线",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过阶段1选定复古拼贴风格，阶段2生成多色并置的各色彩区块（包含彩色条纹地形等特定图案），阶段3实现多色并置合成，阶段4强化复古质感与视觉张力。完整覆盖了'色彩鲜艳、多色并置、高饱和度、复古拼贴风格、视觉冲击'等所有关键需求点，且提供了具体的风格选择（多巴胺拼贴、孟菲斯、丝网印刷）和质感强化手段（复古颗粒、半色调、叠印效果）。"
+      },
+      {
+        "strategy_id": "STRAT-0e87b6a6",
+        "strategy_name": "AI提示词驱动的多色并置视觉冲击生成路线",
+        "is_selected": true,
+        "coverage_score": 0.85,
+        "explanation": "该工作流有效覆盖了高饱和多色并置和视觉张力的核心需求，通过阶段1确定色彩方案、阶段2构建参数化提示词、阶段3生成多版本、阶段4强化色彩对比。但相比STRAT-cdc95b7e，该流程更侧重迷幻艺术风格而非用户明确要求的'复古拼贴风格'，且缺少对'彩色条纹波浪地形'等具体图案类型的针对性生成步骤，对复古质感（丝网印刷、半色调）的处理也不够深入。"
+      }
+    ]
+  },
+  "REQ_087": {
+    "requirement_desc": "生成低饱和度或去色风格的极简画面，整体色彩纯度降低，呈现出克制、安静的视觉质感（如黑白灰调的海洋孤舟场景，或接近无彩色的素雅插画），与高饱和度画面形成鲜明对比",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-737a0111",
+        "strategy_name": "禅意极简水墨路线（主线）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过三阶段系统性地实现极简构图、低饱和度色彩控制和留白质感强化，提供了完整的提示词策略（水墨风、莫兰迪色、禅意）和参数控制方法（--s、--sref），能够生成黑白灰调海洋孤舟等典型场景。唯一轻微不足是缺少后期色彩微调的备选方案。"
+      },
+      {
+        "strategy_id": "STRAT-96f6e387",
+        "strategy_name": "莫兰迪素雅插画路线（备选）",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流有效覆盖了低饱和度生成的核心路径：通过风格参数锁定莫兰迪色系基调，结合极简构图生成克制画面，并创新性地加入高饱和度对比验证环节以确保效果达标。相比STRAT-737a0111，该方案在极简场景语义构建和留白强化方面的描述略显简略，但对比验证机制是独特优势。"
+      }
+    ]
+  },
+  "REQ_088": {
+    "requirement_desc": "生成超现实浪漫场景图：将人物置于不可能存在的宏大环境中，如站在地球边缘俯瞰星空、坐在云端长椅上漂浮、在星海上骑行，画面充满梦幻感和史诗级视觉冲击力",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-4e74f78f",
+        "strategy_name": "诗意提示词驱动·单图超现实人物场景流派",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流完整覆盖了超现实浪漫场景生成的核心需求：通过专业提示词工程构建不可能存在的宏大环境（地球边缘/云端/星海），使用Midjourney V7生成史诗级视觉冲击力的底图，并通过光影精修强化梦幻感和尺度对比。唯一轻微不足是未明确涉及动态视频化环节，但静态图像生成部分已完全满足需求。"
+      },
+      {
+        "strategy_id": "STRAT-4914537c",
+        "strategy_name": "文生图底帧 + 图生视频动态化路线（首尾帧/多镜头/Hailuo-Seedance-Kling）",
+        "is_selected": true,
+        "coverage_score": 0.62,
+        "explanation": "该工作流聚焦于非常规摄像机角度（虫眼仰拍/鸟瞰俯视/POV）的技术实现，虽然可以生成宏大环境的视角效果，但核心侧重点在于视角转换技术而非超现实浪漫场景的艺术表现。缺少对梦幻感、史诗级氛围、超现实元素（如站在地球边缘、坐在云端、星海骑行）的专项设计和光影氛围营造，与用户需求的艺术方向匹配度较低。"
+      }
+    ]
+  },
+  "REQ_089": {
+    "requirement_desc": "制作科技感强烈的活动宣传海报：使用深色背景配合橙色、蓝色等高对比度霓虹色调，融合未来感城市或科技场景插图，搭配大号粗体标题文字，整体呈现出硬核、前沿的视觉气质",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-00faa3e6",
+        "strategy_name": "文字主导型科技活动海报流派（GPT-Image 2文字场景深度融合路线）",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流深度覆盖了用户需求的所有核心要素：深色背景、橙蓝霓虹色调、未来科技场景、大号粗体标题，并特别强调了3D透视文字与场景表面融合的高级效果，以及电影级色彩分级。唯一轻微不足是阶段划分较为技术导向，可能在实际执行中需要更多工具间的协调。"
+      },
+      {
+        "strategy_id": "STRAT-f72fe65d",
+        "strategy_name": "场景主导型科技活动海报全自动化流派（城市场景驱动·霓虹光效强化·版式智能收尾）",
+        "is_selected": true,
+        "coverage_score": 0.88,
+        "explanation": "该工作流完整覆盖了深色背景、霓虹色调、未来城市场景、科技元素、文字排版和高分辨率输出等所有关键需求，并增加了批量生成能力以提供多方案选择。相比第一个方案，文字处理采用传统叠加方式而非深度融合，在视觉冲击力上略逊一筹，但整体流程更加清晰易执行。"
+      }
+    ]
+  },
+  "REQ_090": {
+    "requirement_desc": "生成融合东方传统与现代简约的室内空间效果图：以米白、暖棕为主色调，加入拱形门洞、藤编元素、中式花卉装饰画等传统细节，整体呈现温润雅致的新中式生活美学氛围",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-74adb2a2",
+        "strategy_name": "新中式 LoRA 室内效果图路线",
+        "is_selected": true,
+        "coverage_score": 0.98,
+        "explanation": "该工作流全面覆盖用户需求的所有核心要素：米白暖棕主色调通过阶段1的配色方案智能生成精准实现，拱形门洞通过阶段2的传统建筑造型元素精准生成完整呈现，藤编元素通过阶段3的多材质纹理精准生成清晰可辨，中式花卉装饰画通过阶段4的中式装饰艺术画生成定制化输出，整体温润雅致氛围通过阶段5的灯光氛围与细节收尾完美营造。工作流逻辑清晰、能力匹配精准、案例支撑充分，几乎完全解决用户需求，仅在实际执行的技术细节调优上可能需要微调。"
+      }
+    ]
+  },
+  "REQ_091": {
+    "requirement_desc": "生成拟人化动物角色表情包：用AI生成具有丰富表情和情绪的卡通动物形象（如毛茸茸的红色马、灰色驴），能够呈现出沮丧、无奈、委屈等多种情绪状态，配合不同场景背景（办公室、草地、室内），整体风格介于3D皮克斯动画和水彩插画之间，适合搭配幽默文案使用",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-2c12f52d",
+        "strategy_name": "3D 卡通风情绪矩阵路线（皮克斯/九宫格/表情包）",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流不仅全面覆盖角色生成、毛茸茸质感、多情绪表情、场景适配和风格控制等核心需求，还特别强调了情绪标注驱动机制和场景道具设计，使表情包更适合搭配幽默文案使用，并在阶段4明确包含图像内文字渲染能力实现图文一体。整体语义覆盖更深入且流程更完整。"
+      },
+      {
+        "strategy_id": "STRAT-0902410f",
+        "strategy_name": "锁主体身份 + 情绪 Prompt 矩阵批量路线",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流完整覆盖了拟人化动物角色生成、毛茸茸质感渲染、多情绪表情批量生成、场景背景融合和3D皮克斯/水彩风格切换等核心需求，流程清晰且工具实现具体。略微不足在于缺少文案融合环节，未明确提及如何将幽默文案直接渲染进表情包图像。"
+      }
+    ]
+  },
+  "REQ_092": {
+    "requirement_desc": "制作图文混排的知识科普长图：以深青色/蓝绿色为底色背景，将心理学等知识内容拆分为多个板块，每个板块搭配风格统一的插画小图（奇幻风格人物、动物等），文字与插图穿插排布，整体呈现出版式清晰、视觉层次丰富的杂志风格科普图文效果",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-cde98036",
+        "strategy_name": "LLM 生成代码 → 渲染为图路线（HTML/SVG/Code Interpreter）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：深青/蓝绿色底色背景、心理学知识板块拆分、奇幻风格插画生成与嵌入、图文穿插排布、杂志风格排版，并通过品牌规则文件和QA代理确保风格统一和质量达标。唯一微小不足是流程较为复杂，对于简单场景可能存在一定的学习成本。"
+      },
+      {
+        "strategy_id": "STRAT-052f6ab9",
+        "strategy_name": "科普长图模板化生成路线",
+        "is_selected": false,
+        "coverage_score": 0.82,
+        "explanation": "该工作流覆盖了用户需求的主要元素：深青/蓝绿色背景、内容板块拆分、奇幻插画生成、视觉层次优化和导出。但在风格一致性保障机制、自动化质量检查、HTML模板化生成等方面不如第一个方案完善，缺少品牌规则文件和QA代理等确保批量输出质量稳定的机制。"
+      }
+    ]
+  },
+  "REQ_093": {
+    "requirement_desc": "生成室内空间效果图：用AI渲染出具有温暖奶油色调的室内场景，包含拱形门洞、藤编家具、自然光影等元素，整体呈现出地中海或法式复古风格的高质感室内设计效果，光线柔和、色调统一，适合作为家居内容的视觉展示",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-728a2e72",
+        "strategy_name": "Depth/白模 ControlNet 结构锁定 + 风格迁移室内渲染路线",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "该工作流全面覆盖了用户需求的核心要素：通过ControlNet Depth锁定拱形门洞等空间结构，IPAdapter Plus实现地中海/法式复古风格和奶油色调迁移，Color Grading统一色调，Lighting Modification模拟柔和自然光影，Material Swap强化藤编家具纹理细节，Atmospheric Effects提升照片级质感。工作流逻辑清晰、技术栈完整，能够高质量实现温暖奶油色调、拱形门洞、藤编家具、自然光影等所有关键元素，适合家居视觉展示。唯一微小不足是未明确提及如何确保最终输出分辨率满足商业展示需求。"
+      }
+    ]
+  },
+  "REQ_094": {
+    "requirement_desc": "生成具有强烈戏剧性光影对比的户外场景图，画面中光源方向明确（如侧光或逆光），亮部与暗部之间形成鲜明反差，阴影轮廓清晰，整体呈现出电影感或艺术摄影风格的视觉张力",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-5cfc91aa",
+        "strategy_name": "提示词精细化驱动路线：逐层叠加光影控制词",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了用户需求的所有核心要素：通过阶段1-2精准构建户外场景和光影控制词（侧光/逆光、硬光、高对比度、清晰阴影轮廓），阶段3叠加电影感/艺术摄影风格标签，阶段4确保高清输出。提供了完整的提示词工程方法论（万能公式、光影词库、设备参数锚定）和多模型实现路径（Midjourney/Gemini/Nanobanana），案例参考丰富且具体。唯一微小不足是未涉及ControlNet等空间约束工具，对光影方向的可控性略低于方案二。"
+      },
+      {
+        "strategy_id": "STRAT-092a4373",
+        "strategy_name": "ControlNet精准光影约束路线：参考图驱动空间光影锁定",
+        "is_selected": false,
+        "coverage_score": 0.78,
+        "explanation": "该工作流通过ControlNet光影控制模型提供了对光源方向和阴影分布的精确空间约束能力，解决了纯提示词方案中光影随机性的痛点，特别适合需要高度可复现的批量生产场景。但工作流仅包含3个阶段，在场景构建、风格化美学标签叠加、摄影参数锚定等方面的描述不如方案一详尽，且依赖用户预先准备高质量光影参考图，整体覆盖深度和易用性略逊一筹。"
+      }
+    ]
+  },
+  "REQ_095": {
+    "requirement_desc": "生成室内暖光氛围图，画面中多个光源（吊灯、筒灯、窗外自然光）共同营造出温暖柔和的米色调空间，光线从不同方向照射，形成层次丰富的软阴影，整体氛围温馨舒适",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-1c278c59",
+        "strategy_name": "多光源分层打光策略（三阶段闭环）",
+        "is_selected": true,
+        "coverage_score": 0.95,
+        "explanation": "This workflow comprehensively addresses all core requirements: multi-source lighting (pendant lights, spotlights, natural light), warm beige tones, soft shadows from multiple directions, and cozy atmosphere. It provides detailed three-phase approach covering space foundation, layered lighting setup with specific color temperature control (3000K), and shadow refinement with material reflections, directly matching the user's need for rich layered soft shadows and warm comfortable ambiance."
+      },
+      {
+        "strategy_id": "STRAT-ec8393b8",
+        "strategy_name": "AI提示词直出策略（快速迭代）",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "This workflow effectively covers the main requirements through structured prompt assembly, tool selection, and atmosphere enhancement phases. It addresses multi-source lighting, beige tones, soft shadows, and warm atmosphere with specific prompt engineering techniques. However, it is slightly less detailed than STRAT-1c278c59 in terms of explicit color temperature parameterization and the systematic breakdown of lighting layer strategies."
+      }
+    ]
+  },
+  "REQ_096": {
+    "requirement_desc": "生成充满魔幻或超现实感的彩色光效场景，画面中有多种颜色的光线（如橙、蓝、紫等）交织流动，光源本身成为视觉焦点，整体营造出梦幻、神秘或节日感的强烈氛围",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-2e74394c",
+        "strategy_name": "霓虹粒子风暴+生物发光路线（超现实奇幻）",
+        "is_selected": false,
+        "coverage_score": 0.92,
+        "explanation": "该工作流深度契合用户需求，通过暗黑背景对比、霓虹粒子流动系统、生物发光和棱镜折射等手段，完整实现了多色光线交织流动、光源视觉焦点化和强烈梦幻神秘氛围。特别是粒子河流/瀑布和魔法生物发光的设计强化了超现实感，覆盖度极高。"
+      },
+      {
+        "strategy_id": "STRAT-25ecbf37",
+        "strategy_name": "体积光+霓虹双色对比路线（电影级灯光）",
+        "is_selected": true,
+        "coverage_score": 0.88,
+        "explanation": "该工作流全面覆盖了多彩光效交织、光源成为视觉焦点、梦幻神秘氛围等核心需求，通过体积光、霓虹双色对比和发光粒子系统实现了完整的魔幻光效场景。略微不足在于对超现实感和节日感的营造相对隐含，未明确强调这两个特定氛围维度。"
+      }
+    ]
+  },
+  "REQ_098": {
+    "requirement_desc": "在图片上叠加大字幕文字，字体粗大醒目，常带有描边或阴影效果，文字直接覆盖在照片或场景图上，起到强调说明或搞笑点评的作用",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-2bf80b8e",
+        "strategy_name": "纯AI图文一体生成路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流通过AI图文一体化生成直接输出带有粗大醒目文字、描边/阴影效果的图像，完全覆盖用户需求的核心场景（表情包、海报、宣传图），并提供质量校验与批量生成能力。唯一不足是缺少对已有照片进行文字叠加的明确处理路径。"
+      },
+      {
+        "strategy_id": "STRAT-72f1244e",
+        "strategy_name": "AI底图生成 + 专项文字渲染路线",
+        "is_selected": false,
+        "coverage_score": 0.88,
+        "explanation": "该工作流提供了完整的底图生成、文字样式规划、程序化渲染和格式适配流程，特别强调描边阴影等视觉强化效果和透视变形等高级特性。相比第一个方案更注重传统图像合成路径，但在AI一体化生成的便捷性上略逊一筹。"
+      }
+    ]
+  },
+  "REQ_099": {
+    "requirement_desc": "制作多宫格拼贴式内容图，每个格子内有大标题文字突出显示核心信息（如价格、品类名），配合产品图或场景图，标题字号远大于说明文字，形成层次分明的视觉结构",
+    "strategies": [
+      {
+        "strategy_id": "STRAT-6aeb80a1",
+        "strategy_name": "QA Agent 闭环信息图/海报自动化路线",
+        "is_selected": true,
+        "coverage_score": 0.92,
+        "explanation": "该工作流全面覆盖了多宫格拼贴式内容图的核心需求，特别是通过AI版面自动排布、多类型视觉元素分区生成、图像内文字渲染等能力实现了大标题文字突出显示、产品图/场景图配合、层次分明的视觉结构。唯一轻微不足是其更侧重信息图和混合媒体拼贴的复杂场景，对于简单的多宫格网格布局可能存在一定的流程冗余。"
+      },
+      {
+        "strategy_id": "STRAT-425a984a",
+        "strategy_name": "结构化 Prompt 一次直出多格/网格路线",
+        "is_selected": true,
+        "coverage_score": 0.68,
+        "explanation": "该工作流专注于AI模型一次性直出完整网格大图，能够实现多宫格的基础布局和角色一致性，但在核心需求'大标题文字突出显示核心信息（如价格、品类名）'和'标题字号远大于说明文字，形成层次分明的视觉结构'方面缺乏明确的文字渲染和排版层次控制能力，更适合分镜叙事和多姿态展示场景。"
+      }
+    ]
+  }
+}

examples/process_pipeline/script/dedup_db_records.py

@@ -0,0 +1,803 @@
+"""
+dedup_db_records.py
+语义去重：原子能力 / 制作策略 / 案例素材
+
+用法：
+  --dry-run   分析 + 生成 dedup_plan.json，不写库
+  --execute   读取 dedup_plan.json 并应用（不重新调用 LLM）
+  (无参数)    分析 + 直接执行（不保存 plan）
+
+去重逻辑：
+  Pass 1 - Case:       difflib title 相似度 > 80% → 合并
+  Pass 2 - Capability: difflib name 预筛 (>60%) → Qwen3.5-plus 精判
+  Pass 3 - Strategy:   对 capability_id 集合的 Jaccard 相似度 > 70% → 合并
+            （Strategy 去重必须在 Capability 去重之后，因依赖其 ID）
+"""
+
+import os, sys, json, asyncio, argparse, difflib
+from pathlib import Path
+
+repo_root = str(Path(__file__).parent.parent.parent.parent)
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from knowhub.knowhub_db.pg_requirement_store import PostgreSQLRequirementStore
+from knowhub.knowhub_db.pg_capability_store import PostgreSQLCapabilityStore
+from knowhub.knowhub_db.pg_strategy_store import PostgreSQLStrategyStore
+from knowhub.knowhub_db.pg_resource_store import PostgreSQLResourceStore
+from knowhub.knowhub_db.pg_tool_store import PostgreSQLToolStore
+from agent.llm.openrouter import openrouter_llm_call
+
+PLAN_FILE = Path(__file__).parent / "dedup_plan.json"
+
+# ─── helpers ─────────────────────────────────────────────────────────────────
+
+def sim(a: str, b: str) -> float:
+    return difflib.SequenceMatcher(None, a.lower(), b.lower()).ratio()
+
+def apply_merges(store, entity_table: str, junction_tables: list, merges: list, dry_run: bool):
+    """junction_tables: [(table_name, foreign_key_col), ...]
+    Supports both flat {master_id, duplicate_ids[]} and enriched {master:{id}, duplicates:[{id}]} formats.
+    """
+    if not merges:
+        return
+    cur = store._get_cursor()
+    try:
+        for merge in merges:
+            # Support both flat and enriched plan formats
+            if "master_id" in merge:
+                master_id = merge["master_id"]
+                dup_ids = merge.get("duplicate_ids", [])
+            else:
+                master_id = merge["master"]["id"]
+                dup_ids = [d["id"] for d in merge.get("duplicates", [])]
+            if not merge.get("enabled", True):
+                print("    [SKIP disabled] master=%s" % master_id)
+                continue
+            for dup_id in dup_ids:
+                print("    Merge %s -> %s" % (dup_id, master_id))
+                if dry_run:
+                    continue
+                for (jtable, fkcol) in junction_tables:
+                    # INSERT master rows (skip existing)
+                    cur.execute("SELECT * FROM " + jtable + " WHERE " + fkcol + " = %s", (dup_id,))
+                    rows = cur.fetchall()
+                    for row in rows:
+                        try:
+                            cols = [desc[0] for desc in cur.description]
+                            new_vals = []
+                            for c, v in zip(cols, row):
+                                new_vals.append(master_id if c == fkcol else v)
+                            placeholders = ",".join(["%s"] * len(cols))
+                            cur.execute(
+                                "INSERT INTO " + jtable + " (" + ",".join(cols) + ") VALUES (" + placeholders + ") ON CONFLICT DO NOTHING",
+                                new_vals
+                            )
+                        except Exception:
+                            store.conn.rollback()
+                    cur.execute("DELETE FROM " + jtable + " WHERE " + fkcol + " = %s", (dup_id,))
+                
+                # Instead of deleting, mark them as deprecated based on user request
+                if entity_table == "resource":
+                    cur.execute("UPDATE " + entity_table + " SET title = COALESCE(title, '') || '-已废弃' WHERE id = %s AND COALESCE(title, '') NOT LIKE '%%-已废弃'", (dup_id,))
+                else:
+                    cur.execute("UPDATE " + entity_table + " SET name = COALESCE(name, '') || '-已废弃' WHERE id = %s AND COALESCE(name, '') NOT LIKE '%%-已废弃'", (dup_id,))
+        if not dry_run:
+            store.conn.commit()
+    finally:
+        cur.close()
+
+# ─── Pass 0: Tools ────────────────────────────────────────────────────────────────
+
+async def plan_tool_dedup(tool_store, model="anthropic/claude-sonnet-4.5") -> list:
+    """
+    Deduplicate tools using LLM to catch aliases (e.g. "PS" vs "Photoshop").
+    """
+    print("\n[Pass 0] Tool dedup (LLM semantic batching)...")
+    tools = tool_store.list_all(limit=10000)
+    print("  Total tools: %d" % len(tools))
+
+    payload = []
+    # Deduplicate exact name matching locally first to reduce LLM load
+    name_map = {}
+    exact_merges = []
+    for t in tools:
+        t_name = t.get("name") or t["id"]
+        t_lower = t_name.strip().lower()
+        
+        full_tool = {
+            "id": t["id"], 
+            "name": t_name,
+            "introduction": t.get("introduction", ""),
+            "tutorial": t.get("tutorial", "")
+        }
+        
+        if t_lower in name_map:
+            exact_merges.append((name_map[t_lower], t))
+        else:
+            name_map[t_lower] = t
+            payload.append(full_tool)
+
+    print("  Unique entities to send to LLM: %d" % len(payload))
+
+    tools_schema = [{
+        "type": "function",
+        "function": {
+            "name": "submit_tool_merges",
+            "description": "Submit semantically identical tool merge groups along with their synthesized complete field states",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "merges": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "master_id": {"type": "string", "description": "ID of the tool chosen to be the master"},
+                                "duplicate_ids": {"type": "array", "items": {"type": "string"}, "description": "IDs of the duplicate tools"},
+                                "merged_state": {
+                                    "type": "object",
+                                    "description": "The ultimate merged state of this tool, combining the best information from all duplicates.",
+                                    "properties": {
+                                        "name": {"type": "string", "description": "The standardized, optimal industry-consensus name"},
+                                        "introduction": {"type": "string", "description": "Combined and normalized introduction text"},
+                                        "tutorial": {"type": "string", "description": "Combined tutorial text if any"}
+                                    },
+                                    "required": ["name"]
+                                }
+                            },
+                            "required": ["master_id", "duplicate_ids", "merged_state"]
+                        }
+                    }
+                },
+                "required": ["merges"]
+            }
+        }
+    }]
+
+    prompt = (
+        "你是一个 AI 工具注册表维护专家。下面是一个软件/工具实体的列表。\n"
+        "你的任务是找出所有因为别名、缩写或微小拼写差异（例如 'PS' 和 'Photoshop'）造成的重复工具条目。\n"
+        "对于每一组极其肯定为重复的项，请指定一个 master_id（保留的主干），列出 duplicate_ids（待废弃的重复项），并合成一个强大的 `merged_state` 对象。\n"
+        "这个 `merged_state` 必须智能地吸收并结合它们各自的描述与教程信息，并敲定最官方权威的工具名称 `name`。\n\n"
+        "工具列表:\n" + json.dumps(payload, ensure_ascii=False, indent=2)
+    )
+
+    print("  Calling %s..." % model)
+    try:
+        resp = await openrouter_llm_call(
+            messages=[{"role": "user", "content": prompt}],
+            model=model,
+            tools=tools_schema,
+            tool_choice="required",
+            max_tokens=4096
+        )
+        tool_calls = resp.get("tool_calls", [])
+    except Exception as e:
+        print("  LLM call failed: %s" % e)
+        tool_calls = []
+
+    merges = []
+    
+    # Add the local exact matches first
+    exact_groups = {}
+    for master, dup in exact_merges:
+        exact_groups.setdefault(master["id"], {"master": master, "dups": []})["dups"].append(dup)
+        
+    for m_id, grp in exact_groups.items():
+        merges.append({
+            "enabled": True,
+            "master": {"id": m_id, "name": grp["master"]["name"]},
+            "duplicates": [{"id": d["id"], "name": d["name"], "match_reason": "exact_name_local"} for d in grp["dups"]],
+            "merged_result": "Keep master, redirect relations"
+        })
+
+    # Add the LLM matches
+    if tool_calls:
+        try:
+            args = json.loads(tool_calls[0]["function"]["arguments"])
+            llm_merges = args.get("merges", [])
+            print("  LLM returned %d merge groups." % len(llm_merges))
+            
+            # map back to names
+            id_name_map = {t["id"]: t["name"] for t in payload}
+            
+            for m in llm_merges:
+                m_id = m["master_id"]
+                d_ids = m["duplicate_ids"]
+                m_state = m.get("merged_state", {})
+                if m_id not in id_name_map: continue
+                
+                dups = []
+                for d_id in d_ids:
+                    if d_id in id_name_map and d_id != m_id:
+                        dups.append({"id": d_id, "name": id_name_map[d_id], "match_reason": "llm_semantic"})
+                
+                if dups:
+                    merges.append({
+                        "enabled": True,
+                        "master": {"id": m_id, "name": id_name_map[m_id], "merged_state": m_state},
+                        "duplicates": dups,
+                        "merged_result": "Keep master, update fields to merged_state, redirect relations"
+                    })
+        except Exception as e:
+            print("  Error parsing LLM response:", e)
+
+    print("  Total Tool clusters to merge: %d" % len(merges))
+    return merges
+
+# ─── Pass 1: Cases ────────────────────────────────────────────────────────────
+
+def plan_case_dedup(res_store) -> list:
+    print("\n[Pass 1] Case dedup (source_url exact + title fuzzy >80%%)...")
+    cases = res_store.list_resources(content_type="case", limit=10000)
+    print("  Total cases: %d" % len(cases))
+
+    def get_url(c):
+        import json as _json
+        meta = c.get("metadata") or {}
+        if isinstance(meta, str):
+            try: meta = _json.loads(meta)
+            except Exception: meta = {}
+        return (meta.get("source_url") or "").strip()
+
+    processed = set()
+    merges = []
+
+    # Step 1: Exact URL match
+    url_groups = {}
+    for c in cases:
+        url = get_url(c)
+        if url:
+            url_groups.setdefault(url, []).append(c)
+
+    for url, group in url_groups.items():
+        if len(group) < 2:
+            continue
+        master = group[0]
+        dups = []
+        for b in group[1:]:
+            if b["id"] in processed or master["id"] in processed:
+                continue
+            dups.append({"id": b["id"], "title": b.get("title", ""),
+                         "match_reason": "exact_url", "similarity": 1.0, "source_url": url})
+            processed.add(b["id"])
+        if dups:
+            processed.add(master["id"])
+            merges.append({
+                "enabled": True,
+                "master": {"id": master["id"], "title": master.get("title", ""), "source_url": url},
+                "duplicates": dups,
+                "merged_result": "Keep master, redirect all relations to master id"
+            })
+
+    # Step 2: Title fuzzy match fallback
+    for i, a in enumerate(cases):
+        if a["id"] in processed:
+            continue
+        dups = []
+        for j in range(i + 1, len(cases)):
+            b = cases[j]
+            if b["id"] in processed:
+                continue
+            score = sim(a.get("title", ""), b.get("title", ""))
+            if score > 0.80:
+                dups.append({"id": b["id"], "title": b.get("title", ""),
+                             "match_reason": "title_fuzzy", "similarity": round(score, 3)})
+                processed.add(b["id"])
+        if dups:
+            processed.add(a["id"])
+            merges.append({
+                "enabled": True,
+                "master": {"id": a["id"], "title": a.get("title", ""), "source_url": get_url(a)},
+                "duplicates": dups,
+                "merged_result": "Keep master, redirect all relations to master id"
+            })
+
+    url_m = sum(1 for m in merges if any(d.get("match_reason") == "exact_url" for d in m["duplicates"]))
+    print("  URL exact: %d groups, Title fuzzy: %d groups" % (url_m, len(merges) - url_m))
+    return merges
+
+# ─── Pass 2: Capabilities ─────────────────────────────────────────────────────
+
+async def plan_cap_dedup(cap_store, model="anthropic/claude-sonnet-4.5") -> list:
+    print("\n[Pass 2] Capability dedup (LLM Global Clustering + LLM Detailed Merging)...")
+    caps = cap_store.list_all(limit=10000)
+    print("  Total capabilities: %d" % len(caps))
+
+    # Phase 1: Global LLM Clustering
+    print("  Running Phase 1: Global capability clustering via LLM...")
+    minimal_caps = [{"id": c["id"], "name": c.get("name", "")} for c in caps]
+    
+    cluster_schema = [{
+        "type": "function",
+        "function": {
+            "name": "generate_candidate_clusters",
+            "description": "Group identical or highly similar capability IDs together.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "clusters": {
+                        "type": "array",
+                        "items": {
+                            "type": "array",
+                            "items": {"type": "string", "description": "capability ID"}
+                        }
+                    }
+                },
+                "required": ["clusters"]
+            }
+        }
+    }]
+    
+    cluster_prompt = (
+        "你是一个顶级的全景归类AI。下面是数据库中现存的所有「原子能力」极简清单。\n"
+        "你的任务是仔细阅读它们的名字，找出所有**在业务意义上完全相同或可以合并**的能力，哪怕它们的字面长短不一、用词差异极大。\n"
+        "将那些应当被认为是完全重复或高度同质化的原子能力ID打包在一起，形成聚类数组。\n"
+        "注意：只有包含 2 个或以上名字的能力圈子才需要返回。你必须尽可能不遗漏任何有合并价值的核心节点。\n\n"
+        "能力清单：\n" + json.dumps(minimal_caps, ensure_ascii=False)
+    )
+    
+    try:
+        resp = await openrouter_llm_call(
+            messages=[{"role": "user", "content": cluster_prompt}], 
+            model=model, 
+            tools=cluster_schema, 
+            tool_choice="required", 
+            max_tokens=8192
+        )
+        t_calls = resp.get("tool_calls")
+        if not t_calls:
+            print("  Phase 1 returned no tool calls/clusters.")
+            return []
+        args = json.loads(t_calls[0]["function"]["arguments"])
+        cluster_ids = args.get("clusters", [])
+    except Exception as e:
+        print("  [Error] Phase 1 Global Clustering failed: %s" % e)
+        return []
+        
+    print("  Phase 1 raw LLM clustering returned %d clusters." % len(cluster_ids))
+    
+    # Map IDs back to detailed capability objects
+    caps_map = {c["id"]: c for c in caps}
+    candidate_clusters = []
+    for id_list in cluster_ids:
+        real_objs = [caps_map[cid] for cid in id_list if cid in caps_map]
+        if len(real_objs) > 1:
+            candidate_clusters.append(real_objs)
+
+    print("  Valid candidate clusters hydrated: %d (total items: %d)" % (
+        len(candidate_clusters), sum(len(c) for c in candidate_clusters)))
+
+    if not candidate_clusters:
+        return []
+
+    print("  Running Phase 2: Detailed merging of candidate clusters...")
+
+    # Build payload for Qwen - candidate clusters equipped with details
+    payload = []
+    for cluster in candidate_clusters:
+        grp = []
+        for c in cluster:
+            effects_str = c.get("effects") or "[]"
+            try:
+                if isinstance(effects_str, str): effects_obj = json.loads(effects_str)
+                else: effects_obj = effects_str
+            except: effects_obj = []
+            
+            implements_str = c.get("implements") or "{}"
+            try:
+                if isinstance(implements_str, str): imps_obj = json.loads(implements_str)
+                else: imps_obj = implements_str
+            except: imps_obj = {}
+            
+            criterion_str = c.get("criterion") or "[]"
+            try:
+                if isinstance(criterion_str, str): crit_obj = json.loads(criterion_str)
+                else: crit_obj = criterion_str
+            except: crit_obj = []
+            
+            grp.append({
+                "id": c["id"],
+                "name": c.get("name", ""),
+                "description": c.get("description", ""),
+                "effects": effects_obj,
+                "implements": imps_obj,
+                "criterion": crit_obj
+            })
+        payload.append(grp)
+
+    tools_schema = [{
+        "type": "function",
+        "function": {
+            "name": "submit_capability_merges",
+            "description": "Submit semantically IDENTICAL capability merge groups, complete with synthesized fields",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "merges": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "master_id": {"type": "string"},
+                                "duplicate_ids": {"type": "array", "items": {"type": "string"}},
+                                "merged_description": {"type": "string", "description": "A comprehensive, combined description integrating details from all merged capabilities."},
+                                "synthesized_effects": {
+                                    "type": "array", 
+                                    "items": {"type": "object"},
+                                    "description": "A deduplicated, logically combined array of all effects from the master and duplicates."
+                                },
+                                "synthesized_implements": {
+                                    "type": "object",
+                                    "description": "A deduplicated, logically combined dictionary map of all implements/parameters from the master and duplicates."
+                                },
+                                "synthesized_criterion": {
+                                    "type": "array",
+                                    "items": {"type": "object"},
+                                    "description": "A deduplicated, logically combined array of evaluation criteria from the master and duplicates."
+                                }
+                            },
+                            "required": ["master_id", "duplicate_ids", "merged_description", "synthesized_effects", "synthesized_implements", "synthesized_criterion"]
+                        }
+                    }
+                },
+                "required": ["merges"]
+            }
+        }
+    }]
+
+    prompt_template = (
+        "你是一个高级 AI 知识图谱工程师。下面是若干组经过粗筛的候选「原子能力」簇。\n"
+        "请仔细分析每个簇中的能力，判断它们是否属于语义和操作本质上完全相同的原子动作。\n"
+        "如果它们的核心本质和底层操作逻辑根本就是一回事（即使举例或关联对象有微小差异），你也**必须**将它们合并！\n"
+        "对于每决定好的一组合并：选择一个最佳的 master_id，将其他的塞进 duplicate_ids。\n"
+        "核心任务：你必须亲自操刀，合成一份大一统综合描述 `merged_description`；\n"
+        "生成一个去重后的影响力效果数组 `synthesized_effects`；\n"
+        "生成一个整合了所有实现级参数与独立用法的字典 `synthesized_implements`；\n"
+        "最后，生成一个保留全部评判标准的去重评估数组 `synthesized_criterion`。\n\n"
+        "候选原子能力簇：\n{payload_json}"
+    )
+
+    BATCH_SIZE = 5
+    batches = [payload[i:i + BATCH_SIZE] for i in range(0, len(payload), BATCH_SIZE)]
+    print("  Calling %s in %d batches..." % (model, len(batches)))
+
+    async def process_batch(batch):
+        prompt = prompt_template.format(payload_json=json.dumps(batch, ensure_ascii=False, indent=2))
+        try:
+            resp = await openrouter_llm_call(messages=[{"role": "user", "content": prompt}], model=model, tools=tools_schema, tool_choice="required", max_tokens=4096)
+            t_calls = resp.get("tool_calls")
+            if not t_calls: return []
+            args = json.loads(t_calls[0]["function"]["arguments"])
+            return args.get("merges", [])
+        except Exception as e:
+            print("  [Error] LLM batch failed: %s" % e)
+            return []
+
+    results = await asyncio.gather(*(process_batch(b) for b in batches))
+    
+    final_merges = []
+    total_merges = 0
+    for merges in results:
+        total_merges += len(merges)
+        for m in merges:
+            final_merges.append({
+                "enabled": True,
+                "master": {
+                    "id": m["master_id"],
+                    "merged_description": m.get("merged_description", ""),
+                    "synthesized_effects": m.get("synthesized_effects", []),
+                    "synthesized_implements": m.get("synthesized_implements", {}),
+                    "synthesized_criterion": m.get("synthesized_criterion", [])
+                },
+                "duplicates": [{"id": d_id} for d_id in m["duplicate_ids"]],
+                "merged_result": "Keep master, update fields, redirect relations"
+            })
+            
+    print("  LLM suggested %d total merge groups across all batches." % total_merges)
+    return final_merges
+
+# ─── Pass 3: Strategies (Jaccard on capability_ids) ───────────────────────────
+
+async def plan_strategy_dedup(strat_store, model="anthropic/claude-sonnet-4.5", threshold=0.45) -> list:
+    print("\n[Pass 3] Strategy dedup (Jaccard > %.0f%% + LLM workflow refinement)..." % (threshold * 100))
+    strats = strat_store.list_all(limit=10000)
+    print("  Total strategies: %d" % len(strats))
+
+    cap_sets = {}
+    for s in strats:
+        ids = set(s.get("capability_ids") or [])
+        if ids: cap_sets[s["id"]] = ids
+
+    processed = set()
+    candidate_clusters = []
+    strat_list = [s for s in strats if s["id"] in cap_sets]
+
+    # Pre-filter clusters
+    for i, a in enumerate(strat_list):
+        if a["id"] in processed: continue
+        cluster = [a]
+        sa = cap_sets[a["id"]]
+        for j in range(i + 1, len(strat_list)):
+            b = strat_list[j]
+            if b["id"] in processed: continue
+            sb = cap_sets[b["id"]]
+            if not sa and not sb: continue
+            jaccard = len(sa & sb) / len(sa | sb)
+            if jaccard >= threshold:
+                cluster.append(b)
+                processed.add(b["id"])
+        if len(cluster) > 1:
+            processed.add(a["id"])
+            candidate_clusters.append(cluster)
+
+    print("  Candidate strategy clusters (Jaccard > %.0f%%): %d" % (threshold * 100, len(candidate_clusters)))
+    if not candidate_clusters: return []
+
+    payload = []
+    for cluster in candidate_clusters:
+        grp = []
+        for s in cluster:
+            body_str = s.get("body") or "{}"
+            try:
+                if isinstance(body_str, str): b_obj = json.loads(body_str)
+                else: b_obj = body_str
+            except: b_obj = {"_raw": body_str}
+            
+            # Extract just the steps to save tokens (user requested mainly description)
+            workflow = b_obj.get("workflow", [])
+            condensed_workflow = [{"phase": w.get("phase", ""), "description": w.get("description", "")} for w in workflow]
+            
+            grp.append({
+                "id": s["id"],
+                "name": s.get("name", "Unnamed Strategy"),
+                "workflow_summary": condensed_workflow
+            })
+        payload.append(grp)
+
+    strat_schema = [{
+        "type": "function",
+        "function": {
+            "name": "submit_strategy_merges",
+            "description": "Submit semantically identical strategy workflows, consolidating their step instructions.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "merges": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "master_id": {"type": "string"},
+                                "duplicate_ids": {"type": "array", "items": {"type": "string"}},
+                                "merged_workflow": {
+                                    "type": "array",
+                                    "items": {"type": "object"},
+                                    "description": "A logically synthesized, unified pipeline array combining the best steps from the merged strategies."
+                                }
+                            },
+                            "required": ["master_id", "duplicate_ids", "merged_workflow"]
+                        }
+                    }
+                },
+                "required": ["merges"]
+            }
+        }
+    }]
+
+    prompt_template = (
+        "你是一个资深人工智能工作流引擎架构师。下面是一批疑似重合的候选「执行工序（Strategy）」簇。\n"
+        "每个簇里包含多个工作流定义，请极其苛刻地审视它们的步骤顺序与逻辑意图。\n"
+        "如果多个工作流指挥的是一段**从根本上完全一样的核心处理链路**（即使修饰词、举例、参数或个别无关紧要的废话步骤有别），你也**应该**将它们合并。\n"
+        "注意：如果同一个簇里的工序代表了截然不同的概念流派分支，你可以分别输出多组合并（或直接决绝合并，不返回内容）。\n"
+        "对于同意合并的组：指定一个 master_id、列出 duplicate_ids，并提炼一个 `merged_workflow`（合并后的工作流数组）。\n"
+        "在这个 `merged_workflow` 里，请存放经过你清洗、压缩、取长补短后所形成的最干货、最权威的完整操作指令步骤。\n\n"
+        "候选工序簇：\n{payload_json}"
+    )
+
+    BATCH_SIZE = 8
+    batches = [payload[i:i + BATCH_SIZE] for i in range(0, len(payload), BATCH_SIZE)]
+    print("  Calling %s in %d batches..." % (model, len(batches)))
+
+    async def process_batch(batch):
+        prompt = prompt_template.format(payload_json=json.dumps(batch, ensure_ascii=False, indent=2))
+        try:
+            resp = await openrouter_llm_call(messages=[{"role": "user", "content": prompt}], model=model, tools=strat_schema, tool_choice="required", max_tokens=4096)
+            t_calls = resp.get("tool_calls")
+            if not t_calls: return []
+            args = json.loads(t_calls[0]["function"]["arguments"])
+            return args.get("merges", [])
+        except Exception as e:
+            print("  [Error] LLM batch failed: %s" % e)
+            return []
+
+    results = await asyncio.gather(*(process_batch(b) for b in batches))
+
+    merges = []
+    total_merges = 0
+    for llm_merges in results:
+        total_merges += len(llm_merges)
+        for m in llm_merges:
+            merges.append({
+                "enabled": True,
+                "master": {
+                    "id": m["master_id"],
+                    "merged_workflow": m.get("merged_workflow", [])
+                },
+                "duplicates": [{"id": d_id} for d_id in m["duplicate_ids"]],
+                "merged_result": "Keep master, update workflow body, reparent links"
+            })
+            
+    print("  LLM suggested %d total merge groups across all batches." % total_merges)
+    return merges
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+async def run_analysis(res_store, cap_store, strat_store, req_store, tool_store, caps_only=False):
+    plan = {}
+    plan["tools"] = []
+    plan["cases"] = []
+    plan["capabilities"] = await plan_cap_dedup(cap_store)
+    if not caps_only:
+        plan["strategies"] = await plan_strategy_dedup(strat_store)
+    else:
+        plan["strategies"] = []
+    return plan
+
+def execute_plan(plan, res_store, cap_store, strat_store, req_store, tool_store, dry_run: bool):
+    tag = "[DRY-RUN] " if dry_run else ""
+
+    # 先跳过 tools 和 cases
+    plan["tools"] = []
+    plan["cases"] = []
+
+    print("\n%s=== Applying Tool Merges & Synthesized Fields ===" % tag)
+    tool_merges = plan.get("tools", [])
+    if tool_merges:
+        cur = tool_store._get_cursor()
+        try:
+            for m in tool_merges:
+                if not m.get("enabled", True): continue
+                st = m["master"].get("merged_state")
+                if st:
+                    print("    Update fields for %s -> %s" % (m["master"]["id"], st.get("name")))
+                    if not dry_run:
+                        cur.execute(
+                            "UPDATE tool SET name = COALESCE(%s, name), introduction = COALESCE(%s, introduction), tutorial = COALESCE(%s, tutorial) WHERE id = %s",
+                            (st.get("name"), st.get("introduction"), st.get("tutorial"), m["master"]["id"])
+                        )
+            if not dry_run:
+                tool_store.conn.commit()
+        finally:
+            cur.close()
+
+    apply_merges(tool_store, "tool", [
+        ("capability_tool", "tool_id"),
+        ("tool_knowledge",  "tool_id"),
+        ("tool_provider",   "tool_id"),
+    ], tool_merges, dry_run)
+
+    print("\n%s=== Applying Case Merges ===" % tag)
+    apply_merges(res_store, "resource", [
+        ("requirement_resource", "resource_id"),
+        ("strategy_resource",    "resource_id"),
+        ("capability_resource",  "resource_id"),
+    ], plan.get("cases", []), dry_run)
+
+    print("\n%s=== Applying Capability Merges & Synthesized Fields ===" % tag)
+    cap_merges = plan.get("capabilities", [])
+    if cap_merges:
+        cur = cap_store._get_cursor()
+        try:
+            for m in cap_merges:
+                if not m.get("enabled", True): continue
+                m_desc = m["master"].get("merged_description")
+                s_effs = m["master"].get("synthesized_effects")
+                s_imps = m["master"].get("synthesized_implements")
+                s_crit = m["master"].get("synthesized_criterion")
+                if m_desc or s_effs or s_crit:
+                    print("    Update %s -> new fields" % m["master"]["id"])
+                    if not dry_run:
+                        cur.execute("UPDATE capability SET description = COALESCE(%s, description), effects = COALESCE(%s::jsonb, effects), criterion = COALESCE(%s, criterion) WHERE id = %s",
+                                    (m_desc, json.dumps(s_effs, ensure_ascii=False) if s_effs else None, json.dumps(s_crit, ensure_ascii=False) if s_crit else None, m["master"]["id"]))
+                        
+                        # implements 是关联表 capability_tool 中的 description
+                        if s_imps:
+                            for t_id, desc in s_imps.items():
+                                cur.execute("UPDATE capability_tool SET description = %s WHERE tool_id = %s AND capability_id IN %s",
+                                            (desc, t_id, tuple([m["master"]["id"]] + [d["id"] for d in m.get("duplicates", [])])))
+            if not dry_run:
+                cap_store.conn.commit()
+        finally:
+            cur.close()
+
+    apply_merges(cap_store, "capability", [
+        ("requirement_capability", "capability_id"),
+        ("strategy_capability",    "capability_id"),
+        ("capability_tool",        "capability_id"),
+        ("capability_knowledge",   "capability_id"),
+        ("capability_resource",    "capability_id"),
+    ], plan.get("capabilities", []), dry_run)
+
+    print("\n%s=== Applying Strategy Merges & Workflows ===" % tag)
+    strat_merges = plan.get("strategies", [])
+    if strat_merges:
+        cur = strat_store._get_cursor()
+        try:
+            for m in strat_merges:
+                if not m.get("enabled", True): continue
+                m_wf = m["master"].get("merged_workflow")
+                if m_wf:
+                    print("    Update %s -> new workflow array" % m["master"]["id"])
+                    if not dry_run:
+                        # Strategy body is a jsonb. We update body -> 'workflow'
+                        cur.execute("""
+                            UPDATE strategy
+                            SET body = jsonb_set(body, '{workflow}', %s::jsonb)
+                            WHERE id = %s
+                        """, (json.dumps(m_wf, ensure_ascii=False), m["master"]["id"]))
+            if not dry_run:
+                strat_store.conn.commit()
+        finally:
+            cur.close()
+
+    apply_merges(strat_store, "strategy", [
+        ("requirement_strategy", "strategy_id"),
+        ("strategy_capability",  "strategy_id"),
+        ("strategy_knowledge",   "strategy_id"),
+        ("strategy_resource",    "strategy_id"),
+    ], plan.get("strategies", []), dry_run)
+
+async def main():
+    parser = argparse.ArgumentParser(description="Semantic dedup for KnowHub DB")
+    parser.add_argument("--dry-run",  action="store_true", help="Analyze only, save plan, do not write DB")
+    parser.add_argument("--execute",  action="store_true", help="Execute saved dedup_plan.json without re-analyzing")
+    parser.add_argument("--caps-only", action="store_true", help="Only run capability deduplication and skip strategies")
+    args = parser.parse_args()
+
+    print("Connecting to DB...")
+    res_store   = PostgreSQLResourceStore()
+    cap_store   = PostgreSQLCapabilityStore()
+    strat_store = PostgreSQLStrategyStore()
+    req_store   = PostgreSQLRequirementStore()
+    tool_store  = PostgreSQLToolStore()
+
+    try:
+        if args.execute:
+            if not PLAN_FILE.exists():
+                print("ERROR: dedup_plan.json not found. Run --dry-run first.")
+                return
+            print("Loading plan from %s ..." % PLAN_FILE)
+            plan = json.loads(PLAN_FILE.read_text(encoding="utf-8"))
+            execute_plan(plan, res_store, cap_store, strat_store, req_store, tool_store, dry_run=False)
+            print("\nAll merges applied.")
+
+        else:
+            plan = await run_analysis(res_store, cap_store, strat_store, req_store, tool_store, caps_only=args.caps_only)
+
+            PLAN_FILE.write_text(json.dumps(plan, ensure_ascii=False, indent=2), encoding="utf-8")
+            print("\nPlan saved to: %s" % PLAN_FILE)
+            total_merges = sum(len(plan.get(k, [])) for k in ("tools", "cases", "capabilities", "strategies"))
+            print("Total merge groups planned: %d" % total_merges)
+
+            if args.dry_run:
+                print("\n[DRY-RUN] No DB changes made. Review dedup_plan.json then run --execute.")
+                execute_plan(plan, res_store, cap_store, strat_store, req_store, tool_store, dry_run=True)
+            else:
+                execute_plan(plan, res_store, cap_store, strat_store, req_store, tool_store, dry_run=False)
+                print("\nAll merges applied.")
+    finally:
+        res_store.close()
+        cap_store.close()
+        strat_store.close()
+        req_store.close()
+        tool_store.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/process_pipeline/script/dedup_plan.json

@@ -0,0 +1,608 @@
+{
+  "tools": [],
+  "cases": [],
+  "capabilities": [
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-009",
+        "merged_description": "基于文本描述或参考图像，生成具有时间连贯性的动画帧序列，使内容产生动态运动效果。支持将静态图像转换为动态视频，可实现超现实动态效果（如颜色渐变、光效流动等），适用于魔幻视觉、音乐视频、冥想/ASMR场景等多种内容类型。可在无专业特效团队的情况下独立完成多镜头奇幻短片制作。",
+        "synthesized_effects": [
+          "MidJourney+Kling制作的奇幻音乐视频在YouTube获得4886点赞、399条评论，高互动率证明魔幻光效动态视频的强吸引力",
+          "AI生成的动态光效视频可实现篝火颜色缓慢渐变为彩虹色等超现实效果，适合冥想/ASMR场景",
+          "多镜头奇幻短片可在无专业特效团队的情况下独立完成，大幅降低魔幻视觉内容的制作门槛"
+        ],
+        "synthesized_implements": {
+          "tools/workflow/comfyui": "AnimateDiff 自定义节点 + ControlNet（保持角色一致性）+ KSampler + 视频合成节点工作流",
+          "midjourney_submit_job": "结合Kling等视频生成工具，将MidJourney静态图转换为动态视频"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-523c8623"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-007",
+        "merged_description": "将黑白或低饱和度的图像自动上色，生成色彩自然、符合语义的彩色图像。支持跨图像色彩统一处理，可将多张图像的色调调整为一致风格，显著提升合成场景的视觉真实感和连贯性。",
+        "synthesized_effects": [
+          "5只毛色各异的猫经过色彩统一处理后，视觉上呈现为同一只猫的不同角度，大幅提升合成真实感"
+        ],
+        "synthesized_implements": {
+          "tools/workflow/comfyui": "DeOldify 模型节点或类似上色模型节点 + 图像输入 + VAEDecode 工作流；结合 Hue/Saturation 调整层实现跨图像色彩统一"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-75ba0eac"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-006",
+        "merged_description": "对已生成的图像进行分辨率提升和细节增强，在放大的同时补充高频细节（后处理路径，区别于生成阶段直接高清输出的 CAP-016）。支持将图像放大至4K分辨率，使光效细节（如粒子光点、光线边缘）、纹理细节（如金饰、飘带、发丝）在大尺寸下依然精致锐利，适合大屏展示或商业用途。",
+        "synthesized_effects": [
+          "4K upscale后光效细节（如粒子光点、光线边缘）更加清晰锐利，适合大屏展示或商业用途",
+          "高清放大使金色粒子流光特效的细节纹理（金饰、飘带、发丝）在大尺寸下依然精致"
+        ],
+        "synthesized_implements": {
+          "tools/workflow/comfyui": "Ultimate SD Upscale 自定义节点 + Tile ControlNet 模型 + VAEDecode 工作流；大图使用 Tiled VAE 节点避免显存溢出",
+          "Runway Aleph": "内置4K upscale功能，可将生成的光效视频片段放大到4K分辨率"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-767e7848"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-067edd94",
+        "merged_description": "在图文排版生成中，通过多种技术手段构建清晰的信息层级结构（标题→副标题→正文→注释），引导读者视线按预设路径流动，提升内容的可读性和信息传达效率。技术实现包括：（1）传统排版元素差异化处理：字号大小、字重、留白、分段、图标等视觉元素的差异化应用；（2）AI生成阶段权重控制：通过注意力掩码（Attention Mask）或区域提示词权重控制，在AI生成阶段即对不同信息区域施加差异化的生成权重，使主要信息区域（标题、核心数据）获得更高的视觉突出度，次要信息区域（正文、背景）保持适当的视觉弱化。两种技术路径均可实现版面信息层级的清晰表达，无需后期手工调整。",
+        "synthesized_effects": [
+          "养生类长文排版的阅读完成率提升，用户不因信息密度过高而中途放弃阅读",
+          "清晰的信息层级使健康知识要点一目了然，用户收藏和转发意愿增强",
+          "标准化的层级排版规范可复用于批量内容生产，保证多篇内容的视觉一致性",
+          "版面信息层级清晰，用户视线可自然从标题引导至核心数据再到正文，阅读体验流畅",
+          "主要信息区域视觉突出度显著提升，核心数据和标题在版面中一目了然",
+          "无需后期手工调整各区域对比度，AI 生成阶段即完成信息层级的视觉化表达"
+        ],
+        "synthesized_implements": {
+          "Canva AI设计系统": "通过模板预设字号层级（主标题/副标题/说明文字），AI自动应用到批量生成的内容中，保持视觉层次一致性",
+          "Claude + HTML模板工作流": "在CLAUDE.md品牌规则文件中定义字号层级规范，Claude自动按规则构建HTML排版，QA Agent检查视觉层次是否达标（15+设计检查项）",
+          "提示词工程 + 后期图层分离": "在提示词中详细描述层级需求（如'大标题用72号粗体黑色、小标题用36号中等灰色、正文用18号浅灰色'），生成后通过图层分离工具拆分并调整",
+          "ComfyUI + 自定义排版节点": "通过自定义节点接收结构化文本输入，结合预设的排版规则（字号比例、颜色方案、间距参数），自动生成分层排版的图像",
+          "midjourney_submit_job": "通过提示词指定'bold typography'、'large headline'、'visual hierarchy'等参数，生成具有明确字号层次的图文内容",
+          "Morpholio Trace（Studio Text）": "创建多个 Studio Text Layer 分别承载不同层级的文字内容，通过图层顺序和样式差异实现信息分层",
+          "Canva AI（模板 + 文字层级）": "使用 Canva 预设模板的分区结构，通过调整文字大小、色块背景、图标 bullet 实现信息层级分区，支持 STEP 步骤结构、编号列表、条列式等多种层级表达方式",
+          "AI 海报生成工具（如 Canva AI、Seedream）": "通过提示词描述信息层级结构（如 'large title at top, subtitle below, icon bullet list in middle section'），AI 直接生成符合层级布局的海报",
+          "AI信息图生成工具（如Canva AI、美图设计室AI等）": "输入结构化文本内容和层级标记，AI自动应用版式模板，生成具有层级关系的信息图",
+          "flux_generate": "在提示词中描述排版层级结构（如 clear typographic hierarchy, title in large bold text, body text in smaller regular weight, generous whitespace between sections），引导模型生成具有层级感的图文排版",
+          "tools/workflow/comfyui": "Regional Conditioning 节点（区域条件控制）+ Attention Mask 输入 + CLIP 区域权重调节 + KSampler 工作流，实现版面不同区域的差异化生成权重控制"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-94c648d6"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-6af51b66",
+        "merged_description": "将角色、人物或主体元素与指定的场景背景进行自动合成，生成主体置于目标场景中的完整图像。支持多种背景来源：现成的场景图片、纯色/渐变/材质背景、或AI生成的创意场景（如雪山、梦幻环境、超现实场景）。可处理白底图、透明底图或实拍主体，实现低成本、高创意的场景置景效果，无需手动抠图或复杂合成操作。",
+        "synthesized_effects": [
+          {
+            "description": "白底角色图秒变多场景效果图，一键完成，无需手动合成"
+          },
+          {
+            "description": "同一角色快速适配办公室/草地/室内等多种场景，表情包使用场景大幅扩展"
+          },
+          {
+            "description": "批量场景替换后可快速生成完整表情包系列，上架效率提升数倍"
+          },
+          {
+            "description": "低成本实现梦幻场景，无需外景拍摄"
+          },
+          {
+            "description": "创意天马行空，不受现实场景限制"
+          },
+          {
+            "description": "Great tutorial评价，光照分析部分particularly valuable"
+          },
+          {
+            "description": "统一色调背景使拼贴整体视觉更和谐，无需反复调整"
+          },
+          {
+            "description": "材质背景增加手工质感，用户反馈作品更有温度"
+          },
+          {
+            "description": "局限性：脚周边素材需保持原素材，光线无法映射影子，人物不能乱动"
+          }
+        ],
+        "synthesized_implements": {
+          "flux_generate": "使用场景描述prompt配合角色参考图，生成角色+场景合成图",
+          "bili_015工具流": "AI一键将白底图转换为办公室/草地/室内等场景效果图",
+          "即梦AI / Dreamina": "上传角色图，描述目标场景，AI自动生成角色置于场景中的合成图",
+          "Midjourney + Topaz Photo AI": "在MidJourney生成场景，用Topaz Photo AI放大，分析光照后在工作室重现光效，最后在Photoshop合成",
+          "AI视频合成工具": "自由更换视频背景，但存在光线映射、人物动作等局限性",
+          "Midjourney + Photoshop": "先用Midjourney生成场景图，拍摄时模拟AI场景的光效，在Photoshop里抠图合成",
+          "醒图": "选择色调一致的图片做背景图，不抠图直接导入",
+          "ProCCD 跨屏拼图": "点击跨屏拼图新建画布，选择纯色/渐变色/材质背景（推荐星星卡纸）",
+          "黄油相机": "背景搜索'星星卡纸'，根据照片色调选择合适背景"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-411da039"
+        },
+        {
+          "id": "CAP-66cd9fbf"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-ed4b506e",
+        "merged_description": "通过在AI生成提示词中使用专业摄影布光术语和精确的光照描述，驱动AI精准复现各种经典摄影布光模式和特定光效，包括但不限于：伦勃朗光（Rembrandt Lighting）、蝴蝶光（Butterfly Lighting）、侧逆光/轮廓光（Rim Lighting）、二分光（Split Lighting）、逆光发丝光（Backlit Hair Light）等。使生成图像呈现出专业摄影棚级别的光影结构、人物立体感和情绪氛围，特别擅长生成逆光场景中主体轮廓被光线勾勒的视觉效果，使人物或物体的边缘呈现出发光的金色/白色轮廓，营造神圣感或电影感氛围。",
+        "synthesized_effects": [
+          {
+            "description": "伦勃朗光提示词使AI生成的人像立即呈现出专业摄影棚级别的面部立体感，无需实体灯光设备"
+          },
+          {
+            "description": "侧逆光关键词可精准勾勒发丝轮廓，生成具有强烈情绪感的人像，用户反馈'极具情绪感'"
+          },
+          {
+            "description": "10个神仙光影词的系统化应用使AI摄影图像从普通生成跃升为'单反级质感'，获97点赞"
+          },
+          {
+            "description": "逆光发丝光效果案例获得 6319 赞（小红书），用户学习逆光拍摄技巧，证明该效果具有极高的视觉吸引力和传播价值"
+          },
+          {
+            "description": "B站教程反馈发丝光效果让人物剥离背景，皮肤通透，是最好用的人像布光方式，说明该能力可显著提升人像的专业感和层次感"
+          },
+          {
+            "description": "AI 生成逆光效果可替代需要特定时段（日落）和专业设备（反光板）的实拍条件，大幅降低创作门槛"
+          }
+        ],
+        "synthesized_implements": {
+          "Flux/Nano Banana": "使用 'high-contrast cinematic lighting from the side'、'warm spotlight halo'、'strong natural sunlight through window blinds casting striped shadows'、'sunlight from behind'、'translucent hair'、'glowing edges' 等具体描述实现精准布光效果和逆光轮廓效果",
+          "tools/image_gen/midjourney": "使用 'Rembrandt lighting'、'butterfly lighting'、'rim lighting'、'split lighting'、'underlighting'、'cameo lighting'、'three-point lighting'、'backlit' 等专业布光术语直接触发对应光影模式",
+          "tools/workflow/comfyui": "CheckpointLoader + CLIPTextEncode（含 rim light、backlit、Rembrandt lighting 等关键词）+ KSampler + VAEDecode；可配合 ControlNet Depth 图约束主体位置，确保光源在主体后方或特定角度"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-47151d87"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-d92ffc99",
+        "merged_description": "以参考服装图像为输入，利用扩散模型（如 IDM-VTON、OOTDiffusion、CatVTON、Klein 等）将指定服装自动迁移并穿戴到目标主体（人物模特或宠物）上，保持服装的颜色、纹理、款式特征不变，同时与主体体型、姿态自然融合，实现无需实物拍摄的虚拟换装效果。适用于电商服装展示、宠物表情包制作、时尚营销素材生成等场景。",
+        "synthesized_effects": [
+          "无需实物拍摄即可将任意服装穿戴到模特身上，大幅降低服装展示成本",
+          "可将超大号短裤、篮球短裤等日常物品以夸张方式穿戴到人物上，快速生成视觉反差效果图",
+          "批量生成不同服装组合的模特图，无需多次拍摄",
+          "3分钟内完成从普通主体照片到职业装换装的全流程，无需任何手工操作",
+          "同一主体可批量换遍医生服、西装、厨师服等所有职业服装，效率极高",
+          "换装效果自然贴合，服装与主体体型协调，可直接用于表情包制作或商业展示无需二次修图",
+          "CatVTON 等模型显卡要求低，普通消费级显卡即可运行，降低创作门槛"
+        ],
+        "synthesized_implements": {
+          "nano_banana (Gemini AI)": "使用 'Keep the same character sheet layout. Change the outfit to [outfit description]' 提示词模板更换服装",
+          "GPT-4o": "使用'保持角色风格不变，替换服装为XXX'的指令进行换装",
+          "Stable Diffusion + rolescene-blend LoRA": "使用 rolescene-blend LoRA 模型进行换装换脸万物迁移，支持任何角度姿势，效果超自然",
+          "Stable Diffusion Inpainting": "使用局部重绘（Inpaint）节点，蒙版遮住服装区域后重新生成指定服装",
+          "midjourney_submit_job": "使用 --oref 服装参考图 + 'Clothing Match & Recreating Your OREF' 技巧实现服装匹配",
+          "FLORA AI": "系统化工作流，输入服装单品图（上衣、下装）+ 模特参考 + 环境参考，自动合成完整时尚营销素材",
+          "FashionModelAI": "基于Replit Agent 4构建的专用工具，上传flat lay服装图片后自动生成模特上身效果",
+          "tools/workflow/comfyui": "IDM-VTON 或 OOTDiffusion 或 CatVTON 等虚拟试衣节点 + 服装分割蒙版 + KSampler 工作流，实现精准服装区域替换，支持人物和宠物主体",
+          "OpenAI Image Model": "上传多张服装参考图，使用简单提示词如'street style shot of a woman in this outfit'自动生成模特穿着照片",
+          "即梦AI / Nano Banana 2": "在角色描述中锁定外观特征，仅修改服装相关描述词",
+          "即梦图片 4.5 模型": "上传人物参考图和服装参考图，使用详细提示词描述服装细节，保持服装细节不变",
+          "Klein 模型 + ComfyUI 工作流": "上传人物图片+服装图片，使用 Klein 模型进行虚拟试衣，一键生成换装效果",
+          "Higgsfield AI Canvas": "使用 Canvas + Flux Kontext 在现有角色图上替换服装元素",
+          "LTX-2.3 换装术（RunningHub）": "在 RunningHub 平台调用 LTX-2.3 换装术工作流 → 上传主体照片 → 输入英文提示词描述目标服装 → 3分钟内生成换装结果",
+          "ComfyUI + CatVTON": "安装 CatVTON 插件（中山大学开源项目）→ 输入主体原图 + 职业服装参考图 → 扩散模型推理换装 → 输出换装结果；支持 T恤、套装、裙子等多种服装类型，显卡要求低，适用于宠物换装"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-bcdfba3c"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-c5beae45",
+        "merged_description": "在AI图像生成阶段，通过提示词中的极简主义构图语义描述（如留白、负空间、极简、单一元素、稀疏元素、禅意美学等）引导模型生成大面积空白、元素极少的极简构图画面。该能力适用于多种场景，包括东方禅意艺术创作、现代极简美学表达、产品展示图生成等，使画面呈现'以少胜多'的高级感，避免信息密集的复杂构图。核心特征是干净的单色或简洁背景、居中对称或经典三分构图、最少的视觉干扰元素、突出主体的空间留白。",
+        "synthesized_effects": [
+          {
+            "description": "通过极简构图提示词，AI可直接生成大面积留白的禅意画面，用户评价'黑白之间藏禅意，静谧无声胜万语'",
+            "source": "CAP-c5beae45"
+          },
+          {
+            "description": "极简水墨风格AI生成案例获得346-495赞，证明该构图风格具有稳定的用户审美共鸣",
+            "source": "CAP-c5beae45"
+          },
+          {
+            "description": "极简构图生成可快速产出适合社交媒体的高级感配图，降低内容创作门槛",
+            "source": "CAP-c5beae45"
+          },
+          {
+            "description": "产品主体突出，视觉焦点清晰，符合现代电商和品牌展示的审美趋势",
+            "source": "CAP-e92b8d89"
+          },
+          {
+            "description": "适合产品详情页、广告投放、品牌视觉等商业场景",
+            "source": "CAP-e92b8d89"
+          }
+        ],
+        "synthesized_implements": {
+          "tools/workflow/comfyui": "CLIPTextEncode注入极简构图提示词（'minimalist composition', 'large negative space', 'single subject', 'zen aesthetic', 'sparse elements', 'vast emptiness'等）+ 低CFG值（5-7）减少细节密度 + KSampler工作流生成极简画面",
+          "midjourney_submit_job": "提示词中加入极简构图语义关键词：'minimalist'、'negative space'、'zen composition'、'sparse elements'、'vast emptiness'、'clean modern composition'等；配合--ar参数控制画幅比例（如3:4竖构图强化留白感），实现禅意或产品展示的极简效果",
+          "flux_generate": "在提示词中使用极简构图描述：'seamless pastel backdrop', 'clean modern composition', 'minimalist aesthetic'等，配合产品或主体描述生成极简风格图像"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-e92b8d89"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-cd789496",
+        "merged_description": "在单张画布上将画面划分为多个独立的潜空间区域，每个区域绑定独立的提示词和/或LoRA模型，从而在同一画面内实现不同角色、不同场景、不同风格的并存和精确控制。该能力解决了多人物/多角色生成时特征相互污染、外观混乱的核心问题，使各区域之间有清晰的分割感和独立性。通过可视化分区界面或编程式区域定义，用户可直观配置每个区域的内容，生成成功率从随机抽卡提升至稳定可控，适合商业AI影视制作、活动宣传图、批量内容生产等场景。",
+        "synthesized_effects": [
+          {
+            "description": "实现双角色或多角色同台画面，各角色外观独立控制，无相互干扰",
+            "source": "CAP-cd789496"
+          },
+          {
+            "description": "多人场景中各角色服装、发型、外观特征不再相互污染，生成成功率从随机抽卡提升至稳定可控",
+            "source": "CAP-59491141"
+          },
+          {
+            "description": "不挑模型版本，通用性强，适合商业AI影视制作和批量内容生产",
+            "source": "CAP-cd789496"
+          },
+          {
+            "description": "相比传统多图合成，分区控制在单次生成中完成，减少后期合成工序",
+            "source": "CAP-cd789496"
+          },
+          {
+            "description": "可视化分区界面使非技术用户也能直观配置多角色布局，操作门槛大幅降低",
+            "source": "CAP-59491141"
+          },
+          {
+            "description": "配合ControlNet使用后，多人画面中角色位置固定、特征清晰，可直接用于活动宣传图制作",
+            "source": "CAP-59491141"
+          }
+        ],
+        "synthesized_implements": {
+          "tools/workflow/comfyui": "ComfyUI分区LoRA控制工作流：使用提示词遮罩（Prompt Mask）节点或Latent Couple节点为每个区域绑定独立提示词，配合LoRA Loader为不同区域加载不同角色LoRA，通过easy use的lora工作流模板或自定义节点组合实现多角色同台分区绘制（case_bili_011/012/013）",
+          "Regional Prompter（SD WebUI/Forge插件）": "SD WebUI/Forge平台通过Regional Prompter插件为画面不同区域指定独立提示词，实现多角色分区绘制，每个区域可独立配置正向/负向提示词（case_bili_012）",
+          "Latent Couple（ComfyUI/SD插件）": "将潜空间划分为多个矩形区域，每个区域独立绑定正向提示词，实现分区独立生成后融合输出，避免角色特征混淆",
+          "Composable LoRA（SD插件）": "配合Latent Couple使用，使每个分区可独立加载对应角色的LoRA模型，实现多角色特征隔离和精确控制",
+          "Davemane42 Custom Node（ComfyUI可视化分区插件）": "提供可视化的分区界面，用户可直接拖拽划定各角色的画面区域，并为每个区域配置独立的提示词和LoRA参数，降低技术门槛"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-59491141"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-cee93f12",
+        "merged_description": "根据内容结构、叙事逻辑和设计规范，自动将AI生成的文字内容与配套插画/图像按照预设的版式规则（分栏、色块区分、标题层级、图文穿插位置、对话框位置、说明区布局等）排布为完整的多页版式或长图作品，输出可直接发布或商业化的图文混排成品。该能力适用于多种场景：品牌信息图、产品宣传杂志、儿童故事书、情感叙事图文、教育内容等。通过模板化和自动化流程，使复杂图文排版门槛大幅降低，设计小白也能快速产出专业级效果，制作时间从数小时压缩至分钟级。支持文字位置自适应画面构图，并可格式化为KDP/Etsy等平台的出版格式。",
+        "synthesized_effects": [
+          {
+            "description": "case_x_001实现9步全自动生成品牌信息图，无需设计技能即可产出专业级版式",
+            "source": "CAP-cee93f12"
+          },
+          {
+            "description": "case_x_002高收藏量（1361），用户认为该模板非常适合创建产品宣传杂志",
+            "source": "CAP-cee93f12"
+          },
+          {
+            "description": "秀米固定布局使复杂图文排版门槛大幅降低，设计小白也能快速出效果",
+            "source": "CAP-cee93f12"
+          },
+          {
+            "description": "自动化版式生成将单张长图制作时间从数小时压缩至分钟级",
+            "source": "CAP-cee93f12"
+          },
+          {
+            "description": "完整情感故事通过多张图片+对话文字呈现，阅读流畅，故事性强（case_xhs_005，点赞3471）",
+            "source": "CAP-fbb3586e"
+          },
+          {
+            "description": "适合教师、家长、创意故事讲述者，无需昂贵软件即可制作有趣的卡通风格动画故事（case_youtube_006，点赞7452）",
+            "source": "CAP-fbb3586e"
+          },
+          {
+            "description": "儿童故事书可直接格式化为KDP/Etsy上架销售格式，实现商业变现（case_youtube_007，点赞3253）",
+            "source": "CAP-fbb3586e"
+          }
+        ],
+        "synthesized_implements": {
+          "Canva模板 + AI内容填充": "选择适配的Canva模板（信息图模板、故事书页面模板等），通过AI自动替换文字和图片内容，批量生成多板块版式或叙事性图文页面。支持上方插画+下方文字说明区的经典故事书布局，支持动画场景添加，导出数字友好格式（参考case_youtube_003/006/007）",
+          "Claude + HTML/CSS代码生成": "通过LLM（如Claude）根据品牌规则和内容结构自动生成HTML版式代码，配合Puppeteer截图导出PNG，实现编程式的自动化图文排版（参考case_x_001的9步工作流）",
+          "秀米/飞书固定布局模块化排版": "使用秀米固定布局功能或飞书文档分栏，通过预设模块化组件实现复杂图文混排，支持多知识板块的色块区分和层级化内容组织（参考case_bili_003、case_bili_002）",
+          "ChatGPT + Canva组合流程": "ChatGPT生成故事文案/信息图内容 → Canva设计精美页面 → 为KDP/Etsy格式化故事书或导出社交媒体长图（case_youtube_007）",
+          "ComfyUI批量排版节点": "通过批量图像生成节点+文字渲染节点组合，自动将插画序列与对应文字合成为统一格式的多页图文作品"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-fbb3586e"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-1c71b52e",
+        "merged_description": "在多帧图像、视频或多格分镜画面生成过程中，通过AI模型和工作流技术保持角色外观、场景风格、光照色调、视觉元素在不同生成单元间的高度一致性和连贯性。适用于绘本故事创作、视频分镜制作、故事板设计等需要跨帧视觉统一的场景，确保从单个角色到整体画面风格都保持连贯，避免风格割裂。",
+        "synthesized_effects": [
+          {
+            "description": "轻松解决人物风格不一致问题，从故事创作到图生视频全程保持角色一致性"
+          },
+          {
+            "description": "AI短片制作效率提升10倍，多格分镜画面视觉统一，无需逐帧手动调整"
+          },
+          {
+            "description": "操作简单高效，适合绘本、故事类创作，提供分镜画面提示+提示词+脚本分镜模板+实战疑问解答"
+          },
+          {
+            "description": "9宫格/25宫格分镜画面中各格子场景、角色、光照、色调连贯统一，适合AI视频一致性控制和故事板制作"
+          },
+          {
+            "description": "生成的多格子分镜可直接用于AI视频生成的参考帧，大幅降低视频制作门槛"
+          }
+        ],
+        "synthesized_implements": {
+          "即梦AI故事创作功能": "输入故事脚本和角色设定，使用故事创作功能生成图生视频，全程保持角色一致性",
+          "即梦AI一致性人物场景图片": "配合分镜画面提示词、脚本分镜模板，支持单人和多人场景生成",
+          "midjourney_submit_job": "使用 --cref（character reference）和 --sref（style reference）参数统一多格的风格参考，配合 --stylize 参数控制风格强度；在 prompt 中明确 consistent styling across all frames",
+          "Canva品牌配色系统": "使用Canva的品牌套件功能预设配色方案，一键将所有格子的颜色切换为指定主题色，支持粉色系/黑白系/蓝色系/黄色系等多种预设",
+          "Notebook LM + 导演级Prompt": "将场景资产描述（背景/光照/色调/道具清单）喂入Notebook LM生成结构化导演级Prompt，在每格生成时统一引用该Prompt约束场景一致性",
+          "ComfyUI FLUX-Klein": "分镜流中通过统一的场景ControlNet参考图约束各格背景结构，配合局部修复节点修正场景崩坏区域",
+          "tools/workflow/comfyui": "FLUX-Klein 分镜工作流（ComfyUI）+ IP-Adapter 角色一致性节点 + ControlNet 姿态控制 + KSampler，生成具有超强一致性的九宫格分镜",
+          "PPT/Figma主题色批量替换": "在PPT或Figma中设置全局主题色，修改主题色后所有格子的背景、文字、装饰元素自动同步更新",
+          "AI提示词配色控制（Midjourney/Flux）": "在提示词中指定配色主题（如'pastel pink palette'/'monochrome black and white'），AI生成的多格子画面自动遵循指定配色方案",
+          "ChatGPT代码解释器批量生成": "通过代码解释器一次性生成多格子画面，在提示词中统一指定风格参数（色调/光照/画风），确保所有格子遵循相同的视觉规则",
+          "Gemini + 即梦Seedance 2.0工作流": "使用Gemini构建分镜逻辑和视觉统一规则，通过9宫格/25宫格实现多画面视觉统一，配合即梦Seedance 2.0的单帧镜头混合实现电影感成片"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-e9b763d2"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-4e89bb57",
+        "merged_description": "通过预先定义品牌规则文件或全局配色方案（包含配色、字体、Logo、布局约束、风格指南等视觉规范），在批量生成信息图、数据报告、图表等多个视觉组件时，AI自动遵循统一的视觉规范，确保所有输出元素（图表、标题、文字、背景等）在配色、风格、布局上高度一致，符合品牌视觉体系或指定设计主题，无需每次在提示词中重复描述规范要求。",
+        "synthesized_effects": [
+          {
+            "description": "生成与品牌匹配的美丽信息图和专业数据报告，避免杂乱无章和通用剪贴画，输出专业级品牌化视觉内容"
+          },
+          {
+            "description": "不同主题的信息图、图表在同一品牌规则或配色方案下视觉风格统一，无需每次重复描述品牌要求或手动调整单个元素颜色"
+          },
+          {
+            "description": "麦肯锡/奢侈品级别的报告质感，逻辑清晰、图表专业、设计高级，用户反馈'专业度直接拉满'"
+          },
+          {
+            "description": "5分钟内生成专业信息图或完整数据报告，无需设计经验，效率大幅提升"
+          },
+          {
+            "description": "统一配色后整份年度数据报告或系列信息图视觉风格高度一致，科技风/商务风等主题配色获得'炫酷''专业感满满'的用户评价"
+          }
+        ],
+        "synthesized_implements": {
+          "Claude (claude.ai)": "创建 CLAUDE.md 品牌规则文件 + references 参考图文件夹 + skill 文件定义布局约束，Claude 从模板构建 HTML 信息图并自动遵循品牌规范",
+          "Venngage AI": "Brand Kit 功能：上传 logo、设定颜色和字体，AI 在生成信息图时自动应用品牌套件",
+          "DeepSeek / ChatGPT": "通过 Prompt 指定色彩主题和报告风格，AI 生成包含统一配色方案的完整报告版式代码（HTML/CSS）或设计规范，所有图表自动应用同一色系",
+          "FineBI / 镝数图表": "在平台内设置全局配色主题，所有图表自动继承同一色系（如生长色系渐变、同色系配色），保证指标颜色一致性",
+          "Nano Banana + Gemini": "上传参考版式图片，AI 提取配色方案并应用到新生成的图表和仪表板中，实现风格迁移与统一"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-45a51b6d"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-e80e4194",
+        "merged_description": "以视觉叙事或展示逻辑为驱动，通过在提示词中系统性地指定不同景别/构图尺度描述词（远景/全景/中景/近景/特写，或 full body shot / waist-up shot / close-up / detail shot），批量生成同一主体或场景从宏观到微观的多尺度图像序列。该能力形成具有完整视觉叙事张力或全方位展示效果的图片集合，可应用于短片分镜脚本、漫画叙事、电商详情页多角度展示、商业影视创作等场景。核心是通过景别参数的系统化控制，实现从大范围环境到局部细节的连续视觉过渡。",
+        "synthesized_effects": [
+          "以'万能公式'景别叙事结构一键生成5个景别系列图，用户可直接用于短视频开场、产品展示、旅行打卡内容创作",
+          "连续生成几十个分镜并全部保持一致性，彻底替代传统需反复抽卡/手动修改的多轮操作",
+          "一套冬季穿搭生成15张涵盖全身到局部细节的多角度图，满足电商详情页从整体造型到单品细节的完整展示需求",
+          "多景别图像序列无需实拍，0成本完成从全身造型到围巾、手套等配饰特写的完整展示，获赞2051",
+          "xhs/case_003景别教程获2328赞，印证了景别叙事序列化方法论的强烈用户需求"
+        ],
+        "synthesized_implements": {
+          "kling_ai": "可灵3.0自定义分镜功能，配合场景设定多角度切换工作流，结合5000+分镜画面提示词库和300个AI视频脚本模板，实现从远景到特写的叙事序列生成",
+          "comfyui_runninghub": "在 RunningHub 平台运行专用工作流，同一场景一次性生成16个不同镜头，支持普通版和PLUS版，无废图",
+          "tools/image_gen/midjourney": "在提示词中分别指定景别描述词（full body shot / waist-up shot / close-up of scarf detail / detail shot of gloves / extreme wide shot / establishing shot / medium shot / close-up）生成对应构图，配合--ar参数控制画幅比例",
+          "Stable Diffusion + ControlNet": "使用OpenPose骨架控制保持人物姿态一致性，通过Depth预处理器控制景深，分别生成全身和局部特写图；结合CLIPTextEncode节点为每个景别编写专用提示词"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-1da1bf7a"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-0e3d61ca",
+        "merged_description": "在 AI 图像生成或转换过程中施加鱼眼镜头（Fisheye Lens）或超广角镜头的球形畸变效果，产生桶形畸变、透视压缩和极端透视夸张感，使画面边缘产生弯曲变形，强化视觉冲击力和空间纵深感。该能力支持两种输入模式：（1）文本生成图像（text2img）：通过提示词直接生成具有鱼眼效果的新图像；（2）图像转换（img2img）：将用户上传的普通照片转换为鱼眼视角版本，在保留原始特征的同时施加光学畸变效果。常与虫眼视角、GoPro/Action Cam 风格、大头娃娃效果结合使用，适用于商业摄影、运动视频、社交媒体内容创作等场景。",
+        "synthesized_effects": [
+          "鱼眼视角商业摄影提示词模板（杯子/盒子内部仰拍）获得高收藏量，证明该效果在商业内容创作中具有实用价值",
+          "fisheye + worm's eye 组合可生成极具视觉冲击力的超现实商业摄影效果，无需实体鱼眼镜头设备",
+          "GoPro/Action Cam 风格提示词可快速生成运动感强烈的第一人称视角内容，适合短视频平台",
+          "用户上传自拍照即可一键转换为鱼眼大头娃娃效果，无需专业摄影设备或技术",
+          "X 平台相关教程帖获得 186 赞、131 收藏、5915 浏览，是该需求下互动量最高的案例，证明该能力具有强烈的用户需求",
+          "转换后图像头部显著放大、身体压缩，产生独特的时尚编辑风格视觉效果，适合社交媒体内容创作"
+        ],
+        "synthesized_implements": {
+          "tools/image_gen/stable_diffusion_comfyui": "【文本生成模式】在正向提示词中加入 'fisheye lens, barrel distortion, ultra-wide 180 degree, vignette' 等关键词；可配合专用鱼眼透视 LoRA（如 Civitai 模型 494107，训练自画师 gaku）增强效果；使用 CheckpointLoader + CLIPTextEncode + KSampler 标准工作流。【图像转换模式】使用 img2img 工作流（VAE Encode + KSampler + VAEDecode）+ 提示词注入 'transform into ultra-wide 10mm fisheye portrait, strong perspective distortion'；配合 IP-Adapter 节点保留人物外观特征",
+          "tools/image_gen/midjourney": "【文本生成模式】在提示词末尾加入 'fisheye lens effect, extreme wide angle distortion, circular fisheye frame' 等描述词；配合 --ar 1:1 宽高比强化圆形鱼眼视野感。【图像转换模式】使用 --cref（角色参考）配合鱼眼效果提示词，或使用 Omni Reference 功能同时保留人物特征并施加鱼眼变形",
+          "Flux / ComfyUI / Grok Imagine": "【文本生成模式】提示词关键词：极端广角镜头 / 鱼眼透视 / fisheye distortion / 低角度仰拍 / 从产品底部向上拍摄 / F1.2大光圈浅景深 / 14mm超广角",
+          "Flux / nano_banana": "【文本生成模式】在提示词中描述 '10mm ultra-wide fisheye portrait, strong perspective distortion, visible fisheye curvature, subtle dark vignette around edges' 实现超广角鱼眼人像效果。【图像转换模式】在提示词中使用 'Transform the uploaded photo into a 10mm ultra-wide fisheye portrait with dramatic top-down angle' 等指令式描述，配合图像输入实现照片转鱼眼效果",
+          "ComfyUI（后处理节点）": "在生成后通过图像变换节点应用桶形畸变滤镜，或在提示词中结合 ControlNet 深度图约束实现透视夸张效果",
+          "Gemini AI": "在视角重构提示词中指定 'Fisheye View' 作为目标摄像机角度，模型自动应用桶形畸变效果",
+          "Midjourney / Flux / Seedream": "在提示词中加入 'fisheye lens, barrel distortion, ultra-wide 180 degree, vignette' 等关键词，可叠加 'GoPro footage, action camera, body cam, wide angle' 模拟运动相机风格",
+          "垫图反推": "上传具有透视感的参考图，通过图生文功能反推透视视角描述词（虫瞰视角、鱼眼畸变、微距大特写）再用于生成"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-db22d1ad"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-3e353fc5",
+        "merged_description": "在图片或拼贴画布的指定区域上叠加信息标注元素，包括纯文字内容（说明性文字、情感点评、地点标注、碎碎念）或图标与文字组合而成的标签组件（定位图标+地点名称、勾选符号+任务描述、时钟图标+时间标注、价格标签等）。支持字体样式、背景色、透明度、图标选择等多维度调整，实现信息模块化标注和视觉统一化管理。",
+        "synthesized_effects": [
+          {
+            "description": "文字与图片共同叙事，读者无需额外说明即可理解图片背后的故事"
+          },
+          {
+            "description": "情感点评文字使帖子互动率提升，用户反馈更有共鸣感"
+          },
+          {
+            "description": "地点标注文字使旅行拼贴内容信息量更丰富"
+          },
+          {
+            "description": "每个地点/物品区域自动标注名称和图标，信息一目了然，无需反复手动添加"
+          },
+          {
+            "description": "勾选框+任务描述的标签形式使活动规则清晰可读，用户参与意愿提升"
+          },
+          {
+            "description": "批量为多个区域叠加不同标签内容，整体视觉统一且信息密度高"
+          }
+        ],
+        "synthesized_implements": {
+          "醒图/ProCCD/黄油相机": "添加文字后点击样式-背景调整颜色透明度，支持多种字体",
+          "Photoshop": "文字图层叠加，支持精确位置控制",
+          "CapCut": "文字高亮效果，支持trending stylish text设计",
+          "Canva": "文字工具支持多种字体和样式，适合标题和说明文字；在 Elements 面板搜索并添加定位图标、勾选框等图标，配合 Text Box 组合为标签组件，通过 Bulk Create 数据连接批量为每个区域填充不同标签内容",
+          "Canva AI（图标+文字模板）": "使用预设的标签条模板（定位图标+文字框、勾选框+任务描述），通过数据连接批量替换每个标签的文字内容",
+          "Morpholio Trace（Studio Text）": "在图层上批量添加多个文本框，选择 Select Mode 批量编辑对齐、颜色、字体、大小，实现标注标签的统一样式管理"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-154a84fd"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    },
+    {
+      "enabled": true,
+      "master": {
+        "id": "CAP-1b3e966f",
+        "merged_description": "以等距矩形投影（equirectangular）格式直接生成具备全局空间一致性的 360 度球面全景图，输出图像具有无缝环绕边缘，确保场景在各个方向上的几何关系、光照和风格保持连贯。生成的全景图可被 360 度查看器、VR 设备和游戏引擎直接识别和使用，无需后期拼接，支持自由漫游探索和 mesh 资产导出用于二次建模。",
+        "synthesized_effects": [
+          {
+            "description": "无需昂贵相机设备或实地拍摄，纯 AI 生成即可获得可交互的 360 度全景图"
+          },
+          {
+            "description": "生成的全景图可直接用于 VR 内容、游戏环境、虚拟制作背景等场景"
+          },
+          {
+            "description": "批量生成不同风格的室内全景图，快速探索多种设计方向"
+          },
+          {
+            "description": "单张图片或一句话即可生成可自由漫游的完整 360° 空间世界"
+          },
+          {
+            "description": "导出的 mesh 资产可在 SketchUp、Rhino 等工具中进行二次建模和编辑"
+          },
+          {
+            "description": "空间一致性保证使生成的全景世界可直接用于 VR 仿真和游戏场景"
+          }
+        ],
+        "synthesized_implements": {
+          "ChatGPT / 自定义 Chatbot": "使用特定提示词（如 'Transforms this photo into a 360° panoramic image... equirectangular viewing'）并指定 2:1 或 3000x1500 分辨率生成球面全景图",
+          "tools/image_gen/midjourney": "使用 equirectangular photograph of + 场景描述的提示词公式，配合 2:1 宽高比参数生成等距矩形投影全景图",
+          "ComfyUI 工作流": "配置专用 360 全景工作流节点，输入室内设计提示词，一键生成 360° 室内家装全景图",
+          "Marble World AI": "专门支持360度全景室内图生成的AI平台，配合Gemini提示词生成适配VR展示的全景图",
+          "DiT360 AI": "专用 360 度全景生成模型，通过文本描述直接输出具有无缝环绕边缘和空间一致性的等距矩形全景图，可在 HuggingFace Spaces 在线使用",
+          "Gemini AI": "在提示词中指定'ultra-realistic 360-degree panoramic photo (equirectangular projection, 2:1 aspect ratio)'、'as if captured by a professional 360 camera'、'horizontal seamless continuity, left and right edges perfectly aligned'",
+          "腾讯混元 3D 世界模型": "输入一句话提示词或单张图片，生成具备空间一致性的 360° 全景世界，支持自由漫游探索和 mesh 资产导出二次建模"
+        },
+        "synthesized_criterion": []
+      },
+      "duplicates": [
+        {
+          "id": "CAP-ee5ffa0b"
+        }
+      ],
+      "merged_result": "Keep master, update fields, redirect relations"
+    }
+  ],
+  "strategies": []
+}

examples/process_pipeline/worker_0.bat

@@ -1,286 +0,0 @@
-@echo off
-cd /d %~dp0
-if exist ..\..\.venv\Scripts\activate.bat call ..\..\.venv\Scripts\activate.bat
-echo Worker Group 0 starting...
-echo =======================================
-echo Running Requirement Index: -1
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index -1
-python run_pipeline.py --index -1
-if not exist "output\000\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index -1
-) else (
-    echo [Verified] output\000\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 4
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 4
-python run_pipeline.py --index 4
-if not exist "output\005\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 4
-) else (
-    echo [Verified] output\005\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 9
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 9
-python run_pipeline.py --index 9
-if not exist "output\010\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 9
-) else (
-    echo [Verified] output\010\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 14
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 14
-python run_pipeline.py --index 14
-if not exist "output\015\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 14
-) else (
-    echo [Verified] output\015\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 19
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 19
-python run_pipeline.py --index 19
-if not exist "output\020\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 19
-) else (
-    echo [Verified] output\020\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 24
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 24
-python run_pipeline.py --index 24
-if not exist "output\025\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 24
-) else (
-    echo [Verified] output\025\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 29
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 29
-python run_pipeline.py --index 29
-if not exist "output\030\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 29
-) else (
-    echo [Verified] output\030\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 34
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 34
-python run_pipeline.py --index 34
-if not exist "output\035\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 34
-) else (
-    echo [Verified] output\035\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 39
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 39
-python run_pipeline.py --index 39
-if not exist "output\040\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 39
-) else (
-    echo [Verified] output\040\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 44
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 44
-python run_pipeline.py --index 44
-if not exist "output\045\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 44
-) else (
-    echo [Verified] output\045\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 49
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 49
-python run_pipeline.py --index 49
-if not exist "output\050\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 49
-) else (
-    echo [Verified] output\050\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 54
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 54
-python run_pipeline.py --index 54
-if not exist "output\055\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 54
-) else (
-    echo [Verified] output\055\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 59
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 59
-python run_pipeline.py --index 59
-if not exist "output\060\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 59
-) else (
-    echo [Verified] output\060\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 64
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 64
-python run_pipeline.py --index 64
-if not exist "output\065\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 64
-) else (
-    echo [Verified] output\065\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 69
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 69
-python run_pipeline.py --index 69
-if not exist "output\070\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 69
-) else (
-    echo [Verified] output\070\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 74
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 74
-python run_pipeline.py --index 74
-if not exist "output\075\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 74
-) else (
-    echo [Verified] output\075\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 79
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 79
-python run_pipeline.py --index 79
-if not exist "output\080\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 79
-) else (
-    echo [Verified] output\080\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 84
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 84
-python run_pipeline.py --index 84
-if not exist "output\085\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 84
-) else (
-    echo [Verified] output\085\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 89
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 89
-python run_pipeline.py --index 89
-if not exist "output\090\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 89
-) else (
-    echo [Verified] output\090\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 94
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 94
-python run_pipeline.py --index 94
-if not exist "output\095\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 94
-) else (
-    echo [Verified] output\095\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo Worker Group 0 finished!
-pause

examples/process_pipeline/worker_1.bat

@@ -1,286 +0,0 @@
-@echo off
-cd /d %~dp0
-if exist ..\..\.venv\Scripts\activate.bat call ..\..\.venv\Scripts\activate.bat
-echo Worker Group 1 starting...
-echo =======================================
-echo Running Requirement Index: 0
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 0
-python run_pipeline.py --index 0
-if not exist "output\001\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 0
-) else (
-    echo [Verified] output\001\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 5
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 5
-python run_pipeline.py --index 5
-if not exist "output\006\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 5
-) else (
-    echo [Verified] output\006\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 10
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 10
-python run_pipeline.py --index 10
-if not exist "output\011\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 10
-) else (
-    echo [Verified] output\011\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 15
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 15
-python run_pipeline.py --index 15
-if not exist "output\016\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 15
-) else (
-    echo [Verified] output\016\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 20
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 20
-python run_pipeline.py --index 20
-if not exist "output\021\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 20
-) else (
-    echo [Verified] output\021\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 25
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 25
-python run_pipeline.py --index 25
-if not exist "output\026\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 25
-) else (
-    echo [Verified] output\026\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 30
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 30
-python run_pipeline.py --index 30
-if not exist "output\031\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 30
-) else (
-    echo [Verified] output\031\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 35
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 35
-python run_pipeline.py --index 35
-if not exist "output\036\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 35
-) else (
-    echo [Verified] output\036\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 40
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 40
-python run_pipeline.py --index 40
-if not exist "output\041\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 40
-) else (
-    echo [Verified] output\041\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 45
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 45
-python run_pipeline.py --index 45
-if not exist "output\046\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 45
-) else (
-    echo [Verified] output\046\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 50
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 50
-python run_pipeline.py --index 50
-if not exist "output\051\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 50
-) else (
-    echo [Verified] output\051\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 55
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 55
-python run_pipeline.py --index 55
-if not exist "output\056\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 55
-) else (
-    echo [Verified] output\056\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 60
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 60
-python run_pipeline.py --index 60
-if not exist "output\061\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 60
-) else (
-    echo [Verified] output\061\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 65
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 65
-python run_pipeline.py --index 65
-if not exist "output\066\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 65
-) else (
-    echo [Verified] output\066\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 70
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 70
-python run_pipeline.py --index 70
-if not exist "output\071\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 70
-) else (
-    echo [Verified] output\071\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 75
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 75
-python run_pipeline.py --index 75
-if not exist "output\076\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 75
-) else (
-    echo [Verified] output\076\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 80
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 80
-python run_pipeline.py --index 80
-if not exist "output\081\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 80
-) else (
-    echo [Verified] output\081\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 85
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 85
-python run_pipeline.py --index 85
-if not exist "output\086\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 85
-) else (
-    echo [Verified] output\086\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 90
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 90
-python run_pipeline.py --index 90
-if not exist "output\091\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 90
-) else (
-    echo [Verified] output\091\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 95
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 95
-python run_pipeline.py --index 95
-if not exist "output\096\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 95
-) else (
-    echo [Verified] output\096\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo Worker Group 1 finished!
-pause

examples/process_pipeline/worker_2.bat

@@ -1,286 +0,0 @@
-@echo off
-cd /d %~dp0
-if exist ..\..\.venv\Scripts\activate.bat call ..\..\.venv\Scripts\activate.bat
-echo Worker Group 2 starting...
-echo =======================================
-echo Running Requirement Index: 1
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 1
-python run_pipeline.py --index 1
-if not exist "output\002\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 1
-) else (
-    echo [Verified] output\002\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 6
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 6
-python run_pipeline.py --index 6
-if not exist "output\007\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 6
-) else (
-    echo [Verified] output\007\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 11
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 11
-python run_pipeline.py --index 11
-if not exist "output\012\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 11
-) else (
-    echo [Verified] output\012\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 16
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 16
-python run_pipeline.py --index 16
-if not exist "output\017\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 16
-) else (
-    echo [Verified] output\017\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 21
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 21
-python run_pipeline.py --index 21
-if not exist "output\022\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 21
-) else (
-    echo [Verified] output\022\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 26
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 26
-python run_pipeline.py --index 26
-if not exist "output\027\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 26
-) else (
-    echo [Verified] output\027\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 31
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 31
-python run_pipeline.py --index 31
-if not exist "output\032\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 31
-) else (
-    echo [Verified] output\032\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 36
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 36
-python run_pipeline.py --index 36
-if not exist "output\037\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 36
-) else (
-    echo [Verified] output\037\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 41
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 41
-python run_pipeline.py --index 41
-if not exist "output\042\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 41
-) else (
-    echo [Verified] output\042\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 46
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 46
-python run_pipeline.py --index 46
-if not exist "output\047\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 46
-) else (
-    echo [Verified] output\047\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 51
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 51
-python run_pipeline.py --index 51
-if not exist "output\052\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 51
-) else (
-    echo [Verified] output\052\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 56
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 56
-python run_pipeline.py --index 56
-if not exist "output\057\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 56
-) else (
-    echo [Verified] output\057\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 61
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 61
-python run_pipeline.py --index 61
-if not exist "output\062\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 61
-) else (
-    echo [Verified] output\062\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 66
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 66
-python run_pipeline.py --index 66
-if not exist "output\067\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 66
-) else (
-    echo [Verified] output\067\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 71
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 71
-python run_pipeline.py --index 71
-if not exist "output\072\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 71
-) else (
-    echo [Verified] output\072\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 76
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 76
-python run_pipeline.py --index 76
-if not exist "output\077\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 76
-) else (
-    echo [Verified] output\077\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 81
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 81
-python run_pipeline.py --index 81
-if not exist "output\082\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 81
-) else (
-    echo [Verified] output\082\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 86
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 86
-python run_pipeline.py --index 86
-if not exist "output\087\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 86
-) else (
-    echo [Verified] output\087\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 91
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 91
-python run_pipeline.py --index 91
-if not exist "output\092\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 91
-) else (
-    echo [Verified] output\092\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 96
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 96
-python run_pipeline.py --index 96
-if not exist "output\097\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 96
-) else (
-    echo [Verified] output\097\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo Worker Group 2 finished!
-pause

examples/process_pipeline/worker_3.bat

@@ -1,286 +0,0 @@
-@echo off
-cd /d %~dp0
-if exist ..\..\.venv\Scripts\activate.bat call ..\..\.venv\Scripts\activate.bat
-echo Worker Group 3 starting...
-echo =======================================
-echo Running Requirement Index: 2
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 2
-python run_pipeline.py --index 2
-if not exist "output\003\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 2
-) else (
-    echo [Verified] output\003\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 7
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 7
-python run_pipeline.py --index 7
-if not exist "output\008\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 7
-) else (
-    echo [Verified] output\008\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 12
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 12
-python run_pipeline.py --index 12
-if not exist "output\013\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 12
-) else (
-    echo [Verified] output\013\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 17
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 17
-python run_pipeline.py --index 17
-if not exist "output\018\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 17
-) else (
-    echo [Verified] output\018\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 22
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 22
-python run_pipeline.py --index 22
-if not exist "output\023\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 22
-) else (
-    echo [Verified] output\023\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 27
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 27
-python run_pipeline.py --index 27
-if not exist "output\028\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 27
-) else (
-    echo [Verified] output\028\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 32
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 32
-python run_pipeline.py --index 32
-if not exist "output\033\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 32
-) else (
-    echo [Verified] output\033\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 37
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 37
-python run_pipeline.py --index 37
-if not exist "output\038\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 37
-) else (
-    echo [Verified] output\038\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 42
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 42
-python run_pipeline.py --index 42
-if not exist "output\043\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 42
-) else (
-    echo [Verified] output\043\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 47
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 47
-python run_pipeline.py --index 47
-if not exist "output\048\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 47
-) else (
-    echo [Verified] output\048\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 52
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 52
-python run_pipeline.py --index 52
-if not exist "output\053\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 52
-) else (
-    echo [Verified] output\053\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 57
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 57
-python run_pipeline.py --index 57
-if not exist "output\058\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 57
-) else (
-    echo [Verified] output\058\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 62
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 62
-python run_pipeline.py --index 62
-if not exist "output\063\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 62
-) else (
-    echo [Verified] output\063\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 67
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 67
-python run_pipeline.py --index 67
-if not exist "output\068\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 67
-) else (
-    echo [Verified] output\068\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 72
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 72
-python run_pipeline.py --index 72
-if not exist "output\073\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 72
-) else (
-    echo [Verified] output\073\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 77
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 77
-python run_pipeline.py --index 77
-if not exist "output\078\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 77
-) else (
-    echo [Verified] output\078\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 82
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 82
-python run_pipeline.py --index 82
-if not exist "output\083\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 82
-) else (
-    echo [Verified] output\083\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 87
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 87
-python run_pipeline.py --index 87
-if not exist "output\088\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 87
-) else (
-    echo [Verified] output\088\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 92
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 92
-python run_pipeline.py --index 92
-if not exist "output\093\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 92
-) else (
-    echo [Verified] output\093\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 97
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 97
-python run_pipeline.py --index 97
-if not exist "output\098\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 97
-) else (
-    echo [Verified] output\098\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo Worker Group 3 finished!
-pause

examples/process_pipeline/worker_4.bat

@@ -1,286 +0,0 @@
-@echo off
-cd /d %~dp0
-if exist ..\..\.venv\Scripts\activate.bat call ..\..\.venv\Scripts\activate.bat
-echo Worker Group 4 starting...
-echo =======================================
-echo Running Requirement Index: 3
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 3
-python run_pipeline.py --index 3
-if not exist "output\004\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 3
-) else (
-    echo [Verified] output\004\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 8
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 8
-python run_pipeline.py --index 8
-if not exist "output\009\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 8
-) else (
-    echo [Verified] output\009\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 13
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 13
-python run_pipeline.py --index 13
-if not exist "output\014\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 13
-) else (
-    echo [Verified] output\014\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 18
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 18
-python run_pipeline.py --index 18
-if not exist "output\019\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 18
-) else (
-    echo [Verified] output\019\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 23
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 23
-python run_pipeline.py --index 23
-if not exist "output\024\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 23
-) else (
-    echo [Verified] output\024\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 28
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 28
-python run_pipeline.py --index 28
-if not exist "output\029\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 28
-) else (
-    echo [Verified] output\029\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 33
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 33
-python run_pipeline.py --index 33
-if not exist "output\034\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 33
-) else (
-    echo [Verified] output\034\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 38
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 38
-python run_pipeline.py --index 38
-if not exist "output\039\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 38
-) else (
-    echo [Verified] output\039\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 43
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 43
-python run_pipeline.py --index 43
-if not exist "output\044\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 43
-) else (
-    echo [Verified] output\044\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 48
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 48
-python run_pipeline.py --index 48
-if not exist "output\049\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 48
-) else (
-    echo [Verified] output\049\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 53
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 53
-python run_pipeline.py --index 53
-if not exist "output\054\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 53
-) else (
-    echo [Verified] output\054\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 58
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 58
-python run_pipeline.py --index 58
-if not exist "output\059\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 58
-) else (
-    echo [Verified] output\059\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 63
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 63
-python run_pipeline.py --index 63
-if not exist "output\064\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 63
-) else (
-    echo [Verified] output\064\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 68
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 68
-python run_pipeline.py --index 68
-if not exist "output\069\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 68
-) else (
-    echo [Verified] output\069\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 73
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 73
-python run_pipeline.py --index 73
-if not exist "output\074\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 73
-) else (
-    echo [Verified] output\074\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 78
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 78
-python run_pipeline.py --index 78
-if not exist "output\079\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 78
-) else (
-    echo [Verified] output\079\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 83
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 83
-python run_pipeline.py --index 83
-if not exist "output\084\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 83
-) else (
-    echo [Verified] output\084\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 88
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 88
-python run_pipeline.py --index 88
-if not exist "output\089\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 88
-) else (
-    echo [Verified] output\089\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 93
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 93
-python run_pipeline.py --index 93
-if not exist "output\094\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 93
-) else (
-    echo [Verified] output\094\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo =======================================
-echo Running Requirement Index: 98
-echo =======================================
-echo [Attempt 1] python run_pipeline.py --index 98
-python run_pipeline.py --index 98
-if not exist "output\099\strategy.json" (
-    echo =======================================
-    echo [Retry] target.json missing, retrying once...
-    echo =======================================
-    python run_pipeline.py --index 98
-) else (
-    echo [Verified] output\099\strategy.json generated successfully.
-)
-timeout /t 2 > NUL
-echo Worker Group 4 finished!
-pause

knowhub/knowhub_db/pg_capability_store.py

@@ -142,8 +142,8 @@ class PostgreSQLCapabilityStore:
             cursor.execute("DELETE FROM capability WHERE id = %s", (cap['id'],))
             cursor.execute("""
                 INSERT INTO capability (
-                    id, name, criterion, description, effects, embedding
-                ) VALUES (%s, %s, %s, %s, %s, %s)
+                    id, name, criterion, description, effects, embedding, version
+                ) VALUES (%s, %s, %s, %s, %s, %s, %s)
                 ON CONFLICT (id) DO UPDATE SET
                     name = EXCLUDED.name,
                     criterion = EXCLUDED.criterion,