motionloom 2.2.0 → 2.4.0

package/scripts/setup.mjs

@@ -0,0 +1,500 @@
+/**
+ * MotionLoom onboarding wizard.
+ * Style: Timeline Desk — one clear path, explicit states, no hidden side effects.
+ * The wizard is intentionally Node-only at the entrypoint so npx can explain
+ * missing Python before delegating to the canonical Python contracts.
+ */
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const PACKAGE_JSON_PATH = join(PACKAGE_ROOT, "package.json");
+const PACKAGE = JSON.parse(readFileSync(PACKAGE_JSON_PATH, "utf8"));
+const VERSION = PACKAGE.version;
+const PACKAGE_NAME = PACKAGE.name;
+const MARKER_START = "<!-- MOTIONLOOM:START -->";
+const MARKER_END = "<!-- MOTIONLOOM:END -->";
+
+function usage() {
+  console.log(`MotionLoom ${VERSION} — quick start for project-aware animation
+
+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)
+  --package-manager <name>         auto, npm, pnpm or yarn (default: auto)
+  --motionloom-root <path>         Use a local checkout instead of node_modules
+  --dry-run                        Preview commands and file changes only
+  --skip-install                   Do not install the npm package
+  --skip-memory                    Do not analyze or initialize Project Memory
+  --no-router                      Do not create or update AGENTS.md
+  --yes                            Accept safe defaults without prompting
+  --json                           Emit machine-readable JSON
+  -h, --help                      Show this help
+
+Safe defaults:
+  - local devDependency, never a global install
+  - 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", "init", "status", "repair"].includes(args[0])) action = args.shift();
+  const options = {
+    action,
+    projectRoot: process.cwd(),
+    packageManager: "auto",
+    motionloomRoot: null,
+    dryRun: false,
+    skipInstall: false,
+    skipMemory: false,
+    noRouter: false,
+    yes: false,
+    json: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === "--skip-install") {
+      options.skipInstall = true;
+      continue;
+    }
+    if (arg === "--skip-memory") {
+      options.skipMemory = true;
+      continue;
+    }
+    if (arg === "--no-router") {
+      options.noRouter = true;
+      continue;
+    }
+    if (arg === "--yes") {
+      options.yes = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+    const next = args[index + 1];
+    if (["--project-root", "--package-manager", "--motionloom-root"].includes(arg)) {
+      if (!next || next.startsWith("--")) throw new Error(`${arg} requires a value`);
+      index += 1;
+      if (arg === "--project-root") options.projectRoot = next;
+      if (arg === "--package-manager") options.packageManager = next;
+      if (arg === "--motionloom-root") options.motionloomRoot = next;
+      continue;
+    }
+    throw new Error(`unknown option: ${arg}`);
+  }
+  return options;
+}
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+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(
+    packageJson.dependencies?.[PACKAGE_NAME] ||
+      packageJson.devDependencies?.[PACKAGE_NAME] ||
+      packageJson.optionalDependencies?.[PACKAGE_NAME],
+  );
+}
+
+function detectPackageManager(root, requested) {
+  if (requested !== "auto") return requested;
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "package-lock.json"))) return "npm";
+  const packageJson = projectPackage(root);
+  const declared = String(packageJson?.packageManager || "").split("@")[0];
+  return ["npm", "pnpm", "yarn"].includes(declared) ? declared : "npm";
+}
+
+function installCommand(manager) {
+  if (manager === "pnpm") return ["pnpm", ["add", "--save-dev", `${PACKAGE_NAME}@${VERSION}`]];
+  if (manager === "yarn") return ["yarn", ["add", "--dev", `${PACKAGE_NAME}@${VERSION}`]];
+  return ["npm", ["install", "--save-dev", `${PACKAGE_NAME}@${VERSION}`]];
+}
+
+function run(program, args, cwd, capture = false) {
+  const result = spawnSync(program, args, {
+    cwd,
+    encoding: "utf8",
+    stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    env: process.env,
+  });
+  return {
+    ok: !result.error && result.status === 0,
+    status: result.status ?? 1,
+    error: result.error?.message || null,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+  };
+}
+
+function pythonRuntime() {
+  const candidates = process.platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+  for (const executable of candidates) {
+    const result = run(executable, ["--version"], process.cwd(), true);
+    if (!result.error && result.status === 0) {
+      const version = `${result.stdout}\n${result.stderr}`.match(/Python\s+(\d+)\.(\d+)\.(\d+)/i);
+      if (version) {
+        const major = Number(version[1]);
+        const minor = Number(version[2]);
+        return { executable, version: `${major}.${minor}.${version[3]}`, supported: major > 3 || (major === 3 && minor >= 11) };
+      }
+    }
+  }
+  return { executable: null, version: null, supported: false };
+}
+
+function runtimeChecks() {
+  const nodeMajor = Number(process.versions.node.split(".")[0]);
+  const python = pythonRuntime();
+  return {
+    node: { version: process.versions.node, supported: nodeMajor >= 18 },
+    python,
+  };
+}
+
+function resolveMotionLoomRoot(projectRoot, explicitRoot) {
+  if (explicitRoot) {
+    const root = resolve(explicitRoot);
+    return existsSync(join(root, "bin", "motionloom.mjs")) ? root : null;
+  }
+  const hostPackage = projectPackage(projectRoot);
+  if (hostPackage?.name === PACKAGE_NAME && existsSync(join(projectRoot, "bin", "motionloom.mjs"))) {
+    return projectRoot;
+  }
+  const local = join(projectRoot, "node_modules", PACKAGE_NAME);
+  if (existsSync(join(local, "bin", "motionloom.mjs"))) return resolve(local);
+  try {
+    const require = createRequire(import.meta.url);
+    const packageJson = require.resolve(`${PACKAGE_NAME}/package.json`, { paths: [projectRoot] });
+    const root = dirname(packageJson);
+    return existsSync(join(root, "bin", "motionloom.mjs")) ? root : null;
+  } catch {
+    return null;
+  }
+}
+
+function localCli(motionloomRoot, args, projectRoot, capture = false) {
+  return run(process.execPath, [join(motionloomRoot, "bin", "motionloom.mjs"), ...args], projectRoot, capture);
+}
+
+function routerBlock() {
+  return `${MARKER_START}
+## MotionLoom
+
+When a task involves animation, motion, assets, runtime rendering or Dev Lab review:
+
+- 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.
+- 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}`;
+}
+
+function routerState(projectRoot) {
+  const path = join(projectRoot, "AGENTS.md");
+  if (!existsSync(path)) return { status: "missing", path };
+  const text = readFileSync(path, "utf8");
+  if (text.includes(MARKER_START) && text.includes(MARKER_END)) return { status: "managed", path };
+  if (/^##\s+MotionLoom\s*$/im.test(text)) return { status: "unmarked", path };
+  return { status: "absent", path };
+}
+
+function ensureRouter(projectRoot, dryRun) {
+  const state = routerState(projectRoot);
+  const path = state.path;
+  if (state.status === "managed") {
+    const text = readFileSync(path, "utf8");
+    const pattern = new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}`, "m");
+    const updated = text.replace(pattern, routerBlock());
+    if (updated !== text && !dryRun) writeFileSync(path, updated, "utf8");
+    return { ...state, action: updated !== text ? (dryRun ? "would_update" : "updated") : "unchanged" };
+  }
+  if (state.status === "unmarked") return { ...state, action: "manual_review_required" };
+  const prefix = existsSync(path) ? `\n\n${routerBlock()}\n` : `${routerBlock()}\n`;
+  if (!dryRun) writeFileSync(path, prefix, { encoding: "utf8", flag: existsSync(path) ? "a" : "w" });
+  return { ...state, action: dryRun ? "would_create" : "created" };
+}
+
+function checkMemory(motionloomRoot, projectRoot) {
+  const result = localCli(motionloomRoot, ["memory", "validate", "--project-root", projectRoot, "--json"], projectRoot, true);
+  let payload = null;
+  try {
+    payload = JSON.parse(result.stdout);
+  } catch {
+    payload = { raw: result.stdout.trim() };
+  }
+  return { ok: result.ok, payload, stderr: result.stderr.trim() };
+}
+
+function checkDiscovery(motionloomRoot) {
+  const result = localCli(motionloomRoot, ["discovery", "check", "--root", motionloomRoot, "--json"], motionloomRoot, true);
+  let payload = null;
+  try {
+    payload = JSON.parse(result.stdout);
+  } catch {
+    payload = { raw: result.stdout.trim() };
+  }
+  return { ok: result.ok, payload, stderr: result.stderr.trim() };
+}
+
+function statusReport(options) {
+  const projectRoot = resolve(options.projectRoot);
+  const packageJson = projectPackage(projectRoot);
+  const motionloomRoot = resolveMotionLoomRoot(projectRoot, options.motionloomRoot);
+  const runtime = runtimeChecks();
+  const router = routerState(projectRoot);
+  const context = existsSync(join(projectRoot, "project-context.json"));
+  const memory = existsSync(join(projectRoot, ".motionloom", "project-memory.json"));
+  const memoryCheck = motionloomRoot && memory ? checkMemory(motionloomRoot, projectRoot) : { ok: false, payload: null };
+  const discovery = motionloomRoot ? checkDiscovery(motionloomRoot) : { ok: false, payload: null };
+  const packageInstalled = Boolean(motionloomRoot && existsSync(join(motionloomRoot, "package.json")));
+  const needsReview = Boolean(memory && !memoryCheck.ok);
+  const ready = Boolean(
+    packageInstalled &&
+      runtime.node.supported &&
+      runtime.python.supported &&
+      discovery.ok &&
+      ["managed"].includes(router.status) &&
+      context &&
+      memory &&
+      memoryCheck.ok,
+  );
+  const status = ready ? "ready" : needsReview ? "needs_review" : "needs_setup";
+  return {
+    status,
+    project_root: projectRoot,
+    package: {
+      declared: hasDependency(packageJson),
+      installed: packageInstalled,
+      version: motionloomRoot ? readJson(join(motionloomRoot, "package.json"))?.version || null : null,
+      root: motionloomRoot,
+    },
+    runtime,
+    router,
+    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.",
+    },
+  };
+}
+
+function printStatus(report, json) {
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  const label = report.status === "ready" ? "READY" : report.status === "needs_review" ? "NEEDS REVIEW" : "NEEDS 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) {
+  const projectRoot = resolve(options.projectRoot);
+  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: [],
+    warnings: [],
+    errors: [],
+  };
+  if (!packageJson) {
+    result.errors.push("package.json is missing; run this command from the root of a Node project or pass --project-root");
+    return result;
+  }
+  const runtime = runtimeChecks();
+  if (!runtime.node.supported) result.errors.push(`Node.js ${runtime.node.version} is unsupported; MotionLoom requires Node.js 18+`);
+  if (!runtime.python.supported) result.errors.push("Python 3.11+ was not found; install Python and ensure it is on PATH");
+  if (result.errors.length) {
+    result.runtime = runtime;
+    return result;
+  }
+
+  const manager = detectPackageManager(projectRoot, options.packageManager);
+  if (!["npm", "pnpm", "yarn"].includes(manager)) {
+    result.errors.push(`unsupported package manager: ${manager}`);
+    return result;
+  }
+  result.package_manager = manager;
+  let motionloomRoot = resolveMotionLoomRoot(projectRoot, options.motionloomRoot);
+  const needsInstall = !motionloomRoot || !hasDependency(packageJson);
+  if (needsInstall && options.skipInstall) {
+    result.errors.push("MotionLoom is not installed in this project; remove --skip-install or install the local devDependency first");
+    return result;
+  }
+  if (needsInstall) {
+    const [program, args] = installCommand(manager);
+    result.planned.push({ step: "install", command: [program, ...args] });
+    if (!options.dryRun) {
+      const install = run(program, args, projectRoot, options.json);
+      if (!install.ok) {
+        const detail = install.stderr.trim() || install.stdout.trim();
+        result.errors.push(detail || install.error || `package installation failed with exit code ${install.status}`);
+        return result;
+      }
+      result.changed.push("installed local MotionLoom devDependency");
+      motionloomRoot = resolveMotionLoomRoot(projectRoot, options.motionloomRoot);
+    }
+  } else {
+    result.planned.push({ step: "install", action: "already_installed" });
+  }
+  if (!motionloomRoot && !options.dryRun) {
+    result.errors.push("MotionLoom package root could not be resolved after installation");
+    return result;
+  }
+
+  if (!options.noRouter) {
+    const router = ensureRouter(projectRoot, options.dryRun);
+    if (router.action === "manual_review_required") {
+      result.warnings.push("AGENTS.md already contains an unmarked MotionLoom section; no automatic merge was attempted");
+    } else if (router.action.startsWith("would_") || ["created", "updated"].includes(router.action)) {
+      result[options.dryRun ? "planned" : "changed"].push({ step: "agent_router", action: router.action, path: relative(projectRoot, router.path) });
+    }
+  }
+
+  if (!options.skipMemory && !options.dryRun && motionloomRoot) {
+    const contextPath = join(projectRoot, "project-context.json");
+    const memoryPath = join(projectRoot, ".motionloom", "project-memory.json");
+    let bootstrap;
+    if (!existsSync(contextPath)) {
+      bootstrap = localCli(motionloomRoot, ["analyze", projectRoot, "--init-memory"], projectRoot, options.json);
+      if (bootstrap.ok) result.changed.push("analyzed project and initialized Project Memory");
+    } else if (!existsSync(memoryPath)) {
+      bootstrap = localCli(motionloomRoot, ["memory", "init", "--project-root", projectRoot, "--context-path", contextPath, "--json"], projectRoot, options.json);
+      if (bootstrap.ok) result.changed.push("initialized Project Memory from existing project context");
+    }
+    if (bootstrap && !bootstrap.ok) result.errors.push("Project Memory bootstrap failed; run `npx motionloom analyze . --init-memory` and inspect the reported project path");
+  } else if (!options.skipMemory) {
+    result.planned.push({ step: "project_memory", action: "analyze project and initialize .motionloom/project-memory.json" });
+  }
+
+  if (!options.dryRun && motionloomRoot) {
+    const report = statusReport({ ...options, projectRoot, motionloomRoot });
+    result.status = report.status;
+    result.readiness = report;
+    if (report.status === "needs_review") result.warnings.push("Project Memory exists but needs review; no destructive repair was attempted");
+    if (report.status === "needs_setup") result.warnings.push("Setup completed partially; run `npx motionloom status --json` for the exact missing item");
+  } else {
+    result.status = "planned";
+    result.planned.push({ step: "verification", action: "run discovery check, validate memory and print readiness" });
+  }
+  return result;
+}
+
+function printSetup(result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const label = result.status === "ready" ? "READY" : result.status === "planned" ? "DRY RUN" : result.status === "needs_review" ? "NEEDS REVIEW" : "BLOCKED";
+  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("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 same safe quick start.");
+  } else {
+    console.log("Next: run `npx --no-install motionloom status --json` for details, then resolve the reported setup item.");
+  }
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    usage();
+    return 0;
+  }
+  if (options.action === "status") {
+    const report = statusReport(options);
+    printStatus(report, options.json);
+    return report.status === "ready" ? 0 : report.status === "needs_review" ? 10 : 11;
+  }
+  const result = setup(options);
+  printSetup(result, options.json);
+  return ["ready", "planned"].includes(result.status) ? 0 : result.status === "needs_review" ? 10 : 11;
+}
+
+try {
+  process.exitCode = main();
+} catch (error) {
+  console.error(`MotionLoom onboarding failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 2;
+}

package/scripts/skill-doctor.py

@@ -22,6 +22,7 @@ REQUIRED_SCRIPT_FILES = [
     "scripts/project_memory_loader.py",
     "scripts/analyze.py",
     "scripts/devlab.py",
+    "scripts/setup.mjs",
 ]
 REQUIRED_SCHEMAS = [
     "task.schema.json",
@@ -131,7 +132,7 @@ def run() -> int:
     package_path = ROOT / "package.json"
     try:
         package = json.loads(package_path.read_text(encoding="utf-8"))
-        for script in ("test", "validate", "doctor", "report", "report:check", "review", "memory:bootstrap", "memory:recover", "memory:validate", "devlab", "pack:dotlottie"):
+        for script in ("test", "validate", "doctor", "setup", "setup:dry", "status", "repair", "report", "report:check", "review", "memory:bootstrap", "memory:recover", "memory:validate", "devlab", "pack:dotlottie"):
             if script not in package.get("scripts", {}):
                 warnings.append({"code": "missing_package_script", "message": f"package.json has no {script} script."})
     except (FileNotFoundError, json.JSONDecodeError) as exc:

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

@@ -0,0 +1,77 @@
+{
+  "schema_version": "1.0",
+  "provenance_id": "browser-review-smoke-asset-provenance",
+  "task_id": "browser-review-smoke-task",
+  "scene": "browser-review-smoke",
+  "created_at": "2026-08-14T00:00:00Z",
+  "asset": {
+    "id": "browser-review-smoke-animation",
+    "path": "animation.json",
+    "type": "deterministic-fixture",
+    "framework": "lottie",
+    "version": "fixture-2.2.0"
+  },
+  "authority": "ai_assisted_human_reviewed",
+  "readiness": "production_eligible",
+  "generator": {
+    "model": "motionloom-deterministic-fixture-builder",
+    "task_id": "browser-review-smoke-task",
+    "source": "repository-fixture",
+    "generated_at": "2026-08-14T00:00:00Z",
+    "agent": "motionloom-ci"
+  },
+  "human_review": {
+    "reviewer": "MotionLoom fixture maintainer",
+    "decision": "approved",
+    "scope": "deterministic runtime and contract fixture, not production art approval",
+    "reviewed_at": "2026-08-14T00:00:00Z",
+    "user_confirmed": true,
+    "notes": "The fixture is eligible for repository CI and PR evidence; final product approval remains outside this artifact."
+  },
+  "license": {
+    "spdx": "MIT",
+    "source": "MotionLoom repository fixture",
+    "attribution": "MotionLoom deterministic browser-review smoke fixture."
+  },
+  "files": [
+    {
+      "path": "animation.json",
+      "role": "runtime-scene",
+      "sha256": "c5ab312427678b17ae903d280d89db9d202670f031f10ad6fe774fc9aaecee8a"
+    }
+  ],
+  "provenance_chain": [
+    {
+      "step": "generate",
+      "actor": "agent:motionloom-ci",
+      "source": "repository-fixture",
+      "timestamp": "2026-08-14T00:00:00Z"
+    },
+    {
+      "step": "runtime-test",
+      "actor": "runtime:lottie",
+      "source": "browser-review-smoke runtime evidence",
+      "timestamp": "2026-08-14T00:00:00Z"
+    },
+    {
+      "step": "human-review",
+      "actor": "user:fixture-maintainer",
+      "source": "deterministic fixture review boundary",
+      "timestamp": "2026-08-14T00:00:00Z"
+    }
+  ],
+  "runtime_evidence": {
+    "status": "pass",
+    "runtime": "lottie-runtime",
+    "tested_at": "2026-08-14T00:00:00Z",
+    "evidence_path": "snapshot/.render-meta.json"
+  },
+  "full_gate": {
+    "status": "pass",
+    "quality_gate": "pass",
+    "visual_truth": "pass",
+    "license": "pass",
+    "checked_at": "2026-08-14T00:00:00Z",
+    "report_path": "artifacts/browser-review-smoke-task/quality-report.json"
+  }
+}

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

@@ -5,6 +5,7 @@
   "category": "loading",
   "file": "animation.json",
   "visual_truth": "visual-truth.json",
+  "asset_provenance": "asset-provenance.json",
   "source_binding": {
     "kind": "fixture",
     "source_path": "animation.json",

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

@@ -1,7 +1,7 @@
 {
   "schema_version": "1.0",
   "contract": "motionloom-visual-truth",
-  "generated_at": "2026-08-13T13:53:38.679496Z",
+  "generated_at": "2026-08-13T17:17:31.327320Z",
   "status": "review_required",
   "scene": "browser-review-smoke",
   "task_id": "browser-review-smoke-task",
@@ -51,9 +51,9 @@
     "source_path": "src/output/browser-review-smoke/animation.json",
     "source_sha256": "c5ab312427678b17ae903d280d89db9d202670f031f10ad6fe774fc9aaecee8a",
     "manifest_path": "src/output/browser-review-smoke/manifest.json",
-    "manifest_sha256": "467fea255a18efb8687e78a1a60662ad30d4fa6f77d9c3f3878196f3c5e670ad",
+    "manifest_sha256": "8d1e07c81dbbcbcc060415ac71dfcae7ce88f2e7aa91347b226dbf4f554e5623",
     "runtime_evidence_path": "artifacts/browser-review-smoke-task/runtime-adapters/runtime-evidence.json",
-    "runtime_evidence_sha256": "2d51a37dbd1962c3f8539fed53fd5709448da55f2b00f2ceb37dfd8a55d0d716",
+    "runtime_evidence_sha256": "88194b8ed8e8eb9780a80bc55114b9cf52886c911b70a7f4331c18fa39a9b090",
     "motion_ir_path": "artifacts/browser-review-smoke-task/motion-ir.json",
     "motion_ir_sha256": "bdb2305737e5dee9b9ee078dd5657a4a5717bf4184f112a1d01ac82361c5a23f",
     "runtime_status": "pass",

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"
+    }
+  ]
+}