codymaster 4.1.0

package/skills/cm-git-worktrees/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: cm-git-worktrees
+description: Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Git worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.
+
+**Core principle:** Systematic directory selection + safety verification = reliable isolation.
+
+**Announce at start:** "I'm using the cm-git-worktrees skill to set up an isolated workspace."
+
+## Directory Selection Process
+
+Follow this priority order:
+
+### 1. Check Existing Directories
+
+```bash
+# Check in priority order
+ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+ls -d worktrees 2>/dev/null      # Alternative
+```
+
+**If found:** Use that directory. If both exist, `.worktrees` wins.
+
+### 2. Check CLAUDE.md
+
+```bash
+grep -i "worktree.*director" CLAUDE.md 2>/dev/null
+```
+
+**If preference specified:** Use it without asking.
+
+### 3. Ask User
+
+If no directory exists and no CLAUDE.md preference:
+Ask where to create worktrees.
+
+## Safety Verification
+
+### For Project-Local Directories (.worktrees or worktrees)
+
+**MUST verify directory is ignored before creating worktree:**
+
+```bash
+# Check if directory is ignored (respects local, global, and system gitignore)
+git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
+```
+
+**If NOT ignored:**
+
+Per Jesse's rule "Fix broken things immediately":
+1. Add appropriate line to .gitignore
+2. Commit the change
+3. Proceed with worktree creation
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+### For Global Directory (~/.config/superpowers/worktrees)
+
+No .gitignore verification needed - outside project entirely.
+
+## Creation Steps
+
+### 1. Detect Project Name
+
+```bash
+project=$(basename "$(git rev-parse --show-toplevel)")
+```
+
+### 2. Create Worktree
+
+```bash
+# Determine full path
+case $LOCATION in
+  .worktrees|worktrees)
+    path="$LOCATION/$BRANCH_NAME"
+    ;;
+  ~/.config/superpowers/worktrees/*)
+    path="~/.config/superpowers/worktrees/$project/$BRANCH_NAME"
+    ;;
+esac
+
+# Create worktree with new branch
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+### 3. Run Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+```
+
+### 4. Verify Clean Baseline
+
+Run tests to ensure worktree starts clean (via `cm-quality-gate` conventions).
+
+### 5. Update Working Memory (cm-continuity)
+
+After worktree is created and baseline verified:
+- Update `.cm/CONTINUITY.md` → Working Context: "Now working in worktree: [path], branch: [branch]"
+- Note: `CONTINUITY.md` lives in the **MAIN workspace**, not the worktree. Always read from/write to the main workspace's `.cm/` directory.
+
+## Quick Reference
+
+| Situation | Action |
+|-----------|--------|
+| `.worktrees/` exists | Use it (verify ignored) |
+| `worktrees/` exists | Use it (verify ignored) |
+| Both exist | Use `.worktrees/` |
+| Neither exists | Check CLAUDE.md → Ask user |
+| Directory not ignored | Add to .gitignore + commit |
+| Tests fail during baseline | Report failures + ask |
+
+## Common Mistakes
+
+### Skipping ignore verification
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always use `git check-ignore` before creating project-local worktree
+
+### Assuming directory location
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: existing > CLAUDE.md > ask
+
+### Proceeding with failing tests
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+## Red Flags
+
+**Never:**
+- Create worktree without verifying it's ignored (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+- Assume directory location when ambiguous
+
+**Always:**
+- Follow directory priority: existing > CLAUDE.md > ask
+- Verify directory is ignored for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline
+
+## Integration
+
+**Called by:**
+- **cm-planning** - REQUIRED when design is approved and implementation follows
+- **cm-execution** - REQUIRED before executing any tasks
+
+**Pairs with:**
+- **cm-code-review** - For cleanup after work complete
+- **cm-continuity** - Update Working Context with worktree location

package/skills/cm-how-it-work/SKILL.md

