motionloom 2.1.0 → 2.3.0

package/scripts/visual-truth.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""Build and validate MotionLoom's provenance-bound visual truth contract.
+
+The contract is deliberately a review aid, not an approval engine. It compares
+real rendered PNG frames, records image dimensions and SHA-256 digests, emits a
+small deterministic perceptual summary, and keeps user approval false until a
+separate browser review artifact records a human decision.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import struct
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+SCHEMA_VERSION = "1.0"
+PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
+SHA256_RE = 64
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def json_sha256(path: Path) -> str:
+    return sha256(path)
+
+
+def load_json(path: Path) -> dict:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValueError(f"invalid JSON {path}: {exc}") from exc
+    if not isinstance(value, dict):
+        raise ValueError(f"expected JSON object: {path}")
+    return value
+
+
+def png_dimensions(path: Path) -> tuple[int, int]:
+    """Read PNG dimensions without requiring Pillow or a system image tool."""
+    with path.open("rb") as handle:
+        if handle.read(8) != PNG_SIGNATURE:
+            raise ValueError(f"not a PNG file: {path}")
+        length = struct.unpack(">I", handle.read(4))[0]
+        chunk = handle.read(4)
+        if chunk != b"IHDR" or length < 8:
+            raise ValueError(f"PNG has no IHDR: {path}")
+        width, height = struct.unpack(">II", handle.read(8))
+        if width <= 0 or height <= 0:
+            raise ValueError(f"PNG dimensions are invalid: {path}")
+        return width, height
+
+
+def relpath(path: Path, root: Path) -> str:
+    resolved = path.resolve()
+    try:
+        return resolved.relative_to(root.resolve()).as_posix()
+    except ValueError:
+        raise ValueError(f"path must be inside repository root: {path}")
+
+
+def display_path(path: Path, root: Path) -> str:
+    """Render an output path without weakening repository-bound evidence paths."""
+    try:
+        return relpath(path, root)
+    except ValueError:
+        return path.resolve().as_posix()
+
+
+def frame_record(path: Path, root: Path, role: str, percent: int) -> dict:
+    if not path.is_file() or path.stat().st_size == 0:
+        raise ValueError(f"{role} frame is missing or empty: {path}")
+    width, height = png_dimensions(path)
+    return {
+        "role": role,
+        "percent": percent,
+        "path": relpath(path, root),
+        "sha256": sha256(path),
+        "bytes": path.stat().st_size,
+        "width": width,
+        "height": height,
+    }
+
+
+def perceptual_summary(baseline: dict, candidate: dict) -> dict:
+    """Return a conservative perceptual signal based on byte identity.
+
+    A byte-identical PNG is a strong deterministic equality signal. A changed
+    PNG is intentionally reported as `review_required`, not as a failed quality
+    judgment, because visual acceptability is a user/runtime review decision.
+    """
+    same_dimensions = (baseline["width"], baseline["height"]) == (candidate["width"], candidate["height"])
+    identical = baseline["sha256"] == candidate["sha256"]
+    return {
+        "metric": "sha256-image-identity",
+        "method": "PNG metadata plus byte identity; no visual approval inferred",
+        "same_dimensions": same_dimensions,
+        "byte_identical": identical,
+        "changed": not identical or not same_dimensions,
+        "distance": 0.0 if identical and same_dimensions else 1.0,
+        "threshold": 0.0,
+        "interpretation": "equal" if identical and same_dimensions else "review_required",
+    }
+
+
+def build(args: argparse.Namespace) -> int:
+    root = Path(args.root).resolve()
+    output = Path(args.output)
+    if not output.is_absolute():
+        output = (root / output).resolve()
+    scene = str(args.scene)
+    if not scene or scene in {".", ".."} or "/" in scene or "\\" in scene:
+        print("visual-truth: unsafe scene identifier", file=sys.stderr)
+        return 2
+    try:
+        baseline = Path(args.baseline)
+        candidate = Path(args.candidate)
+        if not baseline.is_absolute():
+            baseline = (root / baseline).resolve()
+        if not candidate.is_absolute():
+            candidate = (root / candidate).resolve()
+        source = Path(args.source)
+        manifest = Path(args.manifest)
+        runtime_evidence = Path(args.runtime_evidence) if args.runtime_evidence else None
+        motion_ir = Path(args.motion_ir) if args.motion_ir else None
+        for value in (source, manifest, runtime_evidence, motion_ir):
+            if value is not None and not value.is_absolute():
+                value = (root / value).resolve()
+        # Rebind optional paths after the loop because Path is immutable.
+        if args.runtime_evidence:
+            runtime_evidence = (root / args.runtime_evidence).resolve() if not Path(args.runtime_evidence).is_absolute() else Path(args.runtime_evidence).resolve()
+        if args.motion_ir:
+            motion_ir = (root / args.motion_ir).resolve() if not Path(args.motion_ir).is_absolute() else Path(args.motion_ir).resolve()
+        source = (root / args.source).resolve() if not Path(args.source).is_absolute() else Path(args.source).resolve()
+        manifest = (root / args.manifest).resolve() if not Path(args.manifest).is_absolute() else Path(args.manifest).resolve()
+        baseline_record = frame_record(baseline, root, "baseline", args.percent)
+        candidate_record = frame_record(candidate, root, "candidate", args.percent)
+        manifest_data = load_json(manifest)
+        if not source.is_file() or not manifest.is_file():
+            raise ValueError("source and manifest must exist")
+        runtime_data = load_json(runtime_evidence) if runtime_evidence else None
+        motion_data = load_json(motion_ir) if motion_ir else None
+        source_hash = sha256(source)
+        manifest_hash = sha256(manifest)
+        motion_hash = sha256(motion_ir) if motion_ir else None
+        runtime_hash = sha256(runtime_evidence) if runtime_evidence else None
+        if manifest_data.get("file") and not str(manifest_data["file"]).strip():
+            raise ValueError("manifest.file must be non-empty")
+        if runtime_data is not None:
+            if runtime_data.get("status") != "pass":
+                raise ValueError("runtime evidence status must be pass")
+            if args.task_id and runtime_data.get("task_id") not in {None, args.task_id}:
+                raise ValueError("runtime evidence task_id does not match requested task")
+            if runtime_data.get("scene") not in {None, scene}:
+                raise ValueError("runtime evidence scene does not match requested scene")
+        comparison = perceptual_summary(baseline_record, candidate_record)
+        changed_regions = []
+        if comparison["changed"]:
+            changed_regions.append({
+                "id": "full-frame",
+                "label": "Full rendered frame",
+                "reason": "Baseline and candidate PNG identities differ; inspect the exact candidate in Dev Lab.",
+                "severity": "review",
+                "evidence": [baseline_record["path"], candidate_record["path"]],
+            })
+        report = {
+            "schema_version": SCHEMA_VERSION,
+            "contract": "motionloom-visual-truth",
+            "generated_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            "status": "review_required" if comparison["changed"] else "pass",
+            "scene": scene,
+            "task_id": args.task_id or None,
+            "frames": {
+                "baseline": baseline_record,
+                "candidate": candidate_record,
+            },
+            "comparison": comparison,
+            "regions": changed_regions,
+            "provenance": {
+                "source_path": relpath(source, root),
+                "source_sha256": source_hash,
+                "manifest_path": relpath(manifest, root),
+                "manifest_sha256": manifest_hash,
+                "runtime_evidence_path": relpath(runtime_evidence, root) if runtime_evidence else None,
+                "runtime_evidence_sha256": runtime_hash,
+                "motion_ir_path": relpath(motion_ir, root) if motion_ir else None,
+                "motion_ir_sha256": motion_hash,
+                "runtime_status": runtime_data.get("status") if runtime_data else None,
+                "motion_ir_schema_version": motion_data.get("schema_version") if motion_data else None,
+            },
+            "review_boundary": {
+                "approval": False,
+                "user_review_required": True,
+                "decision": "pending",
+                "pr_side_effects": "explicit-confirmation",
+            },
+        }
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+        return 0
+    except (OSError, ValueError) as exc:
+        print(f"visual-truth: {exc}", file=sys.stderr)
+        return 1
+
+
+def validate_report(path: Path, root: Path | None = None, expected_scene: str | None = None, expected_task_id: str | None = None, expected_source_sha256: str | None = None, expected_manifest_sha256: str | None = None, expected_motion_ir_sha256: str | None = None) -> list[str]:
+    root = (root or path.parent).resolve()
+    errors: list[str] = []
+    try:
+        data = load_json(path)
+    except ValueError as exc:
+        return [str(exc)]
+    if data.get("schema_version") != SCHEMA_VERSION:
+        errors.append("visual truth schema_version must be 1.0")
+    if data.get("contract") != "motionloom-visual-truth":
+        errors.append("visual truth contract identifier is invalid")
+    if data.get("status") not in {"pass", "review_required"}:
+        errors.append("visual truth status must be pass or review_required")
+    if expected_scene and data.get("scene") != expected_scene:
+        errors.append("visual truth scene does not match requested scene")
+    if expected_task_id and data.get("task_id") != expected_task_id:
+        errors.append("visual truth task_id does not match task bundle")
+    boundary = data.get("review_boundary")
+    if not isinstance(boundary, dict) or boundary.get("approval") is not False or boundary.get("user_review_required") is not True:
+        errors.append("visual truth must preserve approval=false and user_review_required=true")
+    frames = data.get("frames")
+    if not isinstance(frames, dict) or not isinstance(frames.get("baseline"), dict) or not isinstance(frames.get("candidate"), dict):
+        errors.append("visual truth must contain baseline and candidate frame records")
+    else:
+        for role in ("baseline", "candidate"):
+            frame = frames[role]
+            if frame.get("role") != role or not isinstance(frame.get("sha256"), str) or len(frame.get("sha256", "")) != SHA256_RE:
+                errors.append(f"visual truth {role} frame hash is invalid")
+            frame_path = root / str(frame.get("path", ""))
+            try:
+                if not frame_path.is_file() or sha256(frame_path) != frame.get("sha256"):
+                    errors.append(f"visual truth {role} frame hash/path binding is stale")
+                elif png_dimensions(frame_path) != (frame.get("width"), frame.get("height")):
+                    errors.append(f"visual truth {role} frame dimensions are stale")
+            except (OSError, ValueError):
+                errors.append(f"visual truth {role} frame is not a readable PNG")
+    provenance = data.get("provenance")
+    if not isinstance(provenance, dict):
+        errors.append("visual truth provenance is required")
+    else:
+        for label, expected in (("source_sha256", expected_source_sha256), ("manifest_sha256", expected_manifest_sha256), ("motion_ir_sha256", expected_motion_ir_sha256)):
+            if expected and provenance.get(label) != expected:
+                errors.append(f"visual truth {label} does not match current artifact")
+        for label in ("source_path", "manifest_path"):
+            path_value = provenance.get(label)
+            if not isinstance(path_value, str) or Path(path_value).is_absolute() or ".." in Path(path_value).parts:
+                errors.append(f"visual truth {label} must be a safe repository-relative path")
+    comparison = data.get("comparison")
+    if not isinstance(comparison, dict) or comparison.get("interpretation") not in {"equal", "review_required"}:
+        errors.append("visual truth comparison interpretation is invalid")
+    return errors
+
+
+def validate(args: argparse.Namespace) -> int:
+    root = Path(args.root).resolve()
+    path = Path(args.input)
+    if not path.is_absolute():
+        path = (root / path).resolve()
+    errors = validate_report(path, root, args.scene, args.task_id, args.source_sha256, args.manifest_sha256, args.motion_ir_sha256)
+    result = {"status": "pass" if not errors else "fail", "path": display_path(path, root), "errors": errors}
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0 if not errors else 1
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    build_parser = sub.add_parser("build")
+    build_parser.add_argument("--root", default=".")
+    build_parser.add_argument("--scene", required=True)
+    build_parser.add_argument("--baseline", required=True)
+    build_parser.add_argument("--candidate", required=True)
+    build_parser.add_argument("--percent", type=int, default=100)
+    build_parser.add_argument("--source", required=True)
+    build_parser.add_argument("--manifest", required=True)
+    build_parser.add_argument("--runtime-evidence")
+    build_parser.add_argument("--motion-ir")
+    build_parser.add_argument("--task-id")
+    build_parser.add_argument("--output", required=True)
+    build_parser.set_defaults(func=build)
+    validate_parser = sub.add_parser("validate")
+    validate_parser.add_argument("--root", default=".")
+    validate_parser.add_argument("--input", required=True)
+    validate_parser.add_argument("--scene")
+    validate_parser.add_argument("--task-id")
+    validate_parser.add_argument("--source-sha256")
+    validate_parser.add_argument("--manifest-sha256")
+    validate_parser.add_argument("--motion-ir-sha256")
+    validate_parser.set_defaults(func=validate)
+    args = parser.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/output/browser-review-smoke/asset-provenance.json

