@lifeaitools/rdc-skills 0.9.18 → 0.9.20

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.7.9",
+  "version": "0.9.20",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/MANIFEST.md

@@ -1,9 +1,9 @@
 # RDC Skills Library — Manifest
 
 **Created:** 2026-04-13  
-**Last updated:** 2026-04-21  
+**Last updated:** 2026-05-01  
 **Source:** Regen Root project `.claude/skills/user/`  
-**Files:** 17 skill files (2,277 lines), 10 agent guides, 9 main guides  
+**Files:** 18+ skill files, 10 agent guides, command mirrors, and support scripts  
 **Size:** ~480K  
 
 ## Generic Conversion Summary
@@ -51,6 +51,7 @@ All skills have been converted from project-specific to generic/portable:
     ├── handoff/SKILL.md
     ├── prototype/SKILL.md
     ├── workitems/SKILL.md
+    ├── design/SKILL.md       [RDC/Studio design, Palette Library, Rampa CLI]
     ├── help/SKILL.md
     ├── deploy/SKILL.md       [Coolify deployment ops]
     ├── release/SKILL.md      [atomic version release]
@@ -111,6 +112,9 @@ All skills have been converted from project-specific to generic/portable:
 - rdc:prototype — JSX prototypes
 - rdc:workitems — work item CRUD
 
+### Design (1)
+- rdc:design — Studio-aware design workflow with token, Palette Library, and Rampa CLI context
+
 ### Reference (1)
 - rdc:help — skill index
 

package/README.md

@@ -13,7 +13,7 @@ From any Claude Code session:
 /plugin install rdc-skills
 ```
 
-All 17 user-invocable skills become available as slash commands. Agent playbooks in `guides/agents/` are dispatched internally by `rdc:build` and are not user-invocable.
+All user-invocable skills become available as slash commands. Agent playbooks in `guides/agents/` are dispatched internally by `rdc:build` and are not user-invocable.
 
 ### Option B — Directory plugin (LIFEAI dev machines)
 
@@ -78,6 +78,9 @@ Located in `guides/agents/` — plain markdown playbooks spawned as sub-agents:
 ### Utility Skills
 - rdc:collab
 
+### Design Skills
+- rdc:design — RDC/Studio design, tokens, palettes, themes, and Rampa CLI-assisted color systems
+
 ### Reference
 - rdc:help
 
@@ -136,6 +139,7 @@ skills/
   handoff/SKILL.md     (planning → work items)
   prototype/SKILL.md   (build JSX prototype)
   workitems/SKILL.md   (work item management)
+  design/SKILL.md      (RDC/Studio design, Palette Library, Rampa CLI)
   help/SKILL.md        (skill index — shows current version)
   deploy/SKILL.md      (Coolify ops: deploy, new, diagnose, audit)
   release/SKILL.md     (atomic package/app release)
@@ -172,7 +176,7 @@ python3 -c "import json; print(json.load(open('package.json'))['version'])"
 /rdc:help
 ```
 
-Current version: **v0.8.0**
+Current version: **v0.9.20**
 
 ## Quick Start
 

package/commands/design.md

@@ -0,0 +1,31 @@
+---
+name: rdc:design
+description: >-
+  Usage `rdc:design <command|brief>` — RDC-owned design skill for Studio, Palette Library, token-aware UI work, and Rampa CLI-assisted color systems. Forked/adapted from Impeccable concepts without modifying installed Impeccable.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+
+# rdc:design — RDC Design Skill
+
+Use `skills/design/SKILL.md` as the source of truth.
+
+## When to Use
+
+- Studio, Palette Library, brand-token, theme, component, or live-editor work
+- Any design task that must understand RDC's real token tables and Studio routes
+- UI critique, audit, polish, colorize, type, layout, or craft work in `regen-root`
+- Agent-side color-system exploration using Rampa CLI
+
+## Arguments
+
+- `rdc:design studio <target>`
+- `rdc:design tokens <brand-or-route>`
+- `rdc:design palette <brief>`
+- `rdc:design theme <brief>`
+- `rdc:design colorize <target>`
+- `rdc:design audit <target>`
+- `rdc:design critique <target>`
+- `rdc:design polish <target>`
+- `rdc:design craft <feature>`

package/commands/help.md

