@lifeaitools/rdc-skills 0.8.7

package/guides/design.md

@@ -0,0 +1,116 @@
+# Design Agent Guide — Base
+> Role-based context for design system, branding, and visual agents. Generic patterns across projects.
+
+---
+
+## Design Principles
+
+Projects typically define core design principles. Check the overlay for:
+- Philosophy guiding all visual decisions
+- Accessibility standards
+- Motion/animation philosophy
+- Dark/light mode strategy
+- Tone and voice guidelines
+
+---
+
+## Brand Palettes
+
+The project specifies:
+- Primary colors per brand
+- Accent/secondary colors
+- Neutrals and grays
+- Dark mode vs light mode variations
+- Color semantics (error, success, warning, etc.)
+
+Check the overlay for exact hex values and CSS variable names.
+
+---
+
+## Token Inheritance / Design Tokens
+
+Some projects use design token systems. The overlay specifies:
+- Whether tokens are centralized or distributed
+- How tokens are versioned
+- Export formats (JSON, CSS, Figma, etc.)
+- Token hierarchy and relationships
+
+---
+
+## Typography
+
+The project specifies:
+- Primary UI font(s)
+- Display/heading font
+- Mono font for code
+- Type scale (sizes and weights)
+- Line heights and letter spacing
+
+Never hardcode `font-family` — always use tokens or CSS variables.
+
+---
+
+## Component Variant Axes
+
+Most design systems define variant axes. Check overlay for which axes apply:
+- Brand / product line
+- Visual style (default, minimal, heritage, etc.)
+- Size and density
+- Shape (rounded, sharp, pill, etc.)
+- Motion (static, subtle, rich)
+- State (default, hover, disabled, etc.)
+
+Every component should support relevant axes on day one.
+
+---
+
+## OG Images / Social Cards
+
+The project specifies:
+- Dimensions (1200×630 is standard)
+- Format (PNG, JPG)
+- Design spec (fonts, colors, layout)
+- Generation process (Python/Pillow, Node, etc.)
+- File location and naming convention
+
+---
+
+## Asset Organization
+
+The project specifies:
+- Where to store images (folder structure)
+- Naming convention (kebab-case patterns)
+- File formats (WebP for photos, SVG for icons, etc.)
+- Optimization requirements
+
+---
+
+## Animation and Motion
+
+The project specifies:
+- Whether animations are used (CRUD vs public pages)
+- Motion library (Framer, Aceternity, custom, etc.)
+- Easing and duration tokens
+- `prefers-reduced-motion` compliance
+
+---
+
+## Accessibility
+
+The project specifies:
+- WCAG compliance level (A, AA, AAA)
+- Color contrast requirements
+- Focus indicators
+- Keyboard navigation patterns
+- Screen reader expectations
+
+---
+
+## Specialist Context — Read Project Overlay
+
+Your task may require reading additional project-specific guides for:
+- Brand system architecture (token inheritance, export)
+- OG image generation scripts
+- Design token tools and workflows
+- Specific app brand palettes
+- Component inventory and patterns

package/guides/frontend.md

