motionloom 2.0.0 → 2.2.0

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

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

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

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

package/tests/evals/intelligence-cases.json

@@ -126,6 +126,16 @@
       "id": "p2-attestation-unknown-signer",
       "class": "negative",
       "assertion": "A signature whose key id is absent from the configured trust policy is rejected."
+    },
+    {
+      "id": "project-corpus-first-party-pass",
+      "class": "positive",
+      "assertion": "The analyzer recognizes the first-party MotionLoom project through the labeled corpus harness."
+    },
+    {
+      "id": "project-corpus-insufficient-external-explicit",
+      "class": "negative",
+      "assertion": "Missing external project checkouts are reported as insufficient evidence instead of being treated as product-value proof."
     }
   ]
 }

package/tests/evals/project-corpus.json

@@ -0,0 +1,51 @@
+{
+  "schema_version": "1.0",
+  "corpus_id": "motionloom-project-corpus-v1",
+  "description": "Provenance-labeled analyzer corpus. External checkouts are opt-in and are never fetched by MotionLoom CI.",
+  "required_external_projects": 3,
+  "projects": [
+    {
+      "id": "motionloom-first-party",
+      "class": "first-party",
+      "external": false,
+      "scope": "repository",
+      "local_path": ".",
+      "source": "https://github.com/lenhonbp/MotionLoom",
+      "expected": {
+        "name": "motionloom"
+      }
+    },
+    {
+      "id": "motion-one-external",
+      "class": "external",
+      "external": true,
+      "local_path": "external/framer-motion",
+      "source": "https://github.com/motiondivision/motion",
+      "expected": {
+        "name": "motion-one",
+        "framework": "motion"
+      }
+    },
+    {
+      "id": "gsap-external",
+      "class": "external",
+      "external": true,
+      "local_path": "external/gsap",
+      "source": "https://github.com/greensock/GSAP",
+      "expected": {
+        "framework": "gsap"
+      }
+    },
+    {
+      "id": "rive-external",
+      "class": "external",
+      "external": true,
+      "local_path": "external/rive",
+      "source": "https://github.com/rive-app/rive-react",
+      "expected": {
+        "name": "rive-react",
+        "framework": "rive"
+      }
+    }
+  ]
+}

package/tests/scripts/run_tests.py

@@ -49,6 +49,45 @@ def test_analyzer_on_fixture():
         check("analyzer extracts brand primary", ctx.get("brand", {}).get("primary") == "#2563EB")
 
 
+def test_analyzer_scan_budget_and_ignore_rules():
+    with tempfile.TemporaryDirectory() as td:
+        root = Path(td)
+        (root / "package.json").write_text(json.dumps({"name": "bounded-fixture", "dependencies": {"gsap": "^3.0.0"}}))
+        (root / "ignored-dir").mkdir()
+        (root / "ignored-dir" / "ignored.ts").write_text("duration: 999s")
+        (root / "src").mkdir()
+        for index in range(5):
+            (root / "src" / f"scene-{index}.tsx").write_text("const easing = 'ease-out';")
+        context = root / "context.json"
+        result = subprocess.run([
+            sys.executable, str(ROOT / "scripts/analyze.py"), str(root),
+            "--output", str(context), "--max-files", "2", "--max-bytes", "100000",
+            "--max-seconds", "10", "--ignore-dir", "ignored-dir",
+        ], capture_output=True, text=True)
+        data = json.loads(context.read_text())
+        scan = data.get("scan", {})
+        check("bounded analyzer exits cleanly", result.returncode == 0, result.stderr)
+        check("bounded analyzer emits scan metadata", scan.get("files_scanned") == 2)
+        check("bounded analyzer exposes truncation", data.get("scan_truncated") is True and scan.get("scan_truncated") is True)
+        check("bounded analyzer records file limit", "max_files" in scan.get("truncation_reasons", []))
+        check("bounded analyzer records ignored directory", "ignored-dir" in scan.get("ignored_directories", []))
+
+
+def test_project_corpus_harness_is_explicit_about_evidence():
+    result = subprocess.run([
+        sys.executable, str(ROOT / "scripts/eval-projects.py"),
+        "--workspace", str(ROOT), "--require-external", "0", "--allow-insufficient",
+    ], capture_output=True, text=True)
+    report = json.loads(result.stdout)
+    check("project corpus first-party evaluation passes", result.returncode == 0 and report.get("status") == "pass")
+    strict = subprocess.run([
+        sys.executable, str(ROOT / "scripts/eval-projects.py"),
+        "--workspace", str(ROOT), "--allow-insufficient",
+    ], capture_output=True, text=True)
+    strict_report = json.loads(strict.stdout)
+    check("project corpus missing external evidence is explicit", strict.returncode == 0 and strict_report.get("status") == "insufficient_evidence")
+
+
 def test_spec_generate_and_validate():
     with tempfile.TemporaryDirectory() as td:
         ctx = Path(td) / "project-context.json"
