@yuhan1124/draw-prompt 0.4.11 → 0.4.13

package/README.md

@@ -135,7 +135,7 @@ overlay --image out.png --spec spec.json --out final.png      # 按 overlay spec
 visual-check --image final.png --spec spec.json               # 单图质量门：尺寸/画幅/亮度/对比度
 edit-check --reference ref.png --output edited.png            # 改图质量门：主体保留 + 有效变化
 intent-check --request "原始需求" --prompt "生成prompt"       # 检查是否新增/偏离用户未要求内容
-visual-regress references/visual-cases.jsonl                  # 开发仓库本地：多场景 prompt/成品图回归，支持 expect_/forbid_ 断言
+visual-regress references/visual-cases.jsonl                  # 开发仓库本地：多场景/多输出 prompt 回归，支持 expect_/forbid_ 断言
 lint --prompt "…" [--asset-type poster] [--text 必显文字]    # 生图转化硬约束检查
 benchmark references/golden-cases.jsonl --runs 3             # 开发仓库本地：golden cases 稳定性基准
 revise --sample-id last --reason text_error                  # 按失败分类修订 Prompt
@@ -174,7 +174,7 @@ status                                            # 数据 + 下游通道健康
 4. 只有当用户明确要求“文字必须绝对准确/可后处理”或出图反馈属于 `text_error` 时，才切到 `--strict-text` + `overlay` 两段式兜底。
 5. 用 `visual-check` 验证成品图尺寸、画幅、亮度、对比度和基础细节。
 6. 参考图改图用 `edit-check` 验证“主体保留 + 背景/目标确实变化”。
-7. 模板或策略变动后，在开发仓库本地跑 `visual-regress references/visual-cases.jsonl`，确认多场景回归通过；用 `expect_asset_type`、`expect_aspect`、`expect_required_text`、`forbid_required_text`、`expect_prompt_contains`、`forbid_prompt_contains` 把真实场景的产品意图固化成门禁。
+7. 模板或策略变动后，在开发仓库本地跑 `visual-regress references/visual-cases.jsonl`，确认多场景回归通过；它会真实编译 `convert`、`rewrite`、`edit`、`variants`、`series`、`adapt`、`compose`、`brand`、`character`、`data-viz` 等单图/多输出入口。用 `expect_count`、`expect_asset_type(s)`、`expect_aspect(s)`、`expect_required_text(_all)`、`forbid_required_text`、`expect_safety_rewrite`、`expect_prompt_contains`、`forbid_prompt_contains` 把真实场景的产品意图固化成门禁。
 
 这条链路的默认目标不是替 gpt-image-2 重做排版引擎，而是减少跑偏、遗漏和廉价风格；
 两段式 overlay 只是文字极端稳定性兜底，不作为普通用户的默认体验。

package/SKILL.md

@@ -8,7 +8,7 @@ description: >-
   画图的指令"、"优化我的出图 prompt"、"按我的风格生成 prompt"，或在用 GPT Image 2 /
   gpt-image-2 出图前需要一段精准提示词时，使用本 skill。
 metadata:
-  version: 0.4.11
+  version: 0.4.13
   openclaw:
     anyBins: ["uv", "python3"]
 ---
@@ -168,7 +168,7 @@ overlay --image out.png --spec spec.json --out final.png      # 精确中文字/
 visual-check --image final.png --spec spec.json               # 单图质量门
 edit-check --reference ref.png --output edited.png            # 参考图改图质量门
 intent-check --request "原始需求" --prompt "生成prompt"       # 意图保真检查
-visual-regress references/visual-cases.jsonl                  # 开发仓库本地：多场景回归，支持 expect_/forbid_ 断言
+visual-regress references/visual-cases.jsonl                  # 开发仓库本地：多场景/多输出回归，支持 expect_/forbid_ 断言
 lint --prompt "…" [--asset-type poster] [--text 必显文字]    # 生图转化硬约束检查
 benchmark references/golden-cases.jsonl --runs 3             # 开发仓库本地：golden cases 转化稳定性基准
 revise --sample-id last --reason text_error                  # 按失败分类修订 Prompt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuhan1124/draw-prompt",