@@ -0,0 +1,151 @@
+# Frontend Agent Guide — Base
+> Role-based context for frontend/UI agents. Generic patterns across projects.
+
+---
+
+## Core Import Rule
+
+**ALWAYS import from the project's component library.** NEVER import directly from headless UI libraries, animation libs, or icon libraries.
+
+```ts
+// Correct (project import)
+import { Button, DataTable, Card } from "@project/ui";
+
+// Wrong - never do this
+import { Button } from "@/components/ui/button";
+import { motion } from "framer-motion";
+```
+
+The project overlay will specify the exact import path.
+
+---
+
+## Component Tier Architecture
+
+Most projects organize components into tiers. Check the project overlay for:
+- **Tier 1** — Headless/primitive components (forms, layout, data)
+- **Tier 2** — Domain-specific components (app-specific business logic UI)
+- **Tier 3** — Animated effects (hero sections, public pages)
+- **Tier 4** — Brand/personality components (marketing, accent effects)
+
+Use the right tier for the context:
+- CRUD/admin UI → Tiers 1-2
+- Public/marketing pages → Tiers 3-4
+
+---
+
+## Component Creation Contract
+
+All new components must follow the standard contract:
+
+```tsx
+"use client"; // only if uses hooks/browser APIs
+import * as React from "react";
+import { cn } from "../lib/utils";  // from project's UI lib
+
+interface MyComponentProps extends React.HTMLAttributes<HTMLDivElement> {
+  variant?: "default" | "outline";
+}
+
+const MyComponent = React.forwardRef<HTMLDivElement, MyComponentProps>(
+  ({ className, variant = "default", ...props }, ref) => (
+    <div ref={ref} className={cn("base-classes", className)} {...props} />
+  )
+);
+MyComponent.displayName = "MyComponent";
+export { MyComponent };
+```
+
+Then re-export from the project's index. Placement:
+- Generic UI: `packages/ui/src/components/`
+- Animated effects: `packages/ui/src/components/effects/` or similar subdirectory
+- Brand accents: `packages/ui/src/components/brand/` or similar
+
+---
+
+## Variant Axes — Every Component
+
+Every component must support variant axes. Use CVA (class-variance-authority) or equivalent.
+
+| Axis | Examples | When it matters |
+|------|----------|----------------|
+| Brand | app-specific brands | Every component |
+| Visual style | default / heritage / minimal / quiet | Different expression per context |
+| Size | xs / sm / md / lg / xl / 2xl | Hero ≠ sidebar |
+| Shape | sharp / soft / pill / circle | Cards, buttons, badges |
+| Density | compact / comfortable / spacious | Data-heavy vs editorial |
+| State | default / hover / active / disabled / loading | Interactive components |
+
+Every custom component ships with its variant matrix on day one.
+
+---
+
+## Styling Rules
+
+- **Tailwind utility classes only** — never inline styles
+- **Never hardcode colors** — always use CSS variables from the project
+- **Class merging** via `cn()` from project's UI library
+- **No Tailwind conflicts** — use design tokens for everything
+
+---
+
+## Typography
+
+Never hardcode `font-family` — use CSS variables or Tailwind classes.
+
+The project overlay specifies:
+- Primary UI font
+- Display/heading font
+- Mono font for code
+- Type scale (text-xs through text-4xl)
+
+---
+
+## Tailwind Rules
+
+- **Content paths** -- every `tailwind.config.ts` must include the project's UI package
+- **Class merging** -- always use `cn()` from project's UI library
+- **Colors** -- CSS variables only, never hardcode hex
+- **Spacing** -- 4px scale (or project-specific)
+- **Border radius** -- use project's radius token
+
+---
+
+## Asset Handling
+
+The project specifies folder structure, naming convention, and usage patterns.
+
+General pattern:
+- Store in `apps/[app]/public/images/[category]/`
+- Naming: `[type]-[name]-[variant].[ext]` (lowercase kebab-case)
+- Always use framework Image component with `width`, `height`, `alt`
+
+---
+
+## Next.js / React-Specific Patterns
+
+Check project overlay for:
+- Framework version (Next.js 13/14, React 18/19, etc.)
+- App Router vs Pages Router
+- Dynamic import patterns for browser-only libs
+- transpilePackages config for monorepo
+- Middleware patterns
+
+---
+
+## Dependencies Managed by Project UI Library
+
+Most dependencies (Radix, TanStack, recharts, framer-motion, CodeMirror, etc.) are managed by the project's UI package. Apps don't install them separately.
+
+---
+
+## Specialist Context — Read Project Overlay
+
+Your task may require reading additional project-specific rule files.
+
+The project overlay will indicate what specialized guides are needed for:
+- Brand system work
+- Design token inheritance
+- Specific app pages or routes
+- Image/asset handling
+- OG image generation

package/guides/infrastructure.md

