@petercjl/taobao-ai-ops 0.1.0 → 0.1.2

package/skills/taobao-search-product-form/scripts/compile_visual_selection.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""Validate and compile three-axis image observations for selection review.
-
-This script checks provenance and evidence contracts; it does not infer labels
-from pixels or declare product-market opportunity.
-"""
-
-import argparse
-import hashlib
-import json
-from collections import Counter, defaultdict
-from pathlib import Path
-
-
-def load(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def sha256(path):
-    h = hashlib.sha256()
-    with Path(path).open("rb") as stream:
-        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def save(path, value):
-    with Path(path).open("x", encoding="utf-8") as stream:
-        json.dump(value, stream, ensure_ascii=False, indent=2)
-        stream.write("\n")
-
-
-def map_labels(registry, dimension):
-    owner = {}
-    for canonical, info in registry.get(dimension, {}).items():
-        for alias in [canonical, *info.get("aliases", [])]:
-            key = alias.strip().casefold()
-            if not key or key in owner and owner[key] != canonical:
-                raise ValueError(f"invalid or conflicting {dimension} alias: {alias}")
-            owner[key] = canonical
-    return owner
-
-
-def clean_text(value):
-    return str(value or "").strip()
-
-
-def compile_run(args):
-    plan = load(args.plan)
-    draft = load(args.observations)
-    registry = load(args.registry)
-    if draft.get("schema_version") != 2 or registry.get("schema_version") != 2:
-        raise ValueError("three-axis observations and registry require schema_version 2")
-    expected = {str(item["product_id"]): item for item in plan["items"] if item["status"] == "ready"}
-    entries = draft.get("observations", [])
-    ids = [str(item.get("product_id", "")) for item in entries]
-    if len(ids) != len(set(ids)) or set(ids) != set(expected):
-        raise ValueError(f"one observation per ready image required; missing={sorted(set(expected)-set(ids))}, extra={sorted(set(ids)-set(expected))}")
-    maps = {axis: map_labels(registry, axis) for axis in ("form", "style", "audience")}
-    raw = []
-    products = []
-    unresolved = defaultdict(Counter)
-    candidates = defaultdict(Counter)
-    counts = defaultdict(Counter)
-    examples = defaultdict(lambda: defaultdict(list))
-    for entry in entries:
-        pid = str(entry["product_id"])
-        source = expected[pid]
-        if not clean_text(entry.get("visible_evidence")):
-            raise ValueError(f"missing visible evidence: {pid}")
-        status = entry.get("status")
-        if status not in ("tagged", "uncertain"):
-            raise ValueError(f"invalid status: {pid}")
-        bound = {**entry, "product_id": pid, "batch_id": source["batch_id"],
-                 "image_sha256": source["image_sha256"], "image_path": source["image_path"],
-                 "source_rank": source["source_rank"]}
-        row = {"product_id": pid, "source_rank": source["source_rank"],
-               "batch_id": source["batch_id"], "image_path": source["image_path"],
-               "image_sha256": source["image_sha256"], "status": status,
-               "visible_evidence": entry["visible_evidence"],
-               "image_presentation": clean_text(entry.get("image_presentation"))}
-        for axis in ("form", "style", "audience"):
-            item = entry.get(axis)
-            if not isinstance(item, dict):
-                raise ValueError(f"missing {axis} object: {pid}")
-            candidate = clean_text(item.get("candidate"))
-            if axis == "form" and status == "tagged" and not candidate:
-                raise ValueError(f"tagged product needs form candidate: {pid}")
-            if axis == "style" and candidate:
-                cues = item.get("product_cues", [])
-                if not isinstance(cues, list) or len([x for x in cues if clean_text(x)]) < 2 or not clean_text(item.get("physical_delta")):
-                    raise ValueError(f"style requires two product cues and physical delta: {pid}")
-            if axis == "audience" and candidate:
-                cues = item.get("task_cues", [])
-                if not isinstance(cues, list) or not any(clean_text(x) for x in cues) or not clean_text(item.get("physical_delta")):
-                    raise ValueError(f"audience requires task cue and physical delta: {pid}")
-                if item.get("evidence_tier") not in ("image_only", "combined"):
-                    raise ValueError(f"audience evidence tier required: {pid}")
-            canonical = maps[axis].get(candidate.casefold()) if candidate else None
-            if candidate:
-                candidates[axis][candidate] += 1
-                if canonical is None:
-                    unresolved[axis][candidate] += 1
-            if canonical:
-                counts[axis][canonical] += 1
-                if len(examples[axis][canonical]) < 3:
-                    examples[axis][canonical].append(pid)
-            row[axis] = {**item, "candidate": candidate or None, "label": canonical}
-        raw.append(bound)
-        products.append(row)
-    products.sort(key=lambda item: item["source_rank"])
-    unavailable_reasons = Counter(item.get("unavailable_reason", "unknown")
-                                  for item in plan["items"] if item["status"] == "image_unavailable")
-    summary = {"schema_version": 2, "strategy": "visual-selection-three-axis-v1",
-               "source_plan_sha256": sha256(args.plan), "source_observations_sha256": sha256(args.observations),
-               "registry_sha256": sha256(args.registry), "registry_version": registry.get("version"),
-               "scope": plan["scope"], "reviewed_products": len(products),
-               "image_unavailable_by_reason": dict(unavailable_reasons),
-               "axes": {axis: {"candidate_labels": dict(candidates[axis]),
-                                "canonical_counts": dict(counts[axis]),
-                                "examples": dict(examples[axis]),
-                                "unresolved": dict(unresolved[axis]),
-                                "unclassified_products": sum(not row[axis]["label"] for row in products)}
-                        for axis in ("form", "style", "audience")},
-               "qa": {"one_record_per_ready_image": True, "image_hash_bound": True,
-                      "unavailable_reasons_reconciled": sum(unavailable_reasons.values()) == plan["scope"]["image_unavailable"],
-                      "all_candidates_resolved": not any(unresolved.values()),
-                      "physical_deltas_checked": True},
-               "interpretation_boundary": "Pilot product labels and supply descriptions; not actual buyer demographics or proven white-label opportunity."}
-    out = Path(args.output_dir).resolve()
-    if out.exists():
-        raise FileExistsError(out)
-    out.mkdir(parents=True)
-    save(out / "raw_observations.json", {"schema_version": 2, "records": raw})
-    save(out / "product_labels.json", {"schema_version": 2, "records": products})
-    save(out / "label_summary.json", summary)
-    print(json.dumps({"output_dir": str(out), "products": len(products),
-                      "counts": {axis: dict(counts[axis]) for axis in counts},
-                      "unresolved": {axis: dict(unresolved[axis]) for axis in unresolved}}, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--plan", required=True)
-    parser.add_argument("--observations", required=True)
-    parser.add_argument("--registry", required=True)
-    parser.add_argument("--output-dir", required=True)
-    compile_run(parser.parse_args())

package/skills/taobao-search-product-form/scripts/prepare.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""Normalize a Taobao search export and prepare auditable image contact sheets."""
-
-import argparse
-import hashlib
-import io
-import json
-import re
-import urllib.parse
-import urllib.request
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime, timezone
-from pathlib import Path
-
-import pandas as pd
-from PIL import Image, ImageDraw, ImageOps
-
-
-REQUIRED = ["商品ID", "商品名称", "商品图片链接", "占位类型"]
-ALLOWED_IMAGE_HOSTS = ("alicdn.com", "alicdn.cn")
-
-
-def scalar(value):
-    if pd.isna(value):
-        return None
-    if hasattr(value, "item"):
-        value = value.item()
-    if isinstance(value, (int, float, bool, str)):
-        return value
-    return str(value)
-
-
-def number(value):
-    try:
-        return float(value)
-    except (TypeError, ValueError):
-        return None
-
-
-def safe_image_url(url):
-    parsed = urllib.parse.urlparse(str(url))
-    host = (parsed.hostname or "").lower()
-    return parsed.scheme == "https" and any(host == suffix or host.endswith("." + suffix) for suffix in ALLOWED_IMAGE_HOSTS)
-
-
-def fetch_image(product, cache_dir):
-    pid = product["product_id"]
-    url = product["image_url"]
-    if not safe_image_url(url):
-        return pid, {"status": "blocked_host", "path": None}
-    request = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
-    try:
-        with urllib.request.urlopen(request, timeout=15) as response:
-            blob = response.read(10_000_001)
-            if len(blob) > 10_000_000:
-                return pid, {"status": "too_large", "path": None}
-        image = Image.open(io.BytesIO(blob))
-        image.load()
-        image = ImageOps.exif_transpose(image).convert("RGB")
-        image.thumbnail((500, 500))
-        digest = hashlib.sha256(pid.encode()).hexdigest()[:16]
-        path = cache_dir / f"{digest}.jpg"
-        image.save(path, "JPEG", quality=88, optimize=True)
-        return pid, {"status": "ok", "path": str(path.relative_to(cache_dir.parent)), "width": image.width, "height": image.height}
-    except Exception as exc:  # fetch errors are reported, never converted into visual labels
-        return pid, {"status": "fetch_failed", "path": None, "error": type(exc).__name__}
-
-
-def make_sheets(products, fetches, out_dir, prefix):
-    cell_w, cell_h, columns, per_sheet = 180, 190, 8, 80
-    included = [p for p in products if fetches.get(p["product_id"], {}).get("status") == "ok"]
-    result = []
-    for start in range(0, len(included), per_sheet):
-        batch = included[start:start + per_sheet]
-        rows = (len(batch) + columns - 1) // columns
-        sheet = Image.new("RGB", (cell_w * columns, cell_h * rows), "white")
-        draw = ImageDraw.Draw(sheet)
-        for i, product in enumerate(batch):
-            x, y = (i % columns) * cell_w, (i // columns) * cell_h
-            path = out_dir / fetches[product["product_id"]]["path"]
-            image = Image.open(path)
-            image.thumbnail((160, 158))
-            sheet.paste(image, (x + (cell_w - image.width) // 2, y + 4))
-            draw.text((x + 5, y + 164), f"{product['product_id']}", fill="black")
-            rank = product["first_natural"] if product["first_natural"] is not None else product["first_ad"]
-            draw.text((x + 5, y + 177), f"{'N' if product['first_natural'] is not None else 'A'} {rank}", fill="black")
-        path = out_dir / f"{prefix}-{start // per_sheet + 1:02d}.jpg"
-        sheet.save(path, "JPEG", quality=88)
-        result.append(path.name)
-    return result
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--input", required=True)
-    parser.add_argument("--output-dir", required=True)
-    parser.add_argument("--search-term")
-    parser.add_argument("--max-organic", type=int)
-    parser.add_argument("--max-ad-only", type=int, default=50)
-    args = parser.parse_args()
-    source = Path(args.input).expanduser().resolve()
-    out = Path(args.output_dir).expanduser().resolve()
-    if not source.is_file() or source.suffix.lower() != ".xlsx":
-        parser.error("input must be an existing .xlsx file")
-    if out.exists():
-        parser.error("output directory already exists; select a new path")
-    if args.max_organic is not None and args.max_organic < 1:
-        parser.error("--max-organic must be positive")
-    frame = pd.read_excel(source)
-    missing = [column for column in REQUIRED if column not in frame.columns]
-    if missing:
-        parser.error("missing required columns: " + ", ".join(missing))
-    out.mkdir(parents=True)
-    cache = out / "images"
-    cache.mkdir()
-    raw_rows = []
-    products = {}
-    for index, (_, row) in enumerate(frame.iterrows(), start=1):
-        pid = str(scalar(row["商品ID"]))
-        position = int(number(row.get("序号")) or index)
-        placement = str(scalar(row["占位类型"]) or "")
-        if placement not in ("自然位", "广告位"):
-            raise ValueError(f"unknown placement at row {index}: {placement}")
-        raw = {"product_id": pid, "display_position": position, "placement": placement}
-        raw_rows.append(raw)
-        if pid not in products:
-            products[pid] = {
-                "product_id": pid,
-                "title": str(scalar(row["商品名称"]) or ""),
-                "image_url": str(scalar(row["商品图片链接"]) or ""),
-                "item_url": str(scalar(row.get("商品链接")) or ""),
-                "price": number(row.get("现价")),
-                "payment_count": number(row.get("付款人数")),
-                "shop": str(scalar(row.get("店铺名称")) or ""),
-                "shop_type": str(scalar(row.get("店铺类型")) or ""),
-                "platform_category": str(scalar(row.get("类目")) or ""),
-                "natural_positions": [], "ad_positions": [],
-            }
-        key = "natural_positions" if placement == "自然位" else "ad_positions"
-        products[pid][key].append(position)
-    entries = list(products.values())
-    for product in entries:
-        product["first_natural"] = min(product["natural_positions"], default=None)
-        product["first_ad"] = min(product["ad_positions"], default=None)
-    organic = sorted((p for p in entries if p["first_natural"] is not None), key=lambda p: p["first_natural"])
-    for rank, product in enumerate(organic, start=1):
-        product["organic_rank"] = rank
-    ad_only = sorted((p for p in entries if p["first_natural"] is None), key=lambda p: p["first_ad"])
-    selected_organic = organic[:args.max_organic] if args.max_organic else organic
-    selected_ad = ad_only[:args.max_ad_only]
-    selected = selected_organic + selected_ad
-    fetches = {}
-    with ThreadPoolExecutor(max_workers=8) as pool:
-        futures = [pool.submit(fetch_image, p, cache) for p in selected]
-        for future in as_completed(futures):
-            pid, result = future.result()
-            fetches[pid] = result
-    sheets = make_sheets(selected_organic, fetches, out, "organic") + make_sheets(selected_ad, fetches, out, "ad-only")
-    stem = source.stem
-    inferred = re.search(r"市场分析[-_](.+?)[-_]\d{8}$", stem)
-    term = args.search_term or (inferred.group(1) if inferred else "")
-    manifest = {
-        "schema_version": 1,
-        "source": {"name": source.name, "sha256": hashlib.sha256(source.read_bytes()).hexdigest(), "rows": len(raw_rows), "captured_at": datetime.now(timezone.utc).isoformat()},
-        "search_term": term,
-        "search_term_inferred": args.search_term is None,
-        "scope": {"kind": "pilot" if args.max_organic else "full", "organic_selected": len(selected_organic), "organic_total": len(organic), "ad_only_selected": len(selected_ad), "ad_only_total": len(ad_only)},
-        "source_rows": raw_rows,
-        "products": entries,
-        "selected_organic_ids": [p["product_id"] for p in selected_organic],
-        "selected_ad_only_ids": [p["product_id"] for p in selected_ad],
-        "fetches": fetches,
-        "contact_sheets": sheets,
-    }
-    (out / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
-    print(json.dumps({"manifest": str(out / "manifest.json"), "rows": len(raw_rows), "unique_products": len(entries), "organic_products": len(organic), "ad_only_products": len(ad_only), "images_ok": sum(v["status"] == "ok" for v in fetches.values()), "images_requested": len(selected), "contact_sheets": sheets}, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()

package/skills/taobao-search-product-form/scripts/render_report.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-"""Render and validate a report with this package's pinned HTML runtime."""
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-
-RUNTIME = Path(__file__).resolve().parents[1] / "report_runtime"
-sys.path.insert(0, str(RUNTIME))
-
-from renderer import render_file  # noqa: E402
-from validator import validate_file  # noqa: E402
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--input", required=True, help="Existing compact-workbench@1.0 ViewModel JSON")
-    parser.add_argument("--output", required=True, help="New standalone HTML report path")
-    args = parser.parse_args()
-    rendered = render_file(args.input, args.output)
-    checked = validate_file(args.output)
-    result = {"ok": checked["ok"], "render": rendered, "validation": checked}
-    print(json.dumps(result, ensure_ascii=False))
-    if not checked["ok"]:
-        raise SystemExit(1)
-
-
-if __name__ == "__main__":
-    main()

package/skills/taobao-search-product-form/scripts/validate_opportunity_cards.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""Validate opportunity-card structure and links to joined product evidence.
-
-This is a mechanical check. It cannot decide whether natural-language claims are
-commercially justified; the Agent must audit figures and alternative explanations.
-"""
-
-import argparse
-import hashlib
-import json
-from pathlib import Path
-
-
-def validate(cards, evidence, evidence_sha256):
-    if cards.get("schema_version") != 2 or not isinstance(cards.get("cards"), list):
-        raise ValueError("cards must have schema_version 2 and a cards array")
-    if cards.get("source_evidence_sha256") != evidence_sha256:
-        raise ValueError("opportunity cards do not match the current comparison evidence hash")
-    if not evidence.get("sources", {}).get("prototype_labels", {}).get("sha256"):
-        raise ValueError("comparison evidence lacks whole-product prototype labels")
-    candidates = {c["candidate_id"]: c for c in evidence["candidates"]}
-    if not any(c.get("axis") == "product_style" for c in candidates.values()):
-        raise ValueError("comparison evidence lacks product-style candidates")
-    products = {p["product_id"]: p for p in evidence["products"]}
-    seen = set()
-    orders = set()
-    for card in cards["cards"]:
-        cid = card.get("candidate_id")
-        if cid not in candidates or cid in seen:
-            raise ValueError(f"unknown or repeated candidate_id: {cid}")
-        seen.add(cid)
-        candidate = candidates[cid]
-        if candidate.get("axis") != "product_style":
-            raise ValueError(f"{cid}: opportunity card must use a whole-product style prototype")
-        for field in ("definition", "parent_comparison", "scope", "interpretation"):
-            if not isinstance(card.get(field), str) or not card[field].strip():
-                raise ValueError(f"{cid}: missing {field}")
-        if "score" in card or "entry_decision" in card:
-            raise ValueError(f"{cid}: card cannot contain a composite score or entry verdict")
-        for field in ("observations", "supporting_evidence", "counterevidence", "unknowns", "next_checks"):
-            if not isinstance(card.get(field), list) or not card[field]:
-                raise ValueError(f"{cid}: missing {field}")
-        for item in card["observations"] + card["supporting_evidence"] + card["counterevidence"]:
-            if not isinstance(item.get("claim"), str) or not item["claim"].strip():
-                raise ValueError(f"{cid}: evidence item lacks claim")
-            if not isinstance(item.get("refs"), list) or not item["refs"]:
-                raise ValueError(f"{cid}: evidence item lacks references")
-            for ref in item["refs"]:
-                if ref.isdigit():
-                    if ref not in products or ref not in candidate["product_ids"]:
-                        raise ValueError(f"{cid}: product reference is not a member: {ref}")
-                    continue
-                target_id, separator, field_path = ref.partition(".")
-                if not separator or target_id not in candidates:
-                    raise ValueError(f"{cid}: invalid candidate reference: {ref}")
-                target = candidates[target_id]
-                for key in field_path.split("."):
-                    if not isinstance(target, dict) or key not in target:
-                        raise ValueError(f"{cid}: missing evidence field: {ref}")
-                    target = target[key]
-        for check in card["next_checks"]:
-            if not check.get("question") or not check.get("changes_assessment_if"):
-                raise ValueError(f"{cid}: next check lacks a discriminating result")
-        research_order = card.get("research_order")
-        if research_order is not None:
-            position = research_order.get("position")
-            if not isinstance(position, int) or position < 1 or position in orders or not research_order.get("reason"):
-                raise ValueError(f"{cid}: invalid or duplicate research order")
-            orders.add(position)
-    if not cards["cards"]:
-        raise ValueError("no opportunity cards")
-    return {"ok": True, "cards": len(seen), "linked_candidates": len(candidates),
-            "linked_products": len(products)}
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--cards", required=True)
-    parser.add_argument("--evidence", required=True)
-    args = parser.parse_args()
-    cards = json.loads(Path(args.cards).read_text(encoding="utf-8"))
-    evidence = json.loads(Path(args.evidence).read_text(encoding="utf-8"))
-    evidence_sha256 = hashlib.sha256(Path(args.evidence).read_bytes()).hexdigest()
-    print(json.dumps(validate(cards, evidence, evidence_sha256), ensure_ascii=False))

package/skills/taobao-search-product-form/scripts/validate_report_viewmodel.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""Audit the comprehensive report ViewModel against its module sources."""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-from pathlib import Path
-
-from build_report_viewmodel import check_report_bindings, md_blocks, read_json, read_product_links, source_path
-
-
-MODULE_VIEWS = {
-    "advertising": "advertising",
-    "title": "title_roots",
-    "geography": "geography",
-    "price": "price",
-    "visual": "visual",
-}
-
-
-def validate(manifest_path: Path, viewmodel_path: Path) -> dict:
-    manifest = read_json(manifest_path)
-    loaded, srcs = {}, {}
-    for key in ("visual", "decision"):
-        loaded[key], srcs[key] = {}, {}
-        for role, value in manifest["modules"][key].items():
-            path = source_path(manifest_path, value)
-            loaded[key][role] = path.read_text(encoding="utf-8") if path.suffix == ".md" else read_json(path)
-            srcs[key][role] = {"sha256": hashlib.sha256(path.read_bytes()).hexdigest()}
-    check_report_bindings(loaded, srcs)
-    report = read_json(viewmodel_path)
-    expected_binding = {
-        "prototype_labels_sha256": srcs["visual"]["labels"]["sha256"],
-        "prototype_summary_sha256": srcs["visual"]["prototypes"]["sha256"],
-        "comparison_evidence_sha256": srcs["decision"]["evidence"]["sha256"],
-        "opportunity_cards_sha256": srcs["decision"]["cards"]["sha256"],
-    }
-    if report.get("meta", {}).get("artifact_binding") != expected_binding:
-        raise ValueError("ViewModel is not bound to current classification, comparison and cards")
-    views = {view["id"]: view for view in report["views"]}
-    expected_views = {"overview", "sample", "advertising", "title_roots", "geography", "price",
-                      "visual", "candidates", "opportunities", "evidence", "method"}
-    if not expected_views <= views.keys():
-        raise ValueError(f"missing views: {sorted(expected_views - views.keys())}")
-    retained_sections = {}
-    for module, view_id in MODULE_VIEWS.items():
-        item = manifest["modules"][module]
-        if "interpretation" not in item:
-            continue
-        source = source_path(manifest_path, item["interpretation"])
-        interpretation = loaded[module]["interpretation"] if module == "visual" else source.read_text(encoding="utf-8")
-        expected = md_blocks(interpretation)
-        actual = views[view_id]["blocks"]
-        missing = [block for block in expected if block not in actual]
-        if missing:
-            raise ValueError(f"{module}: {len(missing)} reviewed interpretation block(s) missing")
-        retained_sections[module] = len(expected)
-    decision = manifest["modules"]["decision"]
-    evidence = loaded["decision"]["evidence"]
-    cards = loaded["decision"]["cards"]["cards"]
-    candidate_table = next(b for b in views["candidates"]["blocks"] if b.get("title") == "全部候选组合")
-    product_table = next(b for b in views["evidence"]["blocks"] if b.get("title") == "全部自然位商品")
-    tabs = next(b for b in views["opportunities"]["blocks"] if b["type"] == "tabs")["tabs"]
-    if len(candidate_table["rows"]) != len(evidence["candidates"]):
-        raise ValueError("candidate group coverage mismatch")
-    if len(product_table["rows"]) != len(evidence["products"]):
-        raise ValueError("natural product coverage mismatch")
-    source_links = read_product_links(source_path(manifest_path, manifest["cleaned_workbook"]))
-    visual_summary = read_json(source_path(manifest_path, manifest["modules"]["visual"]["summary"]))
-    prototypes = loaded["visual"]["prototypes"]
-    visual_tabs = next(b for b in views["visual"]["blocks"] if b.get("type") == "tabs")["tabs"]
-    expected_family_names = {item["name"] for item in prototypes}
-    actual_tab_names = {tab["label"] for tab in visual_tabs}
-    if not expected_family_names <= actual_tab_names:
-        raise ValueError("visual gallery missing product-style menus")
-    gallery_ids = []
-    gallery_by_label = {}
-    for tab in visual_tabs:
-        gallery = next(b for b in tab["blocks"] if b.get("type") == "products")
-        if gallery.get("page_size") != 50:
-            raise ValueError("visual gallery must show 50 items per page")
-        keys = {option["key"] for option in gallery.get("sort_options", [])}
-        if not {"price", "payment", "score"} <= keys:
-            raise ValueError("visual gallery missing required sort dimensions")
-        for item in gallery["items"]:
-            if not str(item.get("image_url", "")).startswith("https://"):
-                raise ValueError("visual gallery product missing HTTPS image")
-            pid = item.get("copy_value")
-            if item.get("item_url") != source_links.get(pid):
-                raise ValueError(f"visual gallery product link mismatch for {pid}")
-            gallery_ids.append(pid)
-        gallery_by_label[tab["label"]] = {item["copy_value"] for item in gallery["items"]}
-    for prototype in prototypes:
-        if gallery_by_label.get(prototype["name"]) != set(map(str, prototype["product_ids"])):
-            raise ValueError(f"visual gallery prototype membership mismatch: {prototype['style_id']}")
-    expected_ids = {product["product_id"] for product in evidence["products"]}
-    if set(gallery_ids) != expected_ids:
-        raise ValueError("visual gallery product coverage mismatch")
-    card_tabs = [tab for tab in tabs if tab["id"] != "narrative"]
-    if len(card_tabs) != len(cards):
-        raise ValueError("opportunity card coverage mismatch")
-    if {tab["id"] for tab in card_tabs} != {card["candidate_id"] for card in cards}:
-        raise ValueError("opportunity card IDs mismatch")
-    if "interpretation" in decision:
-        source = source_path(manifest_path, decision["interpretation"])
-        expected = md_blocks(loaded["decision"]["interpretation"])
-        narrative = next((tab for tab in tabs if tab["id"] == "narrative"), None)
-        if not narrative or narrative["blocks"] != expected:
-            raise ValueError("reviewed opportunity interpretation missing")
-        retained_sections["decision"] = len(expected)
-    numbered_points = 0
-    for view in views.values():
-        for block in iter_blocks(view.get("blocks", [])):
-            if block.get("type") == "text":
-                passages = [block.get("text", ""), *block.get("paragraphs", [])]
-                if any(len(passage) > 120 for passage in passages):
-                    raise ValueError(f"{view['id']}: oversized unstructured prose block")
-            if block.get("type") == "actions":
-                numbered_points += len(block.get("items", []))
-                for item in block.get("items", []):
-                    if not item.get("title") or not item.get("text"):
-                        raise ValueError(f"{view['id']}: incomplete numbered judgment")
-                    if item.get("source_chunk") and item["text"] not in item["source_chunk"]:
-                        raise ValueError(f"{view['id']}: numbered point lost its source explanation")
-    if numbered_points == 0:
-        raise ValueError("no numbered interpretation points")
-    return {"views": len(views), "reviewed_interpretation_blocks": retained_sections,
-            "natural_products": len(product_table["rows"]), "candidate_groups": len(candidate_table["rows"]),
-            "opportunity_cards": len(card_tabs), "visual_gallery_products": len(gallery_ids),
-            "visual_form_menus": len(visual_tabs), "numbered_points": numbered_points}
-
-
-def iter_blocks(blocks: list[dict]):
-    for block in blocks:
-        yield block
-        yield from iter_blocks(block.get("blocks", []))
-        for tab in block.get("tabs", []):
-            yield from iter_blocks(tab.get("blocks", []))
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--manifest", type=Path, required=True)
-    parser.add_argument("--viewmodel", type=Path, required=True)
-    args = parser.parse_args()
-    print(json.dumps(validate(args.manifest, args.viewmodel), ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()