@@ -0,0 +1,77 @@
+{
+  "schema_version": "1.0",
+  "provenance_id": "browser-review-smoke-asset-provenance",
+  "task_id": "browser-review-smoke-task",
+  "scene": "browser-review-smoke",
+  "created_at": "2026-08-14T00:00:00Z",
+  "asset": {
+    "id": "browser-review-smoke-animation",
+    "path": "animation.json",
+    "type": "deterministic-fixture",
+    "framework": "lottie",
+    "version": "fixture-2.2.0"
+  },
+  "authority": "ai_assisted_human_reviewed",
+  "readiness": "production_eligible",
+  "generator": {
+    "model": "motionloom-deterministic-fixture-builder",
+    "task_id": "browser-review-smoke-task",
+    "source": "repository-fixture",
+    "generated_at": "2026-08-14T00:00:00Z",
+    "agent": "motionloom-ci"
+  },
+  "human_review": {
+    "reviewer": "MotionLoom fixture maintainer",
+    "decision": "approved",
+    "scope": "deterministic runtime and contract fixture, not production art approval",
+    "reviewed_at": "2026-08-14T00:00:00Z",
+    "user_confirmed": true,
+    "notes": "The fixture is eligible for repository CI and PR evidence; final product approval remains outside this artifact."
+  },
+  "license": {
+    "spdx": "MIT",
+    "source": "MotionLoom repository fixture",
+    "attribution": "MotionLoom deterministic browser-review smoke fixture."
+  },
+  "files": [
+    {
+      "path": "animation.json",
+      "role": "runtime-scene",
+      "sha256": "c5ab312427678b17ae903d280d89db9d202670f031f10ad6fe774fc9aaecee8a"
+    }
+  ],
+  "provenance_chain": [
+    {
+      "step": "generate",
+      "actor": "agent:motionloom-ci",
+      "source": "repository-fixture",
+      "timestamp": "2026-08-14T00:00:00Z"
+    },
+    {
+      "step": "runtime-test",
+      "actor": "runtime:lottie",
+      "source": "browser-review-smoke runtime evidence",
+      "timestamp": "2026-08-14T00:00:00Z"
+    },
+    {
+      "step": "human-review",
+      "actor": "user:fixture-maintainer",
+      "source": "deterministic fixture review boundary",
+      "timestamp": "2026-08-14T00:00:00Z"
+    }
+  ],
+  "runtime_evidence": {
+    "status": "pass",
+    "runtime": "lottie-runtime",
+    "tested_at": "2026-08-14T00:00:00Z",
+    "evidence_path": "snapshot/.render-meta.json"
+  },
+  "full_gate": {
+    "status": "pass",
+    "quality_gate": "pass",
+    "visual_truth": "pass",
+    "license": "pass",
+    "checked_at": "2026-08-14T00:00:00Z",
+    "report_path": "artifacts/browser-review-smoke-task/quality-report.json"
+  }
+}