@@ -0,0 +1,179 @@
+# Infrastructure Agent Guide — Base
+> Role-based context for infra/deployment/DevOps agents. Generic patterns across projects.
+
+---
+
+## Rule 1: NEVER Work Around Broken Infrastructure
+
+When a service is unavailable, STOP and report BLOCKED. Do not:
+- Use curl when service APIs are down
+- Use workarounds or alternative approaches
+- Skip verification steps
+- Assume service will return to normal
+
+**Report immediately:**
+
+```
+BLOCKED: [service name] is not responding.
+
+Fix: [specific action for your project's infrastructure stack]
+
+I cannot proceed until this is resolved.
+```
+
+---
+
+## Deployment Tools
+
+Check project overlay for:
+- Primary deployment platform (Coolify, Vercel, AWS, GCP, etc.)
+- MCP connectors or REST API access
+- Authentication method (API token, OAuth, etc.)
+- Credential location (clauth daemon, env vars, etc.)
+
+---
+
+## Server Infrastructure
+
+The project specifies:
+- Server IP/hostname
+- Dashboard URL
+- Default region/availability zones
+- Server/environment IDs (UUIDs or identifiers)
+
+---
+
+## DNS Rules
+
+The project specifies:
+- Wildcard DNS patterns vs individual records
+- Cloudflare or other DNS provider
+- Proxy rules (orange cloud, DNS-only, etc.)
+- SSL/TLS provisioning method
+
+Check overlay for **critical rules** — DNS misconfigurations break deployments.
+
+---
+
+## Deployment Registry
+
+The project likely has a registry/database table tracking all deployments. Before ANY deploy, verify:
+```
+Lookup: <slug> or <domain>
+Returns: UUID, repo location, build command, build type, domain, status
+```
+
+**NEVER guess** UUIDs, domains, or build commands. Always look them up.
+
+---
+
+## Watch Paths
+
+For monorepo deploys, the project specifies:
+- Watch path patterns per app type
+- Why watch paths matter (prevents unnecessary rebuilds)
+- How to set watch paths (usually via API or config)
+
+Without correct watch paths, every push triggers ALL apps to rebuild.
+
+---
+
+## Build Types
+
+The project specifies supported build types:
+- Next.js monorepo
+- Vite / Node
+- Static HTML
+- Docker
+- etc.
+
+Check overlay for:
+- Build pack (nixpacks, docker, static, etc.)
+- Required environment variables
+- Node version constraints
+- Build command and install command
+
+---
+
+## Environment Tiers
+
+The project specifies deployment environments:
+- **development** -- free to experiment
+- **staging** -- test before production
+- **production** -- live traffic, needs confirmation
+
+Check overlay for which tier each app is in and confirmation requirements.
+
+---
+
+## Deploy Checklist
+
+Standard pattern:
+1. Check git status (divergence, unpushed commits)
+2. Confirm with user (especially for production)
+3. Push to trigger auto-deploy (if webhook configured)
+4. Verify deployment success (health check, status endpoint)
+5. Check cache headers (if behind CDN)
+
+---
+
+## New App Deployment
+
+The project specifies:
+- DNS pattern (wildcard subdomains vs custom domains)
+- Coolify/deployment platform setup
+- GitHub repo connection
+- Watch paths configuration
+- Registry update requirement
+
+---
+
+## Credential Safety
+
+- MCP connectors first (if available)
+- clauth daemon second (localhost:52437)
+- Never print keys to stdout
+- Never hardcode credentials
+- Never ask user for keys
+- If daemon is down: report BLOCKED
+
+---
+
+## Git Workflow
+
+The project specifies:
+- Primary branch for features (develop, main, etc.)
+- Force-push rules (usually: NEVER force-push main)
+- Commit message format
+- Auto-commit patterns
+
+---
+
+## Service Health Checks
+
+The project specifies how to health-check each service:
+- Ping endpoint
+- Status endpoint
+- Log location
+- Fallback if primary method fails
+
+---
+
+## Troubleshooting Patterns
+
+The project specifies common issues and fixes:
+- 502/503 errors (check container logs, port mismatch)
+- Disk full (clean Docker cache)
+- SSL provisioning failures (check DNS config)
+- Build failures (check environment variables, Node version)
+
+---
+
+## Specialist Context — Read Project Overlay
+
+Your task may require reading additional project-specific guides for:
+- Full deployment registry schema
+- Complete DNS rules (critical for subdomains)
+- Build type details
+- CI/CD pipeline configuration
+- Scaling and performance tuning

package/guides/output-contract.md

