motionloom 2.3.0 → 2.4.0

package/scripts/runtime-candidate.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""MotionLoom control-to-runtime candidate bridge.
+
+This contract links a provider-neutral Artifact Intake bundle to the existing
+identity/action/frame/atlas/map contracts. It is deterministic, standard
+library only, and intentionally reports runtime-test readiness rather than any
+form of production approval or user review outcome.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import re
+import sys
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SAFE = re.compile(r"^(?!/)(?!.*(?:^|/)\.\.(?:/|$)).+")
+SHA256 = re.compile(r"^[a-f0-9]{64}$")
+KINDS = {"asset_identity": "identity", "action_set": "action-set", "frame_geometry": "frame-geometry", "atlas": "atlas", "layered_map": "layered-map"}
+PROFILE_REQUIREMENTS = {
+    "image": {"asset_identity"},
+    "frame_sequence": {"asset_identity", "action_set", "frame_geometry"},
+    "sprite_atlas": {"asset_identity", "action_set", "frame_geometry", "atlas"},
+    "layered_map": {"asset_identity", "layered_map"},
+    "video": {"asset_identity", "action_set"},
+    "rigged_2d": {"asset_identity", "action_set"},
+    "rigged_3d": {"asset_identity", "action_set"},
+    "runtime_scene": {"asset_identity", "action_set"},
+}
+
+
+@dataclass
+class Issue:
+    severity: str
+    code: str
+    message: str
+    path: str = ""
+
+
+def issue(issues: list[Issue], code: str, message: str, path: str = "", severity: str = "error") -> None:
+    issues.append(Issue(severity, code, message, path))
+
+
+def safe(value: Any) -> bool:
+    return isinstance(value, str) and "\\" not in value and bool(SAFE.fullmatch(value))
+
+
+def resolve(root: Path, value: Any) -> Path | None:
+    if not safe(value):
+        return None
+    raw = root / str(value)
+    try:
+        path = raw.resolve()
+        path.relative_to(root.resolve())
+    except ValueError:
+        return None
+    return path if not raw.is_symlink() and path.is_file() else None
+
+
+def load_json(path: Path, issues: list[Issue], label: str) -> dict[str, Any] | None:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        issue(issues, "invalid_json", f"{label}: {exc}", str(path))
+        return None
+    if not isinstance(value, dict):
+        issue(issues, "invalid_document", f"{label} root must be an object", str(path))
+        return None
+    return value
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def load_module(name: str, path: Path) -> Any:
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def required(document: dict[str, Any], fields: tuple[str, ...], prefix: str, issues: list[Issue]) -> None:
+    for field in fields:
+        if field not in document:
+            issue(issues, "missing_field", f"{prefix}.{field} is required", f"{prefix}.{field}")
+
+
+def valid_datetime(value: Any) -> bool:
+    try:
+        datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        return True
+    except ValueError:
+        return False
+
+
+def resolve_group(root: Path, document: dict[str, Any], key: str, fields: tuple[str, ...], issues: list[Issue]) -> dict[str, Path]:
+    group = document.get(key) if isinstance(document.get(key), dict) else {}
+    required(group, fields, key, issues)
+    resolved: dict[str, Path] = {}
+    for field in fields:
+        path = resolve(root, group.get(field))
+        if path is None:
+            issue(issues, "missing_or_unsafe_ref", f"{key}.{field} must be an existing safe relative file", f"{key}.{field}")
+        else:
+            resolved[field] = path
+    return resolved
+
+
+def validate_runtime_evidence(path: Path, issues: list[Issue]) -> bool:
+    evidence = load_json(path, issues, "runtime evidence")
+    if evidence is None:
+        return False
+    if evidence.get("mode") != "runtime" or evidence.get("status") != "pass":
+        issue(issues, "runtime_evidence_not_pass", "runtime evidence must record mode=runtime and status=pass", "runtime.runtime_evidence_ref")
+        return False
+    frameworks = evidence.get("frameworks")
+    if not isinstance(frameworks, list) or not frameworks or any(item.get("status") != "pass" or item.get("ready") is not True for item in frameworks if isinstance(item, dict)):
+        issue(issues, "runtime_framework_not_ready", "runtime evidence requires at least one ready passing framework", "runtime.runtime_evidence_ref")
+        return False
+    return True
+
+
+def validate_candidate(args: argparse.Namespace) -> dict[str, Any]:
+    root = args.root.resolve()
+    issues: list[Issue] = []
+    candidate_path = args.input.resolve()
+    candidate = load_json(candidate_path, issues, "runtime candidate")
+    if candidate is None:
+        return result(None, issues, {}, None, False)
+    required(candidate, ("schema_version", "candidate_id", "asset_id", "created_at", "artifact_intake", "consistency", "runtime"), "candidate", issues)
+    if candidate.get("schema_version") != "0.1":
+        issue(issues, "schema_version", "candidate.schema_version must be 0.1", "candidate.schema_version")
+    if not isinstance(candidate.get("candidate_id"), str) or len(candidate["candidate_id"]) < 3:
+        issue(issues, "invalid_candidate_id", "candidate_id must be a non-empty stable ID", "candidate.candidate_id")
+    if not isinstance(candidate.get("asset_id"), str) or not candidate["asset_id"].strip():
+        issue(issues, "invalid_asset_id", "asset_id must be non-empty", "candidate.asset_id")
+    if not valid_datetime(candidate.get("created_at")):
+        issue(issues, "invalid_datetime", "created_at must be ISO-8601", "candidate.created_at")
+    intake_paths = resolve_group(root, candidate, "artifact_intake", ("registry", "receipt", "controls", "export_manifest"), issues)
+    consistency_paths = resolve_group(root, candidate, "consistency", ("asset_identity", "action_set"), issues)
+    consistency_group = candidate.get("consistency") if isinstance(candidate.get("consistency"), dict) else {}
+    for name in ("frame_geometry", "atlas", "layered_map"):
+        if name in consistency_group:
+            path = resolve(root, consistency_group.get(name))
+            if path is None:
+                issue(issues, "missing_or_unsafe_ref", f"consistency.{name} must be an existing safe relative file", f"consistency.{name}")
+            else:
+                consistency_paths[name] = path
+    runtime = candidate.get("runtime") if isinstance(candidate.get("runtime"), dict) else {}
+    if runtime.get("review_required") is not True:
+        issue(issues, "review_required", "runtime.review_required must be true; candidate evidence cannot replace human review", "runtime.review_required")
+    if runtime.get("target") not in {"sprite", "canvas", "lottie", "dotlottie", "rive", "gsap", "framer-motion", "spine", "three"}:
+        issue(issues, "invalid_runtime_target", "runtime.target is unsupported", "runtime.target")
+
+    intake_result: dict[str, Any] | None = None
+    controls: dict[str, Any] | None = None
+    export: dict[str, Any] | None = None
+    if len(intake_paths) == 4:
+        try:
+            intake = load_module("motionloom_artifact_intake_bridge", ROOT / "scripts" / "artifact-intake.py")
+            # Intake strictness evaluates provider adapter authority. Candidate strictness
+            # evaluates actual runtime evidence below; a static intake adapter must not be
+            # promoted, but it can feed a separately tested runtime candidate.
+            intake_result = intake.evaluate_bundle(argparse.Namespace(root=root, registry=intake_paths["registry"], receipt=intake_paths["receipt"], controls=intake_paths["controls"], export_manifest=intake_paths["export_manifest"], strict=False))
+            for entry in intake_result.get("errors", []):
+                issue(issues, f"intake_{entry.get('code', 'error')}", entry.get("message", "artifact intake error"), entry.get("path", "artifact_intake"))
+            controls = load_json(intake_paths["controls"], issues, "control track")
+            export = load_json(intake_paths["export_manifest"], issues, "export manifest")
+            receipt = load_json(intake_paths["receipt"], issues, "generation receipt")
+            for label, document in (("receipt", receipt), ("controls", controls), ("export", export)):
+                if document is not None and document.get("asset_id", document.get("asset", {}).get("id")) != candidate.get("asset_id"):
+                    issue(issues, "asset_id_mismatch", f"candidate.asset_id must match {label} asset ID", f"{label}.asset_id")
+        except (OSError, ValueError, AttributeError, KeyError, TypeError, RuntimeError) as exc:
+            issue(issues, "artifact_intake_unavailable", str(exc), "artifact_intake")
+
+    consistency_results: dict[str, Any] = {}
+    try:
+        analyzer = load_module("motionloom_asset_consistency_bridge", ROOT / "scripts" / "asset-consistency.py")
+        for name, path in consistency_paths.items():
+            document = load_json(path, issues, f"consistency {name}")
+            if document is None:
+                continue
+            check = analyzer.run(KINDS[name], document, path.parent.resolve(), args.strict)
+            consistency_results[name] = check
+            for entry in check.get("errors", []):
+                issue(issues, f"consistency_{entry.get('code', 'error')}", entry.get("message", "consistency error"), f"consistency.{name}")
+            if name in {"asset_identity", "action_set", "frame_geometry"} and document.get("asset_id", document.get("asset_identity")) != candidate.get("asset_id"):
+                issue(issues, "consistency_asset_id_mismatch", f"candidate.asset_id must match consistency.{name}", f"consistency.{name}")
+    except (OSError, ValueError, AttributeError, KeyError, TypeError, RuntimeError) as exc:
+        issue(issues, "consistency_unavailable", str(exc), "consistency")
+
+    profile = ((controls or {}).get("output_profile") or {}).get("kind")
+    for name in PROFILE_REQUIREMENTS.get(str(profile), set()):
+        if name not in consistency_paths:
+            issue(issues, "missing_profile_contract", f"{profile} requires consistency.{name}", f"consistency.{name}")
+    if profile not in PROFILE_REQUIREMENTS:
+        issue(issues, "unknown_output_profile", "control output_profile.kind is unsupported for runtime bridging", "controls.output_profile.kind")
+
+    output_paths: dict[Path, dict[str, Any]] = {}
+    for entry in ((export or {}).get("outputs") or []):
+        if isinstance(entry, dict):
+            path = resolve(root, entry.get("path"))
+            if path is not None:
+                output_paths[path] = entry
+    action = consistency_results.get("action_set", {}).get("metrics", {}).get("actions", [])
+    action_doc = load_json(consistency_paths["action_set"], issues, "action set") if "action_set" in consistency_paths else None
+    action_frames: list[Path] = []
+    if isinstance(action_doc, dict):
+        for item in action_doc.get("actions", []):
+            if isinstance(item, dict):
+                action_frames.extend((consistency_paths["action_set"].parent / str(frame)).resolve() for frame in item.get("frames", []) if safe(frame))
+        profile_data = (controls or {}).get("output_profile") or {}
+        expected_count = profile_data.get("expected_frame_count")
+        if profile in {"frame_sequence", "sprite_atlas"} and isinstance(expected_count, int) and len(action_frames) != expected_count:
+            issue(issues, "frame_count_mismatch", "control expected_frame_count must match action-set frame count", "controls.output_profile.expected_frame_count")
+        if profile in {"frame_sequence", "sprite_atlas"}:
+            for frame in action_frames:
+                if frame not in output_paths:
+                    issue(issues, "unexported_action_frame", f"action frame is not hash-bound in export manifest: {frame.name}", "export_manifest.outputs")
+    geometry_doc = load_json(consistency_paths["frame_geometry"], issues, "frame geometry") if "frame_geometry" in consistency_paths else None
+    if isinstance(geometry_doc, dict):
+        for frame in geometry_doc.get("frames", []):
+            if isinstance(frame, dict) and safe(frame.get("image")):
+                path = (consistency_paths["frame_geometry"].parent / str(frame["image"])).resolve()
+                export_entry = output_paths.get(path)
+                if export_entry is None:
+                    issue(issues, "unexported_geometry_frame", f"geometry frame is not hash-bound in export manifest: {path.name}", "export_manifest.outputs")
+                elif not isinstance(frame.get("sha256"), str) or frame.get("sha256") != export_entry.get("sha256") or digest(path) != frame.get("sha256"):
+                    issue(issues, "frame_hash_mismatch", f"geometry/export hash mismatch: {path.name}", "frame_geometry.frames")
+
+    runtime_verified = False
+    if "runtime_evidence_ref" in runtime:
+        evidence_path = resolve(root, runtime.get("runtime_evidence_ref"))
+        if evidence_path is None:
+            issue(issues, "missing_or_unsafe_runtime_evidence", "runtime.runtime_evidence_ref must be an existing safe relative file", "runtime.runtime_evidence_ref")
+        else:
+            runtime_verified = validate_runtime_evidence(evidence_path, issues)
+    if args.strict and not runtime_verified:
+        issue(issues, "runtime_evidence_required", "strict runtime candidate validation requires passing runtime evidence", "runtime.runtime_evidence_ref")
+    return result(candidate, issues, consistency_results, intake_result, runtime_verified)
+
+
+def result(candidate: dict[str, Any] | None, issues: list[Issue], consistency: dict[str, Any], intake: dict[str, Any] | None, runtime_verified: bool) -> dict[str, Any]:
+    errors = [asdict(item) for item in issues if item.severity == "error"]
+    warnings = [asdict(item) for item in issues if item.severity == "warning"]
+    ready = not errors
+    return {
+        "contract": "runtime-candidate",
+        "status": "blocked" if errors else "review_required",
+        "runtime_test_ready": ready,
+        "runtime_verified": runtime_verified,
+        "review_required": True,
+        "production_eligible": False,
+        "production_approved": False,
+        "candidate_id": (candidate or {}).get("candidate_id"),
+        "asset_id": (candidate or {}).get("asset_id"),
+        "intake": {"status": (intake or {}).get("status"), "adapter": (intake or {}).get("adapter")},
+        "consistency": {name: {"status": value.get("status"), "ready": value.get("ready")} for name, value in consistency.items()},
+        "errors": errors,
+        "warnings": warnings,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Bind MotionLoom artifact intake and consistency evidence into a runtime-test candidate")
+    sub = parser.add_subparsers(dest="command", required=True)
+    for command in ("validate", "report"):
+        item = sub.add_parser(command)
+        item.add_argument("--input", required=True, type=Path)
+        item.add_argument("--root", type=Path, default=Path("."))
+        item.add_argument("--strict", action="store_true")
+        item.add_argument("--output", type=Path)
+        item.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    payload = validate_candidate(args)
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    if args.command == "validate" or args.json:
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+    else:
+        print(f"runtime-candidate: {payload['status']} ({len(payload['errors'])} errors, {len(payload['warnings'])} warnings)")
+        for entry in payload["errors"] + payload["warnings"]:
+            print(f"- {entry['severity']}: {entry['code']}: {entry['message']}")
+    return 0 if payload["runtime_test_ready"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/setup.mjs

@@ -19,12 +19,16 @@ const MARKER_START = "<!-- MOTIONLOOM:START -->";
 const MARKER_END = "<!-- MOTIONLOOM:END -->";
 
 function usage() {
-  console.log(`MotionLoom ${VERSION} — onboarding and project readiness
+  console.log(`MotionLoom ${VERSION} — quick start for project-aware animation
 
-Usage:
-  motionloom setup [options]       Install and bootstrap the current project
-  motionloom status [options]      Read-only readiness report
-  motionloom repair [options]      Re-apply safe missing setup pieces
+Start here:
+  motionloom init [options]        One safe setup for the current project
+  motionloom status [options]      Short, read-only project readiness check
+  motionloom doctor                Validate the installed package
+
+Maintenance:
+  motionloom setup [options]       Alias for init (kept for compatibility)
+  motionloom repair [options]      Re-apply only missing managed pieces
 
 Options:
   --project-root <path>            Host project (default: current directory)
@@ -43,13 +47,16 @@ Safe defaults:
   - idempotent AGENTS.md merge, never overwrite existing project guidance
   - Project Memory stays bound to the current project root
   - no commit, push, PR, approval or production promotion
+
+No asset or runtime gate runs during init. Choose an animation task first;
+the installed Agent router will load the relevant MotionLoom workflow then.
 `);
 }
 
 function parseArgs(argv) {
   const args = [...argv];
   let action = "setup";
-  if (["setup", "status", "repair"].includes(args[0])) action = args.shift();
+  if (["setup", "init", "status", "repair"].includes(args[0])) action = args.shift();
   const options = {
     action,
     projectRoot: process.cwd(),
@@ -119,6 +126,23 @@ function projectPackage(root) {
   return readJson(join(root, "package.json"));
 }
 
+function detectProjectKind(packageJson) {
+  const dependencies = {
+    ...(packageJson?.dependencies || {}),
+    ...(packageJson?.devDependencies || {}),
+  };
+  if (dependencies.next) return "Next.js";
+  if (dependencies["@angular/core"]) return "Angular";
+  if (dependencies.vue || dependencies.nuxt) return "Vue";
+  if (dependencies.svelte || dependencies["@sveltejs/kit"]) return "Svelte";
+  if (dependencies.phaser) return "Phaser";
+  if (dependencies["pixi.js"] || dependencies["@pixi/react"]) return "PixiJS";
+  if (dependencies["@babylonjs/core"]) return "Babylon.js";
+  if (dependencies.three || dependencies["@react-three/fiber"]) return "Three.js";
+  if (dependencies.react || dependencies["react-dom"]) return "React";
+  return "Node / unclassified";
+}
+
 function hasDependency(packageJson) {
   if (!packageJson) return false;
   return Boolean(
@@ -219,8 +243,9 @@ When a task involves animation, motion, assets, runtime rendering or Dev Lab rev
 - Read the installed MotionLoom package's canonical \`SKILL.md\` and \`agent-card.json\` first; do not copy them into the host project.
 - Run \`npx --no-install motionloom status --json\` before planning animation work.
 - Keep project context and \`.motionloom/project-memory.json\` bound to this project; never copy them from another project.
-- After rendering, open the MotionLoom Dev Lab candidate for user review before any PR handoff.
-- Treat runtime evidence, quality gates, attestation and heuristics as evidence only; they never imply user approval.
+- Continue normal product work without running MotionLoom gates until the task actually includes animation or an animation asset.
+- For an animation task, follow the applicable canonical workflow; use ingest/runtime checks only when importing assets or testing a target runtime.
+- After rendering, open the MotionLoom Dev Lab candidate for user review before any PR handoff. Evidence never implies user approval.
 - Keep Git side effects local-only until the user explicitly confirms commit, push or PR.
 
 ${MARKER_END}`;
@@ -310,6 +335,11 @@ function statusReport(options) {
     context: { path: join(projectRoot, "project-context.json"), exists: context },
     memory: { path: join(projectRoot, ".motionloom", "project-memory.json"), exists: memory, validation: memoryCheck },
     discovery,
+    quick_start: {
+      project_kind: detectProjectKind(packageJson),
+      gates_active: false,
+      next_action: "Continue normal work. Start an animation task when you are ready; MotionLoom will then load only the relevant workflow.",
+    },
   };
 }
 
@@ -319,15 +349,14 @@ function printStatus(report, json) {
     return;
   }
   const label = report.status === "ready" ? "READY" : report.status === "needs_review" ? "NEEDS REVIEW" : "NEEDS SETUP";
-  console.log(`MotionLoom status: ${label}`);
-  console.log(`Project: ${report.project_root}`);
-  console.log(`Package: ${report.package.installed ? `installed ${report.package.version || "unknown"}` : "not installed locally"}`);
-  console.log(`Runtime: Node ${report.runtime.node.version} ${report.runtime.node.supported ? "PASS" : "BLOCKED"}; Python ${report.runtime.python.version || "missing"} ${report.runtime.python.supported ? "PASS" : "BLOCKED"}`);
-  console.log(`Agent router: ${report.router.status}`);
-  console.log(`Project context: ${report.context.exists ? "present" : "missing"}`);
-  console.log(`Project Memory: ${report.memory.exists ? (report.memory.validation.ok ? "valid" : "needs review") : "missing"}`);
-  console.log(`Discovery: ${report.discovery.ok ? "PASS" : "BLOCKED"}`);
-  if (report.status !== "ready") console.log("Next step: npx --yes motionloom setup");
+  console.log(`MotionLoom: ${label} · ${report.quick_start.project_kind}`);
+  if (report.status === "ready") {
+    console.log("Project memory and Agent routing are ready. No animation gate is active.");
+    console.log("Next: continue normal work. When you start animation, ask the Agent to use MotionLoom.");
+    return;
+  }
+  console.log(`Missing setup pieces: package ${report.package.installed ? "ready" : "missing"}, memory ${report.memory.exists ? "present" : "missing"}, router ${report.router.status}.`);
+  console.log("Next: npx --yes motionloom init");
 }
 
 function setup(options) {
@@ -335,8 +364,10 @@ function setup(options) {
   const packageJson = projectPackage(projectRoot);
   const result = {
     command: options.action,
+    onboarding: "quick_start",
     status: "blocked",
     project_root: projectRoot,
+    project_kind: detectProjectKind(packageJson),
     dry_run: options.dryRun,
     changed: [],
     planned: [],
@@ -432,19 +463,16 @@ function printSetup(result, json) {
     return;
   }
   const label = result.status === "ready" ? "READY" : result.status === "planned" ? "DRY RUN" : result.status === "needs_review" ? "NEEDS REVIEW" : "BLOCKED";
-  console.log(`MotionLoom setup: ${label}`);
-  console.log(`Project: ${result.project_root}`);
-  for (const item of result.changed) console.log(`  PASS  ${typeof item === "string" ? item : `${item.step}: ${item.action}`}`);
-  for (const item of result.planned) console.log(`  PLAN  ${typeof item === "string" ? item : item.command ? item.command.join(" ") : `${item.step}: ${item.action || "planned"}`}`);
-  for (const warning of result.warnings) console.log(`  WARN  ${warning}`);
+  console.log(`MotionLoom quick start: ${label} · ${result.project_kind || "project"}`);
   for (const error of result.errors) console.log(`  BLOCK ${error}`);
+  for (const warning of result.warnings) console.log(`  NOTE  ${warning}`);
   if (result.status === "ready") {
-    console.log("Next: ask your Agent to read the MotionLoom router, inspect project memory, then create a small animation candidate.");
-    console.log("Review: open the Dev Lab candidate before any PR or Git side effect.");
+    console.log("Ready. Project memory is set up and your normal work stays uninterrupted.");
+    console.log("When an animation task begins, ask your Agent to use MotionLoom. Asset and runtime checks appear only when relevant.");
   } else if (result.status === "planned") {
-    console.log("Dry run only: rerun without --dry-run to apply the safe local setup.");
+    console.log("Dry run only: rerun without --dry-run to apply the same safe quick start.");
   } else {
-    console.log("Next: run `npx --no-install motionloom status --json` and follow the reported missing or review-required item.");
+    console.log("Next: run `npx --no-install motionloom status --json` for details, then resolve the reported setup item.");
   }
 }
 

package/src/output/runtime-pilot-framer/asset-provenance.json

@@ -0,0 +1,38 @@
+{
+  "schema_version": "1.0",
+  "provenance_id": "runtime-pilot-framer-scene-provenance",
+  "task_id": "runtime-pilot-001",
+  "scene": "runtime-pilot-framer",
+  "created_at": "2026-08-15T00:00:00Z",
+  "asset": {
+    "id": "runtime/framer-motion-pilot",
+    "path": "scene.jsx",
+    "type": "runtime_scene",
+    "framework": "framer-motion",
+    "version": "13.1.0"
+  },
+  "authority": "code_authored",
+  "readiness": "review_required",
+  "license": {
+    "spdx": "MIT",
+    "source": "MotionLoom repository source",
+    "attribution": "MotionLoom contributors"
+  },
+  "files": [
+    {
+      "path": "scene.jsx",
+      "role": "runtime-source",
+      "sha256": "f4c0e56de842cae6b234566b556e4f07154f8109dde382a474218a9de8b45a8b",
+      "bytes": 1769
+    }
+  ],
+  "provenance_chain": [
+    {
+      "step": "code-authoring",
+      "actor": "MotionLoom runtime-pilot author",
+      "source": "scene.jsx",
+      "timestamp": "2026-08-15T00:00:00Z",
+      "sha256": "f4c0e56de842cae6b234566b556e4f07154f8109dde382a474218a9de8b45a8b"
+    }
+  ]
+}

package/src/output/runtime-pilot-framer/browser-review.json

@@ -0,0 +1,20 @@
+{
+  "schema_version": "1.0",
+  "candidate_id": "8cccc4ac5a7e493ffe40",
+  "task_id": "runtime-pilot-001",
+  "scene": "runtime-pilot-framer",
+  "url": "https://animdevlab-hcxnxr9c.manus.space/lab/?scene=runtime-pilot-framer&task_id=runtime-pilot-001&candidate_id=8cccc4ac5a7e493ffe40&artifact_base=https%3A%2F%2Fanimdevlab-hcxnxr9c.manus.space%2Fscenes%2Fruntime-pilot-framer&task_base=https%3A%2F%2Fanimdevlab-hcxnxr9c.manus.space%2Ftasks%2Fruntime-pilot-001",
+  "status": "prepared",
+  "context_sha256": "9e9bb3bf2e490d23e9f5d52dfc4779b69adf0cc63b32df66adfde7050845fc74",
+  "source_sha256": "f4c0e56de842cae6b234566b556e4f07154f8109dde382a474218a9de8b45a8b",
+  "runtime": "framer-motion",
+  "checkpoints": [
+    0,
+    50,
+    100
+  ],
+  "review_artifact": "review.json",
+  "requires_user_approval": true,
+  "prepared_at": "2026-08-15T15:44:47Z",
+  "expires_at": "2026-08-16T15:44:47Z"
+}

package/src/output/runtime-pilot-framer/framer-motion/runtime-telemetry.json

@@ -0,0 +1,103 @@
+{
+  "schema_version": "1.0",
+  "run_id": "1786808870894-145958",
+  "generated_at": "2026-08-15T15:47:52.478Z",
+  "mode": "runtime-telemetry",
+  "task_id": "runtime-pilot-001",
+  "scene": "runtime-pilot-framer",
+  "framework": "framer-motion",
+  "runtime": "framer-motion@13.1.0",
+  "source_sha256": "f4c0e56de842cae6b234566b556e4f07154f8109dde382a474218a9de8b45a8b",
+  "manifest_sha256": "2b53bf3b6fc8dfe16a271ecd52ec51c2acb5b612c0b77d9fd4e485696989011d",
+  "motion_ir_sha256": "1d339ca2ec9c510e54e53c37ef32c2ddf1485dbaec97c5e9aa178a8f6c9c3287",
+  "samples": [
+    {
+      "sequence": 0,
+      "percent": 0,
+      "captured_at_ms": 767.8999999761581,
+      "raf_intervals_ms": [
+        16.699999999999932,
+        16.600000000000023,
+        16.799999999999955
+      ],
+      "state_sha256": "0769bb6867251ff8d951b01e7d817ab4644d1f7d4a38b0e91ad54ec5b0f81f6b",
+      "state": {
+        "progress": 0,
+        "transform": "matrix(0.82, 0, 0, 0.82, 0, 0)",
+        "opacity": "0.28",
+        "contract": {
+          "framework": "framer-motion",
+          "checkpoints": [
+            0,
+            50,
+            100
+          ],
+          "durationSeconds": 1.2,
+          "loop": true,
+          "sourceAuthority": "code_authored"
+        }
+      }
+    },
+    {
+      "sequence": 1,
+      "percent": 50,
+      "captured_at_ms": 851.1000000238419,
+      "raf_intervals_ms": [
+        16.700000000000045,
+        16.699999999999932,
+        16.600000000000023
+      ],
+      "state_sha256": "015ad2af517be79a3cf102b48b5f61282acd1843c7b5efe20472c2752d79c890",
+      "state": {
+        "progress": 0.5,
+        "transform": "matrix(1.02851, -0.256437, 0.256437, 1.02851, 176, -48)",
+        "opacity": "1",
+        "contract": {
+          "framework": "framer-motion",
+          "checkpoints": [
+            0,
+            50,
+            100
+          ],
+          "durationSeconds": 1.2,
+          "loop": true,
+          "sourceAuthority": "code_authored"
+        }
+      }
+    },
+    {
+      "sequence": 2,
+      "percent": 100,
+      "captured_at_ms": 934.6000000238419,
+      "raf_intervals_ms": [
+        16.700000000000045,
+        16.600000000000023,
+        16.699999999999932
+      ],
+      "state_sha256": "275a832573d3c660f6d820256f95412e253f0a29c02e8f535dfdec2c47e56de2",
+      "state": {
+        "progress": 1,
+        "transform": "matrix(0.882948, 0.469472, -0.469472, 0.882948, 240, -36)",
+        "opacity": "1",
+        "contract": {
+          "framework": "framer-motion",
+          "checkpoints": [
+            0,
+            50,
+            100
+          ],
+          "durationSeconds": 1.2,
+          "loop": true,
+          "sourceAuthority": "code_authored"
+        }
+      }
+    }
+  ],
+  "metrics": {
+    "sample_count": 3,
+    "raf_interval_count": 9,
+    "max_raf_interval_ms": 16.799999999999955,
+    "p95_raf_interval_ms": 16.799999999999955
+  },
+  "status": "pass"
+}

package/src/output/runtime-pilot-framer/manifest.json

@@ -0,0 +1,31 @@
+{
+  "scene": "runtime-pilot-framer",
+  "task_id": "runtime-pilot-001",
+  "name": "Framer Motion Runtime Pilot",
+  "description": "Code-authored Framer Motion scene rendered at deterministic 0/50/100 checkpoints before human review.",
+  "framework": "framer-motion",
+  "category": "runtime-pilot",
+  "file": "scene.jsx",
+  "runtime_evidence": "runtime-evidence.json",
+  "asset_provenance": "asset-provenance.json",
+  "source_binding": {
+    "kind": "project",
+    "source_path": "scene.jsx",
+    "authority": "code_authored",
+    "license": "MIT",
+    "attribution": "MotionLoom contributors",
+    "sha256": "f4c0e56de842cae6b234566b556e4f07154f8109dde382a474218a9de8b45a8b"
+  },
+  "checks": [
+    {
+      "id": "source-bound",
+      "label": "Runtime source is hash-bound before adapter execution",
+      "pass": true
+    },
+    {
+      "id": "review-first",
+      "label": "Runtime evidence does not approve a production release or pull request",
+      "pass": true
+    }
+  ]
+}