package/src/output/browser-review-smoke/manifest.json

@@ -4,6 +4,8 @@
   "framework": "lottie",
   "category": "loading",
   "file": "animation.json",
+  "visual_truth": "visual-truth.json",
+  "asset_provenance": "asset-provenance.json",
   "source_binding": {
     "kind": "fixture",
     "source_path": "animation.json",

package/src/output/browser-review-smoke/visual-truth.json

@@ -0,0 +1,68 @@
+{
+  "schema_version": "1.0",
+  "contract": "motionloom-visual-truth",
+  "generated_at": "2026-08-13T17:17:31.327320Z",
+  "status": "review_required",
+  "scene": "browser-review-smoke",
+  "task_id": "browser-review-smoke-task",
+  "frames": {
+    "baseline": {
+      "role": "baseline",
+      "percent": 100,
+      "path": "src/output/browser-review-smoke/snapshot/frame-00.png",
+      "sha256": "8a3bf18101d395ee00a6c6899c31910fbd2c405aee7e83143ce08832e740c5da",
+      "bytes": 3588,
+      "width": 512,
+      "height": 512
+    },
+    "candidate": {
+      "role": "candidate",
+      "percent": 100,
+      "path": "src/output/browser-review-smoke/snapshot/frame-100.png",
+      "sha256": "b3dac3308b0b7295ee3d5d4d87225017692b4d1f6d46828b482948cdd8979e2e",
+      "bytes": 4228,
+      "width": 512,
+      "height": 512
+    }
+  },
+  "comparison": {
+    "metric": "sha256-image-identity",
+    "method": "PNG metadata plus byte identity; no visual approval inferred",
+    "same_dimensions": true,
+    "byte_identical": false,
+    "changed": true,
+    "distance": 1.0,
+    "threshold": 0.0,
+    "interpretation": "review_required"
+  },
+  "regions": [
+    {
+      "id": "full-frame",
+      "label": "Full rendered frame",
+      "reason": "Baseline and candidate PNG identities differ; inspect the exact candidate in Dev Lab.",
+      "severity": "review",
+      "evidence": [
+        "src/output/browser-review-smoke/snapshot/frame-00.png",
+        "src/output/browser-review-smoke/snapshot/frame-100.png"
+      ]
+    }
+  ],
+  "provenance": {
+    "source_path": "src/output/browser-review-smoke/animation.json",
+    "source_sha256": "c5ab312427678b17ae903d280d89db9d202670f031f10ad6fe774fc9aaecee8a",
+    "manifest_path": "src/output/browser-review-smoke/manifest.json",
+    "manifest_sha256": "8d1e07c81dbbcbcc060415ac71dfcae7ce88f2e7aa91347b226dbf4f554e5623",
+    "runtime_evidence_path": "artifacts/browser-review-smoke-task/runtime-adapters/runtime-evidence.json",
+    "runtime_evidence_sha256": "88194b8ed8e8eb9780a80bc55114b9cf52886c911b70a7f4331c18fa39a9b090",
+    "motion_ir_path": "artifacts/browser-review-smoke-task/motion-ir.json",
+    "motion_ir_sha256": "bdb2305737e5dee9b9ee078dd5657a4a5717bf4184f112a1d01ac82361c5a23f",
+    "runtime_status": "pass",
+    "motion_ir_schema_version": "0.1"
+  },
+  "review_boundary": {
+    "approval": false,
+    "user_review_required": true,
+    "decision": "pending",
+    "pr_side_effects": "explicit-confirmation"
+  }
+}

package/tests/scripts/run_tests.py

@@ -256,6 +256,10 @@ def test_runtime_evidence_binding():
         root = Path(td)
         scene = root / "src/output/browser-review-smoke"
         shutil.copytree(ROOT / "src/output/browser-review-smoke", scene)
+        candidate_path = scene / "browser-review.json"
+        candidate = json.loads(candidate_path.read_text())
+        candidate["expires_at"] = "2099-01-01T00:00:00Z"
+        candidate_path.write_text(json.dumps(candidate, indent=2) + "\n")
         context = root / "project-context.json"
         shutil.copy(ROOT / "artifacts/browser-review-smoke-task/project-context.json", context)
 
@@ -840,6 +844,18 @@ def test_observability_contract():
         ], capture_output=True, text=True)
         check("review rejects foreign task candidate", foreign_review.returncode != 0 and "task_id" in foreign_review.stderr)
 