@@ -0,0 +1,98 @@
+# RDC Skill Output Contract
+> Every `rdc:*` skill MUST follow this contract. Non-negotiable.
+
+## Why
+
+The user has zero visibility when skills narrate tool calls and dump raw output.
+A wall of JSON, MCP responses, and "let me check X..." chatter buries the one
+thing they need: **is this working or not, and what step are we on?**
+
+## The contract
+
+1. **One checklist per invocation.** Show it upfront, update it in place as items
+   progress, print it again at the end with a 1-line verdict.
+
+2. **Checklist markers:**
+   - `[ ]` pending
+   - `[~]` in progress (currently executing)
+   - `[x]` done
+   - `[!]` failed
+   - `[-]` skipped (with one-word reason in parens)
+
+3. **NO narration of tool calls.** Forbidden phrases: "Let me...", "I'll check...",
+   "Now reading...", "Let me fetch...", "Let me verify...". Tool calls happen
+   silently. The checklist is the communication channel.
+
+4. **NO raw tool output in chat.** No MCP JSON, no log dumps, no UUIDs, no
+   SQL result tables, no curl bodies — unless a checklist item explicitly asks
+   for one (e.g., "show HTTP status"). Everything else is consumed silently and
+   folded into checklist state.
+
+5. **Failures are one sentence.** When `[!]` fires, print ONE sentence on what
+   failed and what you're doing about it. Stack traces, full error messages,
+   and debug dumps go in memory, not in chat.
+
+6. **Verdict line.** End every invocation with one line:
+   - `✅ <skill>: <outcome> in Nm Ns`
+   - `⚠️ <skill>: <N findings> — <next action>`
+   - `❌ <skill>: <one-sentence reason>`
+
+7. **Interactive checklists only when human input is required.** If the skill
+   needs a decision (pick an epic, confirm a destructive op), ask ONE question,
+   then resume.
+
+8. **TaskCreate is internal.** If you use TaskCreate/TodoWrite for internal
+   tracking, that's fine — but the checklist shown to the user is the one
+   defined in the skill's markdown, not the raw task list.
+
+## Template
+
+Every skill invocation prints, in order:
+
+```
+<Skill Name>: <one-line subject>
+[ ] Step 1
+[ ] Step 2
+[ ] Step 3
+...
+```
+
+Then executes silently, re-rendering the checklist when state changes (tools
+like CLI agents that stream output should refresh in place). At the end:
+
+```
+<Skill Name>: <one-line subject>
+[x] Step 1
+[x] Step 2
+[x] Step 3
+✅ <verdict>
+```
+
+## What the skill may additionally emit
+
+- **One question at a time** when input is required
+- **One-sentence status updates** at major state transitions (optional)
+- **Final artifacts** if the skill's output is itself a file/report/diff — link,
+  don't inline the full content
+
+## What the skill MUST NOT emit
+
+- Tool call narration
+- Raw MCP responses
+- JSON dumps
+- Log tails
+- SQL result grids
+- UUIDs unless asked
+- "I'm going to..." preambles
+- "Let me now..." transitions
+- Summaries of what just happened (the checklist shows it)
+- Apologies for verbosity
+
+## Enforcement
+
+If a skill violates this contract, the user will say "squelch" — at which point
+any in-flight narration stops, only the checklist + verdict is shown for the
+remainder of the session.
+
+Skills SHOULD self-enforce by treating every tool call as silent and every
+user-facing emission as a deliberate checklist update.