@@ -678,7 +717,7 @@ def test_p1_semantic_continuity_fix_plan():
             task.update({"task_id": task_id, "scene": scene, "scene_order": order, "project_name": "p1-continuity"})
             (path / "task.json").write_text(json.dumps(task, indent=2) + "\n")
             ir = json.loads((path / "motion-ir.json").read_text())
-            ir.update({"task_id": task_id, "scene": scene, "context_hash": task.get("context_hash")})
+            ir.update({"task_id": task_id, "scene": scene, "context_hash": task.get("context_hash") or ir.get("context_hash")})
             (path / "motion-ir.json").write_text(json.dumps(ir, indent=2) + "\n")
 
         continuity = subprocess.run([
@@ -801,6 +840,18 @@ def test_observability_contract():
         ], capture_output=True, text=True)
         check("review rejects foreign task candidate", foreign_review.returncode != 0 and "task_id" in foreign_review.stderr)
 
+
+def test_quality_workflow_rebuilds_replay_after_generated_artifacts():
+    workflow = (ROOT / ".github/workflows/quality.yml").read_text(encoding="utf-8")
+    capture = workflow.find("python3 scripts/intelligence.py replay capture")
+    render = workflow.find("- name: Render runtime snapshot frames for changed scenes")
+    gate = workflow.find("- name: Enforce context-bound quality gate")
+    check("quality workflow rebuilds replay bundle", capture >= 0)
+    check("replay rebuild follows runtime rendering", render >= 0 and render < capture)
+    check("replay rebuild precedes quality gate", gate >= 0 and capture < gate)
+    check("replay rebuild binds task directory and root", '--task-dir "$task_dir" --root .' in workflow)
+    check("replay rebuild writes canonical task bundle path", '--output "$task_dir/replay-bundle.json"' in workflow)
+
     doctor = subprocess.run([sys.executable, str(ROOT / "scripts/skill-doctor.py"), "--json"], capture_output=True, text=True)
     doctor_data = json.loads(doctor.stdout)
     check("skill doctor passes package structure", doctor.returncode == 0 and doctor_data.get("status") == "pass")
@@ -815,10 +866,68 @@ def test_observability_contract():
         attestation_tests.returncode == 0 and "attestation contract tests: PASS" in attestation_tests.stdout,
     )
 
+    memory_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_project_memory.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "project memory recovery and cross-platform contract passes",
+        memory_tests.returncode == 0 and "project memory contract tests: PASS" in memory_tests.stdout,
+    )
+    discovery_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_discovery.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Agent discovery and installation contract passes",
+        discovery_tests.returncode == 0 and "discovery contract tests: PASS" in discovery_tests.stdout,
+    )
+    consumer_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_consumer_fixtures.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Agent consumer fixture contract passes",
+        consumer_tests.returncode == 0 and "consumer fixture tests: PASS" in consumer_tests.stdout,
+    )
+    matrix_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_installation_matrix.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "cross-platform installation matrix contract passes",
+        matrix_tests.returncode == 0 and "installation matrix tests: PASS" in matrix_tests.stdout,
+    )
+    visual_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_visual_truth.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Visual Truth contract preserves provenance and review boundary",
+        visual_tests.returncode == 0 and "visual truth contract tests: PASS" in visual_tests.stdout,
+    )
+    remediation_tests = subprocess.run(
+        [sys.executable, str(ROOT / "tests/scripts/test_remediation_learning.py")],
+        capture_output=True,
+        text=True,
+    )
+    check(
+        "Remediation Learning preserves append-only history and first-pass metrics",
+        remediation_tests.returncode == 0 and "remediation learning tests: PASS" in remediation_tests.stdout,
+        remediation_tests.stdout.strip() or remediation_tests.stderr.strip(),
+    )
+
 
 if __name__ == "__main__":
     print("== MotionLoom engine tests ==")
     test_analyzer_on_fixture()