@@ -40,6 +40,7 @@ Print the full usage menu below verbatim, then ask the project lead which comman
 | `rdc:prototype` | `rdc:prototype <description>` — JSX mock for review |
 | `rdc:workitems` | `rdc:workitems <add\|update\|done\|list\|epics> [args]` |
 | `rdc:collab` | `rdc:collab --session <id>` — claude.ai bidirectional relay |
+| `rdc:design` | `rdc:design <command\|brief>` — RDC/Studio design, tokens, palettes, themes, Rampa CLI |
 
 ## Agent guides (dispatched by rdc:build, not user-invocable)
 
@@ -76,6 +77,7 @@ Project lead says → invoke
 "hand this off" / "give to agents"      → rdc:handoff
 "show me what it looks like"            → rdc:prototype
 "add to backlog" / "create a ticket"    → rdc:workitems
+"design/tokens/palette/theme"           → rdc:design <command>
 "what commands" / "what skills"         → rdc:help
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.9.18",
+  "version": "0.9.20",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -19,13 +19,14 @@
     "type": "plugin",
     "skills": "skills/",
     "guides": "guides/",
-    "version": "0.9.6",
+    "version": "0.9.20",
     "commands": "commands/"
   },
   "scripts": {
     "install-rdc-skills": "node scripts/install-rdc-skills.js",
     "uninstall:win": "powershell -ExecutionPolicy Bypass -File scripts/uninstall.ps1",
     "uninstall:unix": "bash scripts/uninstall.sh",
-    "validate": "node tests/validate-skills.js"
+    "validate": "node tests/validate-skills.js",
+    "rdc-design": "node scripts/rdc-design-cli.mjs"
   }
 }

package/scripts/install-rdc-skills.js

@@ -639,6 +639,42 @@ async function main() {
     info('[2.5] Codex      — skipped (no .agents/ found; use --codex-root <path>)');
   }
 
