motionloom 2.3.0 → 2.5.0

package/scripts/intelligence.py

@@ -82,14 +82,22 @@ def safe_relative(value: str) -> Path:
     return path
 
 
-def has_symlink_component(path: Path) -> bool:
-    current = path
-    while True:
+def has_symlink_component(path: Path, root: Path) -> bool:
+    """Reject symlinks at or below a trusted root, not system parent aliases."""
+    root = root.absolute()
+    path = path.absolute()
+    try:
+        relative = path.relative_to(root)
+    except ValueError:
+        return True
+    if root.is_symlink():
+        return True
+    current = root
+    for component in relative.parts:
+        current = current / component
         if current.is_symlink():
             return True
-        if current.parent == current:
-            return False
-        current = current.parent
+    return False
 
 
 def within(root: Path, candidate: Path) -> bool:
@@ -104,7 +112,7 @@ def task_artifact(task_dir: Path, relative: str) -> dict[str, Any]:
     safe = safe_relative(relative)
     raw_path = task_dir / safe
     path = raw_path.resolve()
-    if has_symlink_component(raw_path) or not within(task_dir, path) or not path.is_file():
+    if has_symlink_component(raw_path, task_dir) or not within(task_dir, path) or not path.is_file():
         raise ValueError(f"artifact is missing or outside task bundle: {relative}")
     return {
         "id": relative.replace("/", ":"),
@@ -179,7 +187,7 @@ def graph_build(args: argparse.Namespace) -> int:
 
     task_files = []
     for path in sorted(task_dir.rglob("*")):
-        if has_symlink_component(path):
+        if has_symlink_component(path, task_dir):
             raise ValueError(f"task bundle cannot contain symlinked artifact: {path.relative_to(task_dir)}")
         if not path.is_file():
             continue
@@ -363,7 +371,7 @@ def provenance_validate(args: argparse.Namespace) -> int:
     if not isinstance(attestation, dict) or not isinstance(attestation.get("steps"), list):
         raise ValueError("provenance attestation must contain steps")
     task_dir = task_dir_from(args.task_dir)
-    if has_symlink_component(raw_path) or not within(task_dir, path):
+    if has_symlink_component(path, task_dir) or not within(task_dir, path):
         raise ValueError("provenance attestation must be a non-symlink file inside task bundle")
     if attestation.get("task_id") != read_json(task_dir / "task.json").get("task_id"):
         raise ValueError("provenance task_id does not match task.json")
@@ -400,13 +408,13 @@ def capability_build(args: argparse.Namespace) -> int:
     if not isinstance(card, dict):
         raise ValueError("agent-card must be an object")
     raw_evidence_path = Path(args.evidence).expanduser() if args.evidence else ROOT / "scripts" / "runtime-adapters.mjs"
-    if has_symlink_component(raw_evidence_path):
-        raise ValueError("capability evidence cannot traverse symlinks")
     evidence_path = raw_evidence_path.resolve()
     if not evidence_path.is_file():
         raise ValueError(f"capability evidence path does not exist: {evidence_path}")
     if not within(ROOT, evidence_path):
         raise ValueError("capability evidence must be inside the repository")
+    if has_symlink_component(raw_evidence_path, ROOT):
+        raise ValueError("capability evidence cannot traverse symlinks")
     evidence_ref = evidence_path.relative_to(ROOT).as_posix()
     evidence_kind = args.evidence_kind
     entries = []
@@ -445,6 +453,13 @@ def capability_build(args: argparse.Namespace) -> int:
 def capability_validate(args: argparse.Namespace) -> int:
     registry_path = Path(args.path).expanduser().resolve()
     registry = read_json(registry_path)
+    capability_registry_validate(registry)
+    ids = [entry.get("id") for entry in registry["capabilities"]]
+    print(json.dumps({"status": "valid", "kind": "capability-registry", "capability_count": len(ids)}, ensure_ascii=False))
+    return 0
+
+
+def capability_registry_validate(registry: Any) -> None:
     if not isinstance(registry, dict) or not isinstance(registry.get("capabilities"), list):
         raise ValueError("capability registry must contain capabilities")
     ids = [entry.get("id") for entry in registry["capabilities"]]
@@ -453,13 +468,61 @@ def capability_validate(args: argparse.Namespace) -> int:
     for entry in registry["capabilities"]:
         for evidence in entry.get("evidence", []):
             evidence_path = ROOT / safe_relative(str(evidence.get("path", "")))
-            if has_symlink_component(evidence_path) or not within(ROOT, evidence_path):
+            if has_symlink_component(evidence_path, ROOT) or not within(ROOT, evidence_path):
                 raise ValueError(f"capability evidence escapes repository: {evidence.get('path')}")
             if not evidence_path.is_file():
                 raise ValueError(f"capability evidence missing: {evidence.get('path')}")
             if digest_file(evidence_path) != evidence.get("sha256"):
                 raise ValueError(f"capability evidence hash mismatch: {evidence.get('path')}")
-    print(json.dumps({"status": "valid", "kind": "capability-registry", "capability_count": len(ids)}, ensure_ascii=False))
+
+
+def capability_card(args: argparse.Namespace) -> int:
+    """Export a read-only, evidence-bound capability projection for Agents.
+
+    The card deliberately exposes declared registry state only. It does not
+    select a runtime, refresh evidence, grant approval, or change policy.
+    Callers must run ``capabilities select`` before execution.
+    """
+    registry = read_json(Path(args.registry).expanduser().resolve())
+    capability_registry_validate(registry)
+    capabilities = []
+    for entry in registry["capabilities"]:
+        capabilities.append({
+            "id": entry.get("id"),
+            "kind": entry.get("kind"),
+            "declared_status": entry.get("status"),
+            "adapter_version": entry.get("adapter_version"),
+            "last_verified_at": entry.get("last_verified_at"),
+            "inputs": entry.get("inputs", []),
+            "outputs": entry.get("outputs", []),
+            "compatibility": entry.get("compatibility", {}),
+            "evidence": entry.get("evidence", []),
+            "limitations": entry.get("limitations", []),
+            "fallback": entry.get("fallback", ""),
+            "risk_level": entry.get("risk_level"),
+            "side_effect_level": entry.get("side_effect_level"),
+        })
+    card = {
+        "schema_version": "0.1",
+        "kind": "motionloom-capability-card",
+        "registry": {
+            "registry_id": registry.get("registry_id"),
+            "schema_version": registry.get("schema_version"),
+            "generated_at": registry.get("generated_at"),
+            "selection_policy": registry.get("selection_policy", {}),
+        },
+        "capabilities": capabilities,
+        "selection": {
+            "required": True,
+            "command": "motionloom capability select --registry <capability-registry.json> --capability <runtime.id>",
+            "note": "This card is discovery metadata. Select validates evidence freshness and integrity before a runtime may be used.",
+        },
+        "review": {
+            "production_approval": "not_derived",
+            "attestation_approval": "not_derived",
+        },
+    }
+    print(json.dumps(card, ensure_ascii=False))
     return 0
 
 
@@ -488,7 +551,7 @@ def capability_select(args: argparse.Namespace) -> int:
         for evidence in entry.get("evidence", []):
             try:
                 evidence_path = ROOT / safe_relative(str(evidence.get("path", "")))
-                if has_symlink_component(evidence_path) or not within(ROOT, evidence_path) or not evidence_path.is_file() or digest_file(evidence_path) != evidence.get("sha256"):
+                if has_symlink_component(evidence_path, ROOT) or not within(ROOT, evidence_path) or not evidence_path.is_file() or digest_file(evidence_path) != evidence.get("sha256"):
                     evidence_ok = False
                     break
             except (OSError, ValueError):
@@ -1383,7 +1446,7 @@ def replay_capture(args: argparse.Namespace) -> int:
     task_rel = task_dir.relative_to(root).as_posix()
     records = []
     for path in sorted(task_dir.rglob("*")):
-        if has_symlink_component(path):
+        if has_symlink_component(path, task_dir):
             raise ValueError(f"task bundle cannot contain symlinked artifact: {path.relative_to(task_dir)}")
         if not path.is_file():
             continue
@@ -1417,7 +1480,7 @@ def replay_verify(args: argparse.Namespace) -> int:
         task_rel = safe_relative(str(bundle.get("task_dir", "")))
         task_dir = (root / task_rel).resolve()
         task = read_json(task_dir / "task.json")
-        if has_symlink_component(root / task_rel) or not within(root, task_dir) or not task_dir.is_dir():
+        if has_symlink_component(root / task_rel, root) or not within(root, task_dir) or not task_dir.is_dir():
             mismatches.append({"path": str(task_rel), "reason": "task_dir_invalid"})
         else:
             if bundle.get("task_id") != task.get("task_id"):
@@ -1430,7 +1493,7 @@ def replay_verify(args: argparse.Namespace) -> int:
         safe = safe_relative(str(record.get("path", "")))
         raw_path = root / safe
         path = raw_path.resolve()
-        if has_symlink_component(raw_path) or not within(root, path) or "task_dir" in locals() and not within(task_dir, path) or not path.is_file():
+        if has_symlink_component(raw_path, root) or not within(root, path) or "task_dir" in locals() and not within(task_dir, path) or not path.is_file():
             mismatches.append({"path": str(safe), "reason": "missing"})
             continue
         actual = digest_file(path)
@@ -1449,7 +1512,7 @@ def replay_mismatches(bundle: dict[str, Any], root: Path) -> list[dict[str, Any]
         safe = safe_relative(str(record.get("path", "")))
         raw_path = root / safe
         path = raw_path.resolve()
-        if has_symlink_component(raw_path) or not within(root, path) or not path.is_file():
+        if has_symlink_component(raw_path, root) or not within(root, path) or not path.is_file():
             mismatches.append({"path": str(safe), "reason": "missing"})
             continue
         actual = digest_file(path)
@@ -1563,6 +1626,10 @@ def add_subcommands(parser: argparse.ArgumentParser) -> None:
     capabilities_select_parser.add_argument("--status", default="verified")
     capabilities_select_parser.add_argument("--allow-scaffold-only", action="store_true")
     capabilities_select_parser.set_defaults(func=capability_select)
+    capabilities_card_parser = capabilities_sub.add_parser("card", help="export a read-only capability card for Agent discovery")
+    capabilities_card_parser.add_argument("--registry", default=str(ROOT / "capability-registry.json"))
+    capabilities_card_parser.add_argument("--format", choices=["json"], default="json")
+    capabilities_card_parser.set_defaults(func=capability_card)
 
     replay = sub.add_parser("replay", help="capture or verify clean-root integrity replay bundle")
     replay_sub = replay.add_subparsers(dest="action", required=True)

package/scripts/isolate-alpha-background.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Deterministically isolate a high-contrast, edge-connected flat background.
+
+This is a narrow recovery utility for generated PNGs where an image provider
+painted a dark background despite a transparency request. It flood-fills only
+edge-connected pixels within a stated RGB-distance of an observed edge color.
+It does not claim the input was provider-native alpha, alter provenance, or
+approve an asset. Review the JSON report before using the result in a bundle.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import struct
+import sys
+import zlib
+from collections import deque
+from pathlib import Path
+from statistics import median
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def load_png_reader() -> Any:
+    source = ROOT / "scripts" / "asset-consistency.py"
+    spec = importlib.util.spec_from_file_location("motionloom_alpha_isolation_png", source)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"could not load PNG reader: {source}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module.PNGImage
+
+
+def median_edge_color(pixels: list[tuple[int, int, int, int]], width: int, height: int) -> tuple[int, int, int]:
+    indices = set(range(width)) | {width * (height - 1) + x for x in range(width)}
+    indices.update(y * width for y in range(height))
+    indices.update(y * width + width - 1 for y in range(height))
+    values = [pixels[index] for index in sorted(indices)]
+    return tuple(int(median([pixel[channel] for pixel in values])) for channel in range(3))
+
+
+def distance(pixel: tuple[int, int, int, int], color: tuple[int, int, int]) -> int:
+    return sum(abs(pixel[index] - color[index]) for index in range(3))
+
+
+def isolate(pixels: list[tuple[int, int, int, int]], width: int, height: int, background: tuple[int, int, int], tolerance: int) -> set[int]:
+    def matches(index: int) -> bool:
+        return pixels[index][3] > 0 and distance(pixels[index], background) <= tolerance
+    edges = set(range(width)) | {width * (height - 1) + x for x in range(width)}
+    edges.update(y * width for y in range(height))
+    edges.update(y * width + width - 1 for y in range(height))
+    queue = deque(index for index in edges if matches(index))
+    visited = set(queue)
+    while queue:
+        index = queue.popleft()
+        x, y = index % width, index // width
+        for neighbour in (index - 1 if x else None, index + 1 if x + 1 < width else None, index - width if y else None, index + width if y + 1 < height else None):
+            if neighbour is not None and neighbour not in visited and matches(neighbour):
+                visited.add(neighbour)
+                queue.append(neighbour)
+    return visited
+
+
+def png_rgba(width: int, height: int, pixels: list[tuple[int, int, int, int]]) -> bytes:
+    raw = bytearray()
+    for y in range(height):
+        raw.append(0)
+        for pixel in pixels[y * width : (y + 1) * width]:
+            raw.extend(pixel)
+    def chunk(kind: bytes, content: bytes) -> bytes:
+        return struct.pack(">I", len(content)) + kind + content + struct.pack(">I", zlib.crc32(kind + content) & 0xFFFFFFFF)
+    return PNG_SIGNATURE + chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 6, 0, 0, 0)) + chunk(b"IDAT", zlib.compress(bytes(raw), level=9)) + chunk(b"IEND", b"")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Flood-fill a flat edge-connected background into alpha=0")
+    parser.add_argument("input", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--report", type=Path, help="Optional JSON evidence report")
+    parser.add_argument("--tolerance", type=int, default=24, help="Manhattan RGB distance from edge background; 0-765")
+    parser.add_argument("--allow-edge-foreground", action="store_true", help="Permit opaque pixels on the canvas edge; only use for intentionally edge-cropped art")
+    args = parser.parse_args(argv)
+    if not 0 <= args.tolerance <= 765:
+        raise SystemExit("--tolerance must be in 0..765")
+    if not args.input.is_file():
+        raise SystemExit(f"input is missing: {args.input}")
+    if args.output.resolve() == args.input.resolve():
+        raise SystemExit("output must differ from input")
+    PNGImage = load_png_reader()
+    image = PNGImage(args.input)
+    pixels = image.rgba()
+    background = median_edge_color(pixels, image.width, image.height)
+    removed = isolate(pixels, image.width, image.height, background, args.tolerance)
+    if not removed:
+        raise SystemExit("no edge-connected background pixels matched; do not use a larger tolerance without visual review")
+    output_pixels = [(r, g, b, 0 if index in removed else a) for index, (r, g, b, a) in enumerate(pixels)]
+    foreground = sum(1 for _, _, _, alpha in output_pixels if alpha > 0)
+    if foreground == 0:
+        raise SystemExit("isolation would remove all pixels; lower tolerance or provide a different source")
+    edge_indices = set(range(image.width)) | {image.width * (image.height - 1) + x for x in range(image.width)}
+    edge_indices.update(y * image.width for y in range(image.height))
+    edge_indices.update(y * image.width + image.width - 1 for y in range(image.height))
+    residual_edge_pixels = sum(1 for index in edge_indices if output_pixels[index][3] > 0)
+    if residual_edge_pixels and not args.allow_edge_foreground:
+        raise SystemExit(
+            f"{residual_edge_pixels} opaque pixel(s) remain at the canvas edge after isolation; "
+            "this is likely residual background contamination. Use a cleaner source, or explicitly review and pass --allow-edge-foreground for intentionally cropped art."
+        )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_bytes(png_rgba(image.width, image.height, output_pixels))
+    report = {
+        "contract": "alpha-isolation-report",
+        "mode": "edge_connected_flat_background",
+        "input": str(args.input),
+        "input_sha256": digest(args.input),
+        "output": str(args.output),
+        "output_sha256": digest(args.output),
+        "canvas": {"width": image.width, "height": image.height},
+        "observed_edge_background_rgb": list(background),
+        "tolerance": args.tolerance,
+        "removed_pixels": len(removed),
+        "foreground_alpha_pixels": foreground,
+        "residual_edge_foreground_pixels": residual_edge_pixels,
+        "edge_foreground_allowed": args.allow_edge_foreground,
+        "human_review_required": True,
+        "production_approved": False,
+    }
+    if args.report:
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/quality-gate.py

@@ -63,6 +63,24 @@ def _load_asset_provenance():
     return module
 
 
+def _load_asset_consistency():
+    path = ROOT / "scripts" / "asset-consistency.py"
+    loader = importlib.util.spec_from_file_location("asset_consistency", path)
+    module = importlib.util.module_from_spec(loader)
+    sys.modules[loader.name] = module
+    loader.loader.exec_module(module)
+    return module
+
+
+def _load_artifact_intake():
+    path = ROOT / "scripts" / "artifact-intake.py"
+    loader = importlib.util.spec_from_file_location("artifact_intake", path)
+    module = importlib.util.module_from_spec(loader)
+    sys.modules[loader.name] = module
+    loader.loader.exec_module(module)
+    return module
+
+
 def _json(path: Path):
     try:
         return json.loads(path.read_text(encoding="utf-8"))
@@ -82,7 +100,7 @@ def _telemetry_bundle_sha256(task_dir: Path) -> str:
     return hashlib.sha256(json.dumps(entries, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest()
 
 
-def validate_scene(scene_dir: Path, context_path: Path, require_review: bool = False, task_dir: Path | None = None, require_intelligence: bool = False, require_p1: bool = False, require_benchmark: bool = False, require_telemetry: bool = False, require_attestation: bool = False, attestation_path: Path | None = None, trust_policy_path: Path | None = None, require_visual_truth: bool = False, require_asset_provenance: bool = False, asset_provenance_path: Path | None = None) -> list[str]:
+def validate_scene(scene_dir: Path, context_path: Path, require_review: bool = False, task_dir: Path | None = None, require_intelligence: bool = False, require_p1: bool = False, require_benchmark: bool = False, require_telemetry: bool = False, require_attestation: bool = False, attestation_path: Path | None = None, trust_policy_path: Path | None = None, require_visual_truth: bool = False, require_asset_provenance: bool = False, asset_provenance_path: Path | None = None, require_asset_consistency: bool = False, asset_consistency_path: Path | None = None, require_artifact_intake: bool = False) -> list[str]:
     issues = []
     manifest_path = scene_dir / "manifest.json"
     spec_path = scene_dir / "motion-spec.json"
@@ -138,6 +156,66 @@ def validate_scene(scene_dir: Path, context_path: Path, require_review: bool = F
             except (OSError, ValueError, AttributeError) as exc:
                 issues.append(f"asset provenance contract: {exc}")
 
+    consistency_name = manifest.get("consistency_ref")
+    if require_asset_consistency and not isinstance(consistency_name, str) and asset_consistency_path is None:
+        issues.append("asset consistency gate requires manifest.consistency_ref")
+    if consistency_name or asset_consistency_path:
+        resolved_consistency = asset_consistency_path or (scene_dir / str(consistency_name)).resolve()
+        if scene_dir.resolve() not in resolved_consistency.parents or not resolved_consistency.is_file():
+            issues.append("manifest.consistency_ref must point to an existing file inside the scene directory")
+        else:
+            try:
+                consistency_kind = manifest.get("consistency_kind", "frame-geometry")
+                consistency_module = _load_asset_consistency()
+                consistency_document = _json(resolved_consistency)
+                consistency_result = consistency_module.run(
+                    consistency_kind,
+                    consistency_document,
+                    scene_dir,
+                    strict=require_asset_consistency,
+                )
+                issues.extend(
+                    f"asset consistency: {item.get('code', 'issue')} — {item.get('message', 'contract violation')}"
+                    for item in consistency_result.get("errors", [])
+                )
+                if require_asset_consistency and not consistency_result.get("ready"):
+                    issues.append("asset consistency contract is not ready")
+            except (OSError, ValueError, AttributeError, KeyError, TypeError) as exc:
+                issues.append(f"asset consistency contract: {exc}")
+
+    intake = manifest.get("artifact_intake")
+    if require_artifact_intake and not isinstance(intake, dict):
+        issues.append("artifact intake gate requires manifest.artifact_intake")
+    if intake is not None:
+        required_intake_keys = ("registry", "receipt", "controls", "export_manifest")
+        if not isinstance(intake, dict) or any(not isinstance(intake.get(key), str) for key in required_intake_keys):
+            issues.append("manifest.artifact_intake requires registry, receipt, controls and export_manifest relative paths")
+        else:
+            resolved_intake = {key: (scene_dir / intake[key]).resolve() for key in required_intake_keys}
+            if any(scene_dir.resolve() not in path.parents or not path.is_file() for path in resolved_intake.values()):
+                issues.append("manifest.artifact_intake paths must point to existing files inside the scene directory")
+            else:
+                try:
+                    intake_module = _load_artifact_intake()
+                    intake_result = intake_module.evaluate_bundle(
+                        argparse.Namespace(
+                            root=scene_dir,
+                            registry=resolved_intake["registry"],
+                            receipt=resolved_intake["receipt"],
+                            controls=resolved_intake["controls"],
+                            export_manifest=resolved_intake["export_manifest"],
+                            strict=require_artifact_intake,
+                        )
+                    )
+                    issues.extend(
+                        f"artifact intake: {item.get('code', 'issue')} — {item.get('message', 'contract violation')}"
+                        for item in intake_result.get("errors", [])
+                    )
+                    if require_artifact_intake and not intake_result.get("ready"):
+                        issues.append("artifact intake contract is not runtime-ready")
+                except (OSError, ValueError, AttributeError, KeyError, TypeError) as exc:
+                    issues.append(f"artifact intake contract: {exc}")
+
     checks = manifest.get("checks")
     if not isinstance(checks, list) or not checks:
         issues.append("manifest.checks must contain the Dev Lab quality checklist")
@@ -414,6 +492,9 @@ def main() -> int:
     parser.add_argument("--require-visual-truth", action="store_true")
     parser.add_argument("--require-asset-provenance", action="store_true")
     parser.add_argument("--asset-provenance")
+    parser.add_argument("--require-asset-consistency", action="store_true")
+    parser.add_argument("--asset-consistency")
+    parser.add_argument("--require-artifact-intake", action="store_true")
     parser.add_argument("--attestation")
     parser.add_argument("--trust-policy")
     args = parser.parse_args()
@@ -429,13 +510,14 @@ def main() -> int:
     attestation_path = Path(args.attestation).resolve() if args.attestation else None
     trust_policy_path = Path(args.trust_policy).resolve() if args.trust_policy else None
     asset_provenance_path = Path(args.asset_provenance).resolve() if args.asset_provenance else None
+    asset_consistency_path = Path(args.asset_consistency).resolve() if args.asset_consistency else None
     scenes = [root / "src" / "output" / args.scene] if args.scene else sorted(p for p in output_root.iterdir() if p.is_dir()) if output_root.exists() else []
     if not scenes:
         print("QUALITY GATE: no scene outputs found")
         return 0
     failed = False
     for scene_dir in scenes:
-        issues = validate_scene(scene_dir, context, args.require_browser_review, task_dir, args.require_intelligence, args.require_p1, args.require_benchmark, args.require_telemetry, args.require_attestation, attestation_path, trust_policy_path, args.require_visual_truth, args.require_asset_provenance, asset_provenance_path)
+        issues = validate_scene(scene_dir, context, args.require_browser_review, task_dir, args.require_intelligence, args.require_p1, args.require_benchmark, args.require_telemetry, args.require_attestation, attestation_path, trust_policy_path, args.require_visual_truth, args.require_asset_provenance, asset_provenance_path, args.require_asset_consistency, asset_consistency_path, args.require_artifact_intake)
         if issues:
             failed = True
             print(f"REJECTED {scene_dir.name}:")
@@ -447,6 +529,10 @@ def main() -> int:
                 suffixes.append("visual-truth contract")
             if args.require_asset_provenance:
                 suffixes.append("asset provenance production eligibility")
+            if args.require_asset_consistency:
+                suffixes.append("asset consistency contract")
+            if args.require_artifact_intake:
+                suffixes.append("runtime-ready artifact intake")
             suffix = f" + {' + '.join(suffixes)}" if suffixes else ""
             print(f"ACCEPTED {scene_dir.name}: context + spec + runtime snapshots + browser-review candidate + checklist{suffix}")
     return 1 if failed else 0

package/scripts/report.py

@@ -63,6 +63,24 @@ def asset_provenance_module():
     return module
 
 
+def asset_consistency_module():
+    path = ROOT / "scripts" / "asset-consistency.py"
+    loader = importlib.util.spec_from_file_location("motionloom_asset_consistency", path)
+    module = importlib.util.module_from_spec(loader)
+    sys.modules[loader.name] = module
+    loader.loader.exec_module(module)
+    return module
+
+
+def artifact_intake_module():
+    path = ROOT / "scripts" / "artifact-intake.py"
+    loader = importlib.util.spec_from_file_location("motionloom_artifact_intake", path)
+    module = importlib.util.module_from_spec(loader)
+    sys.modules[loader.name] = module
+    loader.loader.exec_module(module)
+    return module
+
+
 def asset_provenance_result(scene_manifest_path: Path, scene_manifest: dict, mode: str = "runtime") -> dict:
     name = scene_manifest.get("asset_provenance")
     if not name:
@@ -81,6 +99,44 @@ def asset_provenance_result(scene_manifest_path: Path, scene_manifest: dict, mod
         return {"status": "fail", "errors": [f"asset provenance contract: {exc}"]}
 
 
+def asset_consistency_result(scene_manifest_path: Path, scene_manifest: dict, strict: bool = False) -> dict:
+    name = scene_manifest.get("consistency_ref")
+    if not name:
+        return {"status": "not-run", "ready": False, "errors": []}
+    scene_dir = scene_manifest_path.parent.resolve()
+    consistency_path = (scene_dir / str(name)).resolve()
+    if scene_dir not in consistency_path.parents or not consistency_path.is_file():
+        return {"status": "fail", "ready": False, "errors": ["scene manifest consistency_ref points to a missing or unsafe artifact"]}
+    try:
+        document = read_json(consistency_path)
+        kind = scene_manifest.get("consistency_kind", "frame-geometry")
+        result = asset_consistency_module().run(kind, document, scene_dir, strict=strict)
+        result["status"] = "pass" if result.get("ready") else "fail"
+        return result
+    except (OSError, ValueError, AttributeError, KeyError, TypeError) as exc:
+        return {"status": "fail", "ready": False, "errors": [f"asset consistency contract: {exc}"]}
+
+
+def artifact_intake_result(scene_manifest_path: Path, scene_manifest: dict, strict: bool = False) -> dict:
+    intake = scene_manifest.get("artifact_intake")
+    if not intake:
+        return {"status": "not-run", "ready": False, "errors": []}
+    required = ("registry", "receipt", "controls", "export_manifest")
+    scene_dir = scene_manifest_path.parent.resolve()
+    if not isinstance(intake, dict) or any(not isinstance(intake.get(key), str) for key in required):
+        return {"status": "fail", "ready": False, "errors": ["scene manifest artifact_intake is incomplete"]}
+    paths = {key: (scene_dir / intake[key]).resolve() for key in required}
+    if any(scene_dir not in path.parents or not path.is_file() for path in paths.values()):
+        return {"status": "fail", "ready": False, "errors": ["scene manifest artifact_intake points to a missing or unsafe artifact"]}
+    try:
+        result = artifact_intake_module().evaluate_bundle(
+            argparse.Namespace(root=scene_dir, registry=paths["registry"], receipt=paths["receipt"], controls=paths["controls"], export_manifest=paths["export_manifest"], strict=strict)
+        )
+        return result
+    except (OSError, ValueError, AttributeError, KeyError, TypeError) as exc:
+        return {"status": "fail", "ready": False, "errors": [f"artifact intake contract: {exc}"]}
+
+
 def memory_summary() -> dict | None:
     path = project_memory_path()
     if not path.is_file():
@@ -475,6 +531,18 @@ def check_report(args: argparse.Namespace) -> int:
             errors.append("ready-for-PR or confirmed task requires a passing asset provenance production check")
         elif not provenance.get("summary", {}).get("production_eligible"):
             errors.append("ready-for-PR or confirmed task requires asset provenance production_eligible")
+    consistency = asset_consistency_result(scene_manifest_path, scene_manifest, strict=state in {"ready_for_pr", "confirmed"})
+    if consistency.get("status") == "fail":
+        errors.extend(f"asset consistency: {error}" for error in consistency.get("errors", []))
+    if state in {"ready_for_pr", "confirmed"} and scene_manifest_path.is_file() and scene_manifest.get("consistency_ref"):
+        if consistency.get("status") != "pass" or not consistency.get("ready"):
+            errors.append("ready-for-PR or confirmed task requires a passing asset consistency contract")
+    intake = artifact_intake_result(scene_manifest_path, scene_manifest, strict=state in {"ready_for_pr", "confirmed"})
+    if intake.get("status") == "fail":
+        errors.extend(f"artifact intake: {error}" for error in intake.get("errors", []))
+    if state in {"ready_for_pr", "confirmed"} and scene_manifest_path.is_file() and scene_manifest.get("artifact_intake"):
+        if intake.get("status") != "pass" or not intake.get("ready"):
+            errors.append("ready-for-PR or confirmed task requires a runtime-ready artifact intake contract")
     if state in {"validated", "ready_for_pr", "confirmed"}:
         quality = read_json(task_dir / "quality-report.json")
         if quality.get("status") != "pass":
@@ -576,6 +644,18 @@ def render(args: argparse.Namespace) -> int:
         scene_manifest,
         "production" if task.get("state") in {"ready_for_pr", "confirmed"} else "runtime",
     )
+    consistency = asset_consistency_result(
+        ROOT / "src" / "output" / str(task.get("scene", "")) / "manifest.json",
+        scene_manifest,
+        strict=task.get("state") in {"ready_for_pr", "confirmed"},
+    )
+    intake = artifact_intake_result(
+        ROOT / "src" / "output" / str(task.get("scene", "")) / "manifest.json",
+        scene_manifest,
+        strict=task.get("state") in {"ready_for_pr", "confirmed"},
+    )
+    intake_adapter = intake.get("adapter") or {}
+    intake_evidence = intake.get("evidence") or {}
     lines = [
         f"# Animation Task Report — {task.get('task_id', task_dir.name)}",
         "",
@@ -609,6 +689,11 @@ def render(args: argparse.Namespace) -> int:
         "## Asset provenance",
         f"- Status: **{provenance.get('status', 'not-run')}**; authority: **{provenance.get('summary', {}).get('authority', 'unknown')}**; declared readiness: **{provenance.get('summary', {}).get('declared_readiness', 'blocked')}**; effective readiness: **{provenance.get('summary', {}).get('effective_readiness', 'blocked')}**",
         f"- Production eligible: **{provenance.get('summary', {}).get('production_eligible', False)}**; production approved: **{provenance.get('summary', {}).get('production_approved', False)}**; errors: **{len(provenance.get('errors', []))}**",
+        "## Asset consistency",
+        f"- Status: **{consistency.get('status', 'not-run')}**; contract: **{consistency.get('contract', scene_manifest.get('consistency_kind', 'not-declared'))}**; ready: **{consistency.get('ready', False)}**; errors: **{len(consistency.get('errors', []))}**; warnings: **{len(consistency.get('warnings', []))}**",
+        "## Artifact Intake",
+        f"- Status: **{intake.get('status', 'not-run')}**; adapter: **{intake_adapter.get('adapter_id', 'not-declared')}**; adapter status: **{intake_adapter.get('status', 'not-declared')}**; ready: **{intake.get('ready', False)}**; production eligible: **{intake.get('production_eligible', False)}**; production approved: **{intake.get('production_approved', False)}**",
+        f"- Receipt: `{intake_evidence.get('receipt', '')}`; controls: `{intake_evidence.get('controls', '')}`; export: `{intake_evidence.get('export_manifest', '')}`; errors: **{len(intake.get('errors', []))}**; warnings: **{len(intake.get('warnings', []))}**",
         "## Semantic motion lint",
         f"- Status: **{lint.get('status', 'not-run')}**; errors: **{lint.get('summary', {}).get('errors', 0)}**; warnings: **{lint.get('summary', {}).get('warnings', 0)}**; blocking: **{lint.get('summary', {}).get('blocking', 0)}**",
         md_table(lint.get("findings", []), [("Rule", "rule_id"), ("Severity", "severity"), ("Confidence", "confidence"), ("Message", "message"), ("Basis", "basis")]),