motionloom 2.6.1 → 2.7.0

package/scripts/review-hook.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import argparse
 import hashlib
+import os
 import json
 import re
 import shutil
@@ -14,6 +15,12 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from urllib.parse import urlencode, urlsplit, urlunsplit
 
+try:
+    from browser_review_consistency import candidate_consistency_errors
+except ModuleNotFoundError:  # Support importlib-based contract tests.
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    from browser_review_consistency import candidate_consistency_errors
+
 ROOT = Path(__file__).resolve().parents[1]
 SAFE_SCENE = re.compile(r"^[A-Za-z0-9._-]+$")
 SAFE_ANIMATION = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
@@ -182,6 +189,20 @@ def runtime_bundle(scene_dir: Path) -> dict | None:
     review_policy = descriptor.get("review_policy")
     if not isinstance(review_policy, dict) or not isinstance(review_policy.get("require_all_animations"), bool):
         raise ValueError("devlab-runtime.json review_policy.require_all_animations must be boolean")
+    action_separation = descriptor.get("action_separation")
+    if action_separation is not None:
+        if not isinstance(action_separation, dict):
+            raise ValueError("devlab-runtime.json action_separation must be an object")
+        if action_separation.get("status") not in {"pass", "quarantined"}:
+            raise ValueError("devlab-runtime.json action_separation.status must be pass or quarantined")
+        if not isinstance(action_separation.get("action_id"), str) or not SAFE_ANIMATION.fullmatch(action_separation["action_id"]):
+            raise ValueError("devlab-runtime.json action_separation.action_id is invalid")
+        frame_count = action_separation.get("frame_count")
+        passing_count = action_separation.get("passing_frame_count")
+        if not isinstance(frame_count, int) or frame_count < 1 or not isinstance(passing_count, int) or passing_count < 0 or passing_count > frame_count:
+            raise ValueError("devlab-runtime.json action_separation frame counts are invalid")
+        if not isinstance(action_separation.get("forbidden_action_ids"), list):
+            raise ValueError("devlab-runtime.json action_separation.forbidden_action_ids must be an array")
 
     digest = hashlib.sha256()
     digest.update(b"motionloom-devlab-runtime-v1\0")
@@ -198,6 +219,7 @@ def runtime_bundle(scene_dir: Path) -> dict | None:
         "mode": mode,
         "files": sorted(resolved_files),
         "review_policy": {"require_all_animations": review_policy["require_all_animations"]},
+        "action_separation": action_separation,
     }
 
 
@@ -215,6 +237,7 @@ def runtime_review_payload(bundle: dict | None) -> dict:
         "bundle_sha256": bundle["bundle_sha256"],
         "animations": bundle["animations"],
         "review_policy": bundle["review_policy"],
+        "action_separation": bundle.get("action_separation"),
     }
 
 