+
+def test_quality_workflow_rebuilds_replay_after_generated_artifacts():
+    workflow = (ROOT / ".github/workflows/quality.yml").read_text(encoding="utf-8")
+    capture = workflow.find("python3 scripts/intelligence.py replay capture")
+    render = workflow.find("- name: Render runtime snapshot frames for changed scenes")
+    gate = workflow.find("- name: Enforce context-bound quality gate")
+    check("quality workflow rebuilds replay bundle", capture >= 0)
+    check("replay rebuild follows runtime rendering", render >= 0 and render < capture)
+    check("replay rebuild precedes quality gate", gate >= 0 and capture < gate)
+    check("replay rebuild binds task directory and root", '--task-dir "$task_dir" --root .' in workflow)
+    check("replay rebuild writes canonical task bundle path", '--output "$task_dir/replay-bundle.json"' in workflow)
+
     doctor = subprocess.run([sys.executable, str(ROOT / "scripts/skill-doctor.py"), "--json"], capture_output=True, text=True)
     doctor_data = json.loads(doctor.stdout)
     check("skill doctor passes package structure", doctor.returncode == 0 and doctor_data.get("status") == "pass")
@@ -863,6 +879,72 @@ def test_observability_contract():
         "project memory recovery and cross-platform contract passes",
         memory_tests.returncode == 0 and "project memory contract tests: PASS" in memory_tests.stdout,
     )
