motionloom 2.0.0 → 2.1.0

package/src/core/analyzer.py

@@ -10,9 +10,12 @@ in this context, never in assumptions.
 """
 
 import argparse
+import fnmatch
 import json
+import os
 import re
 import sys
+import time
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -80,6 +83,112 @@ CATEGORIES = {
     },
 }
 
+DEFAULT_IGNORE_DIRS = {
+    ".git",
+    ".hg",
+    ".svn",
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".motionloom",
+    "target",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    "coverage",
+}
+
+
+class ScanBudget:
+    """Bound repository traversal without hiding that the scan was partial."""
+
+    def __init__(
+        self,
+        root: Path,
+        *,
+        max_files: int | None = 2500,
+        max_bytes: int | None = 25_000_000,
+        max_seconds: float | None = 10.0,
+        ignore_dirs: set[str] | None = None,
+        ignore_globs: list[str] | None = None,
+    ) -> None:
+        self.root = root
+        self.max_files = max_files
+        self.max_bytes = max_bytes
+        self.max_seconds = max_seconds
+        self.ignore_dirs = set(DEFAULT_IGNORE_DIRS) | set(ignore_dirs or ())
+        self.ignore_globs = list(ignore_globs or [])
+        self.started = time.monotonic()
+        self.files_scanned = 0
+        self.bytes_scanned = 0
+        self.truncated = False
+        self.truncation_reasons: list[str] = []
+
+    def _mark(self, reason: str) -> None:
+        self.truncated = True
+        if reason not in self.truncation_reasons:
+            self.truncation_reasons.append(reason)
+
+    def _relative(self, path: Path) -> str:
+        return path.relative_to(self.root).as_posix()
+
+    def _ignored(self, path: Path) -> bool:
+        relative = self._relative(path)
+        if any(part in self.ignore_dirs for part in path.relative_to(self.root).parts):
+            return True
+        return any(fnmatch.fnmatch(relative, pattern) for pattern in self.ignore_globs)
+
+    def _limited(self, next_size: int = 0) -> bool:
+        if self.max_files is not None and self.files_scanned >= self.max_files:
+            self._mark("max_files")
+            return True
+        if self.max_bytes is not None and self.bytes_scanned + next_size > self.max_bytes:
+            self._mark("max_bytes")
+            return True
+        if self.max_seconds is not None and time.monotonic() - self.started >= self.max_seconds:
+            self._mark("max_seconds")
+            return True
+        return False
+
+    def files(self, suffixes: set[str] | None = None):
+        """Yield readable candidate files in stable order until a budget is hit."""
+        for directory, dirnames, filenames in os.walk(self.root, topdown=True):
+            directory_path = Path(directory)
+            dirnames[:] = sorted(
+                name for name in dirnames
+                if not self._ignored(directory_path / name)
+            )
+            for filename in sorted(filenames):
+                path = directory_path / filename
+                if self._ignored(path):
+                    continue
+                if suffixes and path.suffix.lower() not in suffixes:
+                    continue
+                try:
+                    size = path.stat().st_size
+                except OSError:
+                    continue
+                if self._limited(size):
+                    return
+                self.files_scanned += 1
+                self.bytes_scanned += size
+                yield path
+
+    def summary(self) -> dict:
+        return {
+            "max_files": self.max_files,
+            "max_bytes": self.max_bytes,
+            "max_seconds": self.max_seconds,
+            "files_scanned": self.files_scanned,
+            "bytes_scanned": self.bytes_scanned,
+            "ignored_directories": sorted(self.ignore_dirs),
+            "ignore_globs": self.ignore_globs,
+            "scan_truncated": self.truncated,
+            "truncation_reasons": self.truncation_reasons,
+        }
+
 
 def read_json(path: Path):
     try:
@@ -91,15 +200,25 @@ def read_json(path: Path):
 def detect_stack(project_root: Path, pkg: dict | None) -> dict:
     stack = {"framework": None, "react": False, "vue": False, "react_native": False, "native_web": False}
     deps = set()
+    package_name = ""
     if pkg:
+        package_name = str(pkg.get("name", "")).lower()
         deps.update(pkg.get("dependencies", {}).keys())
         deps.update(pkg.get("devDependencies", {}).keys())
     stack["react"] = bool({"react", "next", "framer-motion"} & deps)
     stack["vue"] = bool({"vue", "nuxt"} & deps)
     stack["react_native"] = bool({"react-native"} & deps)
     stack["native_web"] = bool({"lottie-web", "dotlottie-web", "gsap", "animejs"} & deps)
-    if "framer-motion" in deps:
+    # Prefer the package's own identity over a transitive/dev dependency in a
+    # monorepo. This prevents Motion One from being labeled GSAP merely
+    # because its root workspace uses GSAP for tests or tooling, and lets
+    # Rive packages expose a distinct runtime signal.
+    if package_name in {"motion", "motion-one"}:
+        stack["framework"] = "motion"
+    elif package_name == "framer-motion" or "framer-motion" in deps:
         stack["framework"] = "framer-motion"
+    elif package_name.startswith("rive") or any("rive" in dependency.lower() for dependency in deps):
+        stack["framework"] = "rive"
     elif "gsap" in deps:
         stack["framework"] = "gsap"
     elif "dotlottie-web" in deps or "lottie-web" in deps or "@lottiefiles/react-lottie-player" in deps:
@@ -113,7 +232,7 @@ def detect_stack(project_root: Path, pkg: dict | None) -> dict:
     return stack
 
 
-def extract_brand_tokens(project_root: Path) -> dict:
+def extract_brand_tokens(project_root: Path, scanner: ScanBudget | None = None) -> dict:
     tokens = {"primary": None, "accent": None, "palette": [], "fonts": []}
     # Tailwind config
     for candidate in ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs"]:
@@ -126,7 +245,7 @@ def extract_brand_tokens(project_root: Path) -> dict:
                 tokens["accent"] = m.group(1).upper()
     # package.json theme / CSS variables
     css_vars = {}
-    css_files = list(project_root.rglob("*.css")) + list(project_root.rglob("*.scss"))
+    css_files = list(scanner.files({".css", ".scss"})) if scanner else list(project_root.rglob("*.css")) + list(project_root.rglob("*.scss"))
     for f in css_files[:20]:
         text = f.read_text(encoding="utf-8", errors="ignore")
         for m in re.finditer(r"--([a-z0-9-]+):\s*(#[0-9a-fA-F]{3,8})", text):
@@ -137,14 +256,13 @@ def extract_brand_tokens(project_root: Path) -> dict:
     return tokens
 
 
-def detect_motion_language(project_root: Path) -> dict:
+def detect_motion_language(project_root: Path, scanner: ScanBudget | None = None) -> dict:
     """Gather existing easing/duration conventions from the project."""
     easings = set()
     durations = set()
-    for pattern in ("*.ts", "*.tsx", "*.js", "*.jsx", "*.css"):
-        for f in project_root.rglob(pattern):
-            if "node_modules" in f.parts:
-                continue
+    suffixes = {".ts", ".tsx", ".js", ".jsx", ".css"}
+    files = scanner.files(suffixes) if scanner else (f for suffix in suffixes for f in project_root.rglob(f"*{suffix}"))
+    for f in files:
             try:
                 text = f.read_text(encoding="utf-8", errors="ignore")
             except OSError:
@@ -160,30 +278,47 @@ def detect_motion_language(project_root: Path) -> dict:
     }
 
 
-def find_existing_animations(project_root: Path) -> list:
+def find_existing_animations(project_root: Path, scanner: ScanBudget | None = None) -> list:
     found = []
-    for ext in ("*.lottie", "*.json", "*.riv"):
-        for f in project_root.rglob(ext):
-            rel = str(f.relative_to(project_root))
-            if "node_modules" in rel or ".git" in rel:
+    suffixes = {".lottie", ".json", ".riv"}
+    files = scanner.files(suffixes) if scanner else (
+        f for suffix in (".lottie", ".json", ".riv") for f in project_root.rglob(f"*{suffix}")
+    )
+    for f in files:
+        rel = f.relative_to(project_root).as_posix()
+        if f.suffix.lower() == ".json":
+            text = f.read_text(encoding="utf-8", errors="ignore")[:200]
+            if '"v"' not in text and "anim" not in text.lower():
                 continue
-            if ext == "*.json":
-                text = f.read_text(encoding="utf-8", errors="ignore")[:200]
-                if '"v"' not in text and "anim" not in text.lower():
-                    continue
-            found.append(rel)
-            if len(found) >= 15:
-                return found
+        found.append(rel)
+        if len(found) >= 15:
+            return found
     return found
 
 
-def analyze(project_root: str) -> dict:
+def analyze(
+    project_root: str,
+    *,
+    max_files: int | None = 2500,
+    max_bytes: int | None = 25_000_000,
+    max_seconds: float | None = 10.0,
+    ignore_dirs: list[str] | None = None,
+    ignore_globs: list[str] | None = None,
+) -> dict:
     root = Path(project_root).resolve()
+    scanner = ScanBudget(
+        root,
+        max_files=max_files,
+        max_bytes=max_bytes,
+        max_seconds=max_seconds,
+        ignore_dirs=ignore_dirs,
+        ignore_globs=ignore_globs,
+    )
     pkg = read_json(root / "package.json")
     manifest = read_json(root / "project-manifest.json")
     readme = (root / "README.md").read_text(encoding="utf-8", errors="ignore")[:3000] if (root / "README.md").exists() else ""
 
-    brand = extract_brand_tokens(root)
+    brand = extract_brand_tokens(root, scanner)
     # project-manifest.json is the explicit project contract and therefore
     # overrides inferred values from Tailwind/CSS when both are present.
     manifest_brand = (manifest or {}).get("brand") or {}
@@ -198,8 +333,10 @@ def analyze(project_root: str) -> dict:
         "description": (manifest or {}).get("description") or (pkg or {}).get("description") or "",
         "stack": detect_stack(root, pkg),
         "brand": brand,
-        "motion_language": detect_motion_language(root),
-        "existing_animations": find_existing_animations(root),
+        "motion_language": detect_motion_language(root, scanner),
+        "existing_animations": find_existing_animations(root, scanner),
+        "scan": scanner.summary(),
+        "scan_truncated": scanner.truncated,
         "manifest_overrides": manifest or {},
         "source_authority": "project-manifest.json then assets/library/, never invented geometry",
     }
@@ -210,11 +347,23 @@ def main():
     parser = argparse.ArgumentParser(description="Analyze a host project and emit its binding context.")
     parser.add_argument("project_root", nargs="?", default=".")
     parser.add_argument("--output", help="Context path; defaults to <project_root>/project-context.json")
+    parser.add_argument("--max-files", type=int, default=2500)
+    parser.add_argument("--max-bytes", type=int, default=25_000_000)
+    parser.add_argument("--max-seconds", type=float, default=10.0)
+    parser.add_argument("--ignore-dir", action="append", default=[])
+    parser.add_argument("--ignore-glob", action="append", default=[])
     args = parser.parse_args()
     root = Path(args.project_root).resolve()
     if not root.is_dir():
         parser.error(f"project root is not a directory: {root}")
-    ctx = analyze(str(root))
+    ctx = analyze(
+        str(root),
+        max_files=args.max_files,
+        max_bytes=args.max_bytes,
+        max_seconds=args.max_seconds,
+        ignore_dirs=args.ignore_dir or None,
+        ignore_globs=args.ignore_glob or None,
+    )
     out = Path(args.output).resolve() if args.output else root / "project-context.json"
     out.parent.mkdir(parents=True, exist_ok=True)
     out.write_text(json.dumps(ctx, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")

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([
@@ -815,10 +854,22 @@ 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,
+    )
+
 
 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()

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")