@@ -0,0 +1,189 @@
+---
+name: cm-how-it-work
+description: "Complete guide to vibe coding with the CodyMaster skill kit — from idea to deploy. Covers the full workflow, skills used at each phase, and common use cases. Read this first if you are new; reference it whenever you're unsure which skill to invoke."
+---
+
+# CodyMaster Kit — The Ultimate Vibe Coding Guide
+
+## Overview
+
+The **CodyMaster (CM)** kit transforms ideas into production code through 13 specialized, optimized skills. This workflow ensures the highest quality, absolute security, and maximum execution speed.
+
+```
+💡 Idea → 🔍 Analysis → 📐 Design → 🧪 Test-first (TDD) → 💻 Code → ✅ Verify → 🚀 Deploy → 🔄 Iterate
+```
+
+---
+
+## Workflow
+
+### Phase 0: Identity & Safety 🔒
+> **Rule #1:** Always verify identity before performing any action that could change the project state.
+
+- **Skill:** `cm-identity-guard`
+- **When:** At the start of a work session, before git push, deploy, or database operations.
+- **Action:** Run `node check-identity.js` (or similar script) to verify GitHub/Cloudflare/Supabase accounts.
+
+---
+
+### Phase 0.5: Strategic Analysis 🔍
+> **For complex initiatives and enhancements on existing products.**
+
+- **Skill:** `cm-brainstorm-idea`
+- **When:** When the task is complex and requires multi-dimensional analysis (tech, product, design, business) before planning.
+- **Action:**
+    1. Scan codebase and interview user (Design Thinking: Empathize).
+    2. Analyze with 9 Windows (TRIZ) to see the full picture across past/present/future.
+    3. Propose 2-3 options, evaluate multi-dimensionally, recommend the best option.
+- **Output:** `brainstorm-output.md` — qualified problem + recommended option → passes to `cm-planning`.
+
+---
+
+### Phase 1: Planning & Design 📐
+> **Understand the 'Job to be Done' (JTBD) and architecture before writing code.**
+
+- **Skill:** `cm-planning` (Combines brainstorming + writing-plans)
+- **Action:**
+    1. Brainstorm requirements and analyze i18n.
+    2. Propose architecture and tech stack.
+    3. Write detailed `implementation_plan.md`.
+- **Output:** Design documentation and execution plan approved by user.
+
+---
+
+### Phase 2: Implementation (TDD & Execution) 💻
+> **Turn the plan into actual source code safely.**
+
+- **Skills:**
+    - `cm-tdd`: Red-Green-Refactor cycle. No production code without a failing test first.
+    - `cm-execution`: Execute plans intelligently (Manual, Parallel, or Subagent mode).
+    - `cm-project-bootstrap`: For new projects — setup repo, i18n, SEO, and deploy pipeline from Day 0.
+    - `cm-git-worktrees`: Isolate different work items to avoid state mixing.
+
+---
+
+### Phase 3: Quality Control & Verification ✅
+> **Prove with evidence, not words.**
+
+- **Skills:**
+    - `cm-quality-gate`: Setup test infrastructure (`test:gate`) and verify output before claiming "done".
+    - `cm-debugging`: When tests fail, use systematic investigation framework to find root cause.
+    - `cm-code-review`: Professional request and feedback review process.
+
+---
+
+### Phase 4: Safe Deployment 🚀
+> **Ship code without fear of incidents.**
+
+- **Skills:**
+    - `cm-safe-deploy`: Run 8-gate pipeline (Secret → Syntax → Test → Build → Deploy → Smoke).
+    - `cm-safe-i18n`: Translate and synchronize languages consistently across the entire project.
+    - `cm-terminal`: Monitor all terminal commands to detect errors immediately.
+
+---
+
+## CodyMaster Kit — 34 Skills Summary
+
+### 🔧 Engineering
+| Skill | Primary Function |
+|-------|-----------------|
+| `cm-tdd` | Strict Red-Green-Refactor TDD — no code without failing test first. |
+| `cm-debugging` | Systematic 5-phase error investigation (root cause first). |
+| `cm-quality-gate` | 6-gate verification: static analysis → blind review → ship. |
+| `cm-test-gate` | Setup 4-layer test infrastructure (unit → integration → e2e → security). |
+| `cm-code-review` | Manage PR lifecycle: request → receive feedback → complete branch. |
+
+### ⚙️ Operations
+| Skill | Primary Function |
+|-------|-----------------|
+| `cm-safe-deploy` | Multi-gate deploy pipeline with rollback strategy. |
+| `cm-identity-guard` | Verify account before push/deploy to prevent wrong-project incidents. |
+| `cm-git-worktrees` | Isolate feature work in separate worktrees — no state mixing. |
+| `cm-terminal` | Safe terminal execution with progress logging and error capture. |
+| `cm-secret-shield` | Defense-in-depth: pre-commit hooks, repo scanning, token lifecycle. |
+| `cm-safe-i18n` | Safe multi-language management with multi-pass batching and 8-gate audit. |
+
+### 🎨 Product
+| Skill | Primary Function |
+|-------|-----------------|
+| `cm-project-bootstrap` | Full project setup: design system → CI → staging → deploy from Day 0. |
+| `cm-brainstorm-idea` | Strategic analysis gate: 9 Windows + Double Diamond → 2-3 qualified options. |
+| `cm-planning` | Brainstorm intent → write implementation plan → coordinate execution. |
+| `cm-ux-master` | 48 UX Laws + 37 Design Tests + Figma/Stitch + BM25 semantic design search. |
+| `cm-ui-preview` | Live UI concept generation via Google Stitch or Pencil MCP. |
+| `cm-dockit` | Generate complete knowledge bases, SOPs, and API docs from codebase. |
+| `cm-readit` | Web audio engine: TTS reader, MP3 audio player, Voice CRO trigger system. |
+| `cm-jtbd` | JTBD customer discovery: Switch Interview → Canvas → Opportunity Scoring. |
+
+### 📈 Growth
+| Skill | Primary Function |
+|-------|-----------------|
+| `cm-content-factory` | Self-learning content engine: research → generate → audit → deploy. |
+| `cm-ads-tracker` | Conversion tracking setup: GTM, Meta CAPI, TikTok, Google Ads. |
+| `cro-methodology` | CRO audit: funnel mapping → persuasion assets → A/B test design. |
+
+### 🎯 Orchestration
+| Skill | Primary Function |
+|-------|-----------------|
+| `cm-execution` | Execute plans: Manual / Parallel / Subagent / RARV batch modes. |
+| `cm-continuity` | Working memory protocol: read at session start, update at session end. |
+| `cm-skill-mastery` | Meta-skill: when to invoke which skill, how to create new skills. |
+| `cm-skill-chain` | Compose skills into automated multi-step pipelines (5 built-in chains). |
+| `cm-skill-index` | Progressive disclosure index — 90% token savings on skill discovery. |
+| `cm-deep-search` | Semantic search via qmd for large codebases (>200 src / >50 docs files). |
+| `cm-how-it-work` | Full vibe coding guide — phases, skills per phase, use cases. |
+
+### 🖥️ Workflow Commands
+| Skill | Primary Function |
+|-------|-----------------|
+| `cm-start` | Orchestrate full workflow from objective to production code. |
+| `cm-dashboard` | Render Kanban board from cm-tasks.json — visual status overview. |
+| `cm-status` | Ultra-concise 1-2 sentence progress summary (what's done, what's next). |
+
+## 🚀 Autonomous Workflow System
+
+The kit supports autonomous mode by applying the **Reason → Act → Reflect → Verify (RARV)** loop.
+
+### How to Use the Workflow:
+1. **`/cm-start [objective]`**: Start work. The system will automatically create `cm-tasks.json`, break down tasks, launch the tracking interface, and autonomously use CM skills to complete them.
+2. **`/cm-dashboard`**: Open the visual tracking Dashboard in browser (shows Kanban board, reasoning log, and progress).
+3. **`/cm-status`**: View quick progress summary in Terminal.
+
+---
+
+## 💡 Activation Guide by Use Cases
+
+There are 2 ways to use CodyMaster: **Fully autonomous (Via Workflows)** or **Manual skill activation (Via Prompting)**.
+
+### 1. Build New Feature / New Project (Autonomous)
+> Best way to delegate complete work packages.
+- **Command:** `/cm-start "Build user management feature with list screen and CRUD form"`
+- **Implicit flow:** Planning → create Task JSON → sub-agents continuously run `cm-tdd` and `cm-quality-gate` for each task until done.
+
+### 2. Fix Production Bug (Manual)
+> Bugs need close supervision and AI should not blindly change too much code.
+- **Step 1:** Activate `cm-debugging` to find Root Cause.
+- **Step 2:** Activate `cm-tdd` to write test reproducing the bug and fix it.
+- **Step 3:** Activate `cm-safe-deploy` to ship code safely.
+
+### 3. Setup New Project From Scratch
+> Establish a solid foundation to avoid technical debt later.
+- **Command:** "Use `cm-identity-guard` to ensure correct account, then run `cm-project-bootstrap` to setup a new Next.js project."
+
+### 4. Batch Multi-Language Translation
+> Tedious work that's error-prone if AI loses focus.
+- **Command:** "Use `cm-safe-i18n` to extract all hardcoded text in `/components` directory to `vi.json` and `en.json` files."
+
+---
+
+## 9 Golden Rules
+
+1. **Identity First:** Verify account (`cm-identity-guard`) before push/deploy.
+2. **Design Before Code:** Always have an approved plan before typing.
+3. **i18n Day 0:** Always consider multi-language from the brainstorm step.
+4. **Test Before Code:** RED → GREEN → REFACTOR. No exceptions (`cm-tdd`).
+5. **Evidence Over Claims:** Only trust terminal/test results output, not AI "saying" it's done.
+6. **Deploy via Gates:** 8 gates must pass sequentially. Any gate fails = STOP (`cm-safe-deploy`).
+7. **Safe Secrets:** Never commit secrets. Pre-commit hooks protect every push (`cm-secret-shield`).
+8. **Parallel Power:** Use parallel execution for i18n or multi-bug fixes (`cm-execution`).
+9. **Working Memory:** Read CONTINUITY.md at session start, update at session end (`cm-continuity`).