+  // 2.7. Symlinks in regen-root/.claude/skills/ (FS MCP + claude.ai access)
+  if (codexRoot) {
+    const skillsLinkDir = path.join(codexRoot, '.claude', 'skills');
+    const skillsSrc     = path.join(repoRoot, 'skills');
+    fs.mkdirSync(skillsLinkDir, { recursive: true });
+    let linked = 0;
+    for (const entry of fs.readdirSync(skillsSrc, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (!fs.existsSync(path.join(skillsSrc, entry.name, 'SKILL.md'))) continue;
+      const linkPath = path.join(skillsLinkDir, entry.name);
+      const target   = path.join(skillsSrc, entry.name);
+      try {
+        if (fs.existsSync(linkPath) || (() => { try { fs.lstatSync(linkPath); return true; } catch { return false; } })()) {
+          fs.rmSync(linkPath, { recursive: true, force: true });
+        }
+      } catch {}
+      try {
+        if (process.platform === 'win32') {
+          const winLink   = linkPath.replace(/\//g, '\\');
+          const winTarget = target.replace(/\//g, '\\');
+          execSync(`cmd /c mklink /J "${winLink}" "${winTarget}"`, { stdio: 'pipe' });
+        } else {
+          fs.symlinkSync(target, linkPath, 'dir');
+        }
+        linked++;
+      } catch {}
+    }
+    if (linked > 0) {
+      ok(`[2.7] Symlinks   — ${linked} skill link(s) in ${skillsLinkDir}`);
+    } else {
+      info('[2.7] Symlinks   — no rdc skill links created (skills may already be linked)');
+    }
+  } else {
+    info('[2.7] Symlinks   — skipped (no codex root found)');
+  }
+
   // 3. Hook files
   const hookCount = copyDir(hooksSrc, hooksDst, '.js');
   ok(`[3/6] Hook files — ${hookCount} file(s) → ${hooksDst}`);

package/scripts/rdc-design-cli.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, "..");
+const skillRoot = join(repoRoot, "skills", "design");
+const reportsRoot = join(repoRoot, ".rdc", "reports", "rdc-design-cli");
+
+const args = process.argv.slice(2);
+const json = args.includes("--json");
+const cleanArgs = args.filter((arg) => arg !== "--json");
+const command = cleanArgs[0] || "help";
+const brief = cleanArgs.slice(1).join(" ").trim();
+
+const commandRefs = {
+  studio: ["studio-model", "lineage"],
+  tokens: ["studio-model", "lineage"],
+  palette: ["studio-model", "rampa", "lineage"],
+  theme: ["studio-model", "rampa", "lineage"],
+  colorize: ["rampa", "studio-model", "lineage"],
+  audit: ["studio-model", "lineage"],
+  critique: ["studio-model", "lineage"],
+  polish: ["studio-model", "lineage"],
+  craft: ["studio-model", "rampa", "lineage"],
+  help: ["lineage"],
+};
+
+function readText(path) {
+  return readFileSync(path, "utf8").replace(/\r\n/g, "\n");
+}
+
+function stripFrontmatter(text) {
+  return text.replace(/^---\n[\s\S]*?\n---\n?/, "").trim();
+}
+
+function approxTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+function wordCount(text) {
+  const m = text.trim().match(/\S+/g);
+  return m ? m.length : 0;
+}
+
+function loadReferences(names) {
+  return names.map((name) => {
+    const path = join(skillRoot, "reference", `${name}.md`);
+    if (!existsSync(path)) throw new Error(`Missing reference: ${path}`);
+    return { name, path, text: readText(path) };
+  });
+}
+
+function buildPrompt() {
+  const skillPath = join(skillRoot, "SKILL.md");
+  if (!existsSync(skillPath)) throw new Error(`Missing skill file: ${skillPath}`);
+
+  const refs = loadReferences(commandRefs[command] || ["studio-model", "lineage"]);
+  const skill = stripFrontmatter(readText(skillPath));
+  const refText = refs.map((ref) => `## Reference: ${ref.name}\n\n${ref.text}`).join("\n\n");
+  const target = brief || "(no brief supplied)";
+
+  const prompt = [
+    "# rdc:design CLI Prompt",
+    "",
+    `Command: ${command}`,
+    `Brief: ${target}`,
+    "",
+    "## Operating Instructions",
+    "",
+    skill,
+    "",
+    refText,
+    "",
+    "## User Task",
+    "",
+    `Execute \`rdc:design ${command}\` for: ${target}`,
+    "",
+    "Return checklist-first output, cite concrete Studio files/routes/tables when relevant, and do not mutate upstream Impeccable.",
+  ].join("\n");
+
+  return { prompt, refs };
+}
+
+function writeReport(report) {
+  mkdirSync(reportsRoot, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const base = join(reportsRoot, `${stamp}-${command}`);
+  writeFileSync(`${base}.txt`, report.prompt);
+  writeFileSync(`${base}.json`, JSON.stringify(report, null, 2));
+  return { textPath: `${base}.txt`, jsonPath: `${base}.json` };
+}
+
+try {
+  const { prompt, refs } = buildPrompt();
+  const report = {
+    command,
+    brief,
+    generated_at: new Date().toISOString(),
+    references: refs.map((ref) => ({
+      name: ref.name,
+      path: ref.path,
+      chars: ref.text.length,
+      words: wordCount(ref.text),
+      approx_tokens: approxTokens(ref.text),
+    })),
+    totals: {
+      chars: prompt.length,
+      words: wordCount(prompt),
+      approx_tokens: approxTokens(prompt),
+    },
+    prompt,
+  };
+  const paths = writeReport(report);
+  report.paths = paths;
+
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(`rdc-design-cli`);
+    console.log(`command: ${command}`);
+    console.log(`brief: ${brief || "(none)"}`);
+    console.log(`chars: ${report.totals.chars}`);
+    console.log(`words: ${report.totals.words}`);
+    console.log(`approx_tokens: ${report.totals.approx_tokens}`);
+    console.log(`references: ${report.references.map((r) => r.name).join(", ")}`);
+    console.log(`text: ${paths.textPath}`);
+    console.log(`json: ${paths.jsonPath}`);
+  }
+} catch (error) {
+  console.error(`rdc-design-cli error: ${error.message}`);
+  process.exit(1);
+}

package/scripts/self-test.mjs

@@ -133,10 +133,12 @@ function parseFrontmatter(text) {
 }
 
 function expectedSkillName(dirOrFile) {
-  // Accept either a directory name (rdc-foo) or legacy filename (rdc-foo.md)
+  // Accept current directory names (foo), legacy directory names
+  // (rdc-foo), or legacy filenames (rdc-foo.md).
   const base = basename(dirOrFile, ".md");
-  if (!base.startsWith("rdc-")) return null;
-  return "rdc:" + base.slice(4);
+  if (base.startsWith("rdc-")) return "rdc:" + base.slice(4);
+  if (base === "tests" || base.startsWith(".")) return null;
+  return "rdc:" + base;
 }
 
 function findReferencedFiles(body) {
@@ -183,7 +185,7 @@ function tryAutoFix(filepath, fm, text, result) {
   // Fix: filename/name mismatch — rename directory or file to match frontmatter name
   const _filename = basename(filepath);
   const _dirName = basename(dirname(filepath));
-  const _isSubdir = _filename === "SKILL.md" && _dirName.startsWith("rdc-");
+  const _isSubdir = _filename === "SKILL.md";
   const _skillDirOrFile = _isSubdir ? _dirName : _filename;
   const expected = expectedSkillName(_skillDirOrFile);
   if (expected && fm.name !== expected && fm.name.startsWith("rdc:")) {
@@ -219,7 +221,7 @@ function auditSkill(filepath) {
   const filename = basename(filepath);
   // Support both flat (rdc-foo.md) and subdirectory (rdc-foo/SKILL.md) layouts
   const dirName = basename(dirname(filepath)); // "rdc-foo" when filepath is .../rdc-foo/SKILL.md
-  const isSubdir = filename === "SKILL.md" && dirName.startsWith("rdc-");
+  const isSubdir = filename === "SKILL.md";
   const skillDirOrFile = isSubdir ? dirName : filename;
   const result = {
     skill: null,
@@ -469,15 +471,13 @@ function auditDuplicates(results) {
       } else {
         skillBase = basename(r.file, ".md"); // legacy
       }
-      if (skillBase.startsWith("rdc-")) {
-        const stem = skillBase.slice(4);
-        if (agentBases.has(stem)) {
-          findings.push({
-            level: "error",
-            code: "skill-guide-filename-collision",
-            message: `skills/${skillBase}/SKILL.md collides with guides/agents/${stem}.md (half-reverted move?)`,
-          });
-        }
+      const stem = skillBase.startsWith("rdc-") ? skillBase.slice(4) : skillBase;
+      if (agentBases.has(stem)) {
+        findings.push({
+          level: "warn",
+          code: "skill-guide-name-overlap",
+          message: `skills/${skillBase}/SKILL.md overlaps guides/agents/${stem}.md; allowed when a user-facing skill delegates to an agent guide`,
+        });
       }
     }
   }
@@ -504,8 +504,9 @@ function auditOrphanHooks(results) {
   const sources = [
     ...readdirSync(SKILLS_DIR)
       .filter((f) => {
-        if (!f.startsWith("rdc-")) return false;
-        try { return statSync(join(SKILLS_DIR, f)).isDirectory(); } catch { return false; }
+        try {
+          return statSync(join(SKILLS_DIR, f)).isDirectory() && existsSync(join(SKILLS_DIR, f, "SKILL.md"));
+        } catch { return false; }
       })
       .map((f) => join(SKILLS_DIR, f, "SKILL.md")),
     join(REPO_ROOT, ".claude", "settings.json"),
@@ -735,8 +736,9 @@ function main() {
   let files;
   try {
     files = readdirSync(SKILLS_DIR).filter((f) => {
-      if (!f.startsWith("rdc-")) return false;
-      try { return statSync(join(SKILLS_DIR, f)).isDirectory(); } catch { return false; }
+      try {
+        return statSync(join(SKILLS_DIR, f)).isDirectory() && existsSync(join(SKILLS_DIR, f, "SKILL.md"));
+      } catch { return false; }
     });
   } catch (e) {
     console.error(`FATAL: cannot read skills dir ${SKILLS_DIR}: ${e.message}`);
@@ -745,7 +747,10 @@ function main() {
 
   if (ONLY_SKILLS.length > 0) {
     files = files.filter((f) => {
-      return ONLY_SKILLS.some((s) => f === s.replace(":", "-"));
+      return ONLY_SKILLS.some((s) => {
+        const bare = s.replace(/^rdc:/, "");
+        return f === bare || f === s.replace(":", "-");
+      });
     });
     if (files.length === 0) {
       console.error(`no skill file matches: ${ONLY_SKILLS.join(", ")}`);

package/skills/design/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: rdc:design
+description: >-
+  Usage `rdc:design <command|brief>` — RDC-owned design skill for Studio, Palette Library, token-aware UI work, and Rampa CLI-assisted color systems. Forked/adapted from Impeccable concepts without modifying installed Impeccable.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+> One checklist upfront, updated in place, shown again at end with a 1-line verdict.
+
+> If dispatching subagents or running as a subagent: read `{PROJECT_ROOT}/.rdc/guides/agent-bootstrap.md` first (fallback: `{PROJECT_ROOT}/.rdc/guides/agent-bootstrap.md`).
+
+> **Sandbox contract:** This skill honors `RDC_TEST=1` per `guides/agent-bootstrap.md` § RDC_TEST Sandbox Contract. Destructive external calls, Supabase writes, git pushes, package publishes, and deploys are skipped under `RDC_TEST=1`.
+
+# rdc:design — RDC Design Skill
+
+RDC-owned design execution for Studio and LIFEAI interfaces. This skill is inspired by and adapted from the Impeccable design workflow, but it is not the installed Impeccable skill and must not modify upstream Impeccable files.
+
+## When to Use
+
+- Studio, Palette Library, brand-token, theme, component, or live-editor work
+- Any design task that must understand RDC's real token tables and Studio routes
+- UI critique, audit, polish, colorize, type, layout, or craft work in `regen-root`
+- Agent-side color-system exploration using Rampa CLI
+- Preparing token-aware implementation instructions for frontend/backend/data agents
+
+Use the installed `impeccable` skill directly only when the task is a general upstream Impeccable workflow and does not need RDC Studio knowledge.
+
+## Arguments
+
+- `rdc:design` — show the command menu
+- `rdc:design studio <target>` — Studio-aware design task
+- `rdc:design tokens <brand-or-route>` — token model, resolver, export, or governance task
+- `rdc:design palette <brief>` — Palette Library or palette generation task
+- `rdc:design theme <brief>` — theme generation/application task
+- `rdc:design colorize <target>` — Rampa-assisted color-system work
+- `rdc:design audit <target>` — design quality audit
+- `rdc:design critique <target>` — UX/design critique
+- `rdc:design polish <target>` — final visual and interaction pass
+- `rdc:design craft <feature>` — shape and build a token-aware UI feature
+
+## Required References
+
+Load only what applies, but do not skip the Studio model for Studio/token/palette/theme work.
+
+| Task type | Required reference |
+|---|---|
+| Studio, tokens, palettes, themes, editor | `skills/design/reference/studio-model.md` |
+| Color generation, ramps, contrast, neutrals | `skills/design/reference/rampa.md` |
+| Attribution, fork boundary, Impeccable relationship | `skills/design/reference/lineage.md` |
+
+Project docs to read for Studio work:
+
+- `docs/systems/studio/ARCHITECTURE.md`
+- `apps/studio/CLAUDE.md`
+- `.claude/context/design-system-global.md`
+- affected route/component/source files
+
+## Procedure
+
+1. **Classify the task.**
+   - `studio`, `tokens`, `palette`, and `theme` always load the Studio model.
+   - `palette`, `theme`, and `colorize` also load the Rampa reference.
+   - `audit`, `critique`, `polish`, and `craft` load Studio model when the target is inside Studio or uses Studio tokens.
+
+2. **Read the actual system context.**
+   - For Studio: read `docs/systems/studio/ARCHITECTURE.md` and `apps/studio/CLAUDE.md`.
+   - For token work: read `.claude/context/design-system-global.md`.
+   - For app UI work: read the app-specific `CLAUDE.md` if present.
+
+3. **Find the source of truth before proposing changes.**
+   - Tokens: Studio APIs, resolver files, and Supabase token tables.
+   - Palette Library: Studio palette APIs and theme/palette model.
+   - Live editor: local editor routes and clauth relay routes.
+   - Components: `@regen/ui`, Studio component registry, and existing local components.
+
+4. **Use Rampa only as proposal tooling.**
+   - Run Rampa CLI for color ramps, APCA/WCAG checks, tinted neutrals, status palettes, or data-viz palettes.
+   - Treat output as draft design material.
+   - Persist only after mapping into Studio token roles or Palette Library payloads.
+
+5. **Apply RDC design rules.**
+   - Use Studio tokens for production surfaces.
+   - Do not hardcode color/font/spacing when a token exists.
+   - Do not modify locked governance tokens.
+   - Keep product UIs compact, operational, and scannable.
+   - Avoid generic AI design patterns and card-heavy layouts.
+
+6. **Plan edits before mutating files.**
+   - State the files/routes/tables involved.
+   - Use RDC work-item protocol for non-trivial implementation.
+   - Keep upstream Impeccable installed and untouched.
+
+7. **Verify.**
+   - Run scoped tests only.
+   - For Studio: prefer route smoke checks, token API checks, and browser screenshots when UI changed.
+   - For CLI prompt work: run `node C:/Dev/rdc-skills/scripts/rdc-design-cli.mjs <command> <brief>` and inspect the generated report under `.rdc/reports/rdc-design-cli/`.
+
+## Command Menu
+
+| Command | Purpose |
+|---|---|
+| `studio` | Studio-aware design/build task with token, route, and editor context |
+| `tokens` | Diagnose or design token usage, resolver flow, API/export, governance |
+| `palette` | Palette Library work, palette generation, external Palette Designer handoff |
+| `theme` | Theme creation/application/export against Studio's canonical model |
+| `colorize` | Rampa-assisted color relationships and contrast checks |
+| `audit` | Technical and visual audit |
+| `critique` | UX/design review |
+| `polish` | Final detail pass |
+| `craft` | Shape and build a token-aware interface |
+
+## CLI Helper
+
+Use the local helper to see exactly how much instruction text the skill is generating before sending it through an agent:
+
+```powershell
+node C:/Dev/rdc-skills/scripts/rdc-design-cli.mjs studio "audit the Studio palette page"
+node C:/Dev/rdc-skills/scripts/rdc-design-cli.mjs palette "generate a PRT palette workflow"
+node C:/Dev/rdc-skills/scripts/rdc-design-cli.mjs --json theme "RDC earth-forward light theme"
+```
+
+The helper writes logs to:
+
+```text
+C:/Dev/rdc-skills/.rdc/reports/rdc-design-cli/
+```
+
+Each run includes character count, word count, approximate token count, references loaded, and the final prompt text.
+
+## Boundaries
+
+- Do not edit installed Impeccable skills.
+- Do not create another skill named `impeccable`.
+- Do not persist Rampa output directly to production without Studio token mapping.
+- Do not fork or ship Palette Designer until its license is verified.
+- Do not use Studio's deprecated `/api/editor/render` route.

package/skills/design/reference/lineage.md

@@ -0,0 +1,31 @@
+# RDC Design Lineage
+
+RDC Design is inspired by and adapted from the Impeccable design workflow. Upstream Impeccable remains installed separately and untouched.
+
+## Rules
+
+- Keep the installed Impeccable skill available for direct use.
+- Do not rename or overwrite installed Impeccable files.
+- Do not create a second skill named `impeccable`.
+- Use `rdc:design` for RDC, Studio, token, Palette Library, Rampa CLI, and LIFEAI interface work.
+- Preserve third-party license and notice files if source material is forked or vendored.
+
+## Attribution Text
+
+Use this attribution in docs or NOTICE files when the implementation materially derives from Impeccable:
+
+```text
+RDC Design is inspired by and adapted from the Impeccable design workflow by Paul Bakaus.
+Upstream Impeccable remains a separate installed skill.
+```
+
+## Practical Boundary
+
+Concepts such as audit, polish, colorize, shape, craft, and anti-pattern checks are useful workflow patterns. RDC Design replaces the generic project model with RDC-specific knowledge:
+
+- Studio as token authority
+- Palette Library as palette persistence boundary
+- Rampa CLI as proposal tooling
+- RDC work-item protocol
+- local Studio editor/debug routes
+- real LIFEAI app and package paths

package/skills/design/reference/rampa.md

@@ -0,0 +1,92 @@
+# Rampa CLI Reference for RDC Design
+
+Rampa is CLI support for agent-side color-system design. It is not the Studio palette UI and does not replace Studio's Palette Library or token tables.
+
+## Preflight
+
+Prefer `npx` so agents do not depend on a global install:
+
+```powershell
+npx @basiclines/rampa --help
+```
+
+If installed globally:
+
+```powershell
+rampa --help
+```
+
+## Usage Rules
+
+- Use Rampa to generate proposals, not to write production tokens directly.
+- Map every accepted output into Studio token roles or Palette Library payloads.
+- Check contrast before recommending text/background pairs.
+- Avoid pure `#000` and `#fff` as final RDC design tokens.
+- Preserve locked/governance tokens.
+
+## Recipes
+
+### Theme Foundation
+
+```powershell
+npx @basiclines/rampa -C "#548235" -L 95:10 --size=10 -O css --name=primary
+npx @basiclines/rampa -C "#548235" --add=complementary -L 95:10 --size=10 -O css --name=secondary
+npx @basiclines/rampa -C "#548235" -L 98:5 -S 5:10 --size=10 -O css --name=neutral
+```
+
+Map into Studio roles:
+
+- `primary` -> primary palette seed / `--color-primary`
+- `secondary` -> secondary palette seed / `--color-secondary`
+- `neutral` -> surface, text, border, muted roles after contrast review
+
+### Tinted Neutrals
+
+```powershell
+npx @basiclines/rampa -C "#548235" -L 98:5 -S 5:10 --size=10 -O json --name=neutral
+```
+
+Use for background, surface, elevated, border, muted text, and disabled states. Keep chroma low near lightness extremes.
+
+### Status Colors
+
+```powershell
+npx @basiclines/rampa -C "#548235" --add=square -L 95:15 --size=10 -O css --name=status
+```
+
+Map hues deliberately:
+
+- green/teal -> success
+- yellow/orange -> warning
+- red/pink -> danger
+- blue/cyan -> info
+
+### Data Visualization
+
+```powershell
+npx @basiclines/rampa -C "#548235" --add=triadic --size=2 -L 50:50 -S 70:70 -O css --name=chart
+npx @basiclines/rampa -C "#548235" --add=square --size=2 -L 50:50 -S 70:70 -O css --name=chart
+```
+
+Use fixed lightness for equal visual weight. Avoid turning chart palettes into ramps unless the data is ordinal.
+
+### Contrast Lint
+
+```powershell
+npx @basiclines/rampa lint --fg "#123123" --bg "#f7faf3"
+npx @basiclines/rampa lint --fg "#123123" --bg "#f7faf3" --mode wcag --output json
+```
+
+Record contrast failures in the design output. Do not bury them as "subjective" design concerns.
+
+## Studio Mapping Checklist
+
+Before persistence:
+
+- identify brand/entity
+- identify palette seed roles
+- map generated ramps to Studio token names
+- validate light and dark values
+- check text/background contrast pairs
+- save through Studio Palette Library or token apply service
+- verify `/api/v2/tokens/[slug]/css` changes as expected

package/skills/design/reference/studio-model.md

@@ -0,0 +1,134 @@
+# Studio Model for RDC Design
+
+Studio is the token authority and live website editor for LIFEAI brands. It is not a page builder. The design skill must work with Studio's real routes, APIs, token tables, and editor/debug model.
+
+## Required Source Docs
+
+Read these before Studio design work:
+
+- `docs/systems/studio/ARCHITECTURE.md`
+- `apps/studio/CLAUDE.md`
+- `.claude/context/design-system-global.md`
+
+## Runtime Locations
+
+- local Studio: `http://localhost:3011`
+- staging Studio: `https://staged.studio.regendevcorp.com`
+- production Studio: `https://studio.regendevcorp.com`
+
+## Brand Pages
+
+- `/brands`
+- `/brands/new`
+- `/brands/[id]/colors`
+- `/brands/[id]/typography`
+- `/brands/[id]/spacing`
+- `/brands/[id]/diff`
+- `/brands/[id]/book`
+- `/brands/[id]/voice`
+- `/brands/[id]/assets`
+- `/brands/[id]/export`
+- `/brands/[id]/table-styles`
+
+## Editor Routes
+
+- `/editor`
+- `/editor/local/[brandSlug]`
+- `/editor/local-test-target`
+- legacy `/editor/[brandSlug]` may redirect to local editor unless `?legacy=1`
+
+Read local debug docs:
+
+- `docs/systems/studio/local-debug-agent.md`
+
+Clauth relay route families:
+
+- `/studio/debug/*`
+- `/studio/claude/*`
+
+## Token APIs
+
+- `GET /api/public/tokens/[slug]` returns legacy public token payload and CSS variables.
+- `GET /api/v2/tokens/[slug]` returns DTCG/M3 token JSON.
+- `GET /api/v2/tokens/[slug]/css` returns shadcn-compatible CSS vars.
+
+Palette APIs currently start here:
+
+- `apps/studio/src/app/api/palettes/route.ts`
+- `apps/studio/src/app/api/palettes/apply/route.ts`
+
+## Canonical Tables
+
+Current token and theme work should prefer v2 where available:
+
+- `global_design_tokens_v2`
+- `brand_token_overrides_v2`
+- `brand_semantic_tokens`
+- `brand_components`
+- `brand_patterns`
+- `token_inheritance_audit`
+
+Legacy/current website token tables:
+
+- `brand_token_overrides`
+- `brand_font_assignments`
+- `brand_fonts`
+
+Legacy read-only or migration tables:
+
+- `global_design_tokens`
+- `brand_colors`
+- `brand_typography`
+- `brand_spacing`
+
+Docs/narrative:
+
+- `brand_design_docs`
+
+Registry/hierarchy:
+
+- `brand_entities`
+- `org_entities`
+
+## Key Files
+
+- `apps/studio/src/contexts/BrandStudioContext.tsx`
+- `apps/studio/src/lib/token-resolver.ts`
+- `apps/studio/src/lib/token-resolver-v2.ts`
+- `apps/studio/src/lib/token-export.ts`
+- `packages/design-tokens/src/types.ts`
+- `packages/ui/src/components/WebsiteLayout.tsx`
+- `packages/ui/src/styles/website-base.css`
+
+## BrandStudioContext
+
+Child pages under `/brands/[id]/*` should use `useBrandStudio()` instead of re-fetching tokens. It provides:
+
+- `brand`
+- `resolved`
+- `setResolved`
+- `globals`
+- `overrides`
+- `loaded`
+
+## Token Rules
+
+- Use Studio tokens for every production design decision.
+- Never invent a brand slug. Query `brand_entities`.
+- Never modify locked governance tokens without an explicit governance decision.
+- Missing token protocol: create a work item, use closest existing token temporarily, and mark the gap.
+- Production code should use `var(--color-*)` or resolved Studio token output.
+
+## Palette Designer Boundary
+
+The forked Palette Designer is a separate tool. Studio should launch it only when installed/enabled/healthy. It should load and save through Palette Library APIs, then Studio should reflect saved palettes.
+
+Do not rebuild Palette Designer inside the colors page in the first pass.
+
+## Deprecated Routes
+
+Do not extend:
+
+- `/api/editor/render`
+- `/api/layout/scan` unless maintaining legacy scanner behavior
+- `/api/layout/sync`

package/skills/help/SKILL.md

@@ -10,6 +10,12 @@ description: >-
 > No preamble. No follow-up question. No summary. No "what would you like to do?".
 > Do NOT add any text before or after the block. Emit it exactly as written. This is non-negotiable.
 
+## When to Use
+
+- The project lead asks what RDC commands exist
+- The active task is unclear and needs command selection
+- A user needs syntax for planning, build, review, deployment, design, or release workflows
+
 ## Arguments
 
 - `rdc:help` — print the full command reference menu
@@ -43,6 +49,7 @@ description: >-
 | `rdc:prototype` | `rdc:prototype <description>` — JSX mock for review |
 | `rdc:workitems` | `rdc:workitems <add\|update\|done\|list\|epics> [args]` |
 | `rdc:collab` | `rdc:collab --session <id>` — claude.ai bidirectional relay |
+| `rdc:design` | `rdc:design <command\|brief>` — RDC/Studio design, tokens, palettes, themes, Rampa CLI |
 
 ## Agent guides (dispatched by rdc:build, not user-invocable)
 
@@ -79,6 +86,7 @@ Project lead says → invoke
 "hand this off" / "give to agents"      → rdc:handoff
 "show me what it looks like"            → rdc:prototype
 "add to backlog" / "create a ticket"    → rdc:workitems
+"design/tokens/palette/theme"           → rdc:design <command>
 "what commands" / "what skills"         → rdc:help
 ```
 

package/skills/tests/rdc-design.test.json

@@ -0,0 +1,14 @@
+{
+  "manifest_version": 1,
+  "skill": "rdc:design",
+  "description": "RDC Design provides Studio-aware design instructions and CLI prompt logging under RDC_TEST.",
+  "fixture": {
+    "prompt": "rdc:design studio audit the palette page",
+    "env": { "RDC_TEST": "1" }
+  },
+  "assertions": {
+    "exit_code": 0,
+    "stdout_contains": ["Verdict"]
+  },
+  "teardown": { "reset_branch": true }
+}