修复种草图生成：以三合一主图为参考 img2img 生成，按颜色分配（每色优先、超出随机补足）；新增 BR/CA/DE/ES/IT/PL/SA 七国配置与提示词；删除验证用测试脚本

graph/nodes/filter_node.py

@@ -64,4 +64,29 @@ def filter_node(state: Dict[str, Any]) -> Dict[str, Any]:
     kept = validate_rows(kept, "filter")
     stats = dict(state.get("stats") or {})
     stats["filter"] = {"kept": len(kept), "dropped": dropped_total}
+
+    # 把过滤后的热点写入 collected_keywords.json（前台显示完整热点池用）：
+    # 完整流水线（run_country）也会写，保证运行后前台能看到所有未用热点，
+    # 而不是只显示简报（design_briefs 仅含本次限量生成的热点）。
+    if kept:
+        try:
+            import json as _json
+            from pathlib import Path as _Path
+            p = _Path(state.get("cache_dir") or state.get("output_dir", "")) / "collected_keywords.json"
+            p.parent.mkdir(parents=True, exist_ok=True)
+            kws = [{"topic": r.get("topic", ""), "source": r.get("source", ""),
+                    "kind": r.get("kind", ""), "raw_score": r.get("raw_score")} for r in kept]
+            p.write_text(_json.dumps({"country": country,
+                                      "collected_at": _datetime_now(),
+                                      "keywords": kws}, ensure_ascii=False, indent=2),
+                         encoding="utf-8")
+            print(f"[filter] 已写入采集缓存 {len(kws)} 条（collected_keywords.json）")
+        except Exception as e:  # noqa: BLE001
+            print(f"[filter] 写入采集缓存失败: {e}")
+
     return {"filtered_rows": kept, "stats": stats}
+
+
+def _datetime_now() -> str:
+    import time
+    return time.strftime("%Y-%m-%dT%H:%M:%S")

graph/nodes/product_node.py