+    test_analyzer_scan_budget_and_ignore_rules()
+    test_project_corpus_harness_is_explicit_about_evidence()
     test_spec_generate_and_validate()
     test_rig_build_and_pose()
     test_lottie_scaffold_valid()
@@ -836,6 +945,7 @@ if __name__ == "__main__":
     sys.path.insert(0, str(ROOT))
     test_category_coverage()
     test_observability_contract()
+    test_quality_workflow_rebuilds_replay_after_generated_artifacts()
     print()
     if FAILED:
         print(f"{len(FAILED)} test(s) FAILED: {', '.join(FAILED)}")

package/tests/scripts/test_project_memory.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""Project Memory recovery and cross-platform path contract tests."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+CLI = ROOT / "scripts" / "project-memory.py"
+NODE_CLI = ROOT / "bin" / "motionloom.mjs"
+
+
+def run_memory(root: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(CLI), *args, "--project-root", str(root)],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def test_memory_recovery_and_relocation() -> None:
+    with tempfile.TemporaryDirectory(prefix="motionloom memory ") as td:
+        root = Path(td) / "Dự án MotionLoom"
+        root.mkdir(parents=True)
+        (root / "package.json").write_text(json.dumps({"name": "memory-fixture"}), encoding="utf-8")
+        (root / "project-context.json").write_text(json.dumps({
+            "schema_version": "2.0",
+            "name": "memory-fixture",
+            "generated_at": "2026-08-13T00:00:00Z",
+        }), encoding="utf-8")
+
+        created = run_memory(root, "init", "--context-path", "project-context.json", "--json")
+        assert created.returncode == 0, created.stderr
+        memory_path = root / ".motionloom" / "project-memory.json"
+        assert memory_path.is_file()
+
+        decision = run_memory(root, "record-decision", "--id", "ease-ui", "--status", "accepted", "--summary", "Use ease-out for UI entry", "--user-confirmed", "--json")
+        assert decision.returncode == 0, decision.stderr
+
+        rejected = run_memory(root, "record-decision", "--id", "linear-ui", "--status", "rejected", "--summary", "Do not use linear easing for UI", "--rationale", "Perceptually mechanical", "--json")
+        assert rejected.returncode == 0, rejected.stderr
+
+        blocked_outcome = run_memory(root, "record-outcome", "--id", "fix-1", "--issue-id", "issue-1", "--summary", "Unreviewed fix", "--result", "pass")
+        assert blocked_outcome.returncode == 2
+        assert "user-confirmed" in blocked_outcome.stderr
+
+        outcome = run_memory(root, "record-outcome", "--id", "fix-1", "--issue-id", "issue-1", "--summary", "Reduce hand-track duration", "--root-cause", "timing", "--resolution", "duration 420ms", "--result", "pass", "--correction-count", "1", "--rerun-scope", "scene:onboarding-wave", "--user-confirmed", "--json")
+        assert outcome.returncode == 0, outcome.stderr
+
+        recovered = run_memory(root, "recover", "--limit", "10")
+        assert recovered.returncode == 0, recovered.stderr
+        payload = json.loads(recovered.stdout)
+        assert payload["project"]["project_id"].startswith("local:")
+        assert payload["decisions"][-1]["id"] == "linear-ui"
+        assert payload["rejected_patterns"][-1]["id"] == "linear-ui"
+        assert payload["remediation"][-1]["user_confirmed"] is True
+        assert payload["instructions"][0].endswith("user approval.")
+        assert payload["instructions"][-1].endswith("artifacts.")
+
+        moved = Path(td) / "relocated" / "MotionLoom copy"
+        moved.parent.mkdir()
+        shutil.copytree(root, moved)
+        relocated = run_memory(moved, "recover", "--limit", "10")
+        assert relocated.returncode == 0, relocated.stderr
+        relocated_payload = json.loads(relocated.stdout)
+        assert relocated_payload["project"]["root_path"] == str(moved.resolve())
+        relocated_validation = run_memory(moved, "validate", "--json")
+        assert relocated_validation.returncode == 0, relocated_validation.stderr
+
+        # Only the volatile checkout path may be rebound without changing the
+        # durable project payload; meaningful direct edits remain integrity failures.
+        rebound = json.loads((moved / ".motionloom" / "project-memory.json").read_text(encoding="utf-8"))
+        rebound["project"]["root_path"] = str(moved.parent / "another-location")
+        (moved / ".motionloom" / "project-memory.json").write_text(json.dumps(rebound), encoding="utf-8")
+        path_only = run_memory(moved, "validate", "--json")
+        assert path_only.returncode == 0, path_only.stdout + path_only.stderr
+
+        context = json.loads((moved / "project-context.json").read_text(encoding="utf-8"))
+        context["changed_by_other_task"] = True
+        (moved / "project-context.json").write_text(json.dumps(context), encoding="utf-8")
+        stale = run_memory(moved, "refresh", "--json")
+        assert stale.returncode == 10, stale.stdout + stale.stderr
+        stale_payload = json.loads(stale.stdout)
+        assert stale_payload["freshness"]["status"] == "stale"
+
+
+def test_cross_project_recovery_is_fail_closed() -> None:
+    with tempfile.TemporaryDirectory(prefix="motionloom-project-a ") as td:
+        source = Path(td) / "source"
+        foreign = Path(td) / "foreign"
+        source.mkdir(); foreign.mkdir()
+        for root, name in ((source, "project-a"), (foreign, "project-b")):
+            (root / "package.json").write_text(json.dumps({"name": name}), encoding="utf-8")
+            (root / "project-context.json").write_text(json.dumps({"schema_version": "2.0", "name": name}), encoding="utf-8")
+        assert run_memory(source, "init").returncode == 0
+        foreign_memory = foreign / ".motionloom"
+        foreign_memory.mkdir()
+        shutil.copy2(source / ".motionloom" / "project-memory.json", foreign_memory / "project-memory.json")
+        result = run_memory(foreign, "recover")
+        assert result.returncode == 11
+        assert "identity mismatch" in result.stderr
+
+
+def test_node_cli_routes_memory_without_shell() -> None:
+    with tempfile.TemporaryDirectory(prefix="motionloom node cli ") as td:
+        root = Path(td)
+        (root / "package.json").write_text(json.dumps({"name": "node-cli-fixture"}), encoding="utf-8")
+        (root / "project-context.json").write_text(json.dumps({"schema_version": "2.0", "name": "node-cli-fixture"}), encoding="utf-8")
+        result = subprocess.run(["node", str(NODE_CLI), "memory", "init", "--project-root", str(root), "--json"], cwd=ROOT, capture_output=True, text=True, check=False)
+        assert result.returncode == 0, result.stderr
+        recover = subprocess.run(["node", str(NODE_CLI), "memory", "recover", "--project-root", str(root)], cwd=ROOT, capture_output=True, text=True, check=False)
+        assert recover.returncode == 0, recover.stderr
+        assert json.loads(recover.stdout)["project"]["name"] == "node-cli-fixture"
+
+
+if __name__ == "__main__":
+    test_memory_recovery_and_relocation()
+    test_cross_project_recovery_is_fail_closed()
+    test_node_cli_routes_memory_without_shell()
+    print("project memory contract tests: PASS")