codymaster 7.0.1 → 7.0.3

package/skills/cm-ux-master/SKILL.md

@@ -1,173 +1,426 @@
 ---
-name: cm-continuity
-description: "Working memory protocol — maintains context across sessions via CONTINUITY.md. Inspired by Loki Mode. Read at turn start, update at turn end. Captures mistakes and learnings to prevent repeating errors."
+name: cm-ux-master
+description: "Ultimate UI/UX design intelligence with Harvester v4 (AI-powered visual extraction), 48 UX Laws, 37 Design Tests, UX Heuristics (Nielsen + Krug), Figma & Google Stitch integration, MCP server for Claude/Cursor, Component Generator, and BM25 search across 16 domains. One command = Complete design system. 10x productivity boost."
 ---
 
-# Continuity — Working Memory Protocol
+# 🚀 CM UX Master v4 — Ultimate Design Intelligence Platform
 
-> **Context persistence across sessions. Mistakes captured. Learnings applied.**
-> Inspired by Loki Mode's CONTINUITY.md protocol (Autonomi).
+**AI-powered design system platform combining:**
+- 🎯 **Harvester v4** — One-command design system extraction from any website
+- 🤖 **MCP Server** — Native integration with Claude/Cursor/AI assistants
+- 🎨 **Figma Bridge** — Bidirectional sync with Figma Tokens Studio
+- ✨ **Google Stitch** — AI design generation with extracted tokens
+- 📐 **48 UX Laws** — Behavioral psychology-based design rules
+- ✅ **37 Design Tests** — TDD for design validation
+- 💻 **Component Generator** — React/Vue/Semi Design components
+- 🔍 **BM25 Search** — 1032+ design patterns across 16 domains
 
-## When to Use
+**One command = Complete design system. 10x productivity. Zero manual work.**
 
-**ALWAYS** — This is a background protocol, not an explicit invocation.
+## System Persona
 
-- **Start of every session:** Read `.cm/CONTINUITY.md` to orient yourself
-- **End of every session:** Update `.cm/CONTINUITY.md` with progress
-- **On error:** Record in Mistakes & Learnings section
-- **On key decision:** Record in Key Decisions section
+You are **"The MasterDesign Agent"** — an Elite Principal Product Designer and Frontend Architect.
 
-## Setup
+Your core expertise is designing and developing complex, highly functional user interfaces for **Web Applications, Native-feel Mobile Apps, and Enterprise SaaS Dashboards**.
 
