@playcraft/cli 0.0.44 → 0.0.47

package/project-templates/phaser/skills/playable-art/scripts/remove-bg.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Batch background removal using WaveSpeed AI API.
+Usage: python remove-bg.py <image_path> [<image_path> ...]
+"""
+import sys, os, time, json, requests
+
+API_KEY = os.environ.get('WAVESPEED_API_KEY', '')
+if not API_KEY:
+    print("Need WAVESPEED_API_KEY env var")
+    sys.exit(1)
+
+API_BASE = "https://api.wavespeed.ai"
+
+def upload_image(path):
+    """Upload image to WaveSpeed media endpoint, return download URL."""
+    url = f"{API_BASE}/api/v3/media/upload/binary"
+    headers = {"Authorization": f"Bearer {API_KEY}"}
+    ext = os.path.splitext(path)[1].lower()
+    mime = {'png':'image/png','jpg':'image/jpeg','jpeg':'image/jpeg','webp':'image/webp'}.get(ext,'image/png')
+    headers["Content-Type"] = mime
+    with open(path, 'rb') as f:
+        data = f.read()
+    r = requests.post(url, headers=headers, data=data, timeout=120)
+    r.raise_for_status()
+    resp = r.json()
+    return resp["data"]["download_url"]
+
+def remove_background(image_url, out_path):
+    """Call background remover API, download result PNG."""
+    pred_url = f"{API_BASE}/api/v3/wavespeed-ai/image-background-remover"
+    headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
+    payload = {"image": image_url}
+    r = requests.post(pred_url, headers=headers, json=payload, timeout=30)
+    r.raise_for_status()
+    resp = r.json()
+    data = resp.get("data", resp)
+    pid = data.get("id", data.get("prediction_id", resp.get("id","")))
+    if not pid:
+        print(f"  No prediction id: {json.dumps(resp)[:500]}")
+        return False
+    print(f"  Prediction started: {pid}")
+
+    result_url = f"{API_BASE}/api/v3/predictions/{pid}/result"
+    for attempt in range(60):
+        time.sleep(2)
+        r2 = requests.get(result_url, headers={"Authorization": f"Bearer {API_KEY}"}, timeout=30)
+        r2.raise_for_status()
+        res = r2.json()
+        data = res.get("data", res)
+        status = data.get("status", "")
+        print(f"  Poll {attempt+1}: {status}")
+        if status in ("succeeded", "completed", "success"):
+            outputs = data.get("outputs", [])
+            img_url = ""
+            if outputs:
+                img_url = outputs[0] if isinstance(outputs[0], str) else outputs[0].get("url", outputs[0].get("image", ""))
+            if not img_url:
+                img_url = data.get("output", data.get("url", ""))
+            if img_url:
+                r3 = requests.get(img_url, timeout=120)
+                r3.raise_for_status()
+                with open(out_path, 'wb') as f:
+                    f.write(r3.content)
+                print(f"  Saved: {out_path} ({len(r3.content)} bytes)")
+                return True
+            print(f"  No image URL in result: {json.dumps(res)[:500]}")
+            return False
+        elif status in ("failed", "error", "canceled"):
+            print(f"  Failed: {json.dumps(res)[:500]}")
+            return False
+    print("  Timeout waiting for result")
+    return False
+
+def main():
+    files = sys.argv[1:]
+    if not files:
+        print("Usage: python remove-bg.py <image> ...")
+        sys.exit(1)
+    for p in files:
+        out = os.path.splitext(p)[0] + "_nobg.png"
+        print(f"\nProcessing: {p}")
+        try:
+            img_url = upload_image(p)
+            print(f"  Uploaded: {img_url}")
+            remove_background(img_url, out)
+        except Exception as e:
+            print(f"  Error: {e}")
+
+if __name__ == "__main__":
+    main()

package/project-templates/phaser/skills/playable-art/scripts/review-processed-assets.py

@@ -0,0 +1,468 @@
+#!/usr/bin/env python3
+"""Generate visual review artifacts for processed image and video assets."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+IMAGE_EXTS = {".png", ".webp", ".jpg", ".jpeg"}
+VIDEO_EXTS = {".mp4", ".webm", ".mov"}
+DEFAULT_IMAGE_PATTERNS = (
+    "assets/images/**/*",
+    "assets/atlas/**/*",
+    "assets/reference/marked/**/*",
+)
+DEFAULT_VIDEO_PATTERNS = (
+    "assets/videos/**/*",
+    "assets/video/**/*",
+    "recordings/**/*",
+    "validate/**/*.mp4",
+    "validate/**/*.webm",
+)
+BLOCKING_SLICE_CLASSES = {"source_clipped", "slice_count_mismatch", "slice_safe_box_invalid"}
+
+
+def project_root() -> Path:
+    cwd = Path.cwd().resolve()
+    if (cwd / "assets").exists() and (cwd / "package.json").exists():
+        return cwd
+    script_path = Path(__file__).resolve()
+    for parent in script_path.parents:
+        if (parent / "assets").exists() and (parent / "package.json").exists():
+            return parent
+    return script_path.parents[3]
+
+
+def rel(path: Path, root: Path) -> str:
+    try:
+        return str(path.relative_to(root))
+    except ValueError:
+        return str(path)
+
+
+def make_issue(
+    issue_id: str,
+    status: str,
+    severity: str,
+    class_name: str,
+    message: str,
+    source_path: str = "",
+    *,
+    evidence_type: str = "asset",
+    box: list[int] | list[float] | None = None,
+    metrics: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    issue: dict[str, Any] = {
+        "id": issue_id,
+        "status": status,
+        "severity": severity,
+        "className": class_name,
+        "message": message,
+        "evidenceType": evidence_type,
+        "sourcePath": source_path,
+        "recommendedSkill": "playable-art",
+        "alphaStrategy": "n-a",
+    }
+    if box is not None:
+        issue["box"] = box
+    if metrics:
+        issue["metrics"] = metrics
+    return issue
+
+
+def load_pillow() -> tuple[Any | None, Any | None, str | None]:
+    try:
+        from PIL import Image, ImageDraw
+
+        return Image, ImageDraw, None
+    except Exception as exc:  # pragma: no cover
+        return None, None, str(exc)
+
+
+def collect_files(root: Path, patterns: tuple[str, ...], exts: set[str]) -> list[Path]:
+    seen: set[Path] = set()
+    out: list[Path] = []
+    for pattern in patterns:
+        for path in root.glob(pattern):
+            if not path.is_file() or path.suffix.lower() not in exts:
+                continue
+            resolved = path.resolve()
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            out.append(path)
+    return sorted(out)
+
+
+def alpha_bbox(image: Any) -> list[int] | None:
+    if "A" not in image.getbands():
+        return None
+    bbox = image.getchannel("A").getbbox()
+    if not bbox:
+        return None
+    return [int(v) for v in bbox]
+
+
+def inspect_image(path: Path, root: Path, Image: Any) -> dict[str, Any]:
+    entry: dict[str, Any] = {
+        "sourcePath": rel(path, root),
+        "ok": False,
+    }
+    try:
+        with Image.open(path) as img:
+            converted = img.convert("RGBA") if "A" in img.getbands() else img.convert("RGB")
+            bbox = alpha_bbox(converted)
+            entry.update(
+                {
+                    "ok": True,
+                    "width": img.width,
+                    "height": img.height,
+                    "mode": img.mode,
+                }
+            )
+            if bbox:
+                entry["alphaBox"] = bbox
+                entry["alphaMargin"] = [
+                    bbox[0],
+                    bbox[1],
+                    img.width - bbox[2],
+                    img.height - bbox[3],
+                ]
+    except Exception as exc:
+        entry["error"] = str(exc)
+    return entry
+
+
+def draw_contact_sheet(images: list[Path], root: Path, out_path: Path, Image: Any, ImageDraw: Any, limit: int) -> str | None:
+    if not images:
+        return None
+    selected = images[:limit]
+    tile_w, tile_h = 220, 172
+    label_h = 36
+    cols = 4
+    rows = (len(selected) + cols - 1) // cols
+    sheet = Image.new("RGB", (cols * tile_w, rows * (tile_h + label_h)), (24, 24, 24))
+    draw = ImageDraw.Draw(sheet)
+    for idx, path in enumerate(selected):
+        col = idx % cols
+        row = idx // cols
+        x = col * tile_w
+        y = row * (tile_h + label_h)
+        try:
+            with Image.open(path) as img:
+                thumb = img.convert("RGBA")
+                thumb.thumbnail((tile_w - 16, tile_h - 16))
+                bg = Image.new("RGBA", (tile_w, tile_h), (42, 42, 42, 255))
+                bg.alpha_composite(thumb, ((tile_w - thumb.width) // 2, (tile_h - thumb.height) // 2))
+                sheet.paste(bg.convert("RGB"), (x, y))
+        except Exception as exc:
+            draw.rectangle((x, y, x + tile_w - 1, y + tile_h - 1), outline=(255, 80, 80))
+            draw.text((x + 8, y + 8), f"open failed: {exc}", fill=(255, 180, 180))
+        label = rel(path, root)
+        if len(label) > 56:
+            label = "..." + label[-53:]
+        draw.rectangle((x, y + tile_h, x + tile_w, y + tile_h + label_h), fill=(10, 10, 10))
+        draw.text((x + 6, y + tile_h + 5), label, fill=(245, 245, 245))
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    sheet.save(out_path)
+    return rel(out_path, root)
+
+
+def ffprobe_video(path: Path) -> dict[str, Any]:
+    ffprobe = shutil.which("ffprobe")
+    if not ffprobe:
+        return {"probeAvailable": False}
+    proc = subprocess.run(
+        [
+            ffprobe,
+            "-v",
+            "error",
+            "-select_streams",
+            "v:0",
+            "-show_entries",
+            "stream=width,height,duration,r_frame_rate",
+            "-of",
+            "json",
+            str(path),
+        ],
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        return {"probeAvailable": True, "error": proc.stderr.strip()[:400]}
+    try:
+        data = json.loads(proc.stdout)
+        streams = data.get("streams") or []
+        return {"probeAvailable": True, **(streams[0] if streams else {})}
+    except Exception as exc:
+        return {"probeAvailable": True, "error": str(exc)}
+
+
+def extract_video_frame(path: Path, out_path: Path) -> bool:
+    ffmpeg = shutil.which("ffmpeg")
+    if not ffmpeg:
+        return False
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    proc = subprocess.run(
+        [ffmpeg, "-y", "-i", str(path), "-vf", "thumbnail,scale=320:-1", "-frames:v", "1", str(out_path)],
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    return proc.returncode == 0 and out_path.exists()
+
+
+def inspect_video(path: Path, root: Path, out_dir: Path) -> dict[str, Any]:
+    entry: dict[str, Any] = {
+        "sourcePath": rel(path, root),
+        "probe": ffprobe_video(path),
+    }
+    frame_path = out_dir / "video-frames" / f"{path.stem}.png"
+    if extract_video_frame(path, frame_path):
+        entry["thumbnail"] = rel(frame_path, root)
+    return entry
+
+
+def read_slice_plan_issues(root: Path, strict: bool) -> list[dict[str, Any]]:
+    plan_path = root / "assets/reference/slice-plan.json"
+    if not plan_path.exists():
+        return []
+    try:
+        plan = json.loads(plan_path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        return [
+            make_issue(
+                "asset_review_slice_plan_invalid",
+                "fail",
+                "P1",
+                "slice_plan_invalid",
+                f"slice-plan JSON is unreadable: {exc}",
+                rel(plan_path, root),
+            )
+        ]
+
+    issues: list[dict[str, Any]] = []
+    for sheet_index, sheet in enumerate(plan.get("sheets", []) if isinstance(plan.get("sheets"), list) else []):
+        if not isinstance(sheet, dict):
+            continue
+        source = str(sheet.get("sourcePath") or sheet.get("source") or rel(plan_path, root))
+        dropped = sheet.get("droppedFragments")
+        if isinstance(dropped, list) and dropped:
+            issues.append(
+                make_issue(
+                    f"asset_review_slice_count_mismatch:{source}",
+                    "fail",
+                    "P1",
+                    "slice_count_mismatch",
+                    f"slice plan dropped {len(dropped)} fragment(s)",
+                    source,
+                    metrics={"sheetIndex": sheet_index, "droppedFragments": len(dropped)},
+                )
+            )
+        for mark_index, mark in enumerate(sheet.get("marks", []) if isinstance(sheet.get("marks"), list) else []):
+            if not isinstance(mark, dict):
+                continue
+            box = mark.get("safeSliceBox") if isinstance(mark.get("safeSliceBox"), list) else None
+            for raw in mark.get("issues", []) if isinstance(mark.get("issues"), list) else []:
+                if not isinstance(raw, dict):
+                    continue
+                class_name = str(raw.get("className") or raw.get("class_name") or raw.get("id") or "slice_issue")
+                severity = str(raw.get("severity") or ("P1" if class_name in BLOCKING_SLICE_CLASSES else "P2"))
+                status = "fail" if class_name in BLOCKING_SLICE_CLASSES or severity in {"P0", "P1"} else "warn"
+                if class_name == "slice_margin_tight" and strict:
+                    status = "fail"
+                    severity = "P1"
+                issues.append(
+                    make_issue(
+                        f"asset_review_{class_name}:{source}:{mark_index}",
+                        status,
+                        "P1" if status == "fail" else severity,
+                        class_name,
+                        str(raw.get("message") or class_name),
+                        source,
+                        box=box,
+                        metrics={"sheetIndex": sheet_index, "markIndex": mark_index, "label": mark.get("label")},
+                    )
+                )
+    return issues
+
+
+def build_report(root: Path, out_dir: Path, images_only: bool, videos_only: bool, limit: int, strict: bool) -> dict[str, Any]:
+    Image, ImageDraw, pillow_error = load_pillow()
+    images = [] if videos_only else collect_files(root, DEFAULT_IMAGE_PATTERNS, IMAGE_EXTS)
+    videos = [] if images_only else collect_files(root, DEFAULT_VIDEO_PATTERNS, VIDEO_EXTS)
+    issues: list[dict[str, Any]] = []
+    report: dict[str, Any] = {
+        "schemaVersion": "playcraft.asset-review.v1",
+        "inspectionRequired": True,
+        "root": str(root),
+        "outputs": [],
+        "summary": {"images": len(images), "videos": len(videos), "status": "pass", "fail": 0, "warn": 0},
+        "images": [],
+        "videos": [],
+        "issues": issues,
+        "warnings": [],
+    }
+    if pillow_error:
+        report["warnings"].append(f"Pillow unavailable: {pillow_error}")
+        issues.append(
+            make_issue(
+                "asset_review_pillow_missing",
+                "fail" if strict else "warn",
+                "P1" if strict else "P2",
+                "asset_review_pillow_missing",
+                f"Pillow unavailable: {pillow_error}",
+                evidence_type="asset-group",
+            )
+        )
+    elif Image and ImageDraw:
+        report["images"] = [inspect_image(path, root, Image) for path in images]
+        for entry in report["images"]:
+            if not entry.get("ok"):
+                issues.append(
+                    make_issue(
+                        f"asset_image_unreadable:{entry['sourcePath']}",
+                        "fail",
+                        "P1",
+                        "asset_image_unreadable",
+                        f"image is unreadable: {entry.get('error', 'unknown error')}",
+                        entry["sourcePath"],
+                    )
+                )
+        image_sheet = draw_contact_sheet(images, root, out_dir / "processed-images-contact-sheet.png", Image, ImageDraw, limit)
+        if image_sheet:
+            report["outputs"].append(image_sheet)
+        elif images and strict:
+            issues.append(
+                make_issue(
+                    "asset_review_image_contact_sheet_missing",
+                    "fail",
+                    "P1",
+                    "asset_review_contact_sheet_missing",
+                    "processed image contact sheet was not generated",
+                    evidence_type="asset-group",
+                )
+            )
+    report["videos"] = [inspect_video(path, root, out_dir) for path in videos]
+    for entry in report["videos"]:
+        probe = entry.get("probe") if isinstance(entry.get("probe"), dict) else {}
+        if not probe.get("probeAvailable", True):
+            issues.append(
+                make_issue(
+                    f"asset_video_probe_unavailable:{entry['sourcePath']}",
+                    "fail" if strict else "warn",
+                    "P1" if strict else "P2",
+                    "asset_video_probe_unavailable",
+                    "ffprobe unavailable: video metadata was not probed",
+                    entry["sourcePath"],
+                )
+            )
+        elif probe.get("error"):
+            issues.append(
+                make_issue(
+                    f"asset_video_probe_failed:{entry['sourcePath']}",
+                    "fail" if strict else "warn",
+                    "P1" if strict else "P2",
+                    "asset_video_probe_failed",
+                    f"video metadata probe failed: {probe.get('error')}",
+                    entry["sourcePath"],
+                )
+            )
+        if "thumbnail" not in entry:
+            issues.append(
+                make_issue(
+                    f"asset_video_frame_extract_failed:{entry['sourcePath']}",
+                    "fail" if strict else "warn",
+                    "P1" if strict else "P2",
+                    "asset_video_frame_extract_failed",
+                    "video keyframe thumbnail was not extracted",
+                    entry["sourcePath"],
+                )
+            )
+    if Image and ImageDraw:
+        thumbnails = [root / v["thumbnail"] for v in report["videos"] if isinstance(v.get("thumbnail"), str)]
+        video_sheet = draw_contact_sheet(thumbnails, root, out_dir / "processed-videos-contact-sheet.png", Image, ImageDraw, limit)
+        if video_sheet:
+            report["outputs"].append(video_sheet)
+        elif videos and strict:
+            issues.append(
+                make_issue(
+                    "asset_review_video_contact_sheet_missing",
+                    "fail",
+                    "P1",
+                    "asset_review_contact_sheet_missing",
+                    "processed video contact sheet was not generated",
+                    evidence_type="asset-group",
+                )
+            )
+    if videos and not shutil.which("ffmpeg"):
+        report["warnings"].append("ffmpeg unavailable: video thumbnails were not extracted")
+    if videos and not shutil.which("ffprobe"):
+        report["warnings"].append("ffprobe unavailable: video metadata was not probed")
+    issues.extend(read_slice_plan_issues(root, strict))
+    if strict and not report["outputs"]:
+        issues.append(
+            make_issue(
+                "asset_review_no_auditable_outputs",
+                "fail",
+                "P1",
+                "asset_review_no_auditable_outputs",
+                "asset review produced no auditable contact sheet outputs",
+                evidence_type="asset-group",
+            )
+        )
+    fail_count = sum(1 for item in issues if item.get("status") == "fail")
+    warn_count = sum(1 for item in issues if item.get("status") == "warn")
+    report["ok"] = fail_count == 0
+    report["summary"].update(
+        {
+            "status": "fail" if fail_count else "warn" if warn_count else "pass",
+            "fail": fail_count,
+            "warn": warn_count,
+            "outputs": len(report["outputs"]),
+            "strict": strict,
+        }
+    )
+    return report
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=project_root())
+    parser.add_argument("--out", type=Path, default=Path("validate/art-review"))
+    parser.add_argument("--images-only", action="store_true")
+    parser.add_argument("--videos-only", action="store_true")
+    parser.add_argument("--limit", type=int, default=120)
+    parser.add_argument("--strict", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    root = args.root.resolve()
+    out_dir = args.out if args.out.is_absolute() else root / args.out
+    report = build_report(root, out_dir, args.images_only, args.videos_only, max(1, args.limit), args.strict)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    report_path = out_dir / "processed-assets-review.json"
+    report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print(f"[review:assets] images={report['summary']['images']} videos={report['summary']['videos']}")
+        for output in report["outputs"]:
+            print(f"  review: {output}")
+        print(f"  report: {rel(report_path, root)}")
+        if report["warnings"]:
+            for warning in report["warnings"]:
+                print(f"  warn: {warning}")
+        if report["issues"]:
+            print(f"  issues: fail={report['summary']['fail']} warn={report['summary']['warn']}")
+    return 2 if args.strict and any(i.get("status") == "fail" for i in report["issues"]) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/project-templates/phaser/skills/playable-art/scripts/review_processed_assets_test.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Unit tests for processed asset review artifact generation."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+try:
+    from PIL import Image, ImageDraw
+except ModuleNotFoundError:
+    print("skipped: Pillow unavailable")
+    raise SystemExit(0)
+
+
+SCRIPT = Path(__file__).resolve().with_name("review-processed-assets.py")
+sys.path.insert(0, str(SCRIPT.parent))
+spec = importlib.util.spec_from_file_location("review_processed_assets", SCRIPT)
+assert spec and spec.loader
+module = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = module
+spec.loader.exec_module(module)
+
+
+class ReviewProcessedAssetsTest(unittest.TestCase):
+    def make_root(self) -> Path:
+        root = Path(tempfile.mkdtemp(prefix="playcraft-asset-review-"))
+        (root / "assets" / "images" / "ui").mkdir(parents=True)
+        (root / "assets" / "atlas").mkdir(parents=True)
+        (root / "assets" / "reference" / "marked").mkdir(parents=True)
+        (root / "package.json").write_text('{"scripts":{}}\n', encoding="utf-8")
+
+        sprite = Image.new("RGBA", (96, 64), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(sprite)
+        draw.rounded_rectangle((8, 10, 88, 54), radius=8, fill=(255, 120, 30, 255))
+        sprite.save(root / "assets" / "images" / "ui" / "cta.png")
+
+        atlas = Image.new("RGBA", (128, 128), (20, 20, 20, 255))
+        atlas.save(root / "assets" / "atlas" / "ui.png")
+
+        marked = Image.new("RGB", (160, 100), (40, 40, 40))
+        draw = ImageDraw.Draw(marked)
+        draw.rectangle((12, 12, 148, 88), outline=(0, 210, 120), width=3)
+        marked.save(root / "assets" / "reference" / "marked" / "ui-slice-marks.png")
+        return root
+
+    def test_build_report_generates_contact_sheet_and_json(self) -> None:
+        root = self.make_root()
+        out_dir = root / "validate" / "art-review"
+
+        report = module.build_report(root, out_dir, images_only=True, videos_only=False, limit=20, strict=True)
+        report_path = out_dir / "processed-assets-review.json"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        report_path.write_text(json.dumps(report), encoding="utf-8")
+
+        self.assertTrue(report["inspectionRequired"])
+        self.assertTrue(report["ok"])
+        self.assertEqual(report["issues"], [])
+        self.assertEqual(report["summary"]["videos"], 0)
+        self.assertGreaterEqual(report["summary"]["images"], 3)
+        self.assertIn("validate/art-review/processed-images-contact-sheet.png", report["outputs"])
+        self.assertTrue((out_dir / "processed-images-contact-sheet.png").exists())
+        self.assertTrue(report_path.exists())
+
+    def test_strict_fails_when_no_auditable_outputs_exist(self) -> None:
+        root = Path(tempfile.mkdtemp(prefix="playcraft-asset-review-empty-"))
+        (root / "package.json").write_text('{"scripts":{}}\n', encoding="utf-8")
+        out_dir = root / "validate" / "art-review"
+
+        report = module.build_report(root, out_dir, images_only=False, videos_only=False, limit=20, strict=True)
+
+        self.assertFalse(report["ok"])
+        self.assertTrue(any(i["className"] == "asset_review_no_auditable_outputs" for i in report["issues"]))
+
+    def test_strict_surfaces_blocking_slice_plan_issues(self) -> None:
+        root = self.make_root()
+        plan_dir = root / "assets" / "reference"
+        (plan_dir / "slice-plan.json").write_text(
+            json.dumps(
+                {
+                    "schemaVersion": "playcraft.slice-plan.v1",
+                    "sheets": [
+                        {
+                            "sourcePath": "assets/reference/ui.png",
+                            "marks": [
+                                {
+                                    "entryName": "cta",
+                                    "safeSliceBox": [0, 0, 10, 10],
+                                    "issues": [
+                                        {
+                                            "className": "source_clipped",
+                                            "severity": "P1",
+                                            "message": "content reaches edge",
+                                        }
+                                    ],
+                                }
+                            ],
+                        }
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
+
+        report = module.build_report(root, root / "validate" / "art-review", images_only=True, videos_only=False, limit=20, strict=True)
+
+        self.assertFalse(report["ok"])
+        self.assertTrue(any(i["className"] == "source_clipped" and i["status"] == "fail" for i in report["issues"]))
+
+
+if __name__ == "__main__":
+    unittest.main()