@@ -334,8 +357,24 @@ def prepare(args: argparse.Namespace) -> int:
         )),
     })
     handoff_path.write_text(json.dumps(handoff, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-    subprocess.run([sys.executable, str(ROOT / "scripts/devlab.py"), scene, "--prepare-only", "--task-dir", str(task_dir)], check=True, capture_output=True, text=True)
-    subprocess.run([sys.executable, str(ROOT / "scripts/report.py"), "collect", "--task-dir", str(task_dir)], check=True, capture_output=True, text=True)
+    project_env = os.environ.copy()
+    project_env["MOTIONLOOM_PROJECT_ROOT"] = str(ROOT)
+    subprocess.run(
+        [sys.executable, str(ROOT / "scripts/devlab.py"), scene, "--prepare-only", "--task-dir", str(task_dir)],
+        check=True,
+        capture_output=True,
+        text=True,
+        cwd=ROOT,
+        env=project_env,
+    )
+    subprocess.run(
+        [sys.executable, str(ROOT / "scripts/report.py"), "collect", "--task-dir", str(task_dir)],
+        check=True,
+        capture_output=True,
+        text=True,
+        cwd=ROOT,
+        env=project_env,
+    )
     print(json.dumps({
         "status": "review_required",
         "task_id": task["task_id"],
@@ -363,6 +402,12 @@ def validate(args: argparse.Namespace) -> int:
         bundle["bundle_sha256"] if bundle else None,
     )
     errors = []
+    errors.extend(candidate_consistency_errors(
+        scene_dir / "browser-review.json",
+        task_dir / "browser-review.json",
+        expected_task_id=task.get("task_id"),
+        expected_scene=task.get("scene"),
+    ))
     if not candidate.get("expires_at"):
         errors.append("browser-review candidate has no expiry")
     else:
@@ -446,17 +491,21 @@ def validate(args: argparse.Namespace) -> int:
 
 
 def main() -> int:
+    global ROOT
     parser = argparse.ArgumentParser(description=__doc__)
     sub = parser.add_subparsers(dest="command", required=True)
     p = sub.add_parser("prepare")
     p.add_argument("--task-dir", required=True)
+    p.add_argument("--root", default=str(ROOT), help="Repository root containing the canonical scene artifacts")
     p.add_argument("--lab-url", default="http://127.0.0.1:3300")
     p.set_defaults(func=prepare)
     v = sub.add_parser("validate")
     v.add_argument("--task-dir", required=True)
+    v.add_argument("--root", default=str(ROOT), help="Repository root containing the canonical scene artifacts")
     v.add_argument("--require-approved", action="store_true")
     v.set_defaults(func=validate)
     args = parser.parse_args()
+    ROOT = Path(args.root).expanduser().resolve()
     try:
         return args.func(args)
     except (KeyError, FileNotFoundError, json.JSONDecodeError, ValueError, subprocess.CalledProcessError) as exc:

package/scripts/skill-doctor.py

@@ -7,6 +7,7 @@ import argparse
 import importlib.util
 import json
 import re
+import subprocess
 import sys
 from pathlib import Path
 
@@ -71,9 +72,35 @@ def parse_frontmatter(text: str) -> dict[str, str] | None:
     return values
 
 
+def chromium_executable() -> tuple[Path | None, str | None]:
+    probe = (
+        "import { chromium } from 'playwright'; "
+        "process.stdout.write(chromium.executablePath());"
+    )
+    try:
+        result = subprocess.run(
+            ["node", "--input-type=module", "--eval", probe],
+            cwd=ROOT,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        return None, str(exc)
+    if result.returncode != 0:
+        return None, (result.stderr or result.stdout).strip() or "Playwright import failed"
+    path = Path(result.stdout.strip())
+    return (path if path else None), None
+
+
 def run() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--json", action="store_true", dest="as_json")
+    parser.add_argument(
+        "--runtime",
+        action="store_true",
+        help="also verify that the Playwright Chromium executable is installed",
+    )
     args = parser.parse_args()
     errors: list[dict] = []
     warnings: list[dict] = []
@@ -156,6 +183,21 @@ def run() -> int:
     except (FileNotFoundError, json.JSONDecodeError) as exc:
         errors.append({"code": "invalid_package_json", "message": str(exc)})
 
+    if args.runtime:
+        chromium_path, chromium_error = chromium_executable()
+        chromium_ready = chromium_path is not None and chromium_path.is_file()
+        checks.append({
+            "id": "runtime:chromium",
+            "status": "pass" if chromium_ready else "fail",
+            "path": str(chromium_path) if chromium_path else None,
+        })
+        if not chromium_ready:
+            detail = chromium_error or f"Chromium executable is missing: {chromium_path}"
+            errors.append({
+                "code": "missing_browser_executable",
+                "message": f"Playwright Chromium is unavailable ({detail}); run `npx playwright install chromium`.",
+            })
+
     cryptography_available = importlib.util.find_spec("cryptography") is not None
     checks.append({"id": "python-dependency:cryptography", "status": "pass" if cryptography_available else "fail"})
     if not cryptography_available:

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

@@ -1,9 +1,9 @@
 {
   "schema_version": "1.0",
-  "candidate_id": "88a2f2f18ba45a07f56e",
-  "task_id": "professional-review-e2e",
+  "candidate_id": "956caeb2f56397430c4f",
+  "task_id": "browser-review-smoke-task",
   "scene": "browser-review-smoke",
-  "url": "https://3300-i8isn2ocahcvfq0jk51ta-68c15abe.sg1.manus.computer/?scene=browser-review-smoke&task_id=professional-review-e2e&candidate_id=88a2f2f18ba45a07f56e&artifact_base=https%3A%2F%2F3300-i8isn2ocahcvfq0jk51ta-68c15abe.sg1.manus.computer%2Fscenes%2Fbrowser-review-smoke&task_base=https%3A%2F%2F3300-i8isn2ocahcvfq0jk51ta-68c15abe.sg1.manus.computer%2Ftasks%2Fprofessional-review-e2e",
+  "url": "http://127.0.0.1:3300/?scene=browser-review-smoke&task_id=browser-review-smoke-task&candidate_id=956caeb2f56397430c4f",
   "status": "approved",
   "context_sha256": "cbbd43a53a0ddd5cf5452df5f6d521f06829465bd58c6d764a59d501ed1710fa",
   "source_sha256": "c5ab312427678b17ae903d280d89db9d202670f031f10ad6fe774fc9aaecee8a",
@@ -15,7 +15,7 @@
   ],
   "review_artifact": "review.json",
   "requires_user_approval": true,
-  "prepared_at": "2026-08-12T17:42:31Z",
-  "expires_at": "2026-08-13T17:42:31Z",
-  "reviewed_at": "2026-08-12T17:48:54Z"
+  "prepared_at": "2026-08-12T14:29:17Z",
+  "expires_at": "2099-01-01T00:00:00Z",
+  "reviewed_at": "2026-08-12T14:32:51Z"
 }

package/tests/scripts/run_tests.py

@@ -511,6 +511,9 @@ def test_approved_browser_review_e2e_contract():
         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")
+        scene_candidate_path = root / "src/output/browser-review-smoke/browser-review.json"
+        scene_candidate = dict(candidate)
+        scene_candidate_path.write_text(json.dumps(scene_candidate, indent=2) + "\n")
 
         review = json.loads((task_dir / "review.json").read_text())
         task = json.loads((task_dir / "task.json").read_text())
@@ -524,7 +527,7 @@ def test_approved_browser_review_e2e_contract():
 
         review_hook = subprocess.run([
             sys.executable, str(ROOT / "scripts/review-hook.py"), "validate",
-            "--task-dir", str(task_dir), "--require-approved",
+            "--task-dir", str(task_dir), "--root", str(root), "--require-approved",
         ], capture_output=True, text=True)
         check("e2e review hook accepts approved candidate", review_hook.returncode == 0, review_hook.stdout.strip())
 
@@ -536,7 +539,7 @@ def test_approved_browser_review_e2e_contract():
         check("e2e quality gate accepts task evidence", quality.returncode == 0, quality.stdout.strip())
 
         report_check = subprocess.run([
-            sys.executable, str(ROOT / "scripts/report.py"), "check", "--task-dir", str(task_dir),
+            sys.executable, str(ROOT / "scripts/report.py"), "check", "--task-dir", str(task_dir), "--root", str(root),
         ], capture_output=True, text=True)
         check("e2e report contract accepts confirmed task", report_check.returncode == 0, report_check.stdout.strip())
 
@@ -1162,6 +1165,46 @@ if __name__ == "__main__":
     test_category_coverage()
     test_observability_contract()
     test_quality_workflow_rebuilds_replay_after_generated_artifacts()
+    browser_review_consistency_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_browser_review_consistency.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "browser review scene/task candidate consistency is fail-closed",
+        browser_review_consistency_tests.returncode == 0 and "browser review consistency tests: PASS" in browser_review_consistency_tests.stdout,
+        browser_review_consistency_tests.stdout.strip() or browser_review_consistency_tests.stderr.strip(),
+    )
+    action_separation_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_action_separation.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "action-scoped frame manifests reject cross-action and ambiguous frames",
+        action_separation_tests.returncode == 0 and "action separation tests: PASS" in action_separation_tests.stdout,
+        action_separation_tests.stdout.strip() or action_separation_tests.stderr.strip(),
+    )
+    asset_generation_plan_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_asset_generation_plan.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "asset planner recommends explicit provider and canvas adaptations",
+        asset_generation_plan_tests.returncode == 0 and "asset generation planner contract tests: PASS" in asset_generation_plan_tests.stdout,
+        asset_generation_plan_tests.stdout.strip() or asset_generation_plan_tests.stderr.strip(),
+    )
+    asset_adapt_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_asset_adapt.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "asset adaptation preserves target geometry without crop or stretch",
+        asset_adapt_tests.returncode == 0 and "asset adaptation contract tests: PASS" in asset_adapt_tests.stdout,
+        asset_adapt_tests.stdout.strip() or asset_adapt_tests.stderr.strip(),
+    )
     print()
     if FAILED:
         print(f"{len(FAILED)} test(s) FAILED: {', '.join(FAILED)}")