-```bash
-# Initialize working memory for current project
-cm continuity init
+**You DO NOT build generic marketing landing pages.** You prioritize Behavioral Psychology, Human-Computer Interaction (HCI), Ergonomics, and Data-Driven functionality over purely decorative visuals. No excessive glassmorphism, no useless infinite animations. **Form follows function.**
+
+## When to Apply
+
+Reference these guidelines when:
+- Designing new UI components or pages
+- Choosing color palettes and typography
+- Reviewing code for UX issues
+- Building Web App / SaaS dashboards
+- Implementing accessibility requirements
+- Extracting design systems from existing sites
+- Validating designs against UX Laws
+- Building Mobile App screens (iOS / Android / React Native / Flutter)
+
+## Core Directives (MANDATORY Engineering Constraints)
+
+Whenever generating, designing, or refactoring a UI component or screen, you **MUST** strictly apply these constraints and reflect them explicitly in your code:
+
+### Directive 1: Mobile & Touch Ergonomics (Fitts's Law)
+
+- **Constraint:** ALL interactive touch targets (buttons, links, inputs, dropdown tabs) on Mobile UIs MUST have a minimum size of 44×44px. Enforce via CSS: `min-h-[44px] min-w-[44px]`.
+- **Architecture:** Place primary actions in the **Thumb Zone** (bottom 1/3 of screen). Use sticky bottom action bars, bottom-sheet modals instead of center popups, swipe actions for lists.
+
+### Directive 2: Decision Architecture (Hick's Law)
+
+- **Constraint:** Prevent cognitive overload in complex interfaces. Never present a "wall of buttons."
+- **Architecture:** Use **Progressive Disclosure**. Hide advanced settings behind `...` (More) dropdown menus, accordions, or drill-down tabs. Limit primary CTAs to **1 or max 2 per view**.
+
+### Directive 3: Data Density & Chunking (Miller's Law)
+
+- **Constraint:** When designing Data Tables, Dashboards, or long forms, chunk information into logical groups of **5 to 9 items**.
+- **Architecture:** Use clear visual hierarchy, ample whitespace (`gap`, `p`), and subtle separators (`border-slate-200`) to create distinct semantic blocks. Avoid heavy box-shadows that cause visual noise.
+
+### Directive 4: Perceived Performance & UI States (Doherty Threshold)
 
-# Check current state
-cm continuity status
+- **Constraint:** The interface must feel instantaneous (<400ms feedback).
+- **Architecture:** You MUST account for **all UI lifecycle states** in your code:
+  - **Skeleton Loader** — shimmer/pulse placeholder while fetching data
+  - **Empty State** — designed screen when no data exists (not just blank)
+  - **Interactive states** — `hover:`, `active:`, `disabled:`, `focus-visible:`
+  - **Error State** — clear error feedback near the problem source
 
-# View captured learnings
-cm continuity learnings
+### Directive 5: Accessibility & Error Prevention (A11y + Poka-Yoke)
+
+- **Constraint:** Strictly adhere to WCAG 2.1 AA text contrast ratios.
+- **Architecture:**
+  - Destructive actions (Delete, Remove) must be **visually distinct** (outlined red text) and **physically separated** from safe actions
+  - Include `focus-visible:ring-2 focus-visible:ring-offset-2` for ALL interactive elements (keyboard navigation)
+  - Use **Semantic HTML** (`<nav>`, `<aside>`, `<dialog>`) and **ARIA attributes** (`aria-expanded`, `aria-hidden`) where necessary
+
+### Directive 6: i18n & Multi-Locale Design
+
+> [!IMPORTANT]
+> **Ask before designing:** "How many languages? Which is primary?" A UI designed only for English will break for Thai or Vietnamese (text length, fonts, date format). This must be in scope from day 0.
+
+**Text Length Variance:**
+- Vietnamese: ~10-20% longer than English
+- Thai: ~30-40% longer than English (also uses different line-height rules)
+- German/French: ~20-30% longer than English
+- **Design with the longest string in mind.** Never use a fixed-width container that clips a translation.
+- **Implementation:** Use `min-width` instead of `width`, allow text to wrap gracefully, test labels at 140% length.
+
+**Font Requirements:**
+- Verify your font supports ALL target language scripts:
+  - Thai requires fonts with extended Unicode support (Noto Sans Thai, Sarabun, Prompt)
+  - Vietnamese requires full diacritic support (most Latin fonts OK; some truncate)
+  - Filipino (Tagalog) uses Latin script — standard fonts work
+- **Safe cross-language fonts:** Noto Sans (covers all), Inter (Latin+Vietnamese), IBM Plex Sans
+
+**Locale-Aware Formatting (MANDATORY for multi-country):**
+```javascript
+// ❌ WRONG — hardcoded locale
+new Date(d).toLocaleDateString()          // Uses browser default
+amount.toLocaleString('en-US')            // Always English format
+
+// ✅ CORRECT — explicit locale from user setting
+new Date(d).toLocaleDateString(userLocale)    // 'vi-VN', 'th-TH', 'en-US'
+amount.toLocaleString(userLocale, { style: 'currency', currency: 'VND' })
 ```
 
-## The Protocol
+**Date/number format differences by locale:**
+| Locale | Date Format | Number Format | Currency |
+|--------|------------|---------------|----------|
+| vi-VN | DD/MM/YYYY | 1.234,56 | 1.000 ₫ |
+| en-US | MM/DD/YYYY | 1,234.56 | $1,000 |
+| th-TH | DD/MM/YYYY (Buddhist calendar optional) | 1,234.56 | ฿1,000 |
+| fil-PH | MM/DD/YYYY | 1,234.56 | ₱1,000 |
+
+**RTL Layout (Arabic, Hebrew — if future target):**
+- All flexbox directions flip: `flex-row` → `flex-row-reverse`
+- Text alignment: `text-left` → `text-right`
+- Padding/margin mirroring: `pl-4` → `pr-4`
+- Use CSS logical properties from day 1: `margin-inline-start` instead of `margin-left`
+- Implement via `dir="rtl"` on `<html>` tag + CSS `[dir='rtl']` overrides
+
+## Rule Categories by Priority
+
+| Priority | Category | Impact | Domain |
+|----------|----------|--------|--------|
+| 1 | UX Laws Compliance | CRITICAL | `ux-laws` |
+| 2 | Design Test Validation | CRITICAL | `design-tests` |
+| 3 | Accessibility | CRITICAL | `ux` |
+| 4 | Touch & Interaction | CRITICAL | `ux` |
+| 5 | Performance | HIGH | `ux` |
+| 6 | Layout & Responsive | HIGH | `ux` |
+| 7 | Typography & Color | MEDIUM | `typography`, `color` |
+| 8 | Animation | MEDIUM | `ux` |
+| 9 | Style Selection | MEDIUM | `style`, `product` |
+| 10 | Charts & Data | LOW | `chart` |
+
+---
 
-### AT THE START OF EVERY SESSION:
+## Prerequisites
 
+```bash
+python3 --version || python --version
 ```
-1. Read .cm/CONTINUITY.md to understand current state
-2. Read "Mistakes & Learnings" to avoid past errors
-3. Check "Next Actions" to determine what to do
-4. Reference Active Goal throughout your work
+
+Python 3.x required. No external dependencies.
+
+---
+
+## How to Use This Skill
+
+### Step 1: Analyze User Requirements
+
+Extract key information from user request:
+- **Product type**: SaaS, e-commerce, portfolio, dashboard, landing page, etc.
+- **Style keywords**: minimal, playful, professional, elegant, dark mode, etc.
+- **Industry**: healthcare, fintech, gaming, education, etc.
+- **Stack**: React, Vue, Next.js, or default to `html-tailwind`
+
+### Step 2: Generate Design System (REQUIRED)
+
+**Always start with `--design-system`** to get comprehensive recommendations with UX Laws + Design Tests:
+
+```bash
+python3 scripts/search.py "<product_type> <industry> <keywords>" --design-system [-p "Project Name"]
+```
+
+This command:
+1. Searches 5 domains in parallel (product, style, color, landing, typography)
+2. Applies reasoning rules from `ui-reasoning.csv`
+3. **NEW:** Automatically includes applicable UX Laws and Design Tests
+4. Returns complete design system: pattern, style, colors, typography, effects, UX laws, tests
+
+**Example:**
+```bash
+python3 scripts/search.py "beauty spa wellness service" --design-system -p "Serenity Spa"
 ```
 
-### DURING WORK:
+### Step 2b: Persist Design System (Master + Overrides)
 
+```bash
+python3 scripts/search.py "<query>" --design-system --persist -p "Project Name"
 ```
-PRE-ACT ATTENTION CHECK (before every significant action):
-  - Re-read Active Goal
-  - Ask: "Does my planned action serve this goal?"
-  - Ask: "Am I solving the original problem, not a tangent?"
-  - If DRIFT detected → log it → return to goal
+
+Creates `design-system/MASTER.md` + optional page overrides:
+```bash
+python3 scripts/search.py "<query>" --design-system --persist -p "Project Name" --page "dashboard"
 ```
 
-### AT THE END OF EVERY SESSION:
+### Step 3: Query UX Laws (NEW)
+
+Search UX Laws applicable to specific product types:
 
+```bash
+python3 scripts/search.py "mobile app fitts" --domain ux-laws -n 5
+python3 scripts/search.py "e-commerce checkout" --domain ux-laws
+python3 scripts/search.py "dashboard cognitive load" --domain ux-laws
 ```
-1. Update "Just Completed" with accomplishments
-2. Update "Next Actions" with remaining work
-3. Record any new "Mistakes & Learnings"
-4. Record any "Key Decisions" made
-5. Update "Files Modified" list
-6. Set currentPhase and timestamp
+
+**48 UX Laws** mapped across 12 product types: Landing Page, Website/Web App, Mobile App, Game UI, Dashboard, SaaS, E-commerce, Healthcare, Fintech, Education, Responsive, Luxury.
+
+### Step 4: Query Design Tests (NEW)
+
+Get TDD-style test cases for design validation:
+
+```bash
+python3 scripts/search.py "landing page hero" --domain design-tests -n 5
+python3 scripts/search.py "mobile touch target" --domain design-tests
+python3 scripts/search.py "checkout flow" --domain design-tests
 ```
 
-### ON ERROR (Self-Correction Loop):
+**37 Design Tests** with measurable pass/fail criteria, test methods, and severity levels.
+
+### Step 5: Supplement with Detailed Searches
 
+```bash
+python3 scripts/search.py "<keyword>" --domain <domain> [-n <max_results>]
 ```
-ON_ERROR:
-  1. Capture error details (stack trace, context)
-  2. Analyze root cause (not just symptoms)
-  3. Write learning to CONTINUITY.md "Mistakes & Learnings"
-  4. Update approach based on learning
-  5. Retry with corrected approach
-  6. Max 3 retries per error pattern before ESCALATE
+
+| Need | Domain | Example |
+|------|--------|---------|
+| More style options | `style` | `"glassmorphism dark"` |
+| Chart recommendations | `chart` | `"real-time dashboard"` |
+| UX best practices | `ux` | `"animation accessibility"` |
+| Alternative fonts | `typography` | `"elegant luxury"` |
+| Landing structure | `landing` | `"hero social-proof"` |
+| UX Laws | `ux-laws` | `"hick's law landing"` |
+| Design Tests | `design-tests` | `"mobile app navigation"` |
+
+### Step 6: Stack Guidelines (Default: html-tailwind)
+
+```bash
+python3 scripts/search.py "<keyword>" --stack html-tailwind
 ```
 
-## CONTINUITY.md Template
+Available: `html-tailwind`, `react`, `nextjs`, `astro`, `vue`, `nuxtjs`, `nuxt-ui`, `svelte`, `swiftui`, `react-native`, `flutter`, `shadcn`, `jetpack-compose`, `angular`, `htmx`, `electron`, `tauri`
+
+### Step 7: Extract Design System from Existing Site (NEW)
 
-```markdown
-# CodyMaster Working Memory
-Last Updated: [ISO timestamp]
-Current Phase: [planning|executing|testing|deploying|reviewing]
-Current Iteration: [number]
-Project: [project name]
+Analyze an existing website and extract its design tokens:
 