@@ -221,6 +221,7 @@ def _process_spu(
         # 6) 模板选择按 SPU.mark 决定：
         #    mark==1 → 新三图合成模板 MODEL_WEAR_PROMPT（图1模特 + 图2印花设计 + 图3底图）
         #    mark!=1 → 旧两图合成模板 composite_prompt（底图 + 印花设计）
+        #    mark==1 统一只做三合一：无模特图时跳过合成，不再回退两图合成（印花+底图）
         if int(spu.get("mark") or 0) == 1:
             print(f"{tag}  SPU {spu['code']} mark=1 → 使用三图合成模板（图1模特+图2印花+图3底图）")
             if model_img is not None:
@@ -231,13 +232,14 @@ def _process_spu(
                 result["model_folder"] = model_img.parent.name
                 print(f"{tag}  模特图（任务级分配，{model_img.parent.name}/）: {model_copy}")
             else:
-                print(f"{tag}  material_library 无模特图，回退两图合成（composite_prompt）")
+                print(f"{tag}  material_library 无模特图，mark=1 统一只做三合一，跳过合成")
         else:
             print(f"{tag}  SPU {spu['code']} mark={spu.get('mark')} → 使用两图合成模板 composite_prompt（底图+印花）")
 
         # 7) 合成：
         #    有模特图 → 三图合成（图1=模特 / 图2=印花设计 / 图3=底图）
-        #    无模特图 → 两图合成平铺服装图（图3=底图 + 图2=印花设计）
+        #    mark=1 无模特图 → 跳过合成（统一只做三合一，不做印花+底图两图合成）
+        #    mark!=1 无模特图 → 两图合成平铺服装图（图3=底图 + 图2=印花设计）
         if "design_path" not in result:
             print(f"{tag}  无设计稿，跳过合成")
         elif model_img is not None:
@@ -267,28 +269,32 @@ def _process_spu(
                     print(f"{tag}  三图合成重试仍失败 → 跳过该产品（不生成标题/不写模板）: {e}")
                     return None
         else:
-            printed_path = str(prod_dir / f"{img_code}_printed.png")
-            try:
-                # 两图合成（无模特）：用平铺印图文案（wearable_prompt），回退旧 composite_prompt
-                flat_prompt = (brief.get("wearable_prompt") or "").strip() or brief.get("composite_prompt", "")
-                ib.print(flat_prompt, str(basemap_img), printed_path,
-                         brief.get("composite_negative", ""),
-                         extra_images=[design_path],  # 图2印花
-                         size="1504x2000")   # 合成统一 1504x2000
-                result["printed_path"] = printed_path
-                print(f"{tag}  平铺服装图已生成（无模特，底图+印花）: {printed_path}")
-            except Exception as e:  # noqa: BLE001
-                print(f"{tag}  平铺服装图失败，退避重试…: {e}")
-                retried = _retry_image(ib.print, flat_prompt, str(basemap_img), printed_path,
-                                       brief.get("composite_negative", ""),
-                                       extra_images=[design_path], size="1504x2000")
-                if retried is not None:
+            # mark=1 无模特图 → 统一只做三合一，不做印花+底图两图合成
+            if int(spu.get("mark") or 0) == 1:
+                print(f"{tag}  mark=1 无模特图，跳过合成（统一只做三合一）")
+            else:
+                printed_path = str(prod_dir / f"{img_code}_printed.png")
+                try:
+                    # 两图合成（无模特，mark!=1）：用平铺印图文案（wearable_prompt），回退旧 composite_prompt
+                    flat_prompt = (brief.get("wearable_prompt") or "").strip() or brief.get("composite_prompt", "")
+                    ib.print(flat_prompt, str(basemap_img), printed_path,
+                             brief.get("composite_negative", ""),
+                             extra_images=[design_path],  # 图2印花
+                             size="1504x2000")   # 合成统一 1504x2000
                     result["printed_path"] = printed_path
-                    print(f"{tag}  平铺服装图重试成功: {printed_path}")
-                else:
-                    errors.append({"node": "product", "type": type(e).__name__, "message": f"平铺服装图生成失败(重试仍失败): {e}", "trace": ""})
-                    print(f"{tag}  平铺服装图重试仍失败 → 跳过该产品（不生成标题/不写模板）: {e}")
-                    return None
+                    print(f"{tag}  平铺服装图已生成（无模特，底图+印花）: {printed_path}")
+                except Exception as e:  # noqa: BLE001
+                    print(f"{tag}  平铺服装图失败，退避重试…: {e}")
+                    retried = _retry_image(ib.print, flat_prompt, str(basemap_img), printed_path,
+                                           brief.get("composite_negative", ""),
+                                           extra_images=[design_path], size="1504x2000")
+                    if retried is not None:
+                        result["printed_path"] = printed_path
+                        print(f"{tag}  平铺服装图重试成功: {printed_path}")
+                    else:
+                        errors.append({"node": "product", "type": type(e).__name__, "message": f"平铺服装图生成失败(重试仍失败): {e}", "trace": ""})
+                        print(f"{tag}  平铺服装图重试仍失败 → 跳过该产品（不生成标题/不写模板）: {e}")
+                        return None
 
         # 7.2) 多色：单 SPU 多色时每个颜色再执行一次三合一（用各自底图），轮播图按颜色路由
         color_composites: List[Dict[str, Any]] = []

graph/nodes/seed_node.py

@@ -34,7 +34,7 @@ def _cache_key(country: str, provider: str, cfg: Dict[str, Any]) -> str:
     避免命中旧参数生成的种子；旧文件保留（不删缓存，取最新）。"""
     fp = hashlib.md5(
         json.dumps(
-            {k: cfg.get(k) for k in ("max_style_seeds", "max_related_seeds",
+            {k: cfg.get(k) for k in ("max_seeds", "max_style_seeds", "max_related_seeds",
                                      "trending_context_limit", "history_limit")},
             sort_keys=True, ensure_ascii=False,
         ).encode("utf-8")
@@ -72,6 +72,7 @@ def seed_node(state: Dict[str, Any]) -> Dict[str, Any]:
     cfg = config.get("seed_provider_cfg") or {}
     trending_limit = int(cfg.get("trending_context_limit", 15))
     history_limit = int(cfg.get("history_limit", 20))
+    max_seeds = int(cfg.get("max_seeds", 0))
     max_style = int(cfg.get("max_style_seeds", 12))
     max_related = int(cfg.get("max_related_seeds", 12))
     guard = COMMON_RISK_WORDS + [b.lower() for b in (config.get("blacklist") or [])]
@@ -84,6 +85,7 @@ def seed_node(state: Dict[str, Any]) -> Dict[str, Any]:
         res = cached
         context: Dict[str, Any] = {
             "country": country,
+            "max_seeds": max_seeds,
             "max_style_seeds": max_style,
             "max_related_seeds": max_related,
         }
@@ -91,6 +93,7 @@ def seed_node(state: Dict[str, Any]) -> Dict[str, Any]:
         # 1) 收集上下文
         context: Dict[str, Any] = {
             "country": country,
+            "max_seeds": max_seeds,
             "max_style_seeds": max_style,
             "max_related_seeds": max_related,
         }

graph/nodes/seed_shot_node.py

@@ -1,14 +1,20 @@
 """节点 8/8：种草图生成（seed_shot）——在 oss_upload 之后。
 
-对每个 product 的合成图（图1），按 seed_shot_templates.yaml 模板 + model_features.yaml 随机模特特征
-生成 N 张种草图（config.seed_shot.count，默认 1）：
+种草图用 img2img 真正生成（不是复用主图）：从 product 已生成的三合一主图
+（color_composites，每颜色一张）中按分配规则选参考图，以该图提取衣服颜色并作为
+参考图，按 seed_shot_templates.yaml 模板 + model_features.yaml 随机模特特征生成新图：
   - [商品名称] ← product 的 cn_title（上一节点多模态生成）
   - [材质]     ← 数据库 SPU.material 字段
   - [模特特征] ← model_features.yaml 随机一条
-种草图同样压缩上传到 OSS（货号计数与 oss_upload 共用 state["oss_seq"] 续接）。
+分配规则（config.seed_shot.count）：
+  - count <= 颜色数：随机取 count 个不同颜色，各生成 1 张
+  - count >  颜色数：每个颜色至少 1 张，剩余随机补足（可重复）
+种草图同样压缩上传到 OSS（货号计数与 oss_upload 共用 state["oss_seq"] 续接），
+URL 写入 r["seed_shot_urls"]，供 template_export 插入模板详情图文列。
 
-未配置图像后端 / 无合成图 / count=0 时跳过，不中断。
+未配置图像后端 / 无三合一主图 / count=0 时跳过，不中断。
 """
+import random
 import time
 from pathlib import Path
 from typing import Any, Dict, List
@@ -16,6 +22,34 @@ from typing import Any, Dict, List
 from graph.validate import with_fallback
 
 
+def _plan_seed_shots(comps: List[Dict[str, Any]], count: int) -> List[tuple]:
+    """按颜色分配种草图数量：count <= 颜色数 → 随机取 count 个不同颜色各 1 张；
+    count > 颜色数 → 每色 1 张 + 随机补足（可重复）。返回 [(composite, n)]。"""
+    if count <= 0 or not comps:
+        return []
+    if len(comps) >= count:
+        picked = random.sample(comps, count)
+        return [(cc, 1) for cc in picked]
+    plan: List[tuple] = [(cc, 1) for cc in comps]          # 每色至少 1 张
+    for _ in range(count - len(comps)):
+        cc = random.choice(comps)                          # 随机补足（可重复）
+        for i, (c, n) in enumerate(plan):
+            if c is cc:
+                plan[i] = (c, n + 1)
+                break
+    return plan
+
+
+def _color_tag(cc: Dict[str, Any], idx: int) -> str:
+    """种草图文件名里的颜色标识：优先 sku_code 的颜色段，回退颜色名/序号。"""
+    sku = str(cc.get("sku_code") or "")
+    if "-" in sku:
+        tag = sku.split("-", 1)[1]
+    else:
+        tag = str(cc.get("color") or "") or f"c{idx}"
+    return "".join(ch for ch in tag if ch.isalnum() or ch in "-_") or f"c{idx}"
+
+
 @with_fallback("seed_shot")
 def seed_shot_node(state: Dict[str, Any]) -> Dict[str, Any]:
     products: List[Dict[str, Any]] = state.get("product") or []
@@ -47,7 +81,6 @@ def seed_shot_node(state: Dict[str, Any]) -> Dict[str, Any]:
     material_map: Dict[str, str] = {}
     try:
         from graph.product import list_spus
-        import yaml
         dbp = (config.get("product") or {}).get("db_path", "db/spu_sku.db")
         p = Path(dbp)
         if not p.is_absolute():
@@ -71,6 +104,7 @@ def seed_shot_node(state: Dict[str, Any]) -> Dict[str, Any]:
     seq = int(state.get("oss_seq") or 0)
     oss_cfg = config.get("oss") or {}
     oss_enabled = bool(oss_cfg.get("enabled", True)) and bool(oss_cfg.get("oss_bucket"))
+    size = str(ss_cfg.get("size") or "1504x2000")
 
     all_shots: List[Dict[str, Any]] = []
     shot_dir = output_dir / "seed_shots"
@@ -83,16 +117,31 @@ def seed_shot_node(state: Dict[str, Any]) -> Dict[str, Any]:
     def _shot_one(r: Dict[str, Any]):
         """单个产品的种草图生成+上传（每产品独立线程）。"""
         nonlocal seq
-        base = r.get("composite_path") or r.get("printed_path")
-        if not base or not Path(base).exists():
-            print(f"[seed_shot] {r.get('spu_code', '')} 无合成图，跳过种草图")
+        # 三合一主图：多色用 color_composites；单色回退 composite_path
+        comps = r.get("color_composites") or []
+        if not comps and r.get("composite_path") and Path(r["composite_path"]).exists():
+            comps = [{"sku_code": r.get("sku_code"), "color": r.get("color", ""),
+                      "composite_path": r["composite_path"]}]
+        if not comps:
+            print(f"[seed_shot] {r.get('spu_code', '')} 无三合一主图，跳过种草图")
             return None
+        plan = _plan_seed_shots(comps, count)
         cn = (r.get("cn_title") or "").strip() or r.get("topic", "")
         material = material_map.get(r.get("spu_code", ""), "")
-        paths = generate_seed_shots(ib, base, cn, material, count, str(shot_dir),
-                                    r.get("composite_negative", ""),
-                                    size=str((config.get("seed_shot") or {}).get("size") or "1504x2000"),
-                                    prefix=r.get("img_code") or r.get("oss_code") or "")
+        base_prefix = r.get("img_code") or r.get("oss_code") or ""
+
+        paths: List[str] = []
+        for ci, (cc, n) in enumerate(plan, start=1):
+            base = cc.get("composite_path")
+            if not base or not Path(base).exists():
+                print(f"[seed_shot] {r.get('spu_code', '')} 参考图缺失（{base}），跳过该颜色种草图")
+                continue
+            tag = _color_tag(cc, ci)
+            pfx = f"{base_prefix}_{tag}" if base_prefix else f"seed_{tag}"
+            generated = generate_seed_shots(ib, base, cn, material, n, str(shot_dir),
+                                            r.get("composite_negative", ""),
+                                            size=size, prefix=pfx)
+            paths.extend(generated)
         if not paths:
             return None
         r["seed_shot_paths"] = paths