motionloom 2.0.0 → 2.1.0

package/SKILL.md

@@ -7,30 +7,48 @@ description: >-
   validate, review, or deliver animation inside an existing project.
 license: MIT
 metadata:
-  version: "2.0.0"
+  version: "2.1.0"
   target_frameworks: "lottie,dotlottie,rive,gsap,framer-motion,spine,threejs"
   verified_runtimes: "lottie-json,dotlottie-package,svg-cutout-rig,rive,gsap,framer-motion"
 ---
 
 # MotionLoom Skill
 
+> Public repository: [github.com/lenhonbp/MotionLoom](https://github.com/lenhonbp/MotionLoom) · npm: [motionloom](https://www.npmjs.com/package/motionloom) · release navigation: [CHANGELOG.md](CHANGELOG.md) · future work: [ROADMAP.md](ROADMAP.md)
+
 Treat every animation request as a production task, not as an isolated asset-generation prompt. Always bind the work to the host project's context, emit machine-readable artifacts, render through the target runtime, expose review evidence in Dev Lab, and stop before commit when a required gate or user confirmation is missing.
 
 ## Required workflow
 
-1. **Understand** — read the host project manifest and run `bash scripts/analyze.sh <project-path>`. Load `project-context.json` from the audited project. If context is missing or ambiguous, stop at `needs_context`.
+1. **Understand** — read the host project manifest and run `motionloom analyze <project-path> --init-memory` (or `python scripts/analyze.py <project-path> --init-memory` in a repository checkout). Load `project-context.json` and `.motionloom/project-memory.json` from the audited project. If context is missing, stale or ambiguous, stop at `needs_context` and refresh before generation.
 2. **Plan** — classify the animation, select a framework, and generate a context-bound `motion-spec.json` with timing, easing, loop, accessibility, performance and source authority.
 3. **Source** — resolve an authoritative asset from the project or `assets/library/`. Record attribution, license and checksum in the scene manifest's required `source_binding`; the binding's SHA-256 must match the bytes referenced by `manifest.file`. Do not promote an unknown or placeholder asset to production.
 4. **Generate** — use the matching template or rig implementation. For body animation, preserve named anatomy, pivot and parent-first hierarchy.
-5. **Render** — run `bash scripts/render.sh <scene>` for scene output, or `node scripts/runtime-adapters.mjs` for the verified Rive/GSAP/Framer Motion adapter matrix. Acceptance requires runtime evidence at 0/50/100%, not a static placeholder. Keep the render metadata beside the snapshots.
+5. **Render** — run the platform-neutral Node entrypoint for scene output, or `node scripts/runtime-adapters.mjs` for the verified Rive/GSAP/Framer Motion adapter matrix. Acceptance requires runtime evidence at 0/50/100%, not a static placeholder. Keep the render metadata beside the snapshots.
 6. **Bind Intelligence Core** — build a framework-neutral `motion-ir.json`, `project-graph.json`, `provenance.json`, `replay-bundle.json`, `semantic-lint-report.json` and `semantic-lint-benchmark.json` with `python3 scripts/intelligence.py`. Select only a capability registry entry whose status is `verified`, whose evidence is fresh and whose compatibility matches the target environment. A confidence score or benchmark result can prioritize investigation; neither can replace deterministic or human acceptance.
 6a. **Harden the trust boundary** — keep artifact and task bundles inside the repository/task root, reject symlinked evidence, bind replay to its exact `task_dir`, `task_id` and scene, select one deterministic report bundle per scene, and require browser candidate/review identity and expiry checks before readiness. The Dev Lab must reject cross-origin or identity-mismatched artifact bases. In strict runtime-observability runs, capture `runtime-telemetry.json` and a read-only `evidence-verifier-report.json`; verifier output must preserve `approval: false`. These checks expose risk and prevent evidence mixing, but do not turn heuristics or evidence integrity into approval.
 6b. **Attest** — derive a canonical statement from the exact scene/task hashes, sign it with an Ed25519 key through `scripts/attestation.py`, and verify it with the independent `scripts/attestation-verifier.py` against a fail-closed `trust-policy.json`. DSSE/SLSA-compatible attestation proves signer and binding integrity only; `approval` must remain `false` and never replaces user review.
 7. **Browser review handoff** — run `python3 scripts/review-hook.py prepare --task-dir artifacts/<task-id> --lab-url <internal-lab-url>`. The hook prepares the exact candidate and emits a JSON action for a browser-capable Agent. Trigger or suggest that Agent to open the emitted URL, inspect frames 0/50/100, scrub the timeline and ask the user to review. This is not a separate Dev Lab Skill; it is a required post-render handoff.
 8. **Review capture** — the browser Agent calls `window.__lab.getReview()` after the user approves or requests changes, then persists it with `python3 scripts/report.py review --task-dir artifacts/<task-id> --candidate-id <id> --decision approved|changes_requested --reviewer user`. A change request returns to generation; no approval means no PR.
-9. **Validate** — run `python3 scripts/review-hook.py validate --task-dir artifacts/<task-id>`, `python3 scripts/intelligence.py semantic-lint benchmark --task-dir artifacts/<task-id> --iterations 25 --threshold-ms 500`, `bash scripts/capture-runtime-telemetry.sh <scene> artifacts/<task-id>`, the independent attestation verifier, `python3 scripts/report-contract.py --root . --scenes-file <changed-scenes> --require-attestation`, `python3 scripts/quality-gate.py --scene <scene> --context <context-path> --task-dir artifacts/<task-id> --require-intelligence --require-p1 --require-benchmark --require-telemetry --require-attestation`, and `python3 scripts/skill-doctor.py --json` when validating the Skill package itself.
+9. **Validate** — run `motionloom review-hook validate --task-dir artifacts/<task-id>`, `motionloom intelligence semantic-lint benchmark --task-dir artifacts/<task-id> --iterations 25 --threshold-ms 500`, `motionloom runtime-telemetry <scene> artifacts/<task-id>`, the independent attestation verifier, `motionloom report-contract --root . --scenes-file <changed-scenes> --require-attestation`, `motionloom quality-gate --scene <scene> --context <context-path> --task-dir artifacts/<task-id> --require-intelligence --require-p1 --require-benchmark --require-telemetry --require-attestation`, and `motionloom doctor --json` when validating the Skill package itself.
 10. **Report** — create or update an artifact bundle with `python3 scripts/report.py`. Record facts with `report.py add`, structural defects with `report.py structure`, collect checksums with `report.py collect`, and run `report.py check` before rendering the final report. The final report must state completed, verified, not completed, blocked/failed, structure problems, browser candidate/review evidence and the recommended next Agent/Skill.
-11. **Confirm** — only after approved browser review and a passing quality gate run `TASK_DIR=artifacts/<task-id> bash scripts/pr.sh <scene>`. Commit, push and open PR are explicit side effects.
+11. **Confirm** — only after approved browser review and a passing quality gate run the platform-neutral PR preparation command. Commit, push and open PR are explicit side effects.
+
+## Durable Project Memory
+
+MotionLoom does not treat chat history as durable project memory. At the beginning of an animation task, load `.motionloom/project-memory.json`, validate its project identity and freshness, then recover the current project context. The memory records motion principles, asset/runtime policy, accepted and rejected decisions, user-confirmed remediation outcomes and invalidation metadata. It must remain task/project-bound and must never be copied across projects merely because the files look similar.
+
+Use the cross-platform CLI surface:
+
+```text
+motionloom memory init --project-root <project>
+motionloom memory inspect --project-root <project> --json
+motionloom memory refresh --project-root <project> --json
+motionloom memory recover --project-root <project> --json
+motionloom memory validate --project-root <project> --json
+```
+
+Only user-confirmed decisions and outcomes may become durable remediation memory. A stale or mismatched memory must produce a machine-readable failure/recovery state; it must not silently influence generation or approval. Ubuntu, macOS and Windows are supported through the Node CLI wrapper and Python path APIs. Do not require Bash, fixed `/tmp` paths, POSIX separators or system `zip`/`unzip` in the npm command surface.
 
 ## Progressive disclosure
 
@@ -70,12 +88,19 @@ Every production `src/output/<scene>/manifest.json` must include a `source_bindi
 The Intelligence Core contracts are defined in `schemas/project-graph.schema.json`, `schemas/provenance.schema.json`, `schemas/capability-registry.schema.json`, `schemas/motion-ir.schema.json`, `schemas/signed-attestation.schema.json` and `schemas/trust-policy.schema.json`. They make project relationships, supply-chain steps, runtime selection, framework-neutral intent and signer trust inspectable without relying on prose.
 
 ```bash
-# Package a Lottie JSON scene as a dotLottie v2 archive.
-bash scripts/to-dotlottie.sh <scene> [output.lottie]
+# Package a Lottie JSON scene as a dotLottie v2 archive (Node/fflate; no system zip required).
+node scripts/to-dotlottie.mjs --scene-dir src/output/<scene> --output src/output/<scene>/animation.lottie
+
+# Initialize and recover durable project memory.
+motionloom memory init --project-root <project-path>
+motionloom memory recover --project-root <project-path> --json
 
 # Run the official runtime adapters in a real browser harness.
 node scripts/runtime-adapters.mjs
 
+# Capture and verify runtime telemetry without Bash dependencies.
+motionloom runtime-telemetry <scene> artifacts/<task-id>
+
 # Build the task-bound Intelligence Core artifacts.
 python3 scripts/intelligence.py motion-ir build --task-dir artifacts/<task-id>
 python3 scripts/intelligence.py graph build --task-dir artifacts/<task-id>
@@ -96,7 +121,7 @@ python3 scripts/attestation-verifier.py --attestation artifacts/<task-id>/attest
 
 `runtime-evidence.json` records the runtime package, three scrub points, observed state and generated snapshots. A template alone is never enough to upgrade a framework from `scaffold_only` to `verified`.
 
-For an observability-enabled run, `bash scripts/capture-runtime-telemetry.sh <scene> artifacts/<task-id>` regenerates the real-browser evidence and writes telemetry under the task bundle. `scripts/evidence-verifier.py` then checks task/scene/hash/path/age bindings with stable machine-readable output. A verifier pass means the evidence is internally consistent; it does not mean the animation is approved.
+For an observability-enabled run, use the platform-neutral runtime telemetry entrypoint exposed by the package. It regenerates the real-browser evidence and writes telemetry under the task bundle. `scripts/evidence-verifier.py` then checks task/scene/hash/path/age bindings with stable machine-readable output. A verifier pass means the evidence is internally consistent; it does not mean the animation is approved.
 
 ## Output contract
 

package/SUPPORT.md

@@ -0,0 +1,23 @@
+# Support
+
+MotionLoom is a public Agent Skill and npm package. Start with the [README](README.md), [SKILL.md](SKILL.md), [production checklist](docs/CHECKLIST.md), [framework selection guide](docs/FRAMEWORK-SELECTION.md) and [runtime capability reference](references/runtime-capability.md).
+
+## Choose the right channel
+
+| Situation | Use |
+|---|---|
+| A reproducible defect in code, schema, CLI or runtime adapter | [Bug report](https://github.com/lenhonbp/MotionLoom/issues/new?template=bug_report.yml) |
+| A proposed capability or workflow improvement | [Feature request](https://github.com/lenhonbp/MotionLoom/issues/new?template=feature_request.yml) |
+| A security or privacy concern | [SECURITY.md](SECURITY.md), never a public issue with exploit details |
+| A documentation correction | Open a small pull request or use a documentation issue |
+| A usage question | Search the README/docs first, then open an issue with the exact command and environment if no answer exists |
+
+## Troubleshooting order
+
+Run `motionloom doctor --json`, confirm Node/Python versions, inspect the JSON exit code, check that the task bundle and project context belong to the same project, and rerun the smallest relevant contract test. A `needs_context`, `stale`, `invalid` or `blocked` state is an actionable result, not an invitation to bypass the gate.
+
+When asking for help, include sanitized command output, the operating system, package version, runtime/framework, task state and a minimal fixture. Do not upload `.motionloom/project-memory.json`, private project context, private assets, credentials, signing keys or browser session data unless they are synthetic and safe to share.
+
+## Maintainer response
+
+The project is maintained on a best-effort basis. A response may request a reproducible fixture or a contract-level test before implementation. Feature requests are evaluated against the [roadmap](ROADMAP.md), user-control principles and the project's ability to produce verifiable runtime evidence.

package/agent-card.json

@@ -1,10 +1,17 @@
 {
   "card_version": "1.0",
   "name": "motionloom",
-  "version": "2.0.0",
-  "description": "Project-aware animation production with graph, provenance, framework-neutral motion IR, runtime verification and telemetry, DSSE-compatible signed attestation, external evidence verification, semantic feedback, continuity checks, internal browser review, trust-boundary hardening and deterministic Agent handoff.",
+  "version": "2.1.0",
+  "description": "Project-aware animation production with durable Project Memory, graph, provenance, framework-neutral motion IR, runtime verification and telemetry, DSSE-compatible signed attestation, external evidence verification, semantic feedback, continuity checks, internal browser review, trust-boundary hardening and deterministic Agent handoff.",
   "capabilities": [
     "project.analyze",
+    "project.memory.init",
+    "project.memory.inspect",
+    "project.memory.refresh",
+    "project.memory.recover",
+    "project.memory.validate",
+    "project.memory.record-decision",
+    "project.memory.record-outcome",
     "project.graph.build",
     "project.graph.validate",
     "motion.plan",
@@ -80,6 +87,7 @@
     "semantic-lint-report",
     "semantic-lint-benchmark",
     "hardening-audit-report",
+    "project-memory",
     "continuity-report",
     "fix-plan",
     "pr-patch"
@@ -124,16 +132,23 @@
     }
   ],
   "entrypoints": {
-    "analyze": "bash scripts/analyze.sh <project-path>",
+    "analyze": "motionloom analyze <project-path> --init-memory",
+    "memory_init": "motionloom memory init --project-root <project-path>",
+    "memory_inspect": "motionloom memory inspect --project-root <project-path> --json",
+    "memory_refresh": "motionloom memory refresh --project-root <project-path> --json",
+    "memory_recover": "motionloom memory recover --project-root <project-path> --json",
+    "memory_validate": "motionloom memory validate --project-root <project-path> --json",
+    "memory_decision": "motionloom memory record-decision --project-root <project-path> --id <id> --status accepted|rejected --summary <summary> --user-confirmed",
+    "memory_outcome": "motionloom memory record-outcome --project-root <project-path> --id <id> --result <result> --user-confirmed",
     "report_init": "python3 scripts/report.py init --task-id <id>",
     "report_collect": "python3 scripts/report.py collect --task-dir <dir>",
     "report_render": "python3 scripts/report.py render --task-dir <dir>",
     "skill_doctor": "python3 scripts/skill-doctor.py --json",
     "quality_gate": "python3 scripts/quality-gate.py --scene <scene> --context <path>",
     "manifest_bind_source": "python3 scripts/manifest.py bind-source --scene <scene> --source <file> --kind <kind> --authority <authority> --license <license>",
-    "dotlottie_package": "bash scripts/to-dotlottie.sh <scene> [output.lottie]",
+    "dotlottie_package": "motionloom manifest package-dotlottie --scene <scene> [--output <output.lottie>]",
     "runtime_adapter_test": "node scripts/runtime-adapters.mjs",
-    "runtime_telemetry": "bash scripts/capture-runtime-telemetry.sh <scene> artifacts/<task-id>",
+    "runtime_telemetry": "node scripts/capture-runtime-telemetry.mjs <scene> artifacts/<task-id>",
     "evidence_verify": "python3 scripts/evidence-verifier.py --scene-dir src/output/<scene> --task-dir artifacts/<task-id> --runtime-evidence runtime-adapters/runtime-evidence.json --max-age-days 1 --output artifacts/<task-id>/evidence-verifier-report.json",
     "intelligence_graph": "python3 scripts/intelligence.py graph build --task-dir artifacts/<task-id>",
     "intelligence_provenance": "python3 scripts/intelligence.py provenance build --task-dir artifacts/<task-id>",
@@ -152,7 +167,7 @@
     "quality_gate_attestation": "python3 scripts/quality-gate.py --scene <scene> --context <path> --task-dir artifacts/<task-id> --require-browser-review --require-intelligence --require-p1 --require-benchmark --require-telemetry --require-attestation",
     "browser_review_prepare": "python3 scripts/review-hook.py prepare --task-dir artifacts/<task-id> --lab-url <internal-lab-url>",
     "browser_review_validate": "python3 scripts/review-hook.py validate --task-dir artifacts/<task-id>",
-    "pr_prepare": "bash scripts/pr.sh <scene>"
+    "pr_prepare": "node scripts/pr.mjs <scene>"
   },
   "report_contract": {
     "required_sections": ["completed", "verified", "not_completed", "problems", "structure_review", "next_agent", "browser_review"],

package/bin/motionloom.mjs

@@ -2,7 +2,7 @@
 /**
  * MotionLoom npm entrypoint.
  * Style: Timeline Desk — terse command routing, explicit evidence verbs and
- * no hidden approval side effects. The CLI delegates to the shipped Python
+ * no hidden approval side effects. The CLI delegates to shipped Python/Node
  * contracts so npm installation and repository execution use one surface.
  */
 import { fileURLToPath } from "node:url";
@@ -13,8 +13,10 @@ const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const PYTHON = process.env.MOTIONLOOM_PYTHON || (process.platform === "win32" ? "python" : "python3");
 
 const PYTHON_COMMANDS = {
-  analyze: "scripts/analyze.sh",
+  analyze: "scripts/analyze.py",
+  memory: "scripts/project-memory.py",
   attestation: "scripts/attestation.py",
+  "attestation-keygen": "scripts/attestation-keygen.py",
   "verify-attestation": "scripts/attestation-verifier.py",
   doctor: "scripts/skill-doctor.py",
   intelligence: "scripts/intelligence.py",
@@ -24,19 +26,26 @@ const PYTHON_COMMANDS = {
   "report-contract": "scripts/report-contract.py",
   report: "scripts/report.py",
   "review-hook": "scripts/review-hook.py",
+  devlab: "scripts/devlab.py",
+  "runtime-telemetry": "scripts/capture-runtime-telemetry.py",
+  render: "scripts/render.py",
+  pr: "scripts/pr.py",
   "validate-lottie": "scripts/validate-lottie.py",
   manifest: "scripts/manifest.py",
+  test: "tests/scripts/run_tests.py",
+  "deep-audit": "tests/scripts/deep-stress.py",
 };
 
 function printHelp() {
-  console.log(`MotionLoom 2.0.0 — project-aware animation production and evidence contracts
+  console.log(`MotionLoom 2.1.0 — project-aware animation production and evidence contracts
 
 Usage:
   motionloom <command> [args...]
 
 Commands:
   doctor                 Validate the installed Skill package
-  analyze                Run project analysis (delegates to scripts/analyze.sh)
+  analyze                Run project analysis and refresh Project Memory
+  memory                 Initialize, inspect, refresh, recover or validate memory
   intelligence           Build or validate Intelligence Core artifacts
   attestation            Build/validate canonical signed-attestation artifacts
   verify-attestation     Verify an attestation against a trust policy
@@ -44,11 +53,20 @@ Commands:
   quality-gate           Run the strict scene acceptance gate
   report-contract        Validate task bundle completeness
   review-hook            Prepare or validate browser review handoff
+  devlab                 Prepare or serve the internal Dev Lab cross-platform
+  runtime-telemetry      Capture and externally verify runtime telemetry
   report                 Read or update task review reports
   validate-lottie        Validate a Lottie animation
   manifest               Build or validate a production manifest
   eval-intelligence      Run adversarial Intelligence Core evaluation
 
+Cross-platform examples:
+  motionloom analyze . --init-memory
+  motionloom memory recover --project-root .
+  motionloom memory refresh --project-root . --json
+  motionloom memory record-decision --project-root . --id ui-easing \\
+    --status accepted --summary "Use ease-out for UI entry" --user-confirmed
+
 The CLI never grants approval or opens a pull request by itself. User review
 and explicit repository side-effect confirmation remain separate gates.
 `);
@@ -67,7 +85,7 @@ if (!script) {
   process.exit(2);
 }
 
-const executable = script.endsWith(".sh") ? "bash" : PYTHON;
+const executable = script.endsWith(".mjs") ? process.execPath : PYTHON;
 const result = spawnSync(executable, [resolve(ROOT, script), ...args], {
   cwd: ROOT,
   stdio: "inherit",

package/docs/STATUS.md

@@ -0,0 +1,33 @@
+# MotionLoom Current Status
+
+> **Authority:** This document describes the current repository contract. Historical audit snapshots and benchmark reports remain valuable evidence, but they must not be read as claims about the latest checkout.
+
+## Current release posture
+
+MotionLoom's repository source and package manifest are at version **2.1.0**. The public npm registry currently serves **2.0.0**; the GitHub repository has no tag or GitHub Release for 2.1.0 until an explicitly approved release is performed. The repository has a cross-platform CLI, durable Project Memory, artifact-first handoff, runtime evidence, signed attestation and a browser-based Dev Lab review contract. The protected manual release workflow verifies package/changelog/release-note alignment before publication.
+
+The repository is **engineering-ready for continued integration work**, not a universal production certification for every animation framework or every host project. CI status must be read from the latest GitHub Actions run, not inferred from historical audit prose.
+
+## Evidence levels
+
+| Capability | Current evidence level | What is actually proven | What is not implied |
+|---|---|---|---|
+| Lottie JSON and SVG cutout rig | End-to-end contract evidence | Context binding, source binding, runtime snapshots, Dev Lab review, quality gate and PR preflight have deterministic fixtures | Visual quality for every brand, asset or device |
+| Rive, GSAP and Framer Motion | Adapter and fixture evidence | Framework-specific runtime adapters and smoke checks can render representative scenes through browser/runtime paths | Equivalent coverage to the Lottie path across arbitrary projects |
+| Project Memory | Contract and relocation evidence | Stable project identity, atomic persistence, integrity guard, freshness states and path rebinding after relocation | Automatic correctness of an Agent's inferred decision |
+| Semantic intelligence | Deterministic evaluation evidence | Project graph, provenance, Motion IR, continuity, fix-plan and adversarial/deep-stress contracts; bounded analyzer reports scan budgets and truncation | Human-level design judgment, external-project product-value evidence or guaranteed first-pass acceptance |
+| Dev Lab | Review infrastructure evidence | Identity-bound candidate loading, deterministic scrub/snapshot, user checklist and review export | A visual editor, automatic approval or PR authorization |
+
+## Normative sources
+
+Use the following order when sources disagree:
+
+1. The active schemas, validators and executable tests define machine-enforced behavior.
+2. `SKILL.md`, `agent-card.json` and the current README define the Agent-facing contract.
+3. This status document defines current capability posture and evidence boundaries.
+4. Versioned release notes and focused audit reports explain a release or milestone at the time it was produced.
+5. Root-level historical audit snapshots are context only and must be labeled historical.
+
+## Known next work
+
+The bounded analyzer has now been exercised against a labeled external corpus; see the [dated evidence note](audits/external-project-corpus-2026-08-13.md). The highest-value remaining evidence work is paired product evaluation across more real projects, then closing version–tag–GitHub Release–npm provenance traceability through an approved manual release. Missing external projects are reported as `insufficient_evidence`, never as a pass. None of these items should weaken the user-review gate or convert heuristic warnings into approval.

package/docs/audits/2.1.0-deep-stress-evaluation.md

@@ -0,0 +1,97 @@
+# MotionLoom 2.1.0 — Deep Stress and Agent Intelligence Evaluation
+
+## Executive conclusion
+
+MotionLoom đã vượt qua một đợt deep stress **6.900 logical trials** trên canonical smoke task `browser-review-smoke-task`, với seed `20260813`, wall time `25.883117s`, `6.900/6.900` pass, `0` false positive và `0` false negative. Các thử nghiệm gọi trực tiếp validator/helper production và fault-injection trên artifact thật; đây **không phải** tuyên bố rằng đã render 6.900 animation trong browser.
+
+Kết luận hiện tại là MotionLoom có nền tảng **trust-boundary, context binding, provenance và review-first** mạnh. Nó đã đủ đáng tin để giảm những vòng chỉnh sửa sai do stale evidence, cross-task mix-up, tamper, wrong scene, replay path escape và attestation sai chữ ký. Tuy nhiên, nó chưa thể được gọi là hệ thống “hiểu chất lượng hình ảnh animation” hoàn chỉnh: visual comparison có nhãn provenance, historical learning, device/browser matrix và đo số vòng sửa thực tế vẫn còn thiếu.
+
+## Test matrix and evidence
+
+| Contract surface | Trials | Expected result | Observed result | p95 / max |
+| --- | ---: | --- | --- | ---: |
+| Canonical JSON metamorphic ordering | 600 | Reordered mappings serialize identically | 600 pass, 0 FP/FN | 0.027 / 0.216 ms |
+| DSSE Ed25519 round-trip | 250 | Valid signature verifies | 250 pass | 0.144 / 0.163 ms |
+| DSSE payload tamper | 250 | Modified payload is rejected | 250 pass | 0.140 / 0.179 ms |
+| Statement contract | 600 | 200 valid accepted; 400 mutated rejected | 600 pass | 0.008 / 0.060 ms |
+| Attestation verifier boundary | 1,500 | Codes 0, 11, 14 and 13 remain stable | 1,500 pass; 375 per code | 0.505 / 0.842 ms |
+| Strict quality gate | 400 | Canonical production bundle accepted | 400 pass | 29.717 / 45.588 ms |
+| Intelligence P1 | 400 | Graph/P1 reports accepted | 400 pass | 21.977 / 32.027 ms |
+| Replay hash validation | 475 | Clean replay remains clean | 475 pass | 10.210 / 13.316 ms |
+| Semantic lint clean path | 475 | Canonical lint report remains valid | 475 pass | 0.063 / 0.121 ms |
+| Continuity clean path | 475 | Canonical multi-scene continuity remains valid | 475 pass | 0.054 / 0.101 ms |
+| Approval invariant | 475 | Attestation and verifier report remain `approval=false` | 475 pass | 0.149 / 0.203 ms |
+| Fault injection: graph, IR, provenance, replay, P1, continuity, semantic, attestation | 1,000 | Every controlled mutation is rejected | 1,000 pass, 0 FN | 0.095–16.092 ms p95 by case |
+
+The machine-readable source is [`data/2.1.0-deep-stress-6900.json`](data/2.1.0-deep-stress-6900.json). Its SHA-256 is `8e4b967a87cf1dab2268c23fc15a98b5ebde1699d81a102505d98ccb89bf3a2d`.
+
+The fault corpus deliberately checks task ID substitution, scene substitution, provenance substitution, replay path escape, fix-plan source hash tampering, wrong-scene P1 validation, continuity structural drift, semantic structural drift, attestation approval mutation and payload mutation. The semantic/continuity validator hardening added during this audit closed a real malformed-report acceptance gap; the continuity regression fixture was then corrected to preserve the production SHA-256 context binding rather than a legacy empty placeholder.
+
+## Runtime and Dev Lab cross-check
+
+The in-process stress run was complemented by a real browser runtime test. Rive, GSAP and Framer Motion all passed the runtime adapter harness with 0/50/100% snapshots, no console errors and telemetry at approximately 16.7–16.8 ms maximum/p95 RAF interval in the sampled run. This establishes that the adapter evidence path works for the canonical examples, but it is not a 5.000-run visual or cross-device benchmark.
+
+The Dev Lab production build passed after the attestation rail and Timeline Desk review-driven pass. Two non-blocking operational warnings remain: pnpm ignores the legacy `pnpm` field in `package.json`, and the main JavaScript bundle is approximately 780.38 kB before gzip / 225.37 kB gzip, above the 500 kB advisory threshold. These do not invalidate the current build, but code splitting should be planned before the Lab grows further.
+
+## Scorecard
+
+The following scores are an engineering rubric based on the evidence above, not a universal benchmark or a claim of autonomous animation taste.
+
+| Capability | Score | Evidence-based assessment |
+| --- | ---: | --- |
+| Determinism and contract integrity | **9.5/10** | 6,900/6,900 pass; canonicalization, replay, semantic and continuity paths remained stable. |
+| Trust boundary and evidence identity | **9.4/10** | 1,500 verifier cases plus 1,000 cross-boundary mutations rejected correctly; approval invariant preserved. |
+| Project-aware binding | **8.8/10** | Graph, provenance, Motion IR, task/scene and fix-plan hashes are actively checked; more project archetypes are needed. |
+| Runtime truthfulness | **7.9/10** | Three real adapters pass with telemetry; visual correctness and environment diversity are not yet measured at scale. |
+| Agent handoff and review-first collaboration | **7.8/10** | Reports, issues, fix-plan, continuity, handoff and Dev Lab review rail exist; remediation-cycle outcomes are not yet learned from history. |
+| Performance and operational ergonomics | **8.2/10** | In-process p95 is low and strict gate is under 30 ms in the fixture; browser/device scaling and bundle size remain open. |
+| Release usability | **8.9/10** | `motionloom@2.0.0` is public on npm with a CLI wrapper and workstation release guide; Python/runtime dependencies remain external prerequisites. |
+
+**Overall engineering readiness: 8.6/10.** The score is high for evidence integrity and deterministic orchestration, not for end-to-end visual intelligence. The strongest differentiator is that MotionLoom can explain why an artifact is unsafe to trust instead of merely generating another animation.
+
+## What is working well
+
+MotionLoom now has a credible chain from project context to graph, provenance, Motion IR, runtime evidence, semantic feedback, continuity, signed attestation and review-first handoff. That chain is materially more useful to an Agent than a collection of framework snippets because the Agent can bind an artifact to a task and explain whether a failure is stale context, wrong scene, tampering, unsupported capability or an actual quality issue.
+
+The new hardening also demonstrates an important behavior: the system distinguishes a valid signature from user approval. A cryptographically verified bundle remains `approval=false`, and the Dev Lab remains the place where the user sees, tests, fixes and explicitly confirms a PR-side effect. This protects against the common failure mode where automation quietly treats “technically valid” as “approved.”
+
+The fix-plan and handoff surfaces are promising for reducing repeated edits. The system can identify a root cause, constrain patch scope and select a rerun scope instead of asking an Agent to regenerate the whole scene. That is the right architecture for reducing accidental churn, even though the audit did not yet measure a historical reduction percentage across real user iterations.
+
+## What is not yet proven
+
+The 6.900 trials are predominantly deterministic contract tests over one canonical smoke task. They prove boundary behavior, not broad semantic understanding across many project types, animation styles, body rigs, asset families, browser engines, device pixel ratios, reduced-motion settings or long-running timelines.
+
+The harness does not yet perform pixel-diff or perceptual comparison against labeled expected frames. Therefore it can prove that a frame was captured, bound and verified, but not that a character’s hand pose, easing feel, silhouette, staging or brand motion is visually correct. A second limitation is that clean-path repetition can hide state leaks that only appear after many different task bundles; a future matrix must rotate fixtures, not only repeat the same fixture.
+
+The Agent collaboration score is also necessarily provisional. The repository emits structured reports and actionable handoff data, but it does not yet have a benchmark of “first-pass acceptance rate,” “mean corrections per scene,” “rerender avoidance rate,” or “time from issue to accepted fix.” Without those measures, the claim that MotionLoom reduces user workload is architecturally plausible but not yet empirically quantified.
+
+## Prioritized development recommendations
+
+| Priority | Recommendation | Why it reduces wrong animation edits | Acceptance metric |
+| --- | --- | --- | --- |
+| P0 | Promote `deep-stress.py` to a documented nightly/PR audit with fixed seeds, thresholds and retained JSON artifacts | Prevents trust-boundary regressions from returning silently | 5,000+ logical trials, 0 FN, 0 FP, stable p95 budget |
+| P0 | Add visual-comparison contract with provenance-labeled 0/50/100% fixtures, pixel diff and perceptual hash | Distinguishes “evidence is valid” from “motion looks correct” | Labeled fixture pass/fail with explainable region-level diff |
+| P1 | Add multi-project corpus: landing UI, product onboarding, body rig, Lottie export, Rive state machine and mixed framework scene | Tests whether project-aware binding generalizes beyond one smoke bundle | At least 10 project archetypes and cross-task mutation coverage |
+| P1 | Add browser matrix for Chromium/WebKit/Firefox, DPR 1/2, reduced motion and 30/60/120 Hz timing | Captures runtime failures that in-process validators cannot see | Zero console errors; telemetry threshold per environment |
+| P1 | Create append-only remediation ledger: issue, proposed fix, patch scope, rerun scope, user outcome | Lets the Agent learn which fixes reduce repeated edits instead of regenerating blindly | Track first-pass acceptance, correction count and rerender avoidance |
+| P1 | Add benchmark history and aggregate metrics by project/context/framework/capability | Detects drift and capability regressions over time | Trend report, outlier alert and reproducible run hash |
+| P2 | Split Dev Lab public route and heavy workbench bundles with dynamic imports; migrate pnpm config to supported settings | Reduces load cost as evidence rails grow | Main chunk below advisory threshold and no pnpm warning |
+| P2 | Add capability confidence and “why this adapter” explanation to Agent handoff | Makes unsupported or stale capability selection visible before rendering | Every selected capability has evidence hash, freshness and reason |
+
+## Recommended next milestone
+
+The next milestone should be **2.2.0 Visual Truth and Remediation Learning**. It should not add more framework adapters first. It should add labeled visual fixtures, perceptual comparison, multi-project context corpus and the remediation ledger. Only after those are working should historical outcomes influence recommendations; otherwise the Agent risks learning from unverified visual outputs.
+
+## Reproduction
+
+From the repository root:
+
+```bash
+npm run audit:deep
+python3 tests/scripts/run_tests.py
+python3 scripts/eval-intelligence.py
+python3 scripts/skill-doctor.py --json
+npm run runtime:test
+```
+
+The deep audit command writes a machine-readable report under `docs/audits/data/` when invoked with the documented script defaults. The strict production checks remain separate so a fast developer test does not accidentally imply that browser review, telemetry, attestation or user approval has occurred.