@yuhan1124/draw-prompt 0.4.9 → 0.4.11

package/README.md

@@ -72,6 +72,7 @@ npx --yes --registry=https://registry.npmjs.org/ @yuhan1124/draw-prompt@latest i
 `visual-cases.jsonl` 不会进入 npm 包或安装目录。安装后可直接跑 `doctor`，它会检查
 包文件、版本一致性、核心单图转化、真实长输入 `compose` 链路，以及
 `variants` / `series` / `adapt` 等主工作流 smoke。
+`brand` / `character` / `data-viz` / `edit` / `rewrite` 这类主入口也在 `doctor` 中做命令级 smoke。
 
 开发者本地调试也可以软链 repo：
 
@@ -134,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
@@ -173,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`，确认多场景回归通过；用 `expect_asset_type`、`expect_aspect`、`expect_required_text`、`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.9
+  version: 0.4.11
   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.9",
+  "version": "0.4.11",
   "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

@@ -45,8 +45,10 @@ DRAW_PROMPT_HOME 覆盖），不进 git repo。
 from __future__ import annotations
 
 import argparse
+import contextlib
 import csv
 import hashlib
+import io
 import json
 import os
 import re
@@ -136,7 +138,7 @@ def ensure_home() -> None:
 
 
 SCHEMA_VERSION = 1
-COMPILER_VERSION = "0.4.9"
+COMPILER_VERSION = "0.4.11"
 
 
 PACKAGED_SKILL_FILES = [
@@ -262,6 +264,38 @@ DOCTOR_WORKFLOW_CASES = [
     },
 ]
 
+DOCTOR_COMMAND_CASES = [
+    {
+        "id": "edit-preserve-change-contract",
+        "kind": "edit",
+        "expect_prompt": ["Preserve exactly: cup silhouette.", "Change only: background only."],
+    },
+    {
+        "id": "brand-compile",
+        "kind": "brand",
+        "expect_required_text": ["山川茶事"],
+        "expect_prompt": ["Brand system for invented brand"],
+    },
+    {
+        "id": "character-reference-and-scene",
+        "kind": "character",
+        "expect_prompt": ["Mira", "same identity anchors"],
+    },
+    {
+        "id": "data-viz-csv",
+        "kind": "data-viz",
+        "expect_title": "转化率趋势",
+        "expect_columns": ["week", "conversion"],
+    },
+    {
+        "id": "rewrite-risky-ip",
+        "kind": "rewrite",
+        "expect_safety_rewrite": True,
+        "forbid_prompt": ["迪士尼"],
+        "expect_prompt": ["original"],
+    },
+]
+
 
 def package_root() -> Path:
     return Path(__file__).resolve().parent.parent