package/hooks/no-stop-open-epics.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — block Claude from stopping when open epics exist.
+ *
+ * Fires on every Stop event where Claude decided to end_turn.
+ * Queries get_open_epics() via Supabase REST.
+ * Only blocks if epics with status=todo exist — in_progress means another session owns them.
+ * Only fires in the regen-root project (scope guard on event.cwd).
+ *
+ * Exit codes:
+ *   0 = allow stop
+ *   2 = block stop (todo epics remain)
+ *
+ * PROJECT CONFIG REQUIRED in .env.local:
+ *   NEXT_PUBLIC_SUPABASE_URL=https://<ref>.supabase.co
+ *   NEXT_PUBLIC_SUPABASE_ANON_KEY=<key>
+ *
+ * PROJECT SCOPE in package.json or plugin config:
+ *   "hookScope": "regen-root"   ← folder name that must appear in event.cwd
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ── Config — override these per project ──────────────────────────────────────
+
+const PROJECT_SCOPE = 'regen-root'; // only block in sessions inside this folder name
+const OVERNIGHT_SENTINEL = 'C:/Dev/regen-root/.rdc/overnight.lock'; // only fire when this exists
+const ENV_PATHS = [
+  'C:/Dev/regen-root/apps/rdc-marketing-engine/.env.local',
+  'C:/Dev/regen-root/.env.local',
+];
+const SUPABASE_URL = process.env.SUPABASE_URL || readEnvVar('NEXT_PUBLIC_SUPABASE_URL');
+
+function readEnvVar(key) {
+  for (const p of ENV_PATHS) {
+    try {
+      const contents = fs.readFileSync(p, 'utf8');
+      const match = contents.match(new RegExp(`^${key}=(.+)$`, 'm'));
+      if (match) return match[1].trim();
+    } catch {}
+  }
+  return null;
+}
+
+async function getOpenEpics(anonKey, supabaseUrl) {
+  const url = `${supabaseUrl}/rest/v1/rpc/get_open_epics`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'apikey': anonKey,
+      'Authorization': `Bearer ${anonKey}`,
+    },
+    body: JSON.stringify({}),
+  });
+  if (!res.ok) return [];
+  const data = await res.json();
+  if (Array.isArray(data) && data.length > 0 && data[0].get_open_epics) {
+    return data[0].get_open_epics;
+  }
+  if (Array.isArray(data)) return data;
+  return [];
+}
+
+async function main() {
+  let event = {};
+  try {
+    const raw = fs.readFileSync('/dev/stdin', 'utf8');
+    event = JSON.parse(raw);
+  } catch {}
+
+  // Scope guard — only apply to sessions inside PROJECT_SCOPE folder
+  const cwd = event.cwd || process.cwd();
+  const normalised = cwd.replace(/\\/g, '/').toLowerCase();
+  if (!normalised.includes(PROJECT_SCOPE.toLowerCase())) {
+    process.exit(0);
+  }
+
+  // Overnight gate — only block when rdc:overnight is actively running.
+  // The overnight skill creates this sentinel at start and removes it on exit.
+  // Interactive sessions never see this file, so they stop freely.
+  if (!fs.existsSync(OVERNIGHT_SENTINEL)) {
+    process.exit(0);
+  }
+
+  // Only block Claude's own end_turn — never block user-forced stops
+  const stopReason = event.stop_reason || event.reason || '';
+  if (stopReason && stopReason !== 'end_turn') {
+    process.exit(0);
+  }
+
+  const anonKey = readEnvVar('NEXT_PUBLIC_SUPABASE_ANON_KEY');
+  const supabaseUrl = SUPABASE_URL || readEnvVar('NEXT_PUBLIC_SUPABASE_URL');
+  if (!anonKey || !supabaseUrl) {
+    process.exit(0); // Can't verify — silent pass
+  }
+
+  let epics = [];
+  try {
+    epics = await getOpenEpics(anonKey, supabaseUrl);
+  } catch {
+    process.exit(0);
+  }
+
+  // Only block on todo — in_progress means another session already owns it
+  const actionable = epics.filter(e => (e.status || '').toLowerCase() === 'todo');
+
+  if (actionable.length === 0) {
+    process.exit(0);
+  }
+
+  const titles = actionable.slice(0, 3).map(e => `  • [${e.priority}] ${e.title}`).join('\n');
+  const more = actionable.length > 3 ? `\n  … and ${actionable.length - 3} more` : '';
+
+  process.stderr.write(
+    `\n🚫 STOP BLOCKED — ${actionable.length} open epic(s) remain in queue:\n${titles}${more}\n\n` +
+    `Continue working. Pick the highest-priority epic and proceed.\n` +
+    `Only stop when get_open_epics() returns empty.\n\n`
+  );
+
+  process.exit(2);
+}
+
+main().catch(() => process.exit(0));

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@lifeaitools/rdc-skills",
+  "version": "0.8.7",
+  "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight builds",
+  "keywords": [
+    "claude-code",
+    "claude-code-plugin",
+    "rdc",
+    "skills",
+    "ai-agents"
+  ],
+  "author": "LIFEAI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LIFEAI/rdc-skills.git"
+  },
+  "claude": {
+    "type": "plugin",
+    "skills": "skills/",
+    "guides": "guides/",
+    "version": "0.8.7",
+    "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"
+  }
+}