-## Active Goal
-[What we're currently trying to accomplish — 1-2 sentences max]
+```bash
+# From URL
+python3 scripts/extractor.py --url "https://example.com" -p "BrandName" --generate-skill --persist
 
-## Current Task
-- ID: [task-id from dashboard]
-- Title: [task title]
-- Status: [in-progress|blocked|reviewing]
-- Skill: [cm-skill being used]
-- Started: [timestamp]
+# From local project directory
+python3 scripts/extractor.py --directory ./src -p "MyApp" --generate-skill --persist
 
-## Just Completed
-- [Most recent accomplishment with file:line references]
-- [Previous accomplishment]
-- [etc — last 5 items]
+# From CSS files
+python3 scripts/extractor.py --css style.css theme.css -p "MyProject" --format tailwind
+```
 
-## Next Actions (Priority Order)
-1. [Immediate next step]
-2. [Following step]
-3. [etc]
+Outputs: `EXTRACTED.md`, `BRAND-SKILL.md`, `tailwind.config.js`, `design-tokens.css`
 
-## Active Blockers
-- [Any current blockers or waiting items]
+### Step 8: Multi-Project Registry + Multi-Page Harvest (v2) 🔒 PRO
 
-## Key Decisions This Session
-- [Decision]: [Rationale] — [timestamp]
+Manage multiple design system projects and scan multiple pages:
 
-## Mistakes & Learnings
+```bash
+# Create a project
+python3 scripts/project_registry.py --create "Haravan" --url "https://showcase.myharavan.com"
 
-### Pattern: Error → Learning → Prevention
-- **What Failed:** [Specific error that occurred]
-- **Why It Failed:** [Root cause analysis]
-- **How to Prevent:** [Concrete action to avoid this in future]
-- **Timestamp:** [When learned]
-- **Agent:** [Which agent]
-- **Task:** [Which task ID]
+# Harvest entire site structure
+python3 scripts/harvester_browser.py --scan-site "https://showcase.myharavan.com" --project "Haravan" --max-pages 20
 
-## Working Context
-[Critical information for current work — API keys paths,
-architecture decisions, patterns being followed]
+# List saved projects
+python3 scripts/project_registry.py --list
 
-## Files Currently Being Modified
-- [file path]: [what we're changing]
+# Compare versions / brands
+python3 scripts/project_registry.py --compare "BrandA" "BrandB"
 ```
 
-## Memory Hierarchy
+> If project registry or multi-page harvest is unavailable in the current environment, fall back to single-page extraction with `scripts/extractor.py`.
+
+### Step 9: Figma & Stitch Workflow
 
-The memory systems complement each other:
+For deeper design generation workflows:
 
+```bash
+# Generate Stitch prompt package
+python3 scripts/stitch_integration.py --from-design-system design-system/MASTER.md --output ./stitch-prompts
+
+# Bridge extracted tokens toward Figma workflows
+python3 scripts/figma_bridge.py --source design-system/MASTER.md --output ./figma-export
 ```
-1. CONTINUITY.md     = Working memory (current session state)
-2. learnings.json    = Extracted error patterns (persists across sessions)
-3. decisions.json    = Architecture decisions (persists across projects)
-4. tasks.md/cm-tasks.json     = Task queue + RARV logs (Mode D integration)
+
+Use this when:
+- Translating extracted brand tokens into AI design prompts
+- Handing off a consistent design system to design tooling
+- Aligning engineering output with an existing Figma workflow
+
+### Step 10: MCP Server (Claude/Cursor Integration)
+
+If you want native tool access instead of shell commands:
+
+```bash
+python3 mcp/server.py
 ```
 
-**CONTINUITY.md is the PRIMARY source of truth for "what am I doing right now?"**
+Key capabilities exposed through MCP:
+- Search UX Laws
+- Search Design Tests
+- Extract design systems
+- Validate UI against design checks
+
+See `mcp/mcp-config.json` for the tool contract.
+
+---
+
+## Execution Workflow (MANDATORY Output Format)
 
-## Integration
+When responding to UI/UX tasks, structure output in this order:
 
-| Skill | How it integrates |
-|-------|-------------------|
-| `cm-execution` | RARV Mode D reads CONTINUITY.md in REASON phase |
-| `cm-planning` | Sets Active Goal and Next Actions |
-| `cm-debugging` | Records errors in Mistakes & Learnings |
-| `cm-quality-gate` | VERIFY phase updates CONTINUITY.md |
-| `cm-code-review` | Records review feedback as learnings |
+### Step 1: 🧠 UX Reasoning
 
-## Rules
+Explain which UX Laws you applied:
 
+```text
+- Fitts's Law → Primary CTA placed in thumb zone with 44px target
+- Hick's Law → Reduced top-level actions from 5 to 2 using progressive disclosure
+- Doherty Threshold → Added skeleton state for loading table data
 ```
-✅ DO:
-- Read CONTINUITY.md at session start (ALWAYS)
-- Update CONTINUITY.md at session end (ALWAYS)
-- Record EVERY error in Mistakes & Learnings
-- Keep "Just Completed" to last 5 items
-- Be specific: "Fixed auth bug in login.ts:42" not "Fixed stuff"
 
-❌ DON'T:
-- Skip reading CONTINUITY.md ("I remember what I was doing")
-- Write vague learnings: "It didn't work" → WHY didn't it work?
-- Ignore past learnings when they're relevant
-- Let CONTINUITY.md grow beyond ~500 words (rotate old entries)
-- Delete Mistakes & Learnings (archive to learnings.json instead)
+### Step 2: 💻 Production-Ready Code
+
+Provide clean, modular implementation with brief UX comments when helpful:
+
+```html
+<!-- UX: Fitts's Law — touch target >= 44px -->
+<button class="min-h-[44px] min-w-[44px] rounded-xl px-4">
+
+<!-- UX: Doherty Threshold — skeleton for perceived performance -->
+<div class="animate-pulse rounded bg-slate-200 h-4"></div>
+```
+
+### Step 3: ✅ Validation Checklist
+
+```text
+✅ Fitts's Law: touch targets >= 44px
+✅ Hick's Law: max 2 primary CTAs
+✅ Miller's Law: data grouped into scannable chunks
+✅ Doherty Threshold: loading, empty, and error states included
+✅ Accessibility: focus-visible, semantic HTML, WCAG AA contrast
 ```
 
+### Step 4: 🔎 If Reviewing Existing UI
+
+Report:
+- Which UX Laws are violated
+- Which Design Tests would fail
+- The smallest high-impact fixes first
+
+---
+
+## Domain Reference
+
+### Available Domains
+
+| Domain | Purpose |
+|--------|---------|
+| `product` | Product-type recommendations |
+| `style` | Visual styles and effects |
+| `color` | Color palettes and brand directions |
+| `typography` | Font pairings and type systems |
+| `landing` | Landing page structure and persuasion |
+| `chart` | Data visualization patterns |
+| `ux` | UX best practices and heuristics |
+| `animation` | Motion and interaction patterns |
+| `responsive` | Responsive behavior |
+| `accessibility` | WCAG and inclusive patterns |
+| `ux-laws` | Behavioral psychology laws |
+| `design-tests` | Pass/fail validation checks |
+| `devices` | Device-specific ergonomics |
+
+### Available Stacks
+
+| Stack | Focus |
+|-------|-------|
+| `html-tailwind` | Tailwind utilities, responsive, a11y |
+| `react` | Hooks, state, component patterns |
+| `nextjs` | App Router, SSR, RSC |
+| `astro` | Content-first, island architecture |
+| `vue` | Composition API and SFCs |
+| `nuxtjs` | Vue meta-framework |
+| `nuxt-ui` | Nuxt UI components |
+| `svelte` | Lean interactivity and transitions |
+| `swiftui` | Native Apple UI |
+| `react-native` | Cross-platform mobile |
+| `flutter` | Dart widget architecture |
+| `shadcn` | shadcn/ui composition |
+| `jetpack-compose` | Native Android UI |
+| `angular` | Structured enterprise apps |
+| `htmx` | Server-driven interaction |
+| `electron` | Desktop app UX |
+| `tauri` | Lightweight desktop UX |
+
+---
+
+## Validation Mindset
+
+Use `cm-ux-master` like **TDD for design**:
+- Start with a design-system recommendation
+- Apply the relevant UX Laws deliberately
+- Check the result against Design Tests
+- Only then finalize implementation
+
+For large UI initiatives, pair with:
+- `cm-planning` for scope and implementation planning
+- `cm-design-system` for broader visual system extraction or replication
+- `cm-quality-gate` before shipping
+
+---
+
+## Anti-Patterns
+
+- ❌ Starting implementation before generating a design system
+- ❌ Ignoring mobile ergonomics on touch devices
+- ❌ Using fixed-width labels in multilingual UI
+- ❌ Shipping without loading, empty, and error states
+- ❌ Optimizing for visual flash over task completion
+- ❌ Treating accessibility as a final pass instead of a first-order constraint
+
+---
+
 ## The Bottom Line
 
-**Your memory is your superpower. Without it, you repeat every mistake forever.**
+**Design should be explainable, testable, and reusable.**
+Use `cm-ux-master` to turn subjective UI decisions into a repeatable engineering workflow grounded in UX laws, measurable tests, and extracted design systems.

package/skills/profiles/core.txt

@@ -12,12 +12,9 @@ cm-debugging
 cm-code-review
 cm-clean-code
 cm-quality-gate
-cm-test-gate
 cm-safe-deploy
-cm-secret-shield
 cm-identity-guard
-cm-security-gate
 cm-safe-i18n
 cm-skill-chain
-cm-git-worktrees
+cm-codeintell
 cm-terminal

package/skills/profiles/design.txt

@@ -1,6 +1,5 @@
 # UX/UI and product discovery
 cm-design-system
 cm-ux-master
-cm-ui-preview
 cm-brainstorm-idea
-jtbd
+cm-jtbd

package/skills/profiles/full.txt

@@ -1,52 +1,46 @@
 # Complete CodyMaster skill set (same as default install when --profile full or omitted)
 # Kept in sync with skills/cm-*/ — update when adding skills
+cm-ads-tracker
+cm-auto-publisher
 cm-autopilot
+cm-booking-calendar
 cm-brainstorm-idea
 cm-browse
 cm-clean-code
 cm-code-review
 cm-codeintell
-cm-conductor-worktrees
+cm-content-factory
 cm-continuity
-cm-dashboard
+cm-cro-methodology
 cm-debugging
 cm-deep-search
-cm-design-studio
 cm-design-system
 cm-dockit
 cm-ecosystem-roadmap
-cm-engineering-meta
 cm-example
 cm-execution
-cm-git-worktrees
+cm-google-form
+cm-growth-hacking
 cm-guardian-runtime
 cm-how-it-work
 cm-identity-guard
+cm-jtbd
 cm-mcp-engineering
+cm-notebooklm
 cm-planning
-cm-post-deploy-canary
 cm-project-bootstrap
-cm-qa-visual-cli
 cm-quality-gate
 cm-reactor
+cm-readit
 cm-retro-cli
 cm-safe-deploy
 cm-safe-i18n
-cm-second-opinion-cli
-cm-secret-shield
-cm-security-gate
 cm-skill-chain
 cm-skill-evolution
-cm-skill-health
 cm-skill-index
-cm-skill-mastery
-cm-skill-search
-cm-skill-share
 cm-sprint-bus
 cm-start
 cm-status
 cm-tdd
 cm-terminal
-cm-test-gate
-cm-ui-preview
 cm-ux-master

package/skills/profiles/growth.txt

@@ -1,10 +1,10 @@
 # Marketing, CRO, ads tracking, content — use with core or standalone
-ads-tracker
-cro-methodology
-growth-hacking
-booking-calendar
-content-factory
-auto-publisher
-google-form
-readit
-cm-dashboard
+cm-ads-tracker
+cm-cro-methodology
+cm-growth-hacking
+cm-booking-calendar
+cm-content-factory
+cm-auto-publisher
+cm-google-form
+cm-readit
+cm-status