+    discovery_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_discovery.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Agent discovery and installation contract passes",
+        discovery_tests.returncode == 0 and "discovery contract tests: PASS" in discovery_tests.stdout,
+    )
+    consumer_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_consumer_fixtures.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Agent consumer fixture contract passes",
+        consumer_tests.returncode == 0 and "consumer fixture tests: PASS" in consumer_tests.stdout,
+    )
+    matrix_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_installation_matrix.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "cross-platform installation matrix contract passes",
+        matrix_tests.returncode == 0 and "installation matrix tests: PASS" in matrix_tests.stdout,
+    )
+    setup_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_setup.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "one-command onboarding is idempotent and project-bound",
+        setup_tests.returncode == 0 and "setup onboarding tests: PASS" in setup_tests.stdout,
+        setup_tests.stdout.strip() or setup_tests.stderr.strip(),
+    )
+    visual_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_visual_truth.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Visual Truth contract preserves provenance and review boundary",
+        visual_tests.returncode == 0 and "visual truth contract tests: PASS" in visual_tests.stdout,
+    )
+    remediation_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_remediation_learning.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Remediation Learning preserves append-only history and first-pass metrics",
+        remediation_tests.returncode == 0 and "remediation learning tests: PASS" in remediation_tests.stdout,
+        remediation_tests.stdout.strip() or remediation_tests.stderr.strip(),
+    )
+    asset_provenance_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_asset_provenance.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Asset provenance preserves runtime-ready and human-governed production boundaries",
+        asset_provenance_tests.returncode == 0 and "asset provenance contract tests: PASS" in asset_provenance_tests.stdout,
+        asset_provenance_tests.stdout.strip() or asset_provenance_tests.stderr.strip(),
+    )
 
 
 if __name__ == "__main__":
@@ -887,6 +969,7 @@ if __name__ == "__main__":
     sys.path.insert(0, str(ROOT))
     test_category_coverage()
     test_observability_contract()
+    test_quality_workflow_rebuilds_replay_after_generated_artifacts()
     print()
     if FAILED:
         print(f"{len(FAILED)} test(s) FAILED: {', '.join(FAILED)}")