package/tests/scripts/test_asset_adapt.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "scripts" / "asset-adapt.mjs"
+SOURCE = ROOT / "examples/agent-consumer/asset-consistency/assets/hero-frame-00.png"
+
+
+def check(condition: bool, message: str) -> None:
+    if not condition:
+        raise AssertionError(message)
+
+
+def main() -> int:
+    with tempfile.TemporaryDirectory() as td:
+        root = Path(td)
+        output = root / "padded.png"
+        report = root / "adaptation.json"
+        result = subprocess.run([
+            "node", str(SCRIPT), "pad", "--input", str(SOURCE), "--output", str(output),
+            "--width", "16", "--height", "16", "--scale", "1", "--anchor", "center",
+            "--report", str(report), "--json",
+        ], capture_output=True, text=True)
+        check(result.returncode == 0, result.stderr)
+        doc = json.loads(report.read_text())
+        check(doc["approval"] is False and doc["production_approved"] is False, "adaptation cannot grant approval")
+        check(doc["source"]["canvas"] == [8, 8] and doc["output"]["canvas"] == [16, 16], "adaptation must bind source/output geometry")
+        check(doc["transform"]["crop"] is False and doc["transform"]["stretch"] is False, "crop/stretch must remain false")
+        check(doc["transform"]["interpolation"] == "nearest-neighbour", "pixel art must use nearest-neighbour")
+        check(output.is_file() and output.stat().st_size > 0, "adapter must emit target PNG")
+
+        blocked = subprocess.run([
+            "node", str(SCRIPT), "pad", "--input", str(SOURCE), "--output", str(root / "blocked.png"),
+            "--width", "4", "--height", "4", "--json",
+        ], capture_output=True, text=True)
+        check(blocked.returncode != 0 and "crop is forbidden" in blocked.stderr, "oversized source must fail closed")
+    print("asset adaptation contract tests: PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/tests/scripts/test_asset_generation_plan.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import copy
+import importlib.util
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+MODULE_PATH = ROOT / "scripts" / "asset-generation-plan.py"
+
+
+def load_module():
+    spec = importlib.util.spec_from_file_location("asset_generation_plan", MODULE_PATH)
+    if spec is None or spec.loader is None:
+        raise RuntimeError("cannot load asset generation planner")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+MODULE = load_module()
+
+
+def check(condition: bool, message: str) -> None:
+    if not condition:
+        raise AssertionError(message)
+
+
+def request(canvas=(256, 448), frame_count=8, isolation="required", preferences=None):
+    value = {
+        "schema_version": "0.1",
+        "request_id": "test-request",
+        "asset_id": "test-hero-attack",
+        "asset_kind": "frame_sequence",
+        "target": {
+            "canvas": {"width": canvas[0], "height": canvas[1]},
+            "frame_count": frame_count,
+            "fps": 8,
+            "alpha_mode": "straight",
+            "pixel_art": True,
+            "anchor": "footline",
+        },
+        "generation_policy": {
+            "frame_isolation": isolation,
+            "allow_crop": False,
+            "allow_stretch": False,
+            "allow_silent_resize": False,
+            "allow_provider_batch_as_provisional": True,
+            "integer_scale_only": True,
+        },
+        "actions": [{"action_id": "attack", "positive_cues": ["sword swing"], "negative_cues": ["walk", "jump"]}],
+    }
+    if preferences is not None:
+        value["provider_preferences"] = preferences
+    return value
+
+
+def verified_adapter(canvas=(256, 448)):
+    return {
+        "adapter_id": "verified.single-frame",
+        "kind": "external_provider",
+        "status": "verified",
+        "adapter_version": "0.1",
+        "invocation_mode": "api",
+        "cost_class": "external",
+        "inputs": ["reference"],
+        "outputs": ["frame_sequence"],
+        "compatibility": {"os": ["linux"]},
+        "availability": {"status": "available", "environment": "test"},
+        "capabilities": {
+            "canvas": {"shapes": ["portrait" if canvas[1] > canvas[0] else "landscape" if canvas[0] > canvas[1] else "square"], "allowed_sizes": [[canvas[0], canvas[1]]], "max_width": canvas[0], "max_height": canvas[1]},
+            "frame_behavior": {"mode": "single_frame", "single_frame": True, "max_frames_per_request": 1},
+            "adaptation": [],
+        },
+        "evidence": [{"path": "evidence.md", "sha256": "a" * 64, "kind": "static"}],
+        "limitations": [],
+        "risk_level": "low",
+        "side_effect_level": "read",
+    }
+
+
+def registry_with(adapters, require_verified=True, allow_scaffold_only=False):
+    return {
+        "schema_version": "0.1",
+        "registry_id": "test-registry",
+        "generated_at": "2026-08-22T00:00:00Z",
+        "selection_policy": {"require_verified": require_verified, "allow_scaffold_only": allow_scaffold_only},
+        "adapters": adapters,
+    }
+
+
+def by_id(plan, adapter_id):
+    return next(item for item in plan["providers"] if item["adapter_id"] == adapter_id)
+
+
+def main() -> int:
+    production_registry = json.loads((ROOT / "artifact-adapter-registry.json").read_text())
+    plan_schema = json.loads((ROOT / "schemas" / "asset-generation-plan.schema.json").read_text())
+    check(plan_schema["properties"]["producer"]["const"] == "MotionLoom" and plan_schema["properties"]["schema_version"]["const"] == "0.2", "published plan schema must bind MotionLoom identity and version")
+    with tempfile.TemporaryDirectory() as td:
+        root = Path(td)
+        request_path = root / "request.json"
+        request_path.write_text(json.dumps(request()))
+        registry_path = root / "registry.json"
+        registry_path.write_text(json.dumps(production_registry))
+
+        plan = MODULE.build_plan(request(), production_registry, root)
+        check(plan["contract"] == "motionloom-asset-generation-plan" and plan["schema_version"] == "0.2", "plan contract must identify MotionLoom plan 0.2")
+        check(plan["producer"] == "MotionLoom" and plan["identity"]["product"] == "MotionLoom", "structured plan must preserve MotionLoom identity")
+        check(plan["approval"] is False and plan["production_approved"] is False, "planner must never grant approval")
+        check(plan["decision"] == "recommendations_available", "normal planning must remain useful without verified execution provider")
+        check(plan["execution_decision"] == "no_execution_eligible_route", "default verified-only execution must remain fail-closed")
+        check(plan["selection"]["eligible_count"] == 0, "default registry must have no eligible execution provider")
+        check(plan["selection"]["provisional_count"] >= 4, "scaffold/manual routes must remain visible as provisional")
+        check(plan["selection"]["recommendation_count"] >= 3, "normal planning must expose useful ranked recommendations")
+        check("fixture.local-artifact-intake" not in plan["selection"]["recommendation_adapter_ids"], "regression fixture must not be recommended as a generation route")
+        check(plan["recommendations"], "normal planning must not collapse to no provider available")
+        check(all(item["recommendation_status"] in {"recommended", "acceptable"} for item in plan["recommendations"]), "recommendation list must exclude not-recommended routes")
+        check(all(item["approval"] is False for item in plan["recommendations"]), "recommendations must preserve approval=false")
+        check(plan["agent_guidance"]["recommended_by"] == "MotionLoom", "plan-level guidance must identify MotionLoom")
+        check(plan["project"]["runtime"] is None and plan["project"]["framework"] is None, "synthetic test request without project context should remain explicit")
+        check(any("MotionLoom" in step for step in plan["next_steps"]), "next steps must use MotionLoom workflow identity")
+
+        pix = by_id(plan, "pixellab.animate-skeleton")
+        check(pix["recommendation_status"] == "recommended" and pix["execution_status"] == "provisional", "PixelLab may be recommended while execution remains provisional")
+        check(pix["execution_eligible"] is False, "PixelLab must not be execution-eligible under verified-only policy")
+        check(pix["canvas"]["status"] == "adaptation_required", "PixelLab skeleton must reject non-square native target")
+        check(pix["frames"]["status"] == "provisional_batch_only", "batch PixelLab output must remain provisional under required isolation")
+        pad = next(option for option in pix["adaptation_options"] if option["id"] == "deterministic-pad-to-target")
+        check(pad["source_canvas"] == [256, 256] and pad["target_canvas"] == [256, 448], "planner must propose explicit 256x256 to 256x448 padding")
+        check(pad["crop"] is False and pad["stretch"] is False, "planner must forbid crop and stretch")
+        check("action-separation" in pad["requires_validation"], "adaptation must require action separation validation")
+        check(pix["availability"]["status"] == "unknown", "PixelLab availability must not be fabricated")
+        check(pix["agent_guidance"]["recommended_by"] == "MotionLoom", "route guidance must identify MotionLoom")
+
+        manual = by_id(plan, "manual.import-frame-sequence")
+        check(manual["recommendation_status"] in {"recommended", "acceptable"}, "manual fallback must remain a normal planning option")
+        check(manual["execution_status"] == "provisional", "manual route remains provisional without runtime evidence")
+        check(manual["availability"]["status"] == "known", "manual route availability should be explicit")
+
+        create_text = by_id(plan, "pixellab.create-animated-object-character")
+        check(create_text["frames"]["frame_count_policy"] == "depends_on_canvas_size", "PixelLab create-from-text frame policy must be dynamic")
+        create_text_adapter = next(item for item in production_registry["adapters"] if item["adapter_id"] == "pixellab.create-animated-object-character")
+        small_canvas_frames = MODULE.frame_assessment(create_text_adapter, MODULE.target_summary(request(canvas=(128, 128), frame_count=4)), request()["generation_policy"])
+        check(small_canvas_frames["max_frames_per_request"] == 4 and small_canvas_frames["limits_by_canvas"], "planner must resolve declared dynamic frame limit for an exact PixelLab canvas")
+        existing_text_adapter = next(item for item in production_registry["adapters"] if item["adapter_id"] == "pixellab.animate-with-text")
+        existing_text = by_id(plan, "pixellab.animate-with-text")
+        check(existing_text["frames"]["frame_count_policy"] == "fixed" and existing_text["frames"]["max_frames_per_request"] == 4, "PixelLab animate-existing-reference route must model its documented four-frame output")
+
+        preferred_request = request(preferences={"preferred_adapter_ids": ["pixellab.animate-skeleton"]})
+        preferred_plan = MODULE.build_plan(preferred_request, production_registry, root)
+        preferred_pix = by_id(preferred_plan, "pixellab.animate-skeleton")
+        check(preferred_pix["user_preference"] == {"state": "preferred", "requested": True}, "explicit user preference must be visible")
+        check(preferred_pix["recommendation_status"] == "recommended", "preferred provisional provider may be recommended")
+        check(preferred_pix["execution_status"] == "provisional" and preferred_pix["execution_eligible"] is False, "preference must not promote provisional execution")
+        check(any("preferred by the user" in reason for reason in preferred_pix["rationale"]), "rationale must explain preferred route")
+        check(preferred_pix["ranking_score"] >= 8 and any(item["adapter_id"] == "pixellab.animate-skeleton" for item in preferred_plan["recommendations"]), "preferred compatible provisional route should receive a strong explainable ranking signal without overriding a safer native route")
+
+        incompatible_request = request(preferences={"preferred_adapter_ids": ["internal.imagegen"]})
+        incompatible_plan = MODULE.build_plan(incompatible_request, production_registry, root)
+        incompatible = by_id(incompatible_plan, "internal.imagegen")
+        check(incompatible["user_preference"]["state"] == "preferred", "incompatible preference must remain visible")
+        check(incompatible["recommendation_status"] == "not_recommended" and incompatible["execution_status"] == "blocked", "hard-incompatible preferred route must be blocked")
+        check("internal.imagegen" not in incompatible_plan["selection"]["recommendation_adapter_ids"], "incompatible preferred route must not be recommended")
+        check(incompatible_plan["recommendations"], "safer alternatives must remain available")
+        check(any("does not declare canvas capability" in reason for reason in incompatible["rationale"]), "incompatibility rationale must explain missing canvas capability")
+
+        excluded_request = request(preferences={"excluded_adapter_ids": ["manual.import-frame-sequence"]})
+        excluded_plan = MODULE.build_plan(excluded_request, production_registry, root)
+        excluded = by_id(excluded_plan, "manual.import-frame-sequence")
+        check(excluded["user_preference"]["state"] == "excluded" and excluded["recommendation_status"] == "not_recommended", "excluded preference must be honored without affecting other routes")
+        check("manual.import-frame-sequence" not in excluded_plan["selection"]["recommendation_adapter_ids"], "excluded route must not be recommended")
+
+        unavailable_registry = registry_with([copy.deepcopy(next(item for item in production_registry["adapters"] if item["adapter_id"] == "pixellab.animate-skeleton"))], require_verified=False, allow_scaffold_only=True)
+        unavailable_registry["adapters"][0]["availability"] = {"status": "unavailable", "reason": "connector not configured"}
+        unavailable_plan = MODULE.build_plan(request(), unavailable_registry, root)
+        unavailable = unavailable_plan["providers"][0]
+        check(unavailable["recommendation_status"] == "recommended" and unavailable["execution_status"] == "blocked", "unavailable compatible route may remain a recommendation but cannot execute")
+        check(unavailable_plan["recommendations"][0]["route"] == "resolve_availability_first", "unavailable route must instruct the Agent to resolve availability")
+
+        unknown_preference = request(preferences={"preferred_adapter_ids": ["future.provider"]})
+        unknown_plan = MODULE.build_plan(unknown_preference, production_registry, root)
+        check(unknown_plan["selection"]["unknown_preferred_adapter_ids"] == ["future.provider"], "unknown preferred provider must be surfaced without fabrication")
+        check(any("future.provider" in warning for warning in unknown_plan["warnings"]), "unknown preference warning must be human-readable")
+
+        cli = subprocess.run([
+            sys.executable, str(MODULE_PATH), "plan", "--request", str(request_path), "--registry", str(registry_path), "--project-root", str(root), "--json", "--strict"
+        ], capture_output=True, text=True)
+        strict_output = json.loads(cli.stdout)
+        check(cli.returncode == 2 and strict_output["execution_decision"] == "no_execution_eligible_route", "strict mode must fail without execution-eligible provider")
+
+        human = subprocess.run([
+            sys.executable, str(MODULE_PATH), "plan", "--request", str(request_path), "--registry", str(registry_path), "--project-root", str(root)
+        ], capture_output=True, text=True)
+        check(human.returncode == 0 and "MotionLoom Project Assessment" in human.stdout and "MotionLoom Recommendations" in human.stdout and "MotionLoom Agent Guidance" in human.stdout, "human CLI must expose MotionLoom identity and guidance")
+
+        permitted = copy.deepcopy(production_registry)
+        permitted["selection_policy"] = {"require_verified": False, "allow_scaffold_only": True}
+        next(item for item in permitted["adapters"] if item["adapter_id"] == "pixellab.animate-skeleton")["availability"] = {"status": "available", "environment": "test-connector"}
+        permitted_plan = MODULE.build_plan(request(), permitted, root)
+        permitted_pix = by_id(permitted_plan, "pixellab.animate-skeleton")
+        check(permitted_pix["execution_status"] == "provisional" and permitted_pix["execution_eligible"] is True, "policy may authorize scaffold execution while preserving provisional status")
+        check(any(item["adapter_id"] == "pixellab.animate-skeleton" for item in permitted_plan["recommendations"]), "permitted scaffold provider may be ranked")
+
+        verified = verified_adapter()
+        verified_plan = MODULE.build_plan(request(), registry_with([verified]), root)
+        check(verified_plan["decision"] == "compatible_execution_route_available", "verified native provider must produce execution route")
+        check(verified_plan["selection"]["eligible_adapter_ids"] == ["verified.single-frame"], "verified provider must be execution-eligible")
+        check(verified_plan["recommendations"][0]["execution_status"] == "verified" and verified_plan["recommendations"][0]["route"] == "use_native", "verified native route must be recommended with verified status")
+
+        unknown = copy.deepcopy(production_registry)
+        unknown["adapters"] = [next(item for item in production_registry["adapters"] if item["adapter_id"] == "internal.imagegen")]
+        unknown_plan = MODULE.build_plan(request(), unknown, root)
+        unknown_item = unknown_plan["providers"][0]
+        check(unknown_plan["decision"] == "no_safe_recommendation_available", "unknown-only provider set must not produce a false recommendation")
+        check(unknown_item["execution_status"] == "blocked" and any("does not declare canvas capability" in warning for warning in unknown_item["warnings"]), "unknown capabilities must be blocked and surfaced")
+
+        oversized = copy.deepcopy(next(item for item in production_registry["adapters"] if item["adapter_id"] == "pixellab.animate-skeleton"))
+        oversized["adapter_id"] = "provider.oversized-square"
+        oversized["capabilities"]["canvas"]["allowed_sizes"] = [[384, 384]]
+        oversized_plan = MODULE.build_plan(request(), registry_with([oversized], require_verified=False, allow_scaffold_only=True), root)
+        oversized_assessment = oversized_plan["providers"][0]
+        check(oversized_assessment["execution_status"] == "blocked", "source exceeding target width must be blocked")
+        check(not oversized_assessment["adaptation_options"] and "no declared safe canvas adaptation strategy" in oversized_assessment["hard_failures"], "384x384 source must not be recommended for 256x448 padding")
+
+        landscape_plan = MODULE.build_plan(request(canvas=(448, 256), frame_count=2), registry_with([existing_text_adapter], require_verified=False, allow_scaffold_only=True), root)
+        landscape = landscape_plan["providers"][0]
+        check(any(option["target_canvas"] == [448, 256] for option in landscape["adaptation_options"]), "landscape target must receive explicit adaptation assessment")
+
+        request_path.write_text(json.dumps(request(canvas=(128, 128), frame_count=1)))
+        contextual = copy.deepcopy(request())
+        contextual["project_context"] = {"runtime": "game-runtime", "framework": "canvas", "existing_assets": ["assets/hero.png"], "rig_requirements": ["footline"], "provenance_requirements": ["receipt"], "validation_requirements": ["MotionLoom Dev Lab"]}
+        contextual_plan = MODULE.build_plan(contextual, production_registry, root)
+        check(contextual_plan["project"]["runtime"] == "game-runtime" and contextual_plan["project"]["framework"] == "canvas", "project context must flow into MotionLoom assessment")
+        check(contextual_plan["project"]["requested_existing_assets"] == ["assets/hero.png"] and contextual_plan["project"]["validation_requirements"] == ["MotionLoom Dev Lab"], "project asset and validation requirements must remain visible")
+
+        cli_native = subprocess.run([
+            sys.executable, str(MODULE_PATH), "plan", "--request", str(request_path), "--registry", str(registry_path), "--project-root", str(root), "--json"
+        ], capture_output=True, text=True)
+        check(cli_native.returncode == 0 and json.loads(cli_native.stdout)["approval"] is False, "CLI must preserve approval=false")
+    print("asset generation planner contract tests: PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/tests/scripts/test_attestation.py

@@ -6,6 +6,8 @@ from __future__ import annotations
 import base64
 import hashlib
 import json
+import os
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -134,19 +136,33 @@ def main() -> int:
 
         scene_dir = ROOT / "src" / "output" / "browser-review-smoke"
         task_dir = ROOT / "artifacts" / "browser-review-smoke-task"
+        smoke_task_dir = temp / "professional-review-e2e-attestation"
+        shutil.copytree(task_dir, smoke_task_dir)
+        shutil.copy(
+            ROOT / "artifacts" / "browser-review-smoke-task" / "project-context.json",
+            smoke_task_dir / "project-context.json",
+        )
+        shutil.copy(
+            ROOT / "artifacts" / "browser-review-smoke-task" / "evidence-verifier-report.json",
+            smoke_task_dir / "evidence-verifier-report.json",
+        )
+        candidate_path = smoke_task_dir / "browser-review.json"
+        candidate = json.loads(candidate_path.read_text(encoding="utf-8"))
+        candidate["expires_at"] = "2099-01-01T00:00:00Z"
+        candidate_path.write_text(json.dumps(candidate, indent=2) + "\n", encoding="utf-8")
         task_statement = make_statement(
             task_id="browser-review-smoke-task",
             scene="browser-review-smoke",
-            context_hash=sha256_file(task_dir / "project-context.json"),
+            context_hash=sha256_file(smoke_task_dir / "project-context.json"),
             source_sha256=sha256_file(scene_dir / "animation.json"),
             manifest_sha256=sha256_file(scene_dir / "manifest.json"),
-            motion_ir_sha256=sha256_file(task_dir / "motion-ir.json"),
+            motion_ir_sha256=sha256_file(smoke_task_dir / "motion-ir.json"),
             evidence={
-                "runtime_evidence_sha256": sha256_file(task_dir / "runtime-adapters" / "runtime-evidence.json"),
-                "runtime_telemetry_sha256": telemetry_bundle_sha256(task_dir),
-                "verifier_report_sha256": sha256_file(task_dir / "evidence-verifier-report.json"),
+                "runtime_evidence_sha256": sha256_file(smoke_task_dir / "runtime-adapters" / "runtime-evidence.json"),
+                "runtime_telemetry_sha256": telemetry_bundle_sha256(smoke_task_dir),
+                "verifier_report_sha256": sha256_file(smoke_task_dir / "evidence-verifier-report.json"),
             },
-            provenance_chain_hash=sha256_file(task_dir / "provenance.json"),
+            provenance_chain_hash=sha256_file(smoke_task_dir / "provenance.json"),
         )
         smoke_statement_file = temp / "smoke-statement.json"
         smoke_statement_file.write_text(json.dumps(task_statement, indent=2) + "\n", encoding="utf-8")
@@ -157,8 +173,8 @@ def main() -> int:
             sys.executable,
             str(ROOT / "scripts" / "quality-gate.py"),
             "--scene", "browser-review-smoke",
-            "--context", str(task_dir / "project-context.json"),
-            "--task-dir", str(task_dir),
+            "--context", str(smoke_task_dir / "project-context.json"),
+            "--task-dir", str(smoke_task_dir),
             "--require-attestation",
             "--attestation", str(smoke_bundle_file),
             "--trust-policy", str(policy_file),