-  "version": "0.4.11",
+  "version": "0.4.13",
   "description": "Convert natural-language image requests into high-quality gpt-image-2 prompts and Codex handoff blocks.",
   "type": "commonjs",
   "bin": {

package/references/conversion-skill-plan.md

@@ -369,7 +369,7 @@ prompt，再交给下游出图。
 | `ui_dashboard` | ui | 侧边栏、顶部栏、KPI、图表、表格 |
 | `slide_corporate_report` | slide | 保留用户显式区域、栏目/行列结构、图标位置、页脚和留白 |
 | `diagram_rag` | diagram | User -> Retriever -> Vector DB -> LLM -> Answer |
-| `diagram_system` | diagram | 分层盒子、有向箭头、图例 |
+| `diagram_system` | diagram | 分层盒子、有向箭头、只保留用户要求的标签 |
 
 ## 质量门
 

package/scripts/prompt_cli.py

@@ -138,7 +138,7 @@ def ensure_home() -> None:
 
 
 SCHEMA_VERSION = 1
-COMPILER_VERSION = "0.4.11"
+COMPILER_VERSION = "0.4.13"
 
 
 PACKAGED_SKILL_FILES = [
@@ -2320,7 +2320,7 @@ TEMPLATE_DEFS = {
     "diagram_system": {
         "asset_type": "diagram",
         "label": "系统架构图",
-        "layout": "layered system boxes with directional arrows and a small legend",
+        "layout": "layered system boxes with directional arrows",
         "keywords": ["架构", "系统", "模块", "服务", "流程"],
     },
     "product_hero": {
@@ -2593,6 +2593,9 @@ NON_DISPLAY_TEXTS = {
     "关系",
     "标签",
     "卖点标签",
+    "主视觉",
+    "产品主视觉",
+    "核心",
     "购买转化氛围",
     "但不要过度促销",
 }
@@ -2642,12 +2645,13 @@ def extract_required_texts(request: str, explicit_texts: list[str]) -> list[str]
 
     def clean_text(text: str) -> str:
         text = text.strip(" \t\n\r，,、。；;：:.!?！？")
-        text = re.sub(r"^(?:[^：:]{0,12}(?:指标卡|卡片|列表|标题|模块|节点|步骤|栏目|分支))[：:]", "", text)
+        text = re.sub(r"^(?:[^：:]{0,20}(?:活动路径|指标卡|卡片|列表|标题|模块|节点|步骤|栏目|分支|路径|卡))[：:]", "", text)
         text = re.sub(r"^(?:顶部|底部|中间|左侧|右侧|上方|下方|首页|页面)?(?:主标题|副标题|标题)\s+", "", text)
         text = re.sub(r"^(?:问候语|核心卡片|主要按钮|主按钮|按钮)\s+", "", text)
         text = re.sub(r"^(?:是|为|叫)\s+", "", text)
         text = re.sub(r"^(?:一个|一枚|一项)?(?:明显的|醒目的|主要的|primary\s+)?(.{1,16})按钮$", r"\1", text, flags=re.IGNORECASE)
-        text = re.sub(r"(?:网格|列表|区域|模块)$", "", text)
+        text = re.sub(r"(?:[一二三四五六七八九十\d]+个)?(?:网格|列表|区域|模块|卡片)$", "", text)
+        text = re.sub(r"\s*[一二三四五六七八九十\d]+个$", "", text)
         text = re.sub(r"(?:要)?(?:渲染)?(?:清晰|清楚|可读|明显)$", "", text)
         text = re.sub(r"(?:这些)?元素$", "", text)
         text = re.sub(r"(?:[一二三四五六七八九十\d]+个)?步骤$", "", text)
@@ -2748,12 +2752,13 @@ def merge_texts(primary: list[str], extra: list[str]) -> list[str]:
     seen: set[str] = set()
     for item in primary + extra:
         text = item.strip(" \t\n\r，,、。；;：:.!?！？")
-        text = re.sub(r"^(?:[^：:]{0,12}(?:指标卡|卡片|列表|标题|模块|节点|步骤|栏目|分支))[：:]", "", text)
+        text = re.sub(r"^(?:[^：:]{0,20}(?:活动路径|指标卡|卡片|列表|标题|模块|节点|步骤|栏目|分支|路径|卡))[：:]", "", text)
         text = re.sub(r"^(?:顶部|底部|中间|左侧|右侧|上方|下方|首页|页面)?(?:主标题|副标题|标题)\s+", "", text)
         text = re.sub(r"^(?:问候语|核心卡片|主要按钮|主按钮|按钮)\s+", "", text)
         text = re.sub(r"^(?:是|为|叫)\s+", "", text)
         text = re.sub(r"^(?:一个|一枚|一项)?(?:明显的|醒目的|主要的|primary\s+)?(.{1,16})按钮$", r"\1", text, flags=re.IGNORECASE)
-        text = re.sub(r"(?:网格|列表|区域|模块)$", "", text)
+        text = re.sub(r"(?:[一二三四五六七八九十\d]+个)?(?:网格|列表|区域|模块|卡片)$", "", text)
+        text = re.sub(r"\s*[一二三四五六七八九十\d]+个$", "", text)
         text = re.sub(r"(?:要)?(?:渲染)?(?:清晰|清楚|可读|明显)$", "", text)
         text = re.sub(r"(?:这些)?元素$", "", text)
         text = re.sub(r"(?:[一二三四五六七八九十\d]+个)?步骤$", "", text)
@@ -2768,19 +2773,30 @@ def merge_texts(primary: list[str], extra: list[str]) -> list[str]:
         if text and key not in seen:
             seen.add(key)
             merged.append(text)
-    return merged
+    pruned: list[str] = []
+    compact_items = [(text, re.sub(r"[\s，,、。；;：:.!?！？]+", "", text)) for text in merged]
+    for idx, (text, key) in enumerate(compact_items):
+        if len(key) <= 8 and any(
+            idx != other_idx and key and key in other_key and len(other_key) > len(key)
+            for other_idx, (_, other_key) in enumerate(compact_items)
+        ):
+            continue
+        pruned.append(text)
+    return pruned
 
 
 def extract_structural_labels(request: str, asset_type: str) -> list[str]:
     if asset_type not in {"diagram", "infographic", "slide", "ui", "poster", "product"}:
         return []
     candidates: list[tuple[int, str]] = []
-    list_intro = r"(?:需要)?(?:展示|呈现|列出|包含|包括|含有|分为|覆盖|输出)"
+    list_intro = r"(?:需要)?(?:展示|呈现|列出|包含|包括|含有|分为|覆盖)"
     stop_words = r"(?:\b16\s*:\s*9\b|\b9\s*:\s*16\b|\b3\s*:\s*4\b|\b1\s*:\s*1\b|适合|用于|画幅|aspect|高质量|高清|clean|corporate)"
     patterns = [
         rf"(?:结构(?:从左到右|从右到左|从上到下|从下到上)?|链路|流程)\s*[：:]\s*([^。\n]{{2,240}})",
         rf"(?:数据|指标|核心数据|关键指标|卖点|亮点|功能点|特性|活动路径|路径)\s*(?:包括|包含|有|为)?[：:\s]*([^。；;\n]{{2,180}})",
         rf"{list_intro}\s*(?:这些|以下|对应的)?(?:模块|部分|层|栏目|节点|入口|能力|场景|列表|指标卡|卡片|步骤|分支|数据|指标|卖点|亮点|功能点|特性|路径)?[：:\s]*([^。；;\n]{{2,180}})",
+        rf"(?:顶部|底部|中间|左侧|右侧|上方|下方|最终|末端)?\s*输出\s*(?!可交给|为|成|到|给)([^。；;\n]{{2,180}})",
+        rf"(?:顶部|底部|中间|左侧|右侧|上方|下方|主区域|页面|首页)?\s*(?:有|显示|放置|排列|提供)\s*([^。；;\n]{{2,180}}?(?:[一二三四五六七八九十\d]+个)?(?:模块|卡片|按钮|入口|标签|列表))",
         rf"(?:模块|节点|栏目|部分|层|入口|能力|场景|列表|指标卡|卡片|步骤|分支|数据|指标|卖点|亮点|功能点|特性|路径)\s*(?:包括|包含|有|为)[：:\s]*([^。；;\n]{{2,180}})",
         rf"(?:模块|节点|栏目|部分|层|入口|能力|场景|列表|指标卡|卡片|步骤|分支|数据|指标|卖点|亮点|功能点|特性|路径)[^。；;\n：:]{{0,16}}[：:]([^。；;\n]{{2,180}})",
     ]
@@ -2790,17 +2806,23 @@ def extract_structural_labels(request: str, asset_type: str) -> list[str]:
         )
     for pattern in patterns:
         for match in re.finditer(pattern, request, flags=re.IGNORECASE):
+            if re.search(r"\bicon\s*:|图标", match.group(0), flags=re.IGNORECASE):
+                continue
             value = re.split(stop_words, match.group(1), maxsplit=1, flags=re.IGNORECASE)[0]
             value = re.sub(r"[()（）]", "、", value)
             value = re.sub(r"(?:进入|再到|到|输出|->|→)", "、", value)
             for part_match in re.finditer(r"[^、,，;；|]+", value):
                 part = part_match.group(0).strip(" \t\n\r，,、：:")
-                part = re.sub(r"^(?:[^：:]{0,12}(?:指标卡|卡片|列表|标题|模块|节点|步骤|栏目|分支))[：:]", "", part)
+                part = re.sub(r"^(?:[^：:]{0,20}(?:活动路径|指标卡|卡片|列表|标题|模块|节点|步骤|栏目|分支|路径|卡))[：:]", "", part)
                 part = re.sub(r"^(?:和|与|及|以及|and|再|则)\s*", "", part, flags=re.IGNORECASE).strip()
                 part = re.sub(r"^(?:底部有|顶部有|左侧有|右侧有|上方有|下方有)\s*", "", part)
                 part = re.sub(r"^(?:包含|包括|含有)\s*", "", part)
+                part = re.sub(r"^(?:问候语|核心卡片|主要按钮|主按钮|按钮)\s+", "", part)
+                part = re.sub(r"^(?:一个|一枚|一项)?(?:明显的|醒目的|主要的|primary\s+)?(.{1,16})按钮$", r"\1", part, flags=re.IGNORECASE)
                 part = re.sub(r"\s*(?:和|与|及|以及|and)$", "", part, flags=re.IGNORECASE).strip()
                 part = re.sub(r"(?:这些)?元素$", "", part)
+                part = re.sub(r"(?:[一二三四五六七八九十\d]+个)?(?:网格|列表|区域|模块|卡片)$", "", part)
+                part = re.sub(r"\s*[一二三四五六七八九十\d]+个$", "", part)
                 part = re.sub(r"(?:[一二三四五六七八九十\d]+个)?步骤$", "", part)
                 part = part.strip(" \t\n\r，,、：:")
                 if not part:
@@ -2854,7 +2876,7 @@ def infer_palette_constraints(request: str) -> list[str]:
     ]
     constraints: list[str] = []
     seen: set[str] = set()
-    for sentence in re.split(r"[。；;\n]", request):
+    for sentence in re.split(r"[。；;\n]|(?<=[A-Za-z)])\.\s+", request):
         for fragment in re.split(r"[，,]", sentence):
             fragment = fragment.strip(" \t\r\n。.；;，,")
             if not fragment:
@@ -3112,7 +3134,7 @@ def infer_must_include(asset_type: str, template_id: str, texts: list[str], stri
         "ui": ["requested screen type", "requested UI sections", "clear component hierarchy"],
         "infographic": ["requested information units", "requested relationships", "clear visual hierarchy"],
         "slide": ["widescreen slide canvas", "all requested sections", "requested visual motifs", "crisp readable text hierarchy"],
-        "diagram": ["labeled components", "directional arrows", "legend or flow semantics"],
+        "diagram": ["labeled components", "directional arrows", "clear flow semantics"],
         "product": ["single hero product", "visible material texture", "controlled studio lighting"],
         "photography": ["realistic subject", "specific scene details", "natural imperfections"],
         "character": ["consistent character identity", "turnaround views", "expression close-ups"],
@@ -3451,7 +3473,7 @@ def render_prompt(spec: dict) -> str:
                 brief_block,
                 f"Style / quality envelope for diagram: {diagram_style}. This only controls presentation polish; the user brief wins.",
                 f"Quality controls: crisp typography, clear node grouping, balanced white space, precise alignment, high contrast, restrained palette ({diagram_palette}).",
-                f"Recommended structure: {layout}. Use boxes, groups, arrows, and a feedback loop only where they match the brief.",
+                f"Recommended structure: {layout}. Use boxes, groups, arrows, and a feedback loop only where they match the brief; do not add a legend or extra explanatory labels unless the brief asks for them.",
                 "Do not over-template the diagram. Preserve the user's named modules, reading order, and product-review context.",
                 f"Must include: {must_include}.",
                 text_block,
@@ -4867,9 +4889,25 @@ def cmd_edit_check(args: argparse.Namespace) -> int:
 
 def visual_case_compile(case: dict) -> dict:
     tool = str(case.get("tool") or case.get("cmd") or "convert")
-    if tool in {"convert", "rewrite", "adapt", "series", "compose", "brand", "character", "data-viz"}:
+    if tool in {"convert", "rewrite"}:
         compiled = compile_visual_case(case, target=case.get("target") or "codex-image")
-        return {**compiled, "tool": tool}
+        return with_compiled_items({**compiled, "tool": tool}, [{"id": case.get("id") or tool, **compiled}])
+    if tool == "edit":
+        return compile_visual_edit_case(case)
+    if tool == "variants":
+        return compile_visual_variants_case(case)
+    if tool == "series":
+        return compile_visual_series_case(case)
+    if tool == "adapt":
+        return compile_visual_adapt_case(case)
+    if tool == "compose":
+        return compile_visual_compose_case(case)
+    if tool == "brand":
+        return compile_visual_brand_case(case)
+    if tool == "character":
+        return compile_visual_character_case(case)
+    if tool == "data-viz":
+        return compile_visual_data_viz_case(case)
     raise ValueError(f"visual-regress 暂不支持 tool={tool}")
 
 
@@ -4918,6 +4956,9 @@ def cmd_visual_regress(args: argparse.Namespace) -> int:
                 "prompt_digest": compiled["prompt_digest"],
                 "asset_type": compiled["spec"]["asset_type"],
                 "aspect": compiled["spec"]["aspect"],
+                "item_count": len(compiled.get("items") or [compiled]),
+                "asset_types": [(entry.get("spec") or {}).get("asset_type") for entry in (compiled.get("items") or [compiled])],
+                "aspects": [(entry.get("spec") or {}).get("aspect") for entry in (compiled.get("items") or [compiled])],
                 "lint": lint,
                 "intent_check": intent,
                 "expectation_findings": expectation_findings,
@@ -5034,6 +5075,293 @@ def compile_visual_case(
     }
 
 
+def with_compiled_items(compiled: dict, items: list[dict]) -> dict:
+    normalized = []
+    for idx, item in enumerate(items, start=1):
+        normalized.append(
+            {
+                "id": item.get("id") or f"item-{idx:02d}",
+                "spec": item["spec"],
+                "prompt": item["prompt"],
+                "prompt_digest": item.get("prompt_digest") or prompt_digest(item["prompt"]),
+                "lint": item.get("lint") or [],
+                "intent_check": item.get("intent_check") or [],
+                "handoff": item.get("handoff"),
+                "text_overlay_spec": item.get("text_overlay_spec"),
+                "acceptance_criteria": item.get("acceptance_criteria", []),
+            }
+        )
+    if len(normalized) == 1:
+        out = dict(compiled)
+        out["items"] = normalized
+        return out
+    joined_digests = "|".join(item["prompt_digest"] for item in normalized)
+    bundle = dict(compiled)
+    bundle.update(
+        {
+            "spec": {
+                "asset_type": "bundle",
+                "aspect": "multi",
+                "template_id": "multi_output",
+                "required_text": [],
+                "strict_text": False,
+            },
+            "prompt": "\n\n".join(item["prompt"] for item in normalized),
+            "prompt_digest": prompt_digest(joined_digests),
+            "lint": [finding for item in normalized for finding in item["lint"]],
+            "intent_check": [finding for item in normalized for finding in item["intent_check"]],
+            "handoff": None,
+            "text_overlay_spec": None,
+            "acceptance_criteria": [],
+            "items": normalized,
+        }
+    )
+    return bundle
+
+
+def visual_case_request(case: dict) -> str:
+    request = case.get("request") or case.get("brief") or case.get("prompt_request") or case.get("input") or case.get("text")
+    if isinstance(request, list):
+        return "\n".join(str(item) for item in request)
+    return str(request or "")
+
+
+def compile_visual_variants_case(case: dict) -> dict:
+    request = visual_case_request(case)
+    if not request:
+        raise ValueError("variants case 缺少 request 字段")
+    presets = parse_style_preset_list(str(case.get("style_presets") or ",".join(DEFAULT_VARIANT_PRESETS)), DEFAULT_VARIANT_PRESETS)
+    custom_styles = case_list(case.get("custom_style") or case.get("custom_styles"))
+    entries: list[dict] = [{"style_preset": preset, "style": case.get("shared_style")} for preset in presets]
+    for custom in custom_styles:
+        entries.append({"style_preset": "auto", "style": "; ".join([str(case.get("shared_style") or ""), custom]).strip("; "), "custom_style": custom})
+    items = []
+    for idx, entry in enumerate(entries, start=1):
+        variant_case = dict(case)
+        variant_case.update(
+            {
+                "request": request,
+                "style": entry.get("style"),
+                "style_preset": entry["style_preset"],
+                "tags": "visual-regress,variants",
+            }
+        )
+        variant_case.pop("tool", None)
+        compiled = compile_visual_case(variant_case, target=case.get("target") or "codex-image", include_handoff=False)
+        items.append({"id": f"variant-{idx:02d}", **compiled})
+    return with_compiled_items({"tool": "variants", "count": len(items)}, items)
+
+
+def compile_visual_edit_case(case: dict) -> dict:
+    goal = str(case.get("goal") or visual_case_request(case))
+    if not goal:
+        raise ValueError("edit case 缺少 goal/request 字段")
+    references = [parse_reference(value) for value in case_list(case.get("reference") or case.get("references"))]
+    preserve = case_list(case.get("preserve")) or ["main subject identity, silhouette, material cues, and composition anchors"]
+    changes = case_list(case.get("change")) or [goal]
+    required_text = case_list(case.get("text") or case.get("required_text"))
+    aspect = str(case.get("aspect") or "3:4")
+    asset_type = str(case.get("asset_type") or "product")
+    quality = str(case.get("quality") or "high")
+    reference_block = "; ".join(f"{item['role']}={item['ref']}" for item in references) or "provided reference image(s)"
+    prompt = "\n".join(
+        [
+            f"Edit the provided reference image(s) into a {aspect} {asset_type} result for: {goal}.",
+            f"References: {reference_block}.",
+            "Preserve exactly: " + "; ".join(preserve) + ".",
+            "Change only: " + "; ".join(changes) + ".",
+            f"Visual target: {case.get('style') or 'production-quality realistic edit, consistent lighting, no visible seams'}; quality={quality}.",
+            exact_text_block(required_text),
+            "Avoid: identity drift; unwanted background changes; mismatched perspective; fake logos; garbled text; low-resolution artifacts.",
+        ]
+    )
+    lint = lint_prompt(prompt, asset_type, quality, required_text)
+    spec = {
+        "asset_type": asset_type,
+        "aspect": aspect,
+        "template_id": "edit",
+        "required_text": required_text,
+        "strict_text": False,
+        "quality": quality,
+    }
+    compiled = {
+        "spec": spec,
+        "prompt": prompt,
+        "prompt_digest": prompt_digest(prompt),
+        "lint": lint,
+        "intent_check": [],
+        "handoff": None,
+        "text_overlay_spec": None,
+        "acceptance_criteria": [],
+    }
+    return with_compiled_items({"tool": "edit", **compiled}, [{"id": "edit-01", **compiled}])
+
+
+def compile_visual_series_case(case: dict) -> dict:
+    raw_items = case.get("briefs") or case.get("items") or case.get("series") or []
+    if isinstance(raw_items, str):
+        raw_items = [raw_items]
+    if not raw_items:
+        request = visual_case_request(case)
+        if request:
+            raw_items = [request]
+    if not raw_items:
+        raise ValueError("series case 缺少 briefs/items/request")
+    shared_style = str(case.get("style") or case.get("shared_style") or "single coherent series style, same camera language, same palette discipline, same visual density")
+    items = []
+    for idx, item in enumerate(raw_items, start=1):
+        item_case = dict(item) if isinstance(item, dict) else {"request": str(item)}
+        brief = str(item_case.get("request") or item_case.get("brief") or "")
+        if not brief:
+            raise ValueError(f"series 第 {idx} 项缺少 request/brief")
+        item_case["request"] = brief
+        if case.get("asset_type") and not item_case.get("asset_type"):
+            item_case["asset_type"] = case.get("asset_type")
+        item_case["style"] = "; ".join([shared_style, str(item_case.get("style") or "").strip()]).strip("; ")
+        for key in ("palette", "style_preset", "strict_text", "target"):
+            if case.get(key) is not None and item_case.get(key) is None:
+                item_case[key] = case.get(key)
+        item_case["tags"] = "visual-regress,series"
+        compiled = compile_visual_case(item_case, target=case.get("target") or "codex-image", include_handoff=False)
+        items.append({"id": f"series-{idx:02d}", **compiled})
+    return with_compiled_items({"tool": "series", "count": len(items)}, items)
+
+
+def compile_visual_adapt_case(case: dict) -> dict:
+    request = visual_case_request(case)
+    if not request:
+        raise ValueError("adapt case 缺少 request 字段")
+    aspects = split_csv(str(case.get("aspects") or case.get("aspect") or "1:1,3:4,16:9,9:16"))
+    items = []
+    for idx, aspect in enumerate(aspects, start=1):
+        asset_type = str(case.get("asset_type") or route_asset_type(request))
+        item_case = dict(case)
+        item_case.update(
+            {
+                "request": request,
+                "asset_type": asset_type,
+                "aspect": aspect,
+                "layout": case.get("layout") or adapt_layout_for_aspect(aspect, asset_type),
+                "tags": "visual-regress,adapt",
+            }
+        )
+        item_case.pop("tool", None)
+        compiled = compile_visual_case(item_case, target=case.get("target") or "codex-image", include_handoff=False)
+        items.append({"id": f"adapt-{idx:02d}", **compiled})
+    return with_compiled_items({"tool": "adapt", "count": len(items)}, items)
+
+
+def compile_visual_compose_case(case: dict) -> dict:
+    text = visual_case_request(case)
+    if not text:
+        raise ValueError("compose case 缺少 request/input 字段")
+    max_images = int(case.get("max_images") or 6)
+    shared_style = str(case.get("shared_style") or infer_compose_style(text))
+    chunks = split_document_sections(text, max_images)
+    items = []
+    for idx, chunk in enumerate(chunks, start=1):
+        asset_type = choose_compose_asset(chunk, idx - 1)
+        labels = extract_visual_labels(chunk, asset_type)
+        purpose = compose_purpose(asset_type, idx)
+        item_case = {
+            "request": f"{purpose}。根据这段内容生成对应画面：{chunk}",
+            "asset_type": asset_type,
+            "style": shared_style,
+            "style_preset": case.get("style_preset"),
+            "palette": case.get("palette"),
+            "text": labels if (case.get("strict_text") or asset_type in {"diagram", "infographic", "ui"}) else [],
+            "strict_text": bool(case.get("strict_text", False)),
+            "target": case.get("target") or "codex-image",
+            "tags": "visual-regress,compose",
+        }
+        compiled = compile_visual_case(item_case, target=case.get("target") or "codex-image", include_handoff=False)
+        items.append({"id": f"compose-{idx:02d}", **compiled})
+    return with_compiled_items({"tool": "compose", "count": len(items), "shared_style": shared_style}, items)
+
+
+def compile_visual_brand_case(case: dict) -> dict:
+    name = str(case.get("name") or "")
+    request = visual_case_request(case)
+    if not name:
+        raise ValueError("brand case 缺少 name 字段")
+    brand_block = "\n".join(
+        [
+            f"Brand system for invented brand \"{name}\":",
+            f"- Industry: {case.get('industry') or 'unspecified'}.",
+            f"- Values: {', '.join(case_list(case.get('values'))) or 'clear, trustworthy, distinctive'}.",
+            f"- Palette: {case.get('palette') or '2-3 controlled brand colors plus neutral support'}.",
+            f"- Style: {case.get('style') or 'original, consistent, premium but restrained brand system'}.",
+            "- Rules: keep mark shapes original; use the same spacing, palette, and typography logic across assets; no real brand logos.",
+        ]
+    )
+    item_case = dict(case)
+    item_case.update({"request": f"{request}\n{brand_block}" if request else brand_block, "text": case.get("text") or [name], "tags": "visual-regress,brand"})
+    item_case.pop("tool", None)
+    compiled = compile_visual_case(item_case, target=case.get("target") or "codex-image", include_handoff=False)
+    return with_compiled_items({"tool": "brand", **compiled}, [{"id": "brand-01", **compiled}])
+
+
+def compile_visual_character_case(case: dict) -> dict:
+    name = str(case.get("name") or "")
+    description = str(case.get("description") or visual_case_request(case))
+    if not name or not description:
+        raise ValueError("character case 缺少 name/description")
+    identity = (
+        f"Original character \"{name}\": {description}. "
+        f"Outfit anchors: {case.get('outfit') or 'stable signature outfit and silhouette'}. "
+        f"Palette: {case.get('palette') or 'stable limited palette'}. Keep the same identity anchors in every image; no existing IP resemblance."
+    )
+    items = []
+    reference_case = {"request": f"角色设定三视图和表情板：{identity}", "asset_type": "character", "style": case.get("style"), "style_preset": case.get("style_preset"), "text": [name], "tags": "visual-regress,character"}
+    reference = compile_visual_case(reference_case, target=case.get("target") or "codex-image", include_handoff=False)
+    items.append({"id": "character-reference", **reference})
+    for idx, scene in enumerate(case_list(case.get("scene") or case.get("scenes")), start=1):
+        scene_case = {"request": f"{identity} 场景图：{scene}", "asset_type": "illustration", "style": case.get("style"), "style_preset": case.get("style_preset"), "tags": "visual-regress,character-scene"}
+        compiled = compile_visual_case(scene_case, target=case.get("target") or "codex-image", include_handoff=False)
+        items.append({"id": f"character-scene-{idx:02d}", **compiled})
+    return with_compiled_items({"tool": "character", "count": len(items)}, items)
+
+
+def compile_visual_data_viz_case(case: dict) -> dict:
+    request = str(case.get("request") or "根据数据生成清晰的信息图")
+    data_preview = read_data_preview(str(case.get("file") or "")) if case.get("file") else {"columns": [], "rows": [], "row_count": 0, "source": ""}
+    title = infer_chart_title(request, str(case.get("title") or "") or None)
+    chart_type = infer_chart_type(request, data_preview["columns"], str(case.get("chart_type") or "") or None)
+    required_text = [] if case.get("strict_text") else [title]
+    prompt = "\n".join(
+        [
+            f"Create a 16:9 high-quality data visualization infographic for: {request}.",
+            f"Chart type: {chart_type}.",
+            f"Data schema: columns={', '.join(data_preview['columns']) or 'not provided'}, rows={data_preview['row_count']}.",
+            f"Rows preview for visual truthfulness: {json.dumps(data_preview['rows'], ensure_ascii=False)}.",
+            "Layout: title band, main chart area, short insight callouts, compact legend, and optional source note.",
+            "Use honest scales, aligned axes, restrained colors, and no decorative fake data.",
+            f'The title must read exactly "{title}". Keep labels large and readable.' if required_text else "Strict chart text mode: reserve clean title, axis, legend, and callout zones; exact labels and numbers will be applied as deterministic vector/text overlay.",
+            "Avoid: misleading charts; unreadable microtext; random numbers not present in the data; fake logos; visual clutter.",
+        ]
+    )
+    lint = lint_prompt(prompt, "infographic", "high", required_text)
+    spec = {
+        "asset_type": "infographic",
+        "aspect": "16:9",
+        "template_id": "data_viz",
+        "required_text": required_text,
+        "strict_text": bool(case.get("strict_text")),
+        "quality": "high",
+    }
+    compiled = {
+        "spec": spec,
+        "prompt": prompt,
+        "prompt_digest": prompt_digest(prompt),
+        "lint": lint,
+        "intent_check": [],
+        "handoff": None,
+        "text_overlay_spec": None,
+        "acceptance_criteria": [],
+    }
+    return with_compiled_items({"tool": "data-viz", **compiled}, [{"id": "data-viz-01", **compiled}])
+
+
 def case_list(value: object) -> list[str]:
     if value is None:
         return []
@@ -5043,12 +5371,25 @@ def case_list(value: object) -> list[str]:
 
 
 def visual_case_expectation_findings(case: dict, compiled: dict) -> list[dict]:
-    spec = compiled.get("spec") or {}
-    prompt = str(compiled.get("prompt") or "")
+    items = compiled.get("items") or [compiled]
+    specs = [(item.get("spec") or {}) for item in items]
+    prompts = [str(item.get("prompt") or "") for item in items]
+    spec = specs[0] if len(specs) == 1 else (compiled.get("spec") or {})
+    prompt = "\n".join(prompts)
     findings: list[dict] = []
 
+    expected_count = case.get("expect_count")
+    if expected_count is not None and len(items) != int(expected_count):
+        findings.append(
+            {
+                "severity": "error",
+                "rule": "case.count_mismatch",
+                "message": f"期望输出数量={expected_count}，实际={len(items)}",
+            }
+        )
+
     expected_asset = case.get("expect_asset_type")
-    if expected_asset and spec.get("asset_type") != expected_asset:
+    if expected_asset and len(items) == 1 and spec.get("asset_type") != expected_asset:
         findings.append(
             {
                 "severity": "error",
@@ -5056,9 +5397,20 @@ def visual_case_expectation_findings(case: dict, compiled: dict) -> list[dict]:
                 "message": f"期望 asset_type={expected_asset}，实际={spec.get('asset_type')}",
             }
         )
+    expected_asset_types = case_list(case.get("expect_asset_types"))
+    if expected_asset_types:
+        actual = [str(item.get("asset_type") or "") for item in specs]
+        if actual != expected_asset_types:
+            findings.append(
+                {
+                    "severity": "error",
+                    "rule": "case.asset_types_mismatch",
+                    "message": f"期望 asset_types={expected_asset_types}，实际={actual}",
+                }
+            )
 
     expected_aspect = case.get("expect_aspect")
-    if expected_aspect and spec.get("aspect") != expected_aspect:
+    if expected_aspect and len(items) == 1 and spec.get("aspect") != expected_aspect:
         findings.append(
             {
                 "severity": "error",
@@ -5066,6 +5418,17 @@ def visual_case_expectation_findings(case: dict, compiled: dict) -> list[dict]:
                 "message": f"期望 aspect={expected_aspect}，实际={spec.get('aspect')}",
             }
         )
+    expected_aspects = case_list(case.get("expect_aspects"))
+    if expected_aspects:
+        actual = [str(item.get("aspect") or "") for item in specs]
+        if actual != expected_aspects:
+            findings.append(
+                {
+                    "severity": "error",
+                    "rule": "case.aspects_mismatch",
+                    "message": f"期望 aspects={expected_aspects}，实际={actual}",
+                }
+            )
 
     expected_template = case.get("expect_template_id")
     if expected_template and spec.get("template_id") != expected_template:
@@ -5076,16 +5439,43 @@ def visual_case_expectation_findings(case: dict, compiled: dict) -> list[dict]:
                 "message": f"期望 template_id={expected_template}，实际={spec.get('template_id')}",
             }
         )
+    expected_templates = case_list(case.get("expect_template_ids"))
+    if expected_templates:
+        actual = [str(item.get("template_id") or "") for item in specs]
+        if actual != expected_templates:
+            findings.append(
+                {
+                    "severity": "error",
+                    "rule": "case.template_ids_mismatch",
+                    "message": f"期望 template_ids={expected_templates}，实际={actual}",
+                }
+            )
 
-    labels = set(spec.get("required_text") or [])
+    if case.get("expect_safety_rewrite"):
+        if not any(item.get("safety_rewrite") for item in specs):
+            findings.append(
+                {
+                    "severity": "error",
+                    "rule": "case.safety_rewrite_missing",
+                    "message": "期望触发安全改写，但 spec.safety_rewrite 为空",
+                }
+            )
+
+    labels_by_item = [set(item.get("required_text") or []) for item in specs]
+    labels = set().union(*labels_by_item) if labels_by_item else set()
     for text in case_list(case.get("expect_required_text")):
         if text not in labels:
             findings.append({"severity": "error", "rule": "case.required_text_missing", "message": f"缺少必显文字：{text}"})
-        elif f'"{text}"' not in prompt and not spec.get("strict_text"):
+        elif f'"{text}"' not in prompt and not any(item.get("strict_text") for item in specs):
             findings.append({"severity": "error", "rule": "case.required_text_not_quoted", "message": f"Prompt 未逐字引用：{text}"})
 
+    for text in case_list(case.get("expect_required_text_all")):
+        for idx, item_labels in enumerate(labels_by_item, start=1):
+            if text not in item_labels:
+                findings.append({"severity": "error", "rule": "case.required_text_all_missing", "message": f"第 {idx} 个输出缺少必显文字：{text}"})
+
     for text in case_list(case.get("forbid_required_text")):
-        if text in labels:
+        if any(text in item_labels for item_labels in labels_by_item):
             findings.append({"severity": "error", "rule": "case.required_text_forbidden", "message": f"不应作为必显文字：{text}"})
 
     for text in case_list(case.get("expect_prompt_contains")):