motionloom 2.0.0 → 2.1.0

package/scripts/devlab.py

@@ -0,0 +1,126 @@
+"""Cross-platform Dev Lab scene/task preparation and local serving helper."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+SAFE_NAME = re.compile(r"^[A-Za-z0-9._-]+$")
+TASK_ARTIFACTS = (
+    "task.json", "browser-review.json", "review.json", "execution-report.json",
+    "handoff.json", "quality-report.json", "artifact-manifest.json",
+    "issue-register.json", "decision-log.jsonl", "project-memory.json",
+    "project-graph.json", "provenance.json", "capability-registry.json",
+    "motion-ir.json", "replay-bundle.json", "semantic-lint-report.json",
+    "continuity-report.json", "fix-plan.json", "browser-observation.md",
+)
+
+
+def fail(message: str) -> "NoReturn":
+    print(f"MotionLoom Dev Lab error: {message}", file=sys.stderr)
+    raise SystemExit(1)
+
+
+def read_json(path: Path) -> dict:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        fail(f"cannot read JSON {path}: {exc}")
+    return value if isinstance(value, dict) else {}
+
+
+def safe_name(value: str, label: str) -> None:
+    if not value or value in {".", ".."} or not SAFE_NAME.fullmatch(value):
+        fail(f"{label} contains unsafe path characters: {value!r}")
+
+
+def inside(child: Path, parent: Path) -> bool:
+    try:
+        child.relative_to(parent)
+        return True
+    except ValueError:
+        return False
+
+
+def prepare_scene(root: Path, lab: Path, scene: str, task_dir: Path | None) -> tuple[Path, Path | None, str | None]:
+    safe_name(scene, "scene")
+    scene_dir = (root / "src" / "output" / scene).resolve()
+    if not scene_dir.is_dir():
+        fail(f"scene directory not found: {scene_dir}; render the scene first")
+    if not (scene_dir / "browser-review.json").is_file():
+        fail("browser-review.json is required; run review-hook prepare first")
+    lab_root = lab.resolve()
+    destination = (lab_root / "public" / "scenes" / scene).resolve()
+    if not inside(destination, (lab_root / "public" / "scenes").resolve()):
+        fail("scene destination escaped Dev Lab public directory")
+    if destination.exists():
+        shutil.rmtree(destination)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(scene_dir, destination)
+
+    task_destination: Path | None = None
+    task_id: str | None = None
+    if task_dir is not None:
+        task_dir = task_dir.resolve()
+        if not inside(task_dir, root.resolve()):
+            fail("task bundle must be inside the MotionLoom repository")
+        task = read_json(task_dir / "task.json")
+        task_id = str(task.get("task_id") or "")
+        safe_name(task_id, "task_id")
+        task_destination = (lab_root / "public" / "tasks" / task_id).resolve()
+        if not inside(task_destination, (lab_root / "public" / "tasks").resolve()):
+            fail("task destination escaped Dev Lab public directory")
+        if task_destination.exists():
+            shutil.rmtree(task_destination)
+        task_destination.mkdir(parents=True, exist_ok=True)
+        for name in TASK_ARTIFACTS:
+            source = task_dir / name
+            if source.is_file():
+                shutil.copy2(source, task_destination / name)
+    return destination, task_destination, task_id
+
+
+def pnpm_executable() -> str:
+    candidate = "pnpm.cmd" if os.name == "nt" else "pnpm"
+    return shutil.which(candidate) or candidate
+
+
+def serve(lab: Path, port: int) -> int:
+    if not (lab / "public").is_dir():
+        fail(f"Dev Lab public directory not found: {lab / 'public'}")
+    if not (lab / "node_modules").is_dir():
+        print("== installing Dev Lab dependencies (first run) ==")
+        subprocess.run([pnpm_executable(), "install", "--silent"], cwd=lab, check=True)
+    print(f"== Dev Lab ready: http://localhost:{port}/ ==")
+    return subprocess.run([sys.executable, "-m", "http.server", str(port), "--directory", str(lab / "public")], check=False).returncode
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("scene")
+    parser.add_argument("--task-dir")
+    parser.add_argument("--lab-dir")
+    parser.add_argument("--port", type=int, default=int(os.environ.get("PORT", "3300")))
+    parser.add_argument("--prepare-only", action="store_true")
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    lab = Path(args.lab_dir or os.environ.get("MOTIONLOOM_DEV_LAB") or root / "dev-lab").expanduser().resolve()
+    task_dir = Path(args.task_dir).expanduser().resolve() if args.task_dir else None
+    destination, task_destination, task_id = prepare_scene(root, lab, args.scene, task_dir)
+    print(f"== Dev Lab scene prepared: {destination} ==")
+    if task_destination:
+        print(f"== Dev Lab task bundle prepared: {task_destination} (task_id={task_id}) ==")
+    if args.prepare_only:
+        return 0
+    return serve(lab, args.port)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/docs-audit.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Validate public documentation, links and workflow safety without network access."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+
+ROOT = Path(sys.argv[1] if len(sys.argv) > 1 else Path(__file__).resolve().parents[1])
+errors: list[str] = []
+
+for markdown in sorted(ROOT.rglob("*.md")):
+    if any(part in {".git", "node_modules"} for part in markdown.parts):
+        continue
+    text = markdown.read_text(encoding="utf-8")
+    for target in re.findall(r"\[[^\]]+\]\(([^)]+)\)", text):
+        target = target.strip().split("#", 1)[0].split("?", 1)[0]
+        if not target or target.startswith(("http://", "https://", "mailto:", "#")):
+            continue
+        if not (markdown.parent / target).resolve().exists():
+            errors.append(f"{markdown.relative_to(ROOT)} -> missing {target}")
+
+for relative in ["package.json", "agent-card.json", "project-context.example.json", "tests/evals/project-corpus.json"]:
+    path = ROOT / relative
+    try:
+        json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        errors.append(f"{relative}: invalid JSON: {exc}")
+
+package = json.loads((ROOT / "package.json").read_text(encoding="utf-8"))
+for required in ["author", "repository", "homepage", "bugs", "license", "engines", "files"]:
+    if not package.get(required):
+        errors.append(f"package.json: missing public metadata {required}")
+if package.get("packageManager") != "pnpm@11.20.0":
+    errors.append("package.json: packageManager must pin pnpm@11.20.0")
+
+readme = (ROOT / "README.md").read_text(encoding="utf-8")
+for heading in ["Why MotionLoom", "Quick start", "Durable Project Memory", "Evidence, trust and review", "Documentation map"]:
+    if f"## {heading}" not in readme:
+        errors.append(f"README.md: missing heading {heading}")
+
+workflow_dir = ROOT / ".github" / "workflows"
+for workflow in sorted(workflow_dir.glob("*.yml")):
+    text = workflow.read_text(encoding="utf-8")
+    top_level_keys: dict[str, int] = {}
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        match = re.match(r"^([A-Za-z_][A-Za-z0-9_-]*):(?:\s|$)", line)
+        if not match:
+            continue
+        key = match.group(1)
+        if key in top_level_keys:
+            errors.append(
+                f"{workflow.relative_to(ROOT)}: duplicate top-level key {key!r} "
+                f"at lines {top_level_keys[key]} and {line_number}"
+            )
+        else:
+            top_level_keys[key] = line_number
+    for required in ["name:", "on:", "jobs:", "permissions:"]:
+        if required not in text:
+            errors.append(f"{workflow.relative_to(ROOT)}: missing {required}")
+    if "pull_request:" in text and "secrets." in text:
+        errors.append(f"{workflow.relative_to(ROOT)}: secrets referenced in pull_request workflow")
+
+release = (workflow_dir / "release.yml").read_text(encoding="utf-8")
+for required in ["workflow_dispatch:", "environment: npm-release", "id-token: write", "release_version:", "scripts/release-verify.py"]:
+    if required not in release:
+        errors.append(f"release.yml: missing release safety control {required}")
+
+devlab = (workflow_dir / "devlab.yml").read_text(encoding="utf-8")
+for required in [
+    "cp -R src/output/browser-review-smoke dev-lab/public/scenes/browser-review-smoke",
+    "scenes/browser-review-smoke/manifest.json",
+    "scenes/browser-review-smoke/motion-spec.json",
+    "--diagnostics /tmp/motionloom-devlab-diagnostics",
+    "id: fixture",
+    "steps.fixture.outputs.task_id",
+    "steps.fixture.outputs.candidate_id",
+    'payload["expires_at"] = "2099-01-01T00:00:00Z"',
+]:
+    if required not in devlab:
+        errors.append(f"devlab.yml: missing fixture/readiness control {required}")
+
+if errors:
+    print("Documentation/workflow audit: FAIL")
+    print("\n".join(f"- {error}" for error in errors))
+    raise SystemExit(1)
+
+print("Documentation/workflow audit: PASS")
+print(f"markdown_files={len(list(ROOT.rglob('*.md')))}")
+print(f"workflow_files={len(list(workflow_dir.glob('*.yml')))}")
+print("internal_links=PASS")
+print("json_metadata=PASS")
+print("workflow_safety=PASS")

package/scripts/eval-intelligence.py

@@ -23,6 +23,7 @@ from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
 
 ROOT = Path(__file__).resolve().parents[1]
 INTELLIGENCE = ROOT / "scripts/intelligence.py"
+PROJECT_EVAL = ROOT / "scripts/eval-projects.py"
 REPORT = ROOT / "scripts/report.py"
 VERIFIER = ROOT / "scripts/evidence-verifier.py"
 ATTESTATION = ROOT / "scripts/attestation.py"
@@ -134,6 +135,27 @@ def run_attestation_cases(root: Path, results: list[dict[str, object]]) -> None:
     record(results, "p2-attestation-unknown-signer", unknown_result.returncode == 13, unknown_result.stdout + unknown_result.stderr)
 
 
+def run_project_corpus_cases(root: Path, results: list[dict[str, object]]) -> None:
+    """Keep first-party analyzer evidence separate from unavailable external evidence."""
+    first_party = invoke([
+        str(PROJECT_EVAL), "--workspace", str(ROOT), "--require-external", "0", "--allow-insufficient"
+    ])
+    first_doc = json.loads(first_party.stdout) if first_party.stdout.strip().startswith("{") else {}
+    first_pass = any(item.get("id") == "motionloom-first-party" and item.get("status") == "pass" for item in first_doc.get("results", []))
+    record(results, "project-corpus-first-party-pass", first_party.returncode == 0 and first_doc.get("status") == "pass" and first_pass, first_party.stdout + first_party.stderr)
+
+    insufficient = invoke([
+        str(PROJECT_EVAL), "--workspace", str(ROOT), "--allow-insufficient"
+    ])
+    insufficient_doc = json.loads(insufficient.stdout) if insufficient.stdout.strip().startswith("{") else {}
+    record(
+        results,
+        "project-corpus-insufficient-external-explicit",
+        insufficient.returncode == 0 and insufficient_doc.get("status") == "insufficient_evidence" and insufficient_doc.get("unavailable_external_projects") == 3,
+        insufficient.stdout + insufficient.stderr,
+    )
+
+
 def run_p1_cases(root: Path, task_dir: Path, results: list[dict[str, object]]) -> None:
     """Exercise P1 semantic, continuity and feedback contracts in isolated copies."""
     lint_task = root / "p1-human-review"
@@ -364,6 +386,7 @@ def main() -> int:
         run_performance_perceptual_cases(root, task_dir, results)
         run_runtime_verifier_cases(root, results)
         run_attestation_cases(root, results)
+        run_project_corpus_cases(root, results)
 
     missing = expected - {str(item["id"]) for item in results}
     for case_id in sorted(missing):

package/scripts/eval-projects.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Evaluate MotionLoom's project-aware analyzer against a labeled project corpus.
+
+The manifest records provenance and expected signals, but this runner never
+clones, installs or executes code from external projects. A checkout is only
+considered available when the caller explicitly places it under --workspace.
+Missing external projects produce ``insufficient_evidence`` rather than a
+false pass. This keeps product-value claims separate from owned fixtures.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_MANIFEST = ROOT / "tests/evals/project-corpus.json"
+ANALYZER = ROOT / "scripts/analyze.py"
+
+
+def invoke(project: Path, output: Path, args: argparse.Namespace) -> subprocess.CompletedProcess[str]:
+    command = [
+        sys.executable,
+        str(ANALYZER),
+        str(project),
+        "--output",
+        str(output),
+        "--max-files",
+        str(args.max_files),
+        "--max-bytes",
+        str(args.max_bytes),
+        "--max-seconds",
+        str(args.max_seconds),
+    ]
+    for value in args.ignore_dir:
+        command.extend(["--ignore-dir", value])
+    for value in args.ignore_glob:
+        command.extend(["--ignore-glob", value])
+    return subprocess.run(command, cwd=ROOT, capture_output=True, text=True)
+
+
+def evaluate_case(case: dict, workspace: Path, repository_root: Path, args: argparse.Namespace, temp: Path) -> dict:
+    relative = Path(str(case["local_path"]))
+    base = repository_root if case.get("scope") == "repository" else workspace
+    project = (base / relative).resolve()
+    try:
+        project.relative_to(base.resolve())
+    except ValueError:
+        return {"id": case["id"], "class": case.get("class"), "status": "fail", "detail": "local_path escapes evaluation root"}
+    if not project.is_dir():
+        return {
+            "id": case["id"],
+            "class": case.get("class"),
+            "status": "unavailable",
+            "external": bool(case.get("external")),
+            "source": case.get("source"),
+            "detail": f"checkout not present at {relative.as_posix()}",
+        }
+
+    output = temp / f"{case['id']}.json"
+    result = invoke(project, output, args)
+    if result.returncode != 0 or not output.is_file():
+        return {
+            "id": case["id"],
+            "class": case.get("class"),
+            "status": "fail",
+            "external": bool(case.get("external")),
+            "source": case.get("source"),
+            "detail": (result.stdout + result.stderr).strip()[-1000:],
+        }
+
+    context = json.loads(output.read_text(encoding="utf-8"))
+    expected = case.get("expected", {})
+    checks = []
+    if expected.get("name") is not None:
+        checks.append((context.get("name") == expected["name"], f"name={context.get('name')!r}"))
+    if expected.get("framework") is not None:
+        actual = context.get("stack", {}).get("framework")
+        checks.append((actual == expected["framework"], f"framework={actual!r}"))
+    if expected.get("scan_truncated") is not None:
+        checks.append((context.get("scan_truncated") is expected["scan_truncated"], f"scan_truncated={context.get('scan_truncated')!r}"))
+    passed = all(item[0] for item in checks)
+    return {
+        "id": case["id"],
+        "class": case.get("class"),
+        "status": "pass" if passed else "fail",
+        "external": bool(case.get("external")),
+        "source": case.get("source"),
+        "checks": [detail for _, detail in checks],
+        "scan": context.get("scan", {}),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run a provenance-labeled MotionLoom project corpus evaluation.")
+    parser.add_argument("--manifest", default=str(DEFAULT_MANIFEST))
+    parser.add_argument("--workspace", default=str(ROOT), help="Explicit directory containing corpus checkouts")
+    parser.add_argument("--repository-root", default=str(ROOT), help="First-party repository root")
+    parser.add_argument("--output")
+    parser.add_argument("--require-external", type=int, help="Override manifest external-project requirement")
+    parser.add_argument("--allow-insufficient", action="store_true", help="Return success while reporting insufficient_evidence")
+    parser.add_argument("--max-files", type=int, default=2500)
+    parser.add_argument("--max-bytes", type=int, default=25_000_000)
+    parser.add_argument("--max-seconds", type=float, default=10.0)
+    parser.add_argument("--ignore-dir", action="append", default=[])
+    parser.add_argument("--ignore-glob", action="append", default=[])
+    args = parser.parse_args()
+
+    manifest_path = Path(args.manifest).expanduser().resolve()
+    workspace = Path(args.workspace).expanduser().resolve()
+    repository_root = Path(args.repository_root).expanduser().resolve()
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    cases = manifest.get("projects", [])
+    required_external = args.require_external if args.require_external is not None else int(manifest.get("required_external_projects", 0))
+
+    with tempfile.TemporaryDirectory(prefix="motionloom-project-eval-") as td:
+        results = [evaluate_case(case, workspace, repository_root, args, Path(td)) for case in cases]
+    available_external = sum(1 for item in results if item.get("external") and item.get("status") == "pass")
+    failed = [item for item in results if item["status"] == "fail"]
+    unavailable_external = [item for item in results if item.get("external") and item["status"] == "unavailable"]
+    if failed:
+        status = "fail"
+    elif available_external < required_external:
+        status = "insufficient_evidence"
+    else:
+        status = "pass"
+
+    report = {
+        "schema_version": "1.0",
+        "corpus_id": manifest.get("corpus_id"),
+        "status": status,
+        "workspace": str(workspace),
+        "required_external_projects": required_external,
+        "available_external_projects": available_external,
+        "unavailable_external_projects": len(unavailable_external),
+        "project_count": len(results),
+        "results": results,
+    }
+    payload = json.dumps(report, indent=2, ensure_ascii=False) + "\n"
+    if args.output:
+        output = Path(args.output).expanduser().resolve()
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(payload, encoding="utf-8")
+    print(payload, end="")
+    if status == "insufficient_evidence" and args.allow_insufficient:
+        return 0
+    return 0 if status == "pass" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/intelligence.py

@@ -824,11 +824,54 @@ def semantic_lint_validate_data(report: dict[str, Any]) -> list[str]:
         issues.append("schema_version must be 0.1")
     if report.get("status") not in {"pass", "warn", "fail"}:
         issues.append("status must be pass, warn or fail")
-    summary = report.get("summary") or {}
-    findings = report.get("findings") or []
+    for field in ("report_id", "task_id", "scene"):
+        if not isinstance(report.get(field), str) or not report.get(field).strip():
+            issues.append(f"{field} must be a non-empty string")
+    ruleset = report.get("ruleset")
+    if not isinstance(ruleset, dict) or not isinstance(ruleset.get("id"), str) or not ruleset.get("id").strip() or not isinstance(ruleset.get("version"), str) or not ruleset.get("version").strip():
+        issues.append("ruleset must contain non-empty id and version")
+    summary = report.get("summary") if isinstance(report.get("summary"), dict) else {}
+    summary_required = {"total", "errors", "warnings", "infos", "blocking"}
+    issues.extend(f"summary missing {field}" for field in sorted(summary_required - set(summary)))
+    findings = report.get("findings") if isinstance(report.get("findings"), list) else []
+    if not isinstance(report.get("findings"), list):
+        issues.append("findings must be an array")
     if summary.get("total") != len(findings):
         issues.append("summary.total does not match findings length")
-    blocking = sum(bool(item.get("approval_blocking")) for item in findings if isinstance(item, dict))
+    finding_required = {"id", "rule_id", "category", "severity", "confidence", "basis", "message", "evidence_refs", "affected_paths", "approval_blocking"}
+    categories = {"intent", "timing", "easing", "accessibility", "performance", "continuity", "anti_pattern"}
+    severities = {"info", "warning", "error"}
+    bases = {"deterministic", "runtime", "human", "heuristic"}
+    severity_counts = {"info": 0, "warning": 0, "error": 0}
+    blocking = 0
+    for index, item in enumerate(findings):
+        if not isinstance(item, dict):
+            issues.append(f"finding[{index}] must be an object")
+            continue
+        issues.extend(f"finding[{index}] missing {field}" for field in sorted(finding_required - set(item)))
+        if item.get("severity") not in severities:
+            issues.append(f"finding[{index}] severity is invalid")
+        else:
+            severity_counts[item["severity"]] += 1
+        if item.get("category") not in categories:
+            issues.append(f"finding[{index}] category is invalid")
+        if item.get("basis") not in bases:
+            issues.append(f"finding[{index}] basis is invalid")
+        if not isinstance(item.get("confidence"), (int, float)) or not 0 <= item.get("confidence", -1) <= 1:
+            issues.append(f"finding[{index}] confidence must be between 0 and 1")
+        if not isinstance(item.get("evidence_refs"), list) or not isinstance(item.get("affected_paths"), list):
+            issues.append(f"finding[{index}] evidence_refs and affected_paths must be arrays")
+        if item.get("approval_blocking") is True:
+            blocking += 1
+    for field in ("total", "errors", "warnings", "infos", "blocking"):
+        if not isinstance(summary.get(field), int) or summary.get(field) < 0:
+            issues.append(f"summary.{field} must be a non-negative integer")
+    if summary.get("errors") != severity_counts["error"]:
+        issues.append("summary.errors does not match findings")
+    if summary.get("warnings") != severity_counts["warning"]:
+        issues.append("summary.warnings does not match findings")
+    if summary.get("infos") != severity_counts["info"]:
+        issues.append("summary.infos does not match findings")
     if summary.get("blocking") != blocking:
         issues.append("summary.blocking does not match findings")
     if report.get("status") == "fail" and blocking == 0:
@@ -1040,15 +1083,72 @@ def continuity_report_data(task_dirs: list[Path], project_id: str | None = None)
 
 def continuity_validate_data(report: dict[str, Any]) -> list[str]:
     issues: list[str] = []
+    required = {"schema_version", "report_id", "project_id", "status", "scenes", "transitions", "summary", "generated_at"}
+    issues.extend(f"missing {field}" for field in sorted(required - set(report)))
     if report.get("schema_version") != "0.1":
         issues.append("schema_version must be 0.1")
-    scenes = report.get("scenes") or []
-    transitions = report.get("transitions") or []
+    if report.get("status") not in {"pass", "warn", "fail"}:
+        issues.append("status must be pass, warn or fail")
+    for field in ("report_id", "project_id"):
+        if not isinstance(report.get(field), str) or not report.get(field).strip():
+            issues.append(f"{field} must be a non-empty string")
+    scenes = report.get("scenes") if isinstance(report.get("scenes"), list) else []
+    transitions = report.get("transitions") if isinstance(report.get("transitions"), list) else []
+    if not isinstance(report.get("scenes"), list):
+        issues.append("scenes must be an array")
+    if not isinstance(report.get("transitions"), list):
+        issues.append("transitions must be an array")
     if not scenes:
         issues.append("continuity report requires at least one scene")
     if len(transitions) != max(0, len(scenes) - 1):
         issues.append("transition count must equal scene count minus one")
-    if report.get("summary", {}).get("scene_count") != len(scenes):
+    scene_names = set()
+    for index, scene in enumerate(scenes):
+        if not isinstance(scene, dict):
+            issues.append(f"scene[{index}] must be an object")
+            continue
+        scene_required = {"scene", "order", "motion_ir_path", "motion_ir_sha256", "context_hash", "intent"}
+        issues.extend(f"scene[{index}] missing {field}" for field in sorted(scene_required - set(scene)))
+        name = scene.get("scene")
+        if not isinstance(name, str) or not name.strip():
+            issues.append(f"scene[{index}].scene must be a non-empty string")
+        elif name in scene_names:
+            issues.append(f"duplicate scene name: {name}")
+        else:
+            scene_names.add(name)
+        if not isinstance(scene.get("order"), int) or scene.get("order", -1) < 0:
+            issues.append(f"scene[{index}].order must be a non-negative integer")
+        for field in ("motion_ir_path", "intent"):
+            if not isinstance(scene.get(field), str) or not scene.get(field).strip():
+                issues.append(f"scene[{index}].{field} must be a non-empty string")
+        for field in ("motion_ir_sha256", "context_hash"):
+            value = scene.get(field)
+            if not isinstance(value, str) or len(value) != 64 or any(char not in "0123456789abcdef" for char in value):
+                issues.append(f"scene[{index}].{field} must be a lowercase SHA-256 digest")
+    for index, transition in enumerate(transitions):
+        if not isinstance(transition, dict):
+            issues.append(f"transition[{index}] must be an object")
+            continue
+        transition_required = {"id", "from_scene", "to_scene", "status", "checks"}
+        issues.extend(f"transition[{index}] missing {field}" for field in sorted(transition_required - set(transition)))
+        if transition.get("status") not in {"pass", "warn", "fail"}:
+            issues.append(f"transition[{index}].status is invalid")
+        if transition.get("from_scene") not in scene_names or transition.get("to_scene") not in scene_names:
+            issues.append(f"transition[{index}] references unknown scene")
+        if not isinstance(transition.get("checks"), list) or any(not isinstance(item, str) or not item.strip() for item in transition.get("checks", [])):
+            issues.append(f"transition[{index}].checks must be a non-empty-string array")
+    summary = report.get("summary") if isinstance(report.get("summary"), dict) else {}
+    summary_required = {"scene_count", "transition_count", "errors", "warnings", "blocking"}
+    issues.extend(f"summary missing {field}" for field in sorted(summary_required - set(summary)))
+    if report.get("summary") is not None and not isinstance(report.get("summary"), dict):
+        issues.append("summary must be an object")
+    for field in ("scene_count", "transition_count", "errors", "warnings", "blocking"):
+        minimum = 1 if field == "scene_count" else 0
+        if not isinstance(summary.get(field), int) or summary.get(field) < minimum:
+            issues.append(f"summary.{field} must be a valid non-negative count")
+    if summary.get("transition_count") != len(transitions):
+        issues.append("summary.transition_count does not match transitions")
+    if summary.get("scene_count") != len(scenes):
         issues.append("summary.scene_count does not match scenes")
     return issues