@ericrisco/rsc 1.1.5 → 1.2.0

package/scripts/originality-check.js

@@ -0,0 +1,137 @@
+import {
+  existsSync, readdirSync, readFileSync, statSync, writeFileSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { stackAgents } from '../targets/agent-catalog.js';
+import { allAgentNames } from '../targets/agents.js';
+import { resolveCommands } from '../targets/commands.js';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const META_PATH = join(ROOT, 'schema', 'ecc-originality.json');
+const DATA_PATH = join(ROOT, 'schema', 'ecc-originality.u64');
+const NGRAM_SIZE = 8;
+const EXEMPTION_CATEGORIES = new Set(['name', 'error', 'tool-command', 'language-term']);
+
+export function normalizeTokens(text) {
+  return String(text || '').normalize('NFKC').toLowerCase().match(/[\p{L}\p{N}_+.#/-]+/gu) || [];
+}
+
+function fingerprint(tokens, offset, size = NGRAM_SIZE) {
+  return createHash('sha256').update(tokens.slice(offset, offset + size).join(' ')).digest('hex').slice(0, 16);
+}
+
+function fingerprintsOf(text, size = NGRAM_SIZE) {
+  const tokens = normalizeTokens(text);
+  const out = [];
+  for (let offset = 0; offset <= tokens.length - size; offset += 1) {
+    out.push({ fingerprint: fingerprint(tokens, offset, size), offset });
+  }
+  return out;
+}
+
+function walk(directory) {
+  if (!existsSync(directory)) throw new Error(`originality: corpus directory missing: ${directory}`);
+  return readdirSync(directory).sort().flatMap((name) => {
+    const path = join(directory, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+}
+
+function catalogDocuments() {
+  const skillIds = readdirSync(join(ROOT, 'skills')).filter((id) => {
+    try { return statSync(join(ROOT, 'skills', id, 'SKILL.md')).isFile(); } catch { return false; }
+  });
+  const commands = resolveCommands({
+    target: 'cursor', skills: skillIds, agents: allAgentNames(), memoryMode: 'full',
+  });
+  return [
+    ...stackAgents().map((agent) => ({ id: `agent:${agent.name}`, text: `${agent.desc}\n${agent.body}` })),
+    ...commands.map((command) => ({ id: `command:${command.name}`, text: `${command.description}\n${command.body}` })),
+  ];
+}
+
+export function fingerprintCorpus(metaPath = META_PATH, dataPath = DATA_PATH) {
+  const metadata = JSON.parse(readFileSync(metaPath, 'utf8'));
+  if (metadata.ngramSize !== NGRAM_SIZE) throw new Error(`originality: unsupported n-gram size ${metadata.ngramSize}`);
+  for (const exemption of metadata.exemptions || []) {
+    if (!EXEMPTION_CATEGORIES.has(exemption.category) || !/^[0-9a-f]{16}$/.test(exemption.fingerprint || '')) {
+      throw new Error('originality: every exemption needs a valid fingerprint and closed category');
+    }
+  }
+  const bytes = readFileSync(dataPath);
+  if (bytes.length % 8 !== 0 || bytes.length / 8 !== metadata.fingerprintCount) {
+    throw new Error('originality: fingerprint corpus length does not match its receipt');
+  }
+  const digest = createHash('sha256').update(bytes).digest('hex');
+  if (digest !== metadata.dataSha256) throw new Error('originality: fingerprint corpus failed its integrity receipt');
+  const fingerprints = new Set();
+  for (let offset = 0; offset < bytes.length; offset += 8) fingerprints.add(bytes.subarray(offset, offset + 8).toString('hex'));
+  return { metadata, fingerprints };
+}
+
+export function checkCatalogOriginality({ corpus = fingerprintCorpus(), documents = catalogDocuments() } = {}) {
+  const exempt = new Set((corpus.metadata.exemptions || []).map((entry) => entry.fingerprint));
+  const matches = [];
+  for (const document of documents) {
+    for (const candidate of fingerprintsOf(document.text, corpus.metadata.ngramSize)) {
+      if (corpus.fingerprints.has(candidate.fingerprint) && !exempt.has(candidate.fingerprint)) {
+        matches.push({ document: document.id, tokenOffset: candidate.offset, fingerprint: candidate.fingerprint });
+      }
+    }
+  }
+  return {
+    ngramSize: corpus.metadata.ngramSize,
+    corpusRevision: corpus.metadata.revision,
+    documents: documents.length,
+    exemptions: exempt.size,
+    matches,
+  };
+}
+
+function refresh(corpusRoot) {
+  const files = ['agents', 'commands'].flatMap((directory) => walk(join(corpusRoot, directory)));
+  const hashes = new Set();
+  for (const path of files) {
+    for (const candidate of fingerprintsOf(readFileSync(path, 'utf8'))) hashes.add(candidate.fingerprint);
+  }
+  const sorted = [...hashes].sort();
+  const bytes = Buffer.alloc(sorted.length * 8);
+  sorted.forEach((hash, index) => Buffer.from(hash, 'hex').copy(bytes, index * 8));
+  writeFileSync(DATA_PATH, bytes);
+  const revision = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: corpusRoot, encoding: 'utf8' }).trim();
+  const metadata = {
+    schemaVersion: 1,
+    source: 'https://github.com/affaan-m/everything-claude-code',
+    revision,
+    generatedAt: new Date().toISOString().slice(0, 10),
+    included: ['agents/**', 'commands/**'],
+    ngramSize: NGRAM_SIZE,
+    normalization: 'NFKC lowercase; Unicode letters/numbers plus _+.#/-; whitespace joined',
+    fingerprintFormat: 'first 64 bits of SHA-256, sorted big-endian; collisions fail closed',
+    fingerprintCount: sorted.length,
+    dataSha256: createHash('sha256').update(bytes).digest('hex'),
+    exemptions: [],
+  };
+  writeFileSync(META_PATH, `${JSON.stringify(metadata, null, 2)}\n`);
+  return metadata;
+}
+
+function main() {
+  if (process.argv[2] === '--refresh') {
+    if (!process.argv[3]) throw new Error('Usage: node scripts/originality-check.js --refresh <ecc-checkout>');
+    const metadata = refresh(process.argv[3]);
+    console.log(`originality corpus refreshed (${metadata.fingerprintCount} fingerprints at ${metadata.revision})`);
+    return;
+  }
+  const result = checkCatalogOriginality();
+  if (result.matches.length) {
+    for (const match of result.matches) console.error(`${match.document}: shared ${result.ngramSize}-token fingerprint ${match.fingerprint} at token ${match.tokenOffset}`);
+    process.exit(1);
+  }
+  console.log(`originality OK (${result.documents} documents vs ${fingerprintCorpus().metadata.fingerprintCount} corpus fingerprints; ${result.exemptions} exemptions)`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();

package/scripts/rsc.js

@@ -4,7 +4,8 @@ import { detectTarget, resolveTargets, TARGETS } from '../targets/index.js';
 import { detectRepo } from './detect-repo.js';
 import { rank } from './consult.js';
 import { expandRecommends, toOutcomes, hasOutcome } from './lib/recommend.js';
-import { applyInstall, listInstalled, uninstall, syncInstalled, purge, collisions } from './install-apply.js';
+import { applyInstall, listInstalled, listInstalledAgents, listInstalledCommands, uninstall, syncInstalled, purge, collisions } from './install-apply.js';
+import { stackAgentNames } from '../targets/agents.js';
 import { doctor } from './doctor.js';
 import { say, select, pickFrom, banner, confirm, isInteractive } from './lib/ui.js';
 import { refreshRegistry, registryStatus } from './lib/registry.js';
@@ -20,6 +21,54 @@ const cmd = argv[0];
 
 const targetLabel = (id) => TARGETS.find((t) => t.id === id)?.label || id;
 
+function requestedIds(start = 1) {
+  const valueFlags = new Set(['--target', '--profile', '--without']);
+  const ids = [];
+  for (let i = start; i < argv.length; i++) {
+    if (valueFlags.has(argv[i])) { i++; continue; }
+    if (argv[i].startsWith('--')) continue;
+    ids.push(argv[i]);
+  }
+  return ids;
+}
+
+function editDistance(a, b) {
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = prev[0];
+    prev[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = prev[j];
+      prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return prev[b.length];
+}
+
+function classifyRequested(ids) {
+  const skills = new Set(loadManifest().skills.map((skill) => skill.id));
+  const agents = new Set(stackAgentNames());
+  const out = { skills: [], agents: [], unknown: [] };
+  for (const id of ids) {
+    if (skills.has(id)) out.skills.push(id);
+    else if (agents.has(id)) out.agents.push(id);
+    else out.unknown.push(id);
+  }
+  return out;
+}
+
+function reportUnknown(ids) {
+  if (!ids.length) return false;
+  const candidates = [...loadManifest().skills.map((skill) => skill.id), ...stackAgentNames()];
+  for (const id of ids) {
+    const close = [...candidates].sort((a, b) => editDistance(id, a) - editDistance(id, b) || a.localeCompare(b)).slice(0, 3);
+    console.error(`rsc: unknown skill or agent '${id}'. Closest: ${close.join(', ')}`);
+  }
+  process.exitCode = 1;
+  return true;
+}
+
 // Commands that act ON one assistant. Only these stop when two are installed and no
 // flag says which: `purge` sweeps every target by design, and the catalog/consult
 // side barely touches one, so blocking them would be a regression, not a safeguard.
@@ -113,6 +162,8 @@ function printNextSteps(targets, ids) {
   say('\n   Add something by hand anytime:    npx @ericrisco/rsc add <skill>');
   say('   Browse the catalog / get picks:   npx @ericrisco/rsc consult "whatever you need"');
   say('────────────────────────────────────────────────────────');
+  if (targets.includes('codex')) say('   Codex: review and trust the project lifecycle hook once with `/hooks`; until then memory is reported as requiring trust.');
+  if (targets.includes('cursor')) say('   Cursor: startup memory is assisted because its sessionStart hook is fire-and-forget; the installed always-on rule performs the read-before-action fallback.');
   printAgentHandoff();
 }
 
@@ -268,15 +319,12 @@ async function main() {
     case undefined:
       return wizard(f ? targets : null);
     case 'add': {
-      // Positional args = skill ids; skip flags and any flag value (the token after a --flag).
-      const requested = [];
-      for (let i = 1; i < argv.length; i++) {
-        if (argv[i].startsWith('--')) { i++; continue; }
-        requested.push(argv[i]);
-      }
-      const ids = withDefaultSkillFloor(requested);
+      const requested = requestedIds();
+      const selected = classifyRequested(requested);
+      if (reportUnknown(selected.unknown)) return;
+      const ids = withDefaultSkillFloor(selected.skills);
       if (!argv.includes('--force') && !(await guardCollisions(targets, ids))) return;
-      for (const t of targets) await applyInstall({ skillIds: ids, target: t });
+      for (const t of targets) await applyInstall({ skillIds: ids, agentIds: selected.agents, target: t });
       say(`✅ Installed for ${targets.join(', ')}: ${requested.join(', ')}`);
       return void say('   ↻ Reload/restart your assistant so the new skill activates.');
     }
@@ -328,14 +376,66 @@ async function main() {
       else say('\n(no harness wiki here — printed above only; run `harness` to keep a written record)');
       return;
     }
-    case 'list':
-      return void say(listInstalled({ target }).join('\n') || '(nothing installed)');
+    case 'list': {
+      const skills = listInstalled({ target }).map((id) => `skill\t${id}`);
+      const agents = listInstalledAgents({ target }).map((agent) => `agent\t${agent.id}\t${agent.source}${agent.skills.length ? `:${agent.skills.join(',')}` : ''}`);
+      const commands = listInstalledCommands({ target }).map((command) => `command\t${command.id}\t${command.path}`);
+      return void say([...skills, ...agents, ...commands].join('\n') || '(nothing installed)');
+    }
     case 'doctor': {
       const report = doctor({ target });
       if (argv.includes('--json')) return void say(JSON.stringify(report, null, 2));
       printContextBudget(report.contextBudget);
       return void say(JSON.stringify({ ...report, contextBudget: undefined }, null, 2));
     }
+    case 'memory': {
+      const sub = argv[1] || 'status';
+      const root = process.cwd();
+      if (sub === 'on' || sub === 'off') {
+        const { readManifest, writeManifest } = await import('./lib/manifest-file.js');
+        const current = readManifest(root) || { version: 1, targets: targets || [], skills: [], agents: [], ownSkills: [], optOuts: [] };
+        writeManifest(root, { ...current, memory: sub === 'off' ? false : { enabled: true } });
+        for (const t of targets) await syncInstalled({ target: t, cwd: root });
+        say(`rsc memory ${sub}: ${sub === 'on' ? 'enabled' : 'disabled'} for this project (${targets.join(', ') || 'declaration only'}).`);
+        return;
+      }
+      const M = await import('../targets/session-memory-core.mjs');
+      if (sub === 'status') {
+        const reports = targets.map((t) => doctor({ target: t, cwd: root }).memory);
+        return void say(JSON.stringify(reports.length === 1 ? reports[0] : reports, null, 2));
+      }
+      if (sub === 'resume') {
+        const result = M.resume({ cwd: root });
+        return void say(argv.includes('--json') ? JSON.stringify(result, null, 2) : (result.context || '(no local continuation for this branch/worktree)'));
+      }
+      if (sub === 'save') {
+        const result = M.capture({
+          cwd: root,
+          sessionId: typeof flag('session') === 'string' ? flag('session') : `manual-${Date.now()}`,
+          target: target || 'manual',
+          event: 'save',
+          force: true,
+        });
+        return void say(JSON.stringify(result, null, 2));
+      }
+      if (sub === 'learn') {
+        const value = (name) => { const v = flag(name); return typeof v === 'string' && !v.startsWith('--') ? v : undefined; };
+        const result = M.learn({
+          cwd: root,
+          text: value('text'),
+          evidence: value('evidence'),
+          scope: value('scope') || 'project',
+          confidence: value('confidence'),
+          approved: argv.includes('--approve'),
+        });
+        if (!result.saved) process.exitCode = 1;
+        return void say(JSON.stringify(result, null, 2));
+      }
+      if (sub === 'metrics') return void say(JSON.stringify(M.metricsSummary({ cwd: root }), null, 2));
+      say('Use: npx @ericrisco/rsc memory on|off|status|save [--session id]|resume [--json]|learn --text "…" --evidence "…" --scope project|global --confidence 0..1 --approve|metrics');
+      process.exitCode = 1;
+      return;
+    }
     case 'sync': {
       const dry = argv.includes('--dry-run');
       for (const t of targets) {
@@ -446,6 +546,13 @@ async function main() {
         } else {
           say(`# ${caps.target} has no file-based agents — the agent option does not apply here`);
         }
+        if (caps.commandsSupported) {
+          for (const command of caps.commands) say(`command\t${command.id}\tproject\t${command.path}`);
+          if (!caps.commands.length) say('# no managed command files found (this target supports them)');
+        } else {
+          say(`# ${caps.target} has no supported project command surface`);
+        }
+        say(`memory\t${caps.memory.mode}\t${caps.memory.status}\t${caps.memory.reason}`);
       }
       if (!full) say('# catalog shown as ids; add --full for descriptions, or use `catalog --available` to match by meaning');
       return;
@@ -623,8 +730,9 @@ async function main() {
       const dry = argv.includes('--dry-run');
       // `uninstall --all` is an alias for a full purge.
       if (argv.includes('--all')) return void (await runPurge(dry, argv.includes('--with-docs')));
-      const ids = argv.slice(1).filter((a) => !a.startsWith('--'));
-      const removed = await uninstall({ skillIds: ids, target, dryRun: dry });
+      const selected = classifyRequested(requestedIds());
+      if (reportUnknown(selected.unknown)) return;
+      const removed = await uninstall({ skillIds: selected.skills, agentIds: selected.agents, target, dryRun: dry });
       return void say((dry ? 'Would remove:\n' : 'Removed:\n') + (removed.join('\n') || '(nothing)'));
     }
     case 'repair': {
@@ -652,7 +760,7 @@ async function main() {
       return void (await runPurge(argv.includes('--dry-run'), argv.includes('--with-docs')));
     default:
       say(`rsc: unknown command '${cmd}'.`);
-      say('Use: npx @ericrisco/rsc | add <id...> | install --profile <p> | consult "<text>" | list | capabilities [--full|gap-log] | audit | registry refresh | doctor | sync | sello <on|off|status|…> | backups | restore <id|latest> | upgrade | repair | uninstall <id> | purge');
+      say('Use: npx @ericrisco/rsc | add <id...> | install --profile <p> | consult "<text>" | list | capabilities [--full|gap-log] | audit | registry refresh | doctor | sync | memory <on|off|status|save|resume|learn|metrics> | sello <on|off|status|…> | backups | restore <id|latest> | upgrade | repair | uninstall <id> | purge');
       say('Any command takes --target <claude|codex|cursor|copilot|gemini|…> (comma-separate for several)');
       say('   → without it, rsc uses the assistant already installed here; if two are, it asks instead of guessing.');
       process.exitCode = 1;

package/skills/design/SKILL.md

@@ -11,9 +11,9 @@ origin: risco
 
 **Hand-off — the visual system vs the craft of motion.** This skill owns the visual system and page
 composition, and sets motion *intent + budget* only. The **implementation** of an animation is
-`../animate/SKILL.md`'s; reviewing motion is `../review-animations/SKILL.md`'s; gesture physics and
-translucent materials are `../apple-design/SKILL.md`'s. When a frontend request could belong to
-several of those, `../design-eng/SKILL.md` is the umbrella that routes it. The motion reference in
+`../motion-craft/SKILL.md`'s; how a piece of interface should be BUILT — boundaries, state, the
+loading and empty and error states — is `../ui-engineering/SKILL.md`'s. When a request could belong to
+several of those, start from the one that owns the decision, not the one that owns the file. The motion reference in
 this skill defers its mechanics to them rather than restating them.
 
 

package/skills/design/references/design-systems.md

@@ -42,7 +42,7 @@ not settle whether the page says anything.
 
 ## Where to browse for component ideas
 
-When a surface needs an idea rather than a primitive, `../../pick-ui-library/references/component-galleries.md`
+When a surface needs an idea rather than a primitive, a gallery of shipped products
 names where to go — Aceternity for marketing effects, 21st.dev for breadth, React Bits for tunable
 animation — and what each is good for. Take the technique and rebuild it in this project's tokens;
 check the brand study for what it refuses first, because a component that contradicts a stated ban

package/skills/design/references/inspiration-sources.md

@@ -59,7 +59,7 @@ these are for when a piece is "the footer" or "the empty state".
 | [Footer.design](https://www.footer.design) | Footers only. Narrow on purpose, and the narrowness is why it is good. |
 | [Collect UI](https://collectui.com) | Daily-UI-style collections by component and pattern. |
 | [UI Garage](https://uigarage.net) | Patterns tagged by element and by industry. |
-| [UI Movement](https://uimovement.com) | Motion and interaction specifically — pair with the frequency gate in `../../animate/SKILL.md` before copying anything. |
+| [UI Movement](https://uimovement.com) | Motion and interaction specifically — pair with the frequency gate in `../../motion-craft/SKILL.md` before copying anything. |
 | [Dark.design](https://dark.design) · [Dark Mode Design](https://darkmodedesign.com) | Dark interfaces done properly, which is a different problem from inverting a light one. |
 | [Scrnshts](https://scrnshts.club) | App Store screenshot design — a real discipline of its own. |
 
@@ -91,6 +91,6 @@ component", these outrank any gallery.
 - **[Bestfolios](https://www.bestfolios.com) returned 502 on 2026-08-24** and is excluded until it
   comes back. Do not cite it.
 - **Component ideas**, as opposed to whole pages, live in
-  `../../pick-ui-library/references/component-galleries.md` — Aceternity, 21st.dev, React Bits.
+  Component galleries — Aceternity, 21st.dev, React Bits.
 - **Identity outranks all of this.** Check `02-DOCS/wiki/brand/` for what the project refuses before
   bringing an idea back. A gallery cannot know what your brand vetoed.

package/skills/design/references/motion-and-interaction.md

@@ -30,8 +30,8 @@ Need one that is not here? Take it from [easing.dev](https://easing.dev/), do no
 
 The choice, in decision order: entering or exiting → `ease-out`; moving on screen → `ease-in-out`;
 hover or color → `ease`; constant motion (marquee, progress) → `linear`; unsure → `ease-out`.
-`../../animate/SKILL.md` owns the full build sequence and the per-element duration table, and
-`../../review-animations/scripts/verify.sh` flags an `ease-in` that slips through.
+`../../motion-craft/SKILL.md` owns the duration ranges, the easing families and the never-animate list, and
+its diagnosis table maps the complaint — sluggish, cheap, janky — back to the cause.
 
 - **Enter vs exit asymmetry:** entrances are slower and softer (`--dur-normal`, `--ease-out`); exits are quicker and quieter (~150ms) so dismissals feel responsive.
 - **Press feedback:** `scale(0.97)` on `:active` gives a tactile button without distracting movement.

package/skills/design-dna/evals/cases.yaml

@@ -30,7 +30,7 @@ should_not_trigger:
     route_to: "nextjs"
     why: "The build. The identity stays in the record; the framework work is the sibling's."
   - prompt: "Give me three different directions for this poster and I'll choose."
-    route_to: "prototype"
+    route_to: "variant-explorer"
     why: "Exploration among variants. One skill per style: merging two candidate identities into one spec produces the average of two good designs, which is a bad design."
 
 capability:

package/skills/design-loop/SKILL.md

@@ -40,7 +40,7 @@ and proposing from memory is how this promise used to resolve to the AI-template
 
 **Where to go looking.** For a whole page to beat, and for the flows and single patterns behind it:
 `../design/references/inspiration-sources.md`. For a component idea rather than a whole reference:
-`../pick-ui-library/references/component-galleries.md`. Browse for the technique, never to clone a
+a gallery of real products. Browse for the technique, never to clone a
 competitor's exact grid — and come back with **a specific page you can open**, because a gallery
 is not a bar.
 
@@ -152,8 +152,8 @@ how the look drifts back to generic by the fifth piece.
   this loop invokes; it stays reachable directly when there is no bar to beat and no loop to run.
 - **Codifying the winner into a permanent identity** → `../design-dna/SKILL.md`.
 - **The words** → `../marketing/SKILL.md`. **The build** → `../nextjs/SKILL.md`.
-- **Motion craft, and routing among the frontend craft siblings** → `../design-eng/SKILL.md`.
-- **"Show me a few versions and I'll pick"** → `../prototype/SKILL.md`. That is selection among
+- **Motion craft** → `../motion-craft/SKILL.md`. **How the interface should be built** → `../ui-engineering/SKILL.md`.
+- **"Show me a few versions and I'll pick"** → `../variant-explorer/SKILL.md`. That is selection among
   variants; this is convergence against a bar.
 - **SDD gate.** This skill runs a method; it does not outrank the chain. If the request is a new
   feature or a non-trivial behaviour change in a real app, `../specify/SKILL.md` runs first, then

package/skills/design-loop/evals/cases.yaml

@@ -24,11 +24,11 @@ should_not_trigger:
     route_to: "design"
     why: "Visual system work with no reference to beat and nothing to judge. `design` stays directly reachable exactly for this."
   - prompt: "Show me three versions of this button and I'll pick the one I like."
-    route_to: "prototype"
+    route_to: "variant-explorer"
     why: "Selection among variants by human preference, not convergence against a measured bar. The user is the judge and there is no reference."
   - prompt: "Review the motion in this diff and tell me what's off."
-    route_to: "review-animations"
-    why: "One diff, motion-specific, no reference and no build-then-judge rounds. Reviewing is not looping."
+    route_to: "motion-craft"
+    why: "One diff, motion-specific, no reference and no build-then-judge rounds. The motion craft skill owns the complaint-to-cause mapping; reviewing is not looping."
   - prompt: "Write the hero headline and value prop for our developer-tool site."
     route_to: "marketing"
     why: "The words, not the bar. `voice` constrains copy in this pipe; it does not write it."

package/skills/expo/SKILL.md

@@ -11,7 +11,7 @@ origin: risco
 **Hand-off — the app vs its motion.** This skill owns the Expo platform: router, config plugins, EAS,
 native modules, store builds. **Animation and gestures** — Reanimated worklets, the UI runtime,
 sheets, screen transitions, press feedback, haptics, motion that stutters on a real device — are
-`../animate-expo/SKILL.md`'s.
+`../motion-craft/SKILL.md`'s.
 
 
 ## What this skill owns

package/skills/motion-craft/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: motion-craft
+description: "Use when an interface moves and the movement has to feel right — durations and easing, what must never animate, fixing motion that reads sluggish, cheap or janky, and reduced-motion. Web and native. NOT the visual system (that is `design`), NOT the graded critique (that is `design-loop`)."
+tags: [motion, animation, interface, craft, frontend]
+recommends: [design]
+profiles: [full]
+origin: risco
+---
+
+# Motion craft — movement that reads as intent
+
+Motion is not decoration laid over an interface. It is the interface **explaining what just
+happened**: what appeared, what it came from, what is still loading, what the user just did. When
+motion feels wrong the complaint is almost never "the curve is off" — it is "this feels cheap", or
+"slow", or "I don't know what happened". Those are the symptoms this skill exists to convert into
+decisions.
+
+## The one rule
+
+**Every animation answers a question the user is already asking.** If you cannot name the question,
+delete the animation — it is costing time and attention and returning nothing.
+
+| The user is asking | The motion that answers it |
+| --- | --- |
+| "Where did this come from?" | It enters from its origin, not from nowhere |
+| "Is it working?" | Immediate feedback, under 100ms, even before the result |
+| "What did I just do?" | The changed thing moves; nothing else does |
+| "Where did it go?" | It exits toward where it can be found again |
+| nothing | **no animation** |
+
+That table is the whole method. Everything below is how to honour it without shipping something
+that janks.
+
+## Duration: the only numbers worth memorising
+
+Movement is read as *slow* long before it is read as *long*. The usable range is narrower than most
+people expect, and the mistake is almost always **too slow**, not too fast.
+
+| What moves | Range | Why |
+| --- | --- | --- |
+| State on an element already on screen (hover, toggle, press) | 100–150ms | It must feel like a response, not an event |
+| Something entering or leaving in place (menu, tooltip, toast) | 150–250ms | Long enough to be seen, short enough not to be waited for |
+| A region rearranging (list reflow, panel) | 250–350ms | Bigger travel needs more time to stay legible |
+| A full view transition | 300–400ms | The ceiling. Past 400ms it is a wait, not a transition |
+
+Two rules that come from those numbers, not from taste:
+
+- **Exits are faster than entrances**, usually by about a third. The user has already decided; making
+  them watch the decision leave is the single most common way an interface feels sluggish.
+- **Distance and duration scale together, sub-linearly.** Doubling the travel does not double the
+  time. If a value grows past 400ms because the element crosses the screen, the layout is the
+  problem, not the timing.
+
+## Easing: three curves cover almost everything
+
+- **Entering, or responding to input** — start fast, settle slow (`ease-out` family). The user's
+  attention is already there; arriving quickly and settling reads as responsive.
+- **Leaving** — start slow, accelerate away (`ease-in` family). It matches how the eye lets go.
+- **Moving between two on-screen positions** — accelerate and decelerate (`ease-in-out` family).
+
+**Linear is for one thing only: continuous, non-positional change** — a progress bar filling, a
+spinner rotating, a colour crossfade. Linear on anything that moves in space reads as mechanical,
+because nothing physical starts at full speed.
+
+Springs are worth reaching for when the motion should feel *physical* — dragging, dismissing,
+anything the user's finger or pointer is still in contact with. They are the wrong tool for
+appearing and disappearing, where a bounce reads as indecision.
+
+## What must never animate
+
+This is where most jank comes from, and it is not a matter of degree.
+
+- **Never animate layout.** Width, height, top, left, margin, padding — each frame forces the engine
+  to recompute geometry. Animate transform and opacity, which do not.
+- **Never `transition: all`.** It is the shortest path to animating layout by accident. List the
+  properties.
+- **Never animate what the user is reading.** Text that moves while being read is illegible.
+- **Never block input on an animation.** The interface accepts the next action immediately, even
+  mid-motion. An animation that must finish before the user may act has become a modal dialog.
+- **Never animate more than one thing per event.** If three things move when one changed, the user
+  cannot tell which one mattered.
+
+## Reduced motion is not an edge case
+
+A real share of people have vestibular conditions for which large movement is nauseating, and they
+have told their operating system so. Honouring it is not optional and it is not a fallback to
+nothing:
+
+- **Keep** the feedback: opacity changes, colour, instant state.
+- **Remove** the travel: no sliding across the screen, no scaling, no parallax, no auto-playing loops.
+- The interface must still say what happened — it just says it without moving.
+
+An implementation with no reduced-motion branch is unfinished, the same way an interface with no
+error state is unfinished.
+
+## Diagnosing motion that feels wrong
+
+The complaint names the symptom; this maps it to a cause.
+
+| Complaint | Usually | Fix |
+| --- | --- | --- |
+| "Sluggish" | Duration too long, or the exit matches the entrance | Cut to the range above; make exits faster |
+| "Cheap" / "amateur" | Linear easing on positional movement, or bounce on entrances | Match curve to direction |
+| "Janky" / "stutters" | Animating layout properties | Move to transform and opacity |
+| "Distracting" | More than one thing moving per event | Animate only what changed |
+| "I don't know what happened" | Motion with no origin or destination | Move it from where it came from |
+| "Nice, but I'd turn it off" | No reduced-motion branch, or motion that repeats | Honour the setting; never loop what is not loading |
+
+## Anti-patterns → STOP
+
+| If you're about to… | Reality / Fix |
+| --- | --- |
+| Add motion because the screen feels static | Static is not a defect. Motion with no question to answer is noise with a frame cost. |
+| Copy a duration from a design you liked | You copied the number without its distance and its context. Take the range, verify against the feel. |
+| Animate a list so every item cascades in | Stagger past ~4 items becomes a queue the user waits through. Cap it, or drop it. |
+| Use a spring for a menu appearing | A bounce on an entrance reads as indecision. Springs are for what the pointer is still touching. |
+| Ship motion without checking reduced-motion | It is not an edge case. Unchecked means unfinished. |
+| Reach here for the visual system | Type, colour, spacing and composition are `../design/SKILL.md`. This skill only moves what that one placed. |
+
+## See Also
+
+- `../design/SKILL.md` — the visual system this motion serves.
+- `../design-loop/SKILL.md` — the graded critique that judges a finished screen, motion included.
+- `../design-dna/SKILL.md` — turning a look, motion rules included, into a reusable identity.
+- `../accessibility/SKILL.md` — the wider ground reduced-motion sits in.

package/skills/motion-craft/evals/cases.yaml

@@ -0,0 +1,38 @@
+skill: motion-craft
+
+should_trigger:
+  - prompt: "The menu animation feels sluggish, can you make it feel snappier?"
+    why: "The canonical case: a complaint about feel, which this skill converts into a duration and an easing decision."
+  - prompt: "What duration and easing should this dropdown use?"
+    why: "Directly the numbers this skill owns, for an element entering in place."
+  - prompt: "My list animation stutters when it reflows."
+    why: "Jank is the symptom of animating layout properties, which is the one hard rule here."
+  - prompt: "Añade una animación al abrir el panel, pero que no quede cutre."
+    why: "Same ask in Spanish; the trigger is the intent, not the language."
+  - prompt: "Does this respect prefers-reduced-motion? I don't think we handled it."
+    why: "Reduced-motion is treated here as part of finishing the work, not as an edge case."
+  - prompt: "Everything on the page moves at once when I click one button."
+    why: "More than one thing moving per event is a named diagnosis in this skill."
+
+should_not_trigger:
+  - prompt: "Design a landing page for my analytics SaaS — hero, pricing, the works."
+    route_to: "design"
+    why: "Type, colour, spacing and composition are the visual system, which this skill only moves once it exists."
+  - prompt: "Review this checkout screen and tell me how good it actually is, with a grade."
+    route_to: "design-loop"
+    why: "Graded critique of a finished screen is the loop's job; this skill builds motion, it does not judge screens."
+  - prompt: "This design came out great — turn it into a style I can reuse everywhere."
+    route_to: "design-dna"
+    why: "Codifying a look into a permanent identity is capture, not motion craft."
+  - prompt: "Make the site keyboard navigable and fix the contrast failures."
+    route_to: "accessibility"
+    why: "Accessibility beyond reduced-motion is its own ground; only the motion half lives here."
+  - prompt: "Our React app re-renders too much and the profiler shows wasted renders."
+    route_to: "react"
+    why: "A rendering performance problem is framework work, even when the symptom looks like stutter."
+
+capability:
+  - prompt: "This modal slides in over 600ms with a linear curve and it feels cheap. Fix it and say why."
+    why: "Exercises the two most common defects at once — too slow, and linear on positional movement — and demands the reasoning, not just new numbers."
+  - prompt: "We animate width and height on the sidebar and it janks on mobile. What do we do instead?"
+    why: "The layout-vs-compositor rule is the load-bearing piece of technical content here."