@yuhan1124/draw-prompt 0.4.10 → 0.4.12

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/成品图回归
+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`，确认多场景回归通过。
+7. 模板或策略变动后，在开发仓库本地跑 `visual-regress references/visual-cases.jsonl`，确认多场景回归通过；它会真实编译 `convert`、`variants`、`series`、`adapt`、`compose` 等单图/多输出入口。用 `expect_count`、`expect_asset_type(s)`、`expect_aspect(s)`、`expect_required_text(_all)`、`forbid_required_text`、`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.10
+  version: 0.4.12
   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                  # 开发仓库本地：多场景回归
+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.10",
+  "version": "0.4.12",
   "description": "Convert natural-language image requests into high-quality gpt-image-2 prompts and Codex handoff blocks.",
   "type": "commonjs",
   "bin": {

package/scripts/prompt_cli.py

@@ -138,7 +138,7 @@ def ensure_home() -> None:
 
 
 SCHEMA_VERSION = 1
-COMPILER_VERSION = "0.4.10"
+COMPILER_VERSION = "0.4.12"
 
 
 PACKAGED_SKILL_FILES = [
@@ -2793,7 +2793,7 @@ def extract_structural_labels(request: str, asset_type: str) -> list[str]:
             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):
+            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"^(?:和|与|及|以及|and|再|则)\s*", "", part, flags=re.IGNORECASE).strip()
@@ -4867,9 +4867,23 @@ 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 == "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}")
 
 
@@ -4882,6 +4896,7 @@ def cmd_visual_regress(args: argparse.Namespace) -> int:
     results = []
     lint_errors = 0
     intent_errors = 0
+    expectation_errors = 0
     visual_errors = 0
     missing_images = 0
     for idx, case in enumerate(cases, start=1):
@@ -4907,16 +4922,22 @@ def cmd_visual_regress(args: argparse.Namespace) -> int:
             compiled = visual_case_compile(case)
             lint = compiled["lint"]
             intent = compiled.get("intent_check", [])
+            expectation_findings = visual_case_expectation_findings(case, compiled)
             lint_errors += sum(1 for item in lint if item.get("severity") == "error")
             intent_errors += sum(1 for item in intent if item.get("severity") == "error")
+            expectation_errors += sum(1 for item in expectation_findings if item.get("severity") == "error")
             item = {
                 "id": case_id,
                 "scenario": case.get("scenario") or case.get("tool") or "convert",
                 "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,
                 "status": "compiled",
             }
             image = case.get("image") or case.get("output")
@@ -4951,15 +4972,20 @@ def cmd_visual_regress(args: argparse.Namespace) -> int:
         "cases": len(cases),
         "lint_error_count": lint_errors,
         "intent_error_count": intent_errors,
+        "expectation_error_count": expectation_errors,
         "visual_error_count": visual_errors,
         "missing_image_count": missing_images,
-        "pass": lint_errors == 0 and intent_errors == 0 and visual_errors == 0 and missing_images == 0,
+        "pass": lint_errors == 0 and intent_errors == 0 and expectation_errors == 0 and visual_errors == 0 and missing_images == 0,
     }
     output = {"summary": summary, "results": results}
     if args.json:
         print(json.dumps(output, ensure_ascii=False, indent=2))
     else:
-        print(f"visual-regress: cases={summary['cases']} pass={summary['pass']} lint_errors={lint_errors} intent_errors={intent_errors} visual_errors={visual_errors} missing_images={missing_images}")
+        print(
+            f"visual-regress: cases={summary['cases']} pass={summary['pass']} "
+            f"lint_errors={lint_errors} intent_errors={intent_errors} expectation_errors={expectation_errors} "
+            f"visual_errors={visual_errors} missing_images={missing_images}"
+        )
         for item in results:
             print(f"- {item['id']}: {item['status']} asset={item.get('asset_type', '?')} digest={item.get('prompt_digest', '?')}")
     return 0 if summary["pass"] else 1
@@ -5025,6 +5051,354 @@ 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_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 []
+    if isinstance(value, list):
+        return [str(item) for item in value if str(item).strip()]
+    return [str(value)] if str(value).strip() else []
+
+
+def visual_case_expectation_findings(case: dict, compiled: dict) -> list[dict]:
+    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 len(items) == 1 and spec.get("asset_type") != expected_asset:
+        findings.append(
+            {
+                "severity": "error",
+                "rule": "case.asset_type_mismatch",
+                "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 len(items) == 1 and spec.get("aspect") != expected_aspect:
+        findings.append(
+            {
+                "severity": "error",
+                "rule": "case.aspect_mismatch",
+                "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:
+        findings.append(
+            {
+                "severity": "error",
+                "rule": "case.template_mismatch",
+                "message": f"期望 template_id={expected_template}，实际={spec.get('template_id')}",
+            }
+        )
+
+    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 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 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")):
+        if text not in prompt:
+            findings.append({"severity": "error", "rule": "case.prompt_missing", "message": f"Prompt 缺少片段：{text}"})
+
+    for text in case_list(case.get("forbid_prompt_contains")):
+        if text in prompt:
+            findings.append({"severity": "error", "rule": "case.prompt_forbidden", "message": f"Prompt 不应包含片段：{text}"})
+
+    return findings
+
+
 def has_lint_error(items: list[dict]) -> bool:
     return any(item.get("severity") == "error" for item in items)