@rune-kit/rune 2.25.0 → 2.26.0

package/README.md

@@ -103,7 +103,11 @@ Plus **9 domain packs** (product, sales, data-science, support, growth, media, p
 
 ---
 
-## What's New (v2.25.0 — Council)
+## What's New (v2.26.0 — Motion Craft)
+
+> **v2.26.0 (2026-07-18):** Rune's UI mesh gains a deep **motion authority**. New reference `skills/design/MOTION-CRAFT.md` is the canonical source for animation decisions: the *should-it-animate* frequency gate (never animate keyboard/100+-per-day actions), easing decision tree with strong custom curves, per-element duration budgets (UI under 300ms, modals/drawers exempt to 500ms), physicality rules (never `scale(0)`, origin-aware popovers, press feedback), spring physics (damping/response, velocity handoff, momentum projection, rubber-banding), interruptibility (transitions vs keyframes, `@starting-style`), motion performance, reduced-motion, and a reverse-lookup vocabulary glossary. `design` (v0.8.0) loads it whenever a domain involves motion and gains an advisory motion-audit mode. `review` (v1.5.0) adds **Motion Craft Checks** — an advisory lens that fires only on motion diffs, flagging `ease-in` on UI, `scale(0)` entrances, animation on high-frequency actions, layout-property animation, and more, citing MOTION-CRAFT for exact fixes. `perf` (v0.6.0) adds **Step 5.5 Motion Performance** — GPU-property, Framer-Motion-shorthand, and recalc-storm detection ranked in the Cost Impact Hierarchy. Advisory-first throughout (no new HARD-GATEs) — enrichment only, mesh unchanged at 66 skills.
+
+### Previous (v2.25.0 — Council)
 
 > **v2.25.0 (2026-07-11):** New **`council`** L3 primitive — genuinely decorrelated multi-perspective gathering. Detects installed AI CLIs, fans a question across distinct model families (external CLIs when present, subagents when not), gates off-topic/malformed voices, normalizes claims (anchor-first + shared-evidence arbiter fallback — prose similarity never counts), and arbitrates inline with an honest `NO_DECORRELATION` stamp when fewer than 2 real model families answered. Wired into 4 consumers: `adversary` (CRITICAL-tier plans), `review` (high-blast-radius diffs), `brainstorm` (Design-It-Twice candidate judgment), `problem-solver` (high-stakes conclusions) — every integration explicitly refuses to launder a same-family run as independent confirmation. **Live-dogfooded same day**: a real 3-voice self-test (external `grok` dispatch + 2 subagent fallbacks) independently converged on a real gap — "confirmed" `model_family` was CLI-brand identity, not verified backend identity, letting two CLIs redirected to the same backend (BYOK/proxy override) defeat the gate — fixed before shipping. **Pro**: `council-cockpit` (separate repo) adds a read-only live panel + cost-aware allocation + history-informed family weighting, PRE-council advisory only — Free never depends on Pro. Mesh now 66 skills / 208 connections / 45 signals.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "65-skill mesh for AI coding assistants — runtime auto-discipline via native hooks (Claude/Cursor/Windsurf/Antigravity), 5-layer architecture, 204 connections + 43 signals, multi-platform compiler. converge (L3) scans spec vs code so dead-button/frontend-only implementations can't ship.",
   "type": "module",
   "bin": {

package/skills/council/SKILL.md

@@ -58,7 +58,7 @@ None at the skill level — council dispatches via `Bash` (external CLI bridge)
 ### Fed By ←
 
 - Caller's `PerspectiveRequest` — question, mode, n, diversity constraints, evidence requirements (see `.rune/council-voice-contract.md`)
-- `.rune/runtimes.json` — cached CLI detection from the current session
+- `.rune/runtimes.json` — cached CLI detection from the current session (council writes this in Step 1, OR `sentinel-env --agents` may have pre-written it during env pre-flight — same council-owned schema, council's Step 1.1 cache-reuse path picks up whichever wrote first)
 
 ## Workflow
 

package/skills/design/DESIGN-REFERENCE.md

@@ -196,7 +196,7 @@ xl:  1280px  — desktop
 | Trigger | Animation | Duration | Easing |
 |---------|-----------|----------|--------|
 | Hover on card | scale(1.02) + shadow lift | 200ms | ease-out |
-| Button click | scale(0.97) | 100ms | ease-in |
+| Button click | scale(0.97) | 100ms | ease-out |
 | Page transition | fade + slide 8px | 200ms | ease |
 | Data loading | Skeleton shimmer | loop | linear |
 | Toast notification | slide-in from edge | 300ms | cubic-bezier(0.34, 1.56, 0.64, 1) |

package/skills/design/MOTION-CRAFT.md

@@ -0,0 +1,263 @@
+# Motion Craft Reference
+
+The motion authority for Rune's UI mesh. `design`, `cook`, `review`, and `perf` cite these exact values instead of approximating. The premise: in a world where every product works, motion is a differentiator — but **most interfaces are over-animated, not under-animated**. Default to less. Every value below is a fact you can defend, not a preference.
+
+Load this when generating, reviewing, or auditing any animation/motion code.
+
+---
+
+## 1. Should it animate at all?
+
+Decide before writing a single line. The gate is **frequency** — how often a user sees the motion.
+
+| Frequency | Decision |
+| --- | --- |
+| 100+ times/day (keyboard shortcuts, command palette toggle, core nav) | **No animation. Ever.** |
+| Tens/day (hover effects, list navigation, frequent toggles) | Remove or drastically reduce |
+| Occasional (modals, drawers, toasts, settings) | Standard animation |
+| Rare / first-time (onboarding, empty states, success, celebration) | Delight is welcome here |
+
+**Never animate keyboard-initiated actions.** They repeat hundreds of times a day; motion makes them feel slow, delayed, and disconnected from the input. A command palette with zero open/close animation is the *correct* experience, not a missing feature.
+
+---
+
+## 2. Purpose — why does this animate?
+
+Every animation must answer this in one word. If it can't, delete it.
+
+- **Feedback** — confirming the interface heard the user (press scale, hold-to-confirm fill)
+- **Spatial consistency** — showing where something came from or went (a toast enters and exits the same edge; a panel grows from its trigger)
+- **State indication** — making a state change legible (morphing button, expanding accordion)
+- **Preventing a jarring change** — content that would otherwise teleport, appear, or vanish with no bridge
+- **Explanation** — motion that demonstrates how a feature works (marketing/onboarding only)
+- **Delight** — allowed *only* at the rare/first-time frequency tier
+
+"It looks cool" is not on this list. On a frequently-seen element, it's a regression.
+
+---
+
+## 3. Easing
+
+Decision order:
+
+- Entering or exiting → **`ease-out`** (starts fast, feels responsive)
+- Moving / morphing on screen → **`ease-in-out`**
+- Hover / color change → **`ease`**
+- Constant motion (marquee, progress, spinner) → **`linear`**
+- Default → **`ease-out`**
+
+**Never `ease-in` on UI.** It starts slow, delaying the exact moment the user is watching most closely. `ease-out` at 200ms *feels* faster than `ease-in` at 200ms.
+
+Built-in CSS easings are too weak — they lack the punch that reads as intentional. Use strong custom curves:
+
+```css
+--ease-out-strong: cubic-bezier(0.23, 1, 0.32, 1);  /* punchy ease-out for deliberate UI interactions */
+--ease-in-out: cubic-bezier(0.77, 0, 0.175, 1);      /* strong ease-in-out for on-screen movement */
+--ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);       /* iOS-like drawer/sheet curve */
+```
+
+These are the *punchy* variants for deliberate, high-attention motion. The baseline `--ease-out: cubic-bezier(0.16, 1, 0.3, 1)` in `DESIGN-REFERENCE.md` remains the general-purpose default; reach for `--ease-out-strong` when an interaction needs extra snap. Don't hand-roll curves from scratch — start from a known strong variant and tune.
+
+---
+
+## 4. Duration
+
+| Element | Duration |
+| --- | --- |
+| Button press feedback | 100–160ms |
+| Tooltips, small popovers | 125–200ms |
+| Dropdowns, selects | 150–250ms |
+| Modals, drawers | 200–500ms |
+| Marketing / explanatory | Can be longer |
+
+**Rule: UI animations stay under 300ms — with one exception: modals/drawers, whose larger surface area justifies 200–500ms.** A 180ms dropdown feels more responsive than a 400ms one. Perceived performance is real: a faster spinner makes load *feel* faster at identical actual time; instant tooltips after the first (skip delay + animation) make a whole toolbar feel faster.
+
+---
+
+## 5. Physicality
+
+- **Never `scale(0)`.** Nothing in the real world appears from nothing. Start from `scale(0.9–0.97)` + `opacity: 0`. Even a barely-visible initial scale makes the entrance read as natural.
+  ```css
+  /* Bad */   .entering { transform: scale(0); }
+  /* Good */  .entering { transform: scale(0.95); opacity: 0; }
+  ```
+- **Origin-aware popovers.** A popover/dropdown/tooltip scales in from its trigger, not its center. `transform-origin: center` is wrong for almost every trigger-anchored surface.
+  ```css
+  .popover { transform-origin: var(--radix-popover-content-transform-origin); }  /* Radix */
+  .popover { transform-origin: var(--transform-origin); }                        /* Base UI */
+  ```
+  **Modals are exempt** — they aren't anchored to a trigger; keep them centered.
+- **Press feedback.** `transform: scale(0.97)` on `:active`, `transition: transform 160ms ease-out`. Subtle (0.95–0.98). Applies to any pressable element. `scale()` scales children too (font, icons) — a feature here.
+- **Tooltips: skip delay on subsequent hovers.** Delay the first to prevent accidental activation; once one is open, adjacent tooltips open instantly (`transition-duration: 0ms`). Faster feel without losing the guard.
+
+---
+
+## 6. Interruptibility
+
+CSS **transitions** can be interrupted and retargeted mid-flight; **keyframes** restart from zero. For anything triggered rapidly (toasts being added, toggles) or gesture-driven, transitions (or springs) are smoother.
+
+```css
+/* Interruptible — good for dynamic UI */
+.toast { transition: transform 400ms ease; }
+
+/* Not interruptible — avoid for dynamic UI */
+@keyframes slideIn { from { transform: translateY(100%); } to { transform: translateY(0); } }
+```
+
+Animate entry without JS using `@starting-style`:
+
+```css
+.toast {
+  opacity: 1; transform: translateY(0);
+  transition: opacity 400ms ease, transform 400ms ease;
+  @starting-style { opacity: 0; transform: translateY(100%); }
+}
+```
+
+Legacy fallback where browser support is short: `useEffect(() => setMounted(true), [])` + a `data-mounted` attribute.
+
+`translate` percentages are relative to the element's own size — `translateY(100%)` moves by the element's height regardless of dimensions. Prefer over hardcoded px.
+
+---
+
+## 7. Springs (physics-based motion)
+
+Springs feel natural because they simulate physics and have no fixed duration — they settle on parameters. Reach for them for anything a user can touch: drag with momentum, "alive" elements, interruptible gestures, decorative mouse-tracking.
+
+Think in two designer-friendly parameters, not the raw physics triplet:
+
+- **Damping ratio** — controls overshoot. `1.0` = critically damped, smooth settle, no bounce. `< 1.0` overshoots and oscillates. Lower = bouncier.
+- **Response** — how quickly the value reaches target, in seconds. Lower = snappier. This is *not* "duration."
+
+**Defaults:**
+- Start most UI at **damping `1.0`** — graceful and non-distracting.
+- Add bounce (**damping ~`0.8`**) **only when the gesture itself carried momentum** (a flick, a throw, a drag release). Overshoot on a menu that just faded in feels wrong; overshoot on a card you flicked feels right. Keep bounce subtle (0.1–0.3).
+
+**Concrete values:**
+
+| Interaction | Damping | Response |
+| --- | --- | --- |
+| Move / reposition | `1.0` | `0.4` |
+| Rotation | `0.8` | `0.4` |
+| Drawer / sheet | `0.8` | `0.3` |
+
+Web mapping (Motion / Framer Motion) — `bounce` + `duration` maps closely to damping + response:
+
+```js
+import { animate } from 'motion';
+animate(el, { y: 0 }, { type: 'spring', bounce: 0, duration: 0.4 });      // critically damped default
+animate(el, { y: target }, { type: 'spring', bounce: 0.2, duration: 0.4 }); // momentum → slight bounce
+```
+
+For mouse-tracking, interpolate with `useSpring` rather than tying the value directly to pointer position (direct = artificial, no momentum) — and only when the motion is decorative.
+
+Springs **maintain velocity when interrupted** — keyframes restart from zero — so they're ideal for gestures a user may reverse mid-motion.
+
+---
+
+## 8. Fluid gesture interactions
+
+The through-line of a fluid interface: motion starts from the current on-screen value, inherits the user's velocity, projects momentum forward, and can be grabbed and reversed at any instant.
+
+- **Respond on pointer-down, not release.** Highlight the instant it's pressed; waiting for `click` feels dead. Feedback must be continuous *during* the gesture, not only at the end.
+- **1:1 tracking** — the dragged element stays glued to the finger and respects the grab offset (don't snap to center on grab). Use Pointer Events + `setPointerCapture` so tracking continues when the pointer leaves bounds.
+- **Velocity handoff** — when the gesture ends, the animation continues at the finger's exact release velocity so there's no seam between drag and animate. Some spring APIs want relative velocity: `gestureVelocity / (target − current)`.
+- **Momentum projection** — don't snap to the nearest boundary from the release point; project the resting position from velocity (like scroll deceleration), then snap to the target nearest that projection:
+  ```js
+  function project(v /* px/s */, decel = 0.998) { return (v / 1000) * decel / (1 - decel); }
+  const target = nearestSnapPoint(currentPosition + project(releaseVelocity));
+  ```
+- **Momentum dismissal** — don't require crossing a distance threshold; compute velocity (`Math.abs(distance) / elapsedMs`) and dismiss if `> ~0.11`. A flick should be enough.
+- **Rubber-banding** — at a boundary, resist progressively instead of stopping hard (a hard stop reads as "frozen"):
+  ```js
+  function rubberband(overshoot, dim, c = 0.55) { return (overshoot * dim * c) / (dim + c * Math.abs(overshoot)); }
+  ```
+- **Multi-touch protection** — ignore extra touch points once a drag begins (`if (isDragging) return`) to prevent jumps.
+- **Decompose 2D motion into independent X and Y springs** — a single spring on a 2D distance desyncs when the axes have different velocities.
+- **Interrupt from the presentation value** — on interrupt, read the element's live on-screen transform and animate from there; starting from the logical/target value causes a visible jump.
+
+---
+
+## 9. Motion performance
+
+Full detail lives in `perf`; the rules that gate motion:
+
+- **Only animate `transform` and `opacity`** — they skip layout and paint and run on the GPU. `width`/`height`/`margin`/`padding`/`top`/`left` trigger all three rendering steps.
+- **Avoid `transition: all`** — it animates unintended properties, often off-GPU.
+- **Framer Motion shorthands (`x`/`y`/`scale`) are NOT hardware-accelerated** — they run on the main thread via rAF and drop frames under load. Use the full transform string: `animate={{ transform: "translateX(100px)" }}`.
+- **Don't drive child transforms via a CSS variable on the parent** — it recalculates styles for all children. Set `transform` directly on the element.
+- **CSS animations beat JS under load** — they run off the main thread while the browser loads/scripts/paints. Use CSS for predetermined motion, JS/springs for dynamic/interruptible.
+- **WAAPI** gives JS control at CSS performance (hardware-accelerated, interruptible, no library).
+- **`will-change`** hints imminent motion — use where motion is about to happen, don't leave it on permanently.
+
+---
+
+## 10. Accessibility
+
+Reduced motion means *fewer and gentler*, not zero — keep opacity/color transitions that aid comprehension, drop movement/position/parallax.
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  .element { transition: opacity 200ms ease; transform: none !important; }
+}
+@media (prefers-reduced-transparency: reduce) {
+  .toolbar { background: white; backdrop-filter: none; } /* frostier/solid translucent surfaces */
+}
+@media (hover: hover) and (pointer: fine) {
+  .element:hover { transform: scale(1.05); } /* gate hover motion — touch fires false hovers on tap */
+}
+```
+
+```jsx
+const reduce = useReducedMotion();
+const closedX = reduce ? 0 : '-100%';
+```
+
+Also avoid full-viewport moving backgrounds and slow looping oscillations (~0.2 Hz); ease dark↔light theme changes rather than jumping brightness.
+
+---
+
+## 11. Polish
+
+- **Asymmetric enter/exit** — slow where the user is deciding, fast where the system responds. A hold-to-delete fills over 2s linear; the release snaps back in 200ms ease-out.
+- **Stagger group entrances** — 30–80ms between items; longer feels slow. Decorative, so never block interaction while it plays.
+  ```css
+  .item { opacity: 0; transform: translateY(8px); animation: fadeIn 300ms ease-out forwards; }
+  .item:nth-child(2) { animation-delay: 50ms; }
+  .item:nth-child(3) { animation-delay: 100ms; }
+  @keyframes fadeIn { to { opacity: 1; transform: translateY(0); } }
+  ```
+- **Blur to mask imperfect crossfades** — when two states visibly overlap despite tuning easing/duration, add `filter: blur(2px)` during the transition to blend them into one perceived transformation. Keep blur < 20px (heavy blur is expensive, especially Safari).
+- **`clip-path: inset(t r b l)`** is a powerful animation tool — each value eats in from that side. Uses: reveal-on-scroll (`inset(0 0 100% 0)` → `inset(0 0 0 0)`), hold-to-delete overlay, seamless tab color transitions (duplicate the list, clip the active copy), comparison sliders.
+- **Cohesion** — match motion to the component's personality and the rest of the product. A playful component can be bouncier; a dashboard stays crisp and fast. Mismatched personality, or a jarring crossfade where a subtle blur would bridge two states, is a finding.
+- **Translucent chrome** — build nav/toolbars/sheets as translucent layers (`backdrop-filter: blur()` + semi-transparent bg) with content scrolling under, not opaque bars. Never stack a light translucent surface on another. Materialize (animate blur + scale together on enter) rather than a plain opacity fade.
+
+---
+
+## 12. Feel-checking (when code alone can't decide)
+
+Motion feel often can't be judged from source. When uncertain, recommend a feel-check instead of guessing:
+
+- **Slow motion** — bump duration 2–5× or use DevTools animation inspector. Check colors crossfade cleanly, easing doesn't stop abruptly, `transform-origin` is right, coordinated properties stay in sync.
+- **Frame-by-frame** — Chrome DevTools Animations panel reveals timing drift between coordinated properties.
+- **Real devices** for gestures (drawers, swipe) — desktop emulation lies about touch feel.
+- **Fresh eyes next day** — imperfections invisible during development surface later.
+
+---
+
+## 13. Vocabulary (reverse-lookup glossary)
+
+When a user describes a motion effect without knowing its name, map the sensation to the term. Lead with the closest match; note alternates only when two genuinely compete.
+
+**Entrances/Exits** — Fade in/out · Slide in · Scale in · **Pop in** (slight overshoot) · **Reveal** (uncover via clip-path/mask) · Enter/Exit.
+**Sequencing** — Keyframes · Interpolation/Tween · **Stagger** (cascade with per-item delay) · Orchestration · Delay · Duration · Fill mode · Stepped animation.
+**Transforms** — Translate · Scale · Rotate · Skew · 3D tilt/Flip · Perspective · Transform origin · **Origin-aware** (grows from its trigger, not center).
+**State transitions** — Crossfade · Continuity transition · **Morph** (one shape into another) · **Shared element transition** (element travels + transforms between positions) · **Layout animation** (animates to new size/pos instead of snapping) · Accordion/Collapse · Direction-aware transition.
+**Scroll** — Scroll reveal · Scroll-driven animation · Parallax · Page transition · View transition.
+**Feedback** — Hover effect · **Press/Tap feedback** (subtle scale-down) · **Hold to confirm** (fill while held) · Drag · Drag to reorder · Swipe to dismiss · **Rubber-banding** (resist + snap-back past a boundary) · Shake/Wiggle (error) · Ripple.
+**Easing** — Easing · Ease-out (default for UI) · Ease-in (usually avoid) · Ease-in-out · Linear (spinners/marquees only) · Cubic-bezier · Asymmetric easing.
+**Springs** — Spring · Stiffness/Tension · Damping · Mass · Bounce · Perceptual duration · Momentum · Velocity · Interruptible animation.
+**Ambient** — Marquee · Loop · Alternate (yoyo) · Orbit · Pulse · Float · Idle animation.
+**Polish** — Blur · Clip-path · Mask (soft fadeable edges) · Before/after slider · Line drawing · Text morph · Skeleton/Shimmer · **Number ticker** · **Tabular numbers** (fixed-width digits, essential for counters) · Typewriter.
+**Performance** — Frame rate (FPS) · Jank · Dropped frame · Compositing · will-change · Layout thrashing.
+**Principles** — Purposeful animation · Anticipation · Follow-through · Squash & stretch · Perceived performance · Frequency of use · Spatial consistency · Hardware acceleration · Reduced motion.

package/skills/design/SKILL.md

@@ -3,7 +3,7 @@ name: design
 description: "Design system reasoning. Maps product domain to style, palette, typography, and platform-specific patterns. Generates .rune/design-system.md as the shared design contract for all UI-generating skills."
 metadata:
   author: runedev
-  version: "0.7.0"
+  version: "0.8.0"
   layer: L2
   model: sonnet
   group: creation
@@ -57,6 +57,9 @@ Load the design knowledge base before reasoning:
 2. If no user override → `Read` the baseline: `skills/design/DESIGN-REFERENCE.md` (shipped with Rune)
 3. The loaded reference provides: font pairings, chart selection, component architecture, color principles, UX checklist, interaction patterns, anti-pattern signatures
 4. Apply reference knowledge throughout Steps 3-5 (domain reasoning, token generation, checklist)
+5. **When the domain involves any UI motion** (transitions, animations, gestures, springs, micro-interactions) → also `Read` `skills/design/MOTION-CRAFT.md`. It is the canonical motion authority: the should-it-animate frequency gate, easing/duration budgets, physicality (never `scale(0)`, origin-aware popovers), spring physics, gesture handoff, motion performance, reduced-motion, and a reverse-lookup vocabulary. Cite its exact values in the design-system motion section; never approximate curves or durations. **When MOTION-CRAFT.md and DESIGN-REFERENCE.md disagree on a motion detail (easing, duration, interaction timing), MOTION-CRAFT.md wins** — it is the deeper, motion-specific source; DESIGN-REFERENCE.md's Animation Timing / Interaction Patterns tables are the general baseline.
+
+> **Advisory motion-audit mode**: When asked to "improve the animations" / "make this feel better" / "what could be animated here", operate read-only — survey the motion surface against MOTION-CRAFT.md, report frequency-gated findings (and deliberately rejected candidates), and hand precise recipes to `cook`/`fix`. Suggesting motion everywhere is worse than useless; expect to reject most candidates.
 
 > **Why two layers**: The baseline ships "good enough" universal design knowledge. Users who care about aesthetics create their own `design-dna.md` with curated palettes, font pairings, and style preferences. The design skill works well with either — it just works _better_ with a curated reference.
 

package/skills/perf/SKILL.md

@@ -3,7 +3,7 @@ name: perf
 description: "Performance regression gate. Detects N+1 queries, sync-in-async, missing indexes, memory leaks, and bundle bloat before they reach production. Ranks findings by Cost Impact Hierarchy (architecture > data transfer > compute > DB > caching) so fix priority maps to actual unit-cost reduction."
 metadata:
   author: runedev
-  version: "0.5.0"
+  version: "0.6.0"
   layer: L2
   model: sonnet
   group: quality
@@ -212,6 +212,16 @@ Do NOT downgrade this gate.
 If no URL available (dev-only environment): log `INFO: no URL for Lighthouse — run manually before deploy`
 If Lighthouse MCP not installed: log `INFO: Lighthouse MCP not available — run lighthouse [url] --output json manually`
 
+### Step 5.5 — Motion / Animation Performance (frontend only)
+
+Apply only when the diff touches motion. Strong signals: `@keyframes`, `motion.`, `animate={`, `useSpring`, `will-change`, `transition:` / `transition-`. Weak signals: bare `transition` / `animation` / `transform` — these also match non-motion code and prose (state-machine "transition", `AnimationController`, static layout transforms), so treat them as a trigger only when they co-occur with a strong signal (mirrors `review`'s Motion Craft Checks). These are frame-budget regressions — a dropped frame is a 16.7ms miss at 60fps. Findings are **WARN** by default (jank degrades feel, rarely blocks a merge); escalate to **BLOCK** only when motion runs on a hot, always-on path (scroll handler, drag loop, list with many animated rows). Rank within the Cost Impact Hierarchy under *compute* (main-thread work) — note this is client-side compute: the cost is UX/conversion degradation and engineering-hour ROI, not a cloud-billing multiplier like Tier 3's infra examples. For remediation values and the full rationale, point to `skills/design/MOTION-CRAFT.md §9`.
+
+- **Non-GPU property animation** — animating `width`/`height`/`margin`/`padding`/`top`/`left` (or `transition: all`) triggers layout + paint every frame. Finding: `MOTION_LAYOUT_THRASH — [file:line] — animating [prop] forces layout/paint per frame — use transform/opacity`
+- **Framer Motion shorthands under load** — `x`/`y`/`scale` props run on the main thread via rAF and drop frames while the page is busy. Finding: `MOTION_NOT_HW_ACCEL — [file:line] — FM x/y/scale shorthand — use full transform string for GPU compositing`
+- **CSS-variable-driven child transforms** — updating a variable on a parent to drive children recalculates styles for every child (recalc storm). Finding: `MOTION_RECALC_STORM — [file:line] — parent CSS var drives child transform — set transform on the element directly`
+- **`will-change` misuse** — missing on imminent, frequently-triggered motion, or left on permanently (permanent layer promotion wastes GPU memory). Finding: `MOTION_WILL_CHANGE — [file:line] — [missing on hot path | left on permanently]`
+- **Keyframes on rapidly-triggered / interruptible motion** — restart-from-zero causes visible jank under rapid retriggering; CSS transitions or springs retarget smoothly. Finding: `MOTION_NON_INTERRUPTIBLE — [file:line] — keyframes on rapidly-triggered element`
+
 ### Step 6 — Framework-Specific Checks
 
 **React:**

package/skills/review/SKILL.md

@@ -3,7 +3,7 @@ name: review
 description: "Code quality review — patterns, security, performance, correctness. Finds bugs, suggests improvements, triggers fix for issues found. Escalates to opus for security-critical code."
 metadata:
   author: runedev
-  version: "1.4.0"
+  version: "1.5.0"
   layer: L2
   model: sonnet
   group: development
@@ -559,6 +559,29 @@ className="focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-500"
 - iOS target: solid-background cards (iOS 26 Liquid Glass deprecates this visual language) — should use translucent/blur surfaces
 - Android target: hardcoded hex colors instead of `MaterialTheme.colorScheme` tokens → not adaptive to dynamic color
 
+## Motion Craft Checks
+
+Apply **only** when the diff touches motion. Strong signals: `@keyframes`, `motion.`, `animate={`, `useSpring`, `cubic-bezier`, `@starting-style`, `transition:` / `transition-`. Weak signals: bare `transform` or `ease-` — these also match static layout transforms (`translate(-50%,-50%)`) and non-motion identifiers, so treat them as a trigger only when they co-occur with a strong signal. Skip entirely for diffs with no motion code.
+
+These are **advisory** — default severity MEDIUM. Escalate to HIGH only for *feel-breaking* regressions (the first five triggers below). Motion is a taste call: when feel can't be judged from source, say so and recommend a slow-motion / frame-by-frame check rather than asserting a defect. **For every finding, cite the exact remediation value from `skills/design/MOTION-CRAFT.md`** — do not restate its tables here.
+
+**Escalation triggers — flag on sight (first five = HIGH, feel-breaking):**
+- `ease-in` on any UI interaction (delays the moment the user watches most)
+- `scale(0)` or pure-fade entrances with no initial transform (nothing appears from nothing → initial scale + opacity per MOTION-CRAFT §5)
+- Animation on a keyboard shortcut / command-palette toggle / 100+/day action (should have none)
+- Animating layout properties (`width`/`height`/`margin`/`padding`/`top`/`left`) instead of `transform`/`opacity` (off-GPU, drops frames)
+- UI animation duration over the budget with no stated reason (duration budget + modals/drawers exemption per MOTION-CRAFT §4)
+- `transition: all` — unbounded property animation (MEDIUM)
+- `transform-origin: center` on a trigger-anchored popover/dropdown/tooltip (should scale from trigger; modals exempt) (MEDIUM)
+- Keyframes on toasts/toggles/anything triggered rapidly (can't retarget → use CSS transitions or springs) (MEDIUM)
+- Framer Motion `x`/`y`/`scale` shorthands on motion that runs while the page is busy (not hardware-accelerated → full `transform` string) (MEDIUM)
+- Driving a child transform via a CSS variable on the parent (style-recalc storm) (MEDIUM)
+- Missing `prefers-reduced-motion` handling on movement, or ungated `:hover` motion (missing `@media (hover: hover) and (pointer: fine)`) (MEDIUM)
+- Symmetric enter/exit timing on a press-and-release or hold interaction (deliberate phase should be slower, response snappier) (LOW–MEDIUM)
+- Everything-at-once entrance where a stagger belongs (stagger interval per MOTION-CRAFT §11) (LOW)
+
+**Remedial preference (propose the earliest that applies):** delete the animation (high-frequency / no purpose) → reduce it → fix the easing → fix origin/physicality → make it interruptible → move it to the GPU → asymmetric timing → polish (blur/stagger/`@starting-style`/spring). Pull the exact curve, duration, or spring config from MOTION-CRAFT.md. Findings feed the existing Report + Fix-First triage — do not create a parallel output path.
+
 ## Weighted Composite Scoring
 
 When a review is part of a recurring quality-gate cycle (e.g., sprint review, pre-release gate), produce a **composite quality score** alongside the findings list. This makes review output numeric and comparable across runs.
@@ -667,7 +690,7 @@ Append to Code Review Report when invoked standalone. Suppress when called as su
 ```yaml
 chain_metadata:
   skill: "rune:review"
-  version: "1.3.0"
+  version: "1.5.0"
   status: "[DONE | DONE_WITH_CONCERNS]"
   domain: "[area reviewed]"
   files_changed: []  # review doesn't change files

package/skills/sentinel-env/SKILL.md

@@ -3,11 +3,11 @@ name: sentinel-env
 description: "Environment-aware pre-flight check. Use when starting work in a new environment, switching machines, or when 'works on my machine' bugs surface. Validates OS, runtime versions, installed tools, port availability, env vars, and disk space BEFORE coding starts. Like sentinel but for the environment, not the code."
 metadata:
   author: runedev
-  version: "0.4.0"
+  version: "0.5.0"
   layer: L3
   model: haiku
   group: validation
-  tools: "Bash, Read, Glob, Grep"
+  tools: "Bash, Read, Write, Glob, Grep"
 ---
 
 # sentinel-env
@@ -28,7 +28,7 @@ This is the environment counterpart to `sentinel` (which checks code security) a
 
 ## Calls (outbound)
 
-None — sentinel-env is a pure read-only utility. It checks and reports, never modifies.
+None — sentinel-env never calls another Rune skill and never modifies the developer's machine/environment (no install/update). In `--agents` mode it writes ONE Rune-owned advisory cache file, `.rune/runtimes.json` (a Rune state file, not the dev's environment — same category as the files `journal`/`session-bridge`/`council` write).
 
 ## Called By (inbound)
 
@@ -36,6 +36,13 @@ None — sentinel-env is a pure read-only utility. It checks and reports, never
 - `scaffold` (L1): post-bootstrap environment validation
 - `onboard` (L2): developer onboarding verification
 - User: `/rune env-check` direct invocation
+- User: `/rune env-check --agents` — also run AI-Agent Fleet Detection (Step 6.6)
+
+## Data Flow
+
+### Feeds Into →
+
+- `council` (L3): `.rune/runtimes.json` — when `--agents` mode ran during env pre-flight, it PRE-WARMS council's Step 1 DETECT cache (council reuses a same-session cache instead of re-probing the bridge). Schema + model-family map are OWNED by `skills/council/references/dispatch-protocol.md` §Detect — sentinel-env writes that exact shape, it does not define its own.
 
 ## Execution
 
@@ -135,6 +142,7 @@ Detect and verify tools the project depends on:
 
    **Verdict:**
    - Tool found via any tier → PASS (log which tier + version)
+   - Tool resolves to DIFFERENT paths across tiers (e.g. a `~/.local/bin` copy AND a PATH copy, or two PATH entries) → **WARN [ENV-AMBIG]**: `'<tool>' resolves to N paths — the shell picks <selected>, but <other> also exists`. This is the "wrong binary runs" class of "works on my machine" (stale/shadowed installs, two Pythons, two npms). Don't stop at the first tier hit for the ambiguity check — after a PASS, cheaply confirm PATH (`where`/`which -a`) doesn't disagree with the winning tier. List all paths + versions so the developer can prune the shadow.
    - Tool NOT found → **BLOCK** with per-OS install guidance:
      ```
      [ENV-XXX] Required tool '<tool>' not found (9-tier lookup exhausted)
@@ -193,6 +201,18 @@ Quick system health check:
    - **macOS**: Check Xcode CLI tools if native modules detected (`node-gyp` in dependencies)
    - **Linux**: Check file watcher limit if large project (`fs.inotify.max_user_watches`)
 
+### Step 6.6: AI-Agent Fleet Detection (opt-in — `--agents` flag, or when called by `council`)
+
+Skip this step unless `--agents` was passed or `council` requested it. It answers ONE question: *"how many distinct AI model families can this machine reach for a decorrelated council run?"* — and pre-warms council's cache so its first invocation skips a redundant probe.
+
+**Schema and model-family map are OWNED by `skills/council/references/dispatch-protocol.md` §Detect. Do NOT redefine them here — read that file and write its exact shape.** This keeps a single source of truth; if that reference changes, this step follows it.
+
+1. **Resolve the bridge**: look for `1devtool-agent` on PATH, then the per-user location for the current OS (`~/.1devtool/bin/1devtool-agent` POSIX, `%USERPROFILE%\.1devtool\bin\1devtool-agent.cmd` Windows). Resolve relative to the current user's home — never hardcode a specific user's path.
+2. **Bridge found** → `1devtool-agent list --json`; for each `status: detected` entry map its id → `model_family` per the council reference table (claude→anthropic, codex→openai, gemini/agy→google, grok→xai, qwen→alibaba, wrapper CLIs cline/amp/opencode/aider→`unknown`). Reading `~/.1devtool/state/cli-registry.json` directly is an acceptable faster path (it is the pre-scanned manifest `list` returns).
+3. **Bridge NOT found** → `detected: []`, `bridge_path: null`. This is normal, not an error. Optionally 9-tier detect raw AI-agent binaries for the human report only ("5 AI CLIs installed but no 1devtool bridge → council will run subagent-only"), but do NOT put unbridged binaries in `detected[]` — council can't dispatch to them.
+4. **Write** `.rune/runtimes.json` in the council-owned schema (`checked_at` session marker, `bridge_path`, `detected[]`). Only bridge-reachable `status: detected` entries belong in `detected[]`.
+5. **Count distinct CONFIRMED families** (exclude `unknown` wrappers) → report `MULTI_FAMILY-capable` (≥2) or `NO_DECORRELATION-only` (<2). **Honesty (inherit council's caveat): "confirmed" = the CLI is vendor-dedicated by product design, NOT that a given response was verified to come from that vendor's backend** (BYOK / base-URL / gateway override can collapse families invisibly). Report the count as advisory availability, never as a decorrelation guarantee — that call is council's at run time.
+
 ### Step 7: Report
 
 Produce a structured environment report:
@@ -227,11 +247,17 @@ For each finding, include a specific remediation command the developer can copy-
 - [ENV-005] Git 2.44.0 ✓
 - [ENV-006] Docker 25.0.3 ✓
 - [ENV-007] Disk space: 42 GB available ✓
+
+### AI AGENTS (only when --agents / council mode ran)
+- Bridge: 1devtool-agent ✓ (or: not found → council runs subagent-only)
+- Reachable: codex (openai), grok (xai), gemini (google), agy (google) — 3 distinct confirmed families
+- council capability: MULTI_FAMILY-capable (advisory — not a decorrelation guarantee; backend override can collapse families)
+- Wrote .rune/runtimes.json (pre-warms council DETECT)
 ```
 
 ## Constraints
 
-1. MUST be read-only — never install, update, or modify anything on the developer's machine
+1. MUST NOT install, update, or modify anything on the developer's MACHINE/environment (no `apt install`, no version switches, no PATH edits). Writing the Rune-owned advisory cache `.rune/runtimes.json` in `--agents` mode is the ONE exception and is not a machine modification — it is Rune state, same as `journal`/`council` run files.
 2. MUST NOT log environment variable VALUES — only check key presence (security)
 3. MUST provide copy-paste remediation commands for every BLOCK and WARN finding
 4. MUST handle cross-platform differences (Windows/macOS/Linux) gracefully
@@ -249,6 +275,9 @@ For each finding, include a specific remediation command the developer can copy-
 | Over-checking — flagging optional tools as required | MEDIUM | Only check tools evidenced by config files, not speculative |
 | Missing hard dependency — project wraps external CLI but tool not checked | HIGH | Step 3.6: scan for `shutil.which`, `subprocess.run`, `child_process.exec` → verify tool exists on PATH |
 | Hard dep found but wrong version — tool exists but API changed | MEDIUM | Log version for manual review. Version compatibility is project-specific — don't guess |
+| `--agents` writes `.rune/runtimes.json` with a schema that drifts from council's | HIGH | Schema + family map are OWNED by `skills/council/references/dispatch-protocol.md` §Detect — sentinel-env writes that shape, never its own; if the reference changes, this step follows it |
+| Reporting an installed-but-unbridged AI CLI as council-reachable | HIGH | Step 6.6.3: only bridge-reachable `status: detected` entries go in `detected[]`; unbridged binaries are report-only text, never dispatchable state |
+| Claiming a distinct-family count as a decorrelation guarantee | MEDIUM | Step 6.6.5: report as advisory availability only; "confirmed" ≠ backend-verified (BYOK/gateway override) — the real decorrelation call is council's at run time |
 
 ## Done When
 
@@ -259,6 +288,7 @@ For each finding, include a specific remediation command the developer can copy-
 - Disk space verified adequate
 - Structured report with READY / READY WITH WARNINGS / BLOCKED verdict
 - Every BLOCK/WARN finding has a copy-paste remediation command
+- In `--agents` mode only: `.rune/runtimes.json` written in council's canonical schema and a distinct-family count reported (advisory, not a decorrelation guarantee)
 
 ## Cost Profile