@@ -2519,12 +2553,69 @@ def infer_aspect(request: str, asset_type: str, override: str | None, profile: d
         return "3:4"
     if any(k in lower for k in ["方图", "方形", "square"]):
         return "1:1"
+    if asset_type == "ui":
+        desktop_terms = [
+            "saas",
+            "后台",
+            "控制台",
+            "dashboard",
+            "仪表盘",
+            "看板",
+            "网页",
+            "web",
+            "desktop",
+            "左侧导航",
+            "顶部状态栏",
+            "右侧",
+        ]
+        mobile_terms = ["手机", "mobile", "app 首页", "小程序", "9:16"]
+        if any(term in lower for term in desktop_terms) and not any(term in lower for term in mobile_terms):
+            return "16:9"
     prof = str(profile.get("default_aspect") or "").strip()
     if prof and prof != "未设置":
         return prof
     return str(ASSET_ROUTES[asset_type]["aspect"])
 
 
+NON_DISPLAY_TEXTS = {
+    "顶部导航",
+    "底部导航",
+    "左侧导航",
+    "右侧导航",
+    "导航栏",
+    "顶部栏",
+    "底部栏",
+    "状态栏",
+    "顶部状态栏",
+    "底部状态栏",
+    "箭头关系",
+    "箭头",
+    "关系",
+    "标签",
+    "卖点标签",
+    "购买转化氛围",
+    "但不要过度促销",
+}
+
+
+def is_non_display_text(text: str) -> bool:
+    value = text.strip(" \t\n\r，,、。；;：:.!?！？")
+    lower = value.lower()
+    if value in NON_DISPLAY_TEXTS:
+        return True
+    if lower.startswith(("不要", "不需要", "不能", "不得", "但不要", "avoid ", "do not ")):
+        return True
+    if re.fullmatch(r"\d+\s*%\s*(?:height|width|高|宽|高度|宽度)", lower):
+        return True
+    if re.fullmatch(r"\d+\s*(?:px|pt|rem|em)\s*(?:height|width|高|宽|高度|宽度)?", lower):
+        return True
+    if re.fullmatch(r"\d+\s*[:x×]\s*\d+", lower):
+        return True
+    if value.endswith("氛围"):
+        return True
+    return False
+
+
 def infer_size(aspect: str, override: str | None, asset_type: str) -> str:
     if override:
         return override
@@ -2564,7 +2655,7 @@ def extract_required_texts(request: str, explicit_texts: list[str]) -> list[str]
             return ""
         if re.fullmatch(r"[A-Za-z]{1,2}", text) and text.upper() not in {"AI", "UI"}:
             return ""
-        if text in {"顶部导航", "底部导航", "左侧导航", "右侧导航", "导航栏", "顶部栏", "状态栏", "箭头关系", "箭头", "关系"}:
+        if is_non_display_text(text):
             return ""
         return text.strip(" \t\n\r，,、。；;：:.!?！？")
 
@@ -2671,7 +2762,7 @@ def merge_texts(primary: list[str], extra: list[str]) -> list[str]:
             continue
         if re.fullmatch(r"[A-Za-z]{1,2}", text) and text.upper() not in {"AI", "UI"}:
             continue
-        if text in {"顶部导航", "底部导航", "左侧导航", "右侧导航", "导航栏", "顶部栏", "状态栏", "箭头关系", "箭头", "关系"}:
+        if is_non_display_text(text):
             continue
         key = re.sub(r"\s+", "", text)
         if text and key not in seen:
@@ -2693,12 +2784,16 @@ def extract_structural_labels(request: str, asset_type: str) -> list[str]:
         rf"(?:模块|节点|栏目|部分|层|入口|能力|场景|列表|指标卡|卡片|步骤|分支|数据|指标|卖点|亮点|功能点|特性|路径)\s*(?:包括|包含|有|为)[：:\s]*([^。；;\n]{{2,180}})",
         rf"(?:模块|节点|栏目|部分|层|入口|能力|场景|列表|指标卡|卡片|步骤|分支|数据|指标|卖点|亮点|功能点|特性|路径)[^。；;\n：:]{{0,16}}[：:]([^。；;\n]{{2,180}})",
     ]
+    if asset_type in {"diagram", "infographic", "slide", "ui"}:
+        patterns.append(
+            r"(?:图中|图里|画面中|架构图中|系统图中|流程图中)\s*(?:需要)?(?:要有|应有|需有|有)[：:\s]*([^。；;\n]{2,180})"
+        )
     for pattern in patterns:
         for match in re.finditer(pattern, request, flags=re.IGNORECASE):
             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()
@@ -2712,7 +2807,7 @@ def extract_structural_labels(request: str, asset_type: str) -> list[str]:
                     continue
                 if re.search(r"箭头.*(?:关系|展示|输入|输出)|(?:关系|展示|输入|输出).*箭头|展示输入输出关系", part):
                     continue
-                if part in {"顶部", "底部", "左侧", "右侧", "上方", "下方", "中间", "顶部导航", "底部导航", "左侧导航", "右侧导航", "导航栏", "顶部栏", "状态栏", "箭头关系", "箭头", "关系"}:
+                if part in {"顶部", "底部", "左侧", "右侧", "上方", "下方", "中间"} or is_non_display_text(part):
                     continue
                 if re.fullmatch(r"\d+(?:\s*:\s*\d+)?", part):
                     continue
@@ -3197,12 +3292,16 @@ def build_spec(args: argparse.Namespace) -> dict:
 
 
 def exact_text_block(texts: list[str]) -> str:
+    non_display_rule = (
+        "Do not render layout measurements, area percentages, placement notes, placeholder source notes, "
+        "or prompt instruction phrases as visible in-image text unless they are explicitly listed above as exact strings."
+    )
     if not texts:
-        return "No required in-image text unless explicitly useful; avoid decorative fake text."
+        return f"No required in-image text unless explicitly useful; avoid decorative fake text. {non_display_rule}"
     quoted = " / ".join(f'"{t}"' for t in texts)
     return (
         "The image must accurately display these exact strings, unchanged and large enough to read: "
-        f"{quoted}. Use crisp, legible typography; keep Chinese text exactly as written."
+        f"{quoted}. Use crisp, legible typography; keep Chinese text exactly as written. {non_display_rule}"
     )
 
 
@@ -3559,6 +3658,8 @@ def request_mentions_any(request: str, variants: list[str]) -> bool:
 def intent_group_allowed_by_context(group: str, request: str, spec: dict) -> bool:
     lower = request.lower()
     asset_type = str(spec.get("asset_type") or "")
+    if group == "background_scene":
+        return any(k in lower for k in ["场景", "背景", "环境", "scene", "background", "environment", "beside", "inside", "outside"])
     if group == "cards" and asset_type == "ui":
         return any(k in lower for k in ["首页", "展示", "列表", "作品", "项目", "内容", "recent", "gallery", "feed"])
     if group == "modules" and asset_type in {"diagram", "infographic", "slide"}:
@@ -4781,6 +4882,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):
@@ -4806,8 +4908,10 @@ 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",
@@ -4816,6 +4920,7 @@ def cmd_visual_regress(args: argparse.Namespace) -> int:
                 "aspect": compiled["spec"]["aspect"],
                 "lint": lint,
                 "intent_check": intent,
+                "expectation_findings": expectation_findings,
                 "status": "compiled",
             }
             image = case.get("image") or case.get("output")
@@ -4850,15 +4955,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
@@ -4924,6 +5034,71 @@ def compile_visual_case(
     }
 
 
+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]:
+    spec = compiled.get("spec") or {}
+    prompt = str(compiled.get("prompt") or "")
+    findings: list[dict] = []
+
+    expected_asset = case.get("expect_asset_type")
+    if expected_asset 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_aspect = case.get("expect_aspect")
+    if expected_aspect and spec.get("aspect") != expected_aspect:
+        findings.append(
+            {
+                "severity": "error",
+                "rule": "case.aspect_mismatch",
+                "message": f"期望 aspect={expected_aspect}，实际={spec.get('aspect')}",
+            }
+        )
+
+    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 = set(spec.get("required_text") or [])
+    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"):
+            findings.append({"severity": "error", "rule": "case.required_text_not_quoted", "message": f"Prompt 未逐字引用：{text}"})
+
+    for text in case_list(case.get("forbid_required_text")):
+        if text in labels:
+            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)
 
@@ -6022,6 +6197,174 @@ def doctor_check_workflow_case(case: dict) -> dict:
     }
 
 
+def doctor_run_json_command(func, args: argparse.Namespace) -> tuple[int, dict, str]:
+    stdout = io.StringIO()
+    with contextlib.redirect_stdout(stdout):
+        code = func(args)
+    output = stdout.getvalue()
+    data = json.loads(output)
+    return code, data, output
+
+
+def doctor_collect_quality(findings: list[dict], scope: str, payload: dict) -> None:
+    for item in payload.get("lint") or []:
+        findings.append({"severity": item["severity"], "rule": f"{scope}.lint.{item['rule']}", "message": item["message"]})
+    for item in payload.get("intent_check") or []:
+        findings.append({"severity": item["severity"], "rule": f"{scope}.intent.{item['rule']}", "message": item["message"]})
+
+
+def doctor_check_command_case(case: dict) -> dict:
+    findings: list[dict] = []
+    kind = case.get("kind")
+    data: dict = {}
+    prompt_blobs: list[str] = []
+    cleanup_paths: list[Path] = []
+    try:
+        if kind == "edit":
+            code, data, _ = doctor_run_json_command(
+                cmd_edit,
+                argparse.Namespace(
+                    goal="把杯子背景换成夏季冷泡茶吧台",
+                    reference=["product:/tmp/cup.png"],
+                    preserve=["cup silhouette"],
+                    change=["background only"],
+                    text=[],
+                    aspect="3:4",
+                    asset_type="product",
+                    quality="high",
+                    style=None,
+                    target="raw",
+                    out=None,
+                    json=True,
+                ),
+            )
+            if code != 0:
+                doctor_add(findings, "error", "command.exit", f"edit 返回非零状态：{code}")
+            doctor_collect_quality(findings, "edit", data)
+            prompt_blobs.append(str(data.get("prompt") or ""))
+        elif kind == "brand":
+            code, data, _ = doctor_run_json_command(
+                cmd_brand,
+                argparse.Namespace(
+                    name="山川茶事",
+                    industry="茶饮",
+                    palette="moss green,ivory",
+                    avoid=None,
+                    values=None,
+                    style=None,
+                    request="新品冷泡茶品牌主视觉",
+                    asset_type="poster",
+                    style_preset=None,
+                    text=["山川茶事"],
+                    strict_text=False,
+                    target="raw",
+                    json=True,
+                ),
+            )
+            if code != 0:
+                doctor_add(findings, "error", "command.exit", f"brand 返回非零状态：{code}")
+            compiled = data.get("compiled") or {}
+            doctor_collect_quality(findings, "brand.compiled", compiled)
+            prompt_blobs.extend([str(data.get("brand_prompt_block") or ""), str(compiled.get("prompt") or "")])
+            labels = set((compiled.get("spec") or {}).get("required_text") or [])
+            for text_item in case.get("expect_required_text") or []:
+                if text_item not in labels:
+                    doctor_add(findings, "error", "command.required_text_missing", f"brand 缺少必显文字：{text_item}")
+        elif kind == "character":
+            code, data, _ = doctor_run_json_command(
+                cmd_character,
+                argparse.Namespace(
+                    name="Mira",
+                    description="short silver hair, amber eyes, explorer coat",
+                    scene=["standing beside a glowing archive machine"],
+                    style=None,
+                    outfit=None,
+                    palette=None,
+                    style_preset=None,
+                    target="raw",
+                    json=True,
+                ),
+            )
+            if code != 0:
+                doctor_add(findings, "error", "command.exit", f"character 返回非零状态：{code}")
+            reference = data.get("reference_sheet") or {}
+            doctor_collect_quality(findings, "character.reference", reference)
+            prompt_blobs.append(str(reference.get("prompt") or ""))
+            for idx, scene in enumerate(data.get("scene_prompts") or [], start=1):
+                doctor_collect_quality(findings, f"character.scene.{idx}", scene)
+                prompt_blobs.append(str(scene.get("prompt") or ""))
+        elif kind == "data-viz":
+            with NamedTemporaryFile("w", suffix=".csv", encoding="utf-8", delete=False) as tmp:
+                tmp.write("week,conversion\nW1,0.12\nW2,0.18\n")
+                tmp_path = Path(tmp.name)
+            cleanup_paths.append(tmp_path)
+            code, data, _ = doctor_run_json_command(
+                cmd_data_viz,
+                argparse.Namespace(
+                    file=str(tmp_path),
+                    request="展示转化率趋势",
+                    title="转化率趋势",
+                    chart_type=None,
+                    strict_text=False,
+                    json=True,
+                ),
+            )
+            if code != 0:
+                doctor_add(findings, "error", "command.exit", f"data-viz 返回非零状态：{code}")
+            doctor_collect_quality(findings, "data-viz", data)
+            prompt_blobs.append(str(data.get("prompt") or ""))
+            chart_spec = data.get("chart_data_spec") or {}
+            if case.get("expect_title") and chart_spec.get("title") != case["expect_title"]:
+                doctor_add(findings, "error", "command.title", f"data-viz 标题错误：{chart_spec.get('title')}")
+            for column in case.get("expect_columns") or []:
+                if column not in (chart_spec.get("columns") or []):
+                    doctor_add(findings, "error", "command.column_missing", f"data-viz 缺少列：{column}")
+        elif kind == "rewrite":
+            code, data, _ = doctor_run_json_command(
+                cmd_rewrite,
+                argparse.Namespace(
+                    prompt_text=["做一个迪士尼风格的角色海报，好看高级"],
+                    file=None,
+                    asset_type="poster",
+                    style=None,
+                    style_preset=None,
+                    strict_text=False,
+                    text=[],
+                    target="raw",
+                    json=True,
+                ),
+            )
+            if code != 0:
+                doctor_add(findings, "error", "command.exit", f"rewrite 返回非零状态：{code}")
+            doctor_collect_quality(findings, "rewrite", data)
+            prompt_blobs.append(str(data.get("prompt") or ""))
+            safety = (data.get("spec") or {}).get("safety_rewrite") or []
+            if case.get("expect_safety_rewrite") and not safety:
+                doctor_add(findings, "error", "command.safety_rewrite", "rewrite 未触发风险引用改写")
+        else:
+            doctor_add(findings, "error", "command.kind", f"未知命令类型：{kind}")
+    finally:
+        for path in cleanup_paths:
+            try:
+                path.unlink()
+            except OSError:
+                pass
+
+    joined_prompt = "\n".join(prompt_blobs)
+    for phrase in case.get("expect_prompt") or []:
+        if phrase not in joined_prompt:
+            doctor_add(findings, "error", "command.prompt_missing", f"{kind} 输出缺少片段：{phrase}")
+    for phrase in case.get("forbid_prompt") or []:
+        if phrase in joined_prompt:
+            doctor_add(findings, "error", "command.forbidden_prompt", f"{kind} 输出出现不应出现的片段：{phrase}")
+    return {
+        "name": f"command-{case['id']}",
+        "pass": not has_lint_error(findings),
+        "kind": kind,
+        "findings": findings,
+    }
+
+
 def cmd_doctor(args: argparse.Namespace) -> int:
     root = package_root()
     checks = [doctor_check_package(root)]
@@ -6040,6 +6383,11 @@ def cmd_doctor(args: argparse.Namespace) -> int:
             checks.append(doctor_check_workflow_case(case))
         except Exception as exc:
             checks.append({"name": f"workflow-{case.get('id', 'case')}", "pass": False, "findings": [{"severity": "error", "rule": "workflow.exception", "message": str(exc)}]})
+    for case in DOCTOR_COMMAND_CASES:
+        try:
+            checks.append(doctor_check_command_case(case))
+        except Exception as exc:
+            checks.append({"name": f"command-{case.get('id', 'case')}", "pass": False, "findings": [{"severity": "error", "rule": "command.exception", "message": str(exc)}]})
     passed = all(item["pass"] for item in checks)
     summary = {"pass": passed, "version": COMPILER_VERSION, "checks": len(checks), "failed": len([item for item in checks if not item["pass"]])}
     if args.json: