5-phase-workflow 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "5-phase-workflow",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "A 5-phase feature development workflow for Claude Code",
   "bin": {
     "5-phase-workflow": "bin/install.js"

package/src/commands/5/configure.md

@@ -149,6 +149,129 @@ fi
 **1f. Scan existing skills:**
 - Check `.claude/skills/` for existing project-specific skills
 
+**1g. Detect codebase patterns** for potential skills:
+
+Use Glob to count files matching common architectural patterns:
+
+| Pattern | Glob Patterns                                                                 | Typical Location |
+|---------|-------------------------------------------------------------------------------|------------------|
+| **Core Architecture** |                                                                               | |
+| Controllers | `**/*Controller.{ts,js,java,py,rb}`, `**/controllers/**`                      | src/controllers/ |
+| Services | `**/*Service.{ts,js,java,py,rb}`, `**/services/**`                            | src/services/ |
+| Repositories | `**/*Repository.{ts,js,java,py}`, `**/repositories/**`                        | src/repositories/ |
+| Models/Entities | `**/*Model.{ts,js}`, `**/*Entity.java`, `**/models/**`                        | src/models/ |
+| Handlers | `**/*Handler.{ts,js,java,go}`, `**/handlers/**`                               | src/handlers/ |
+| **Data Transfer** |                                                                               | |
+| DTOs | `**/*Dto.{ts,js,java}`, `**/*DTO.{ts,js,java}`, `**/dto/**`                   | src/dto/ |
+| Requests | `**/*Request.{ts,js,java}`, `**/requests/**`                                  | src/requests/ |
+| Responses | `**/*Response.{ts,js,java}`, `**/responses/**`                                | src/responses/ |
+| Mappers | `**/*Mapper.{ts,js,java}`, `**/mappers/**`                                    | src/mappers/ |
+| Validators | `**/*Validator.{ts,js,java}`, `**/validators/**`                              | src/validators/ |
+| Schemas | `**/*Schema.{ts,js}`, `**/schemas/**`                                         | src/schemas/ |
+| **Frontend (React/Vue)** |                                                                               | |
+| Components | `**/components/**/*.{tsx,jsx,vue}`                                            | src/components/ |
+| Hooks | `**/hooks/**/*.{ts,js}`, `**/use*.{ts,js}`                                    | src/hooks/ |
+| Contexts | `**/contexts/**/*.{tsx,jsx}`, `**/*Context.{tsx,jsx}`                         | src/contexts/ |
+| Stores | `**/stores/**/*.{ts,js}`, `**/*Store.{ts,js}`                                 | src/stores/ |
+| Pages | `**/pages/**/*.{tsx,jsx}`, `**/app/**/page.{tsx,jsx}`                         | pages/, app/ |
+| Layouts | `**/layouts/**/*.{tsx,jsx,vue}`, `**/*Layout.{tsx,jsx}`                       | src/layouts/ |
+| **API/Routes** |                                                                               | |
+| API Routes | `**/api/**/*.{ts,js}`, `**/routes/**`                                         | src/api/, pages/api/ |
+| Middleware | `**/*Middleware.{ts,js,java}`, `**/middleware/**`                             | src/middleware/ |
+| Guards | `**/*.guard.{ts,js}`, `**/guards/**`                                          | src/guards/ |
+| Interceptors | `**/*.interceptor.{ts,js}`, `**/interceptors/**`                              | src/interceptors/ |
+| Filters | `**/*.filter.{ts,js}`, `**/*Filter.java`                                      | src/filters/ |
+| **Testing** |                                                                               | |
+| Tests | `**/*.test.{ts,js,tsx,jsx}`, `**/*.spec.{ts,js,tsx,jsx}`, `**/tests/**`       | src/, tests/ |
+| Specs | `**/*_spec.rb`, `**/spec/**/*.rb`, `**/*_test.go`, `**/test_*.py`             | spec/, tests/ |
+| Test Fixtures | `**/fixtures/**`,`**/testFixtures/**`, `**/__fixtures__/**`, `**/testdata/**` | fixtures/, testdata/ |
+| Factories | `**/*Factory.{ts,js,java,rb}`, `**/factories/**`                              | factories/ |
+| Mocks | `**/__mocks__/**`, `**/mocks/**`, `**/*Mock.{ts,js}`                          | __mocks__/, mocks/ |
+| **Utilities** |                                                                               | |
+| Utils | `**/utils/**/*.{ts,js,java,py}`, `**/*Utils.{ts,js,java}`                     | src/utils/ |
+| Helpers | `**/helpers/**/*.{ts,js,java,py,rb}`, `**/*Helper.{ts,js,java}`               | src/helpers/ |
+| Constants | `**/constants/**/*.{ts,js}`, `**/*Constants.{ts,js}`                          | src/constants/ |
+| Types/Interfaces | `**/types/**/*.{ts,js}`, `**/interfaces/**/*.{ts,java}`                       | src/types/ |
+| Config | `**/config/**/*.{ts,js,py}`, `**/*Config.{ts,js}`                             | src/config/ |
+| **Framework-Specific** |                                                                               | |
+| Modules (NestJS/Angular) | `**/*.module.{ts,js}`                                                         | src/modules/ |
+| Pipes (NestJS) | `**/*.pipe.{ts,js}`, `**/pipes/**`                                            | src/pipes/ |
+| Decorators | `**/decorators/**/*.{ts,js}`, `**/*.decorator.{ts,js}`                        | src/decorators/ |
+| Blueprints (Flask) | `**/blueprints/**/*.py`                                                       | blueprints/ |
+| Views (Django) | `**/views.py`, `**/views/**/*.py`                                             | app/views/ |
+| Serializers (Django) | `**/serializers.py`, `**/serializers/**/*.py`                                 | app/serializers/ |
+| **Background/Async** |                                                                               | |
+| Jobs | `**/jobs/**/*.{ts,js,rb}`, `**/*Job.{ts,js,rb}`                               | src/jobs/ |
+| Workers | `**/workers/**/*.{ts,js}`, `**/*Worker.{ts,js}`                               | src/workers/ |
+| Events | `**/events/**/*.{ts,js,java}`, `**/*Event.{ts,js,java}`                       | src/events/ |
+| Listeners | `**/listeners/**/*.{ts,js,java}`, `**/*Listener.{ts,js}`                      | src/listeners/ |
+| Commands (CLI) | `**/commands/**/*.{ts,js,java}`, `**/*Command.{ts,js}`                        | src/commands/ |
+| **Database** |                                                                               | |
+| Migrations | `**/migrations/**/*.{ts,js,sql,rb,py}`                                        | migrations/ |
+| Seeds | `**/seeds/**/*.{ts,js,rb}`, `**/seeders/**`                                   | seeds/ |
+| **Error Handling** |                                                                               | |
+| Exceptions | `**/exceptions/**/*.{ts,js,java}`, `**/*Exception.{ts,js,java}`               | src/exceptions/ |
+| Errors | `**/errors/**/*.{ts,js}`, `**/*Error.{ts,js}`                                 | src/errors/ |
+
+For each pattern found:
+- Count matching files
+- Identify primary location (most common directory)
+- Sample 1 file name to show convention
+
+**1h. Detect runnable commands** for potential command skills:
+
+Scan project configuration files for commands that can become skills:
+
+| Source | How to Detect | Example Commands |
+|--------|---------------|------------------|
+| package.json | Read `scripts` object | build, test, lint, format, dev, start, typecheck |
+| Makefile | Grep for targets (lines ending with `:`) | build, test, lint, clean, docker-build |
+| pyproject.toml | Read `[tool.poetry.scripts]` or `[project.scripts]` | test, lint, format, typecheck |
+| Cargo.toml | Check for `[[bin]]` sections, common cargo commands | build, test, clippy, fmt |
+| build.gradle | Grep for `task` definitions | build, test, lint, spotlessApply |
+| composer.json | Read `scripts` object | test, lint, format, analyse |
+| Rakefile | Grep for `task :name` patterns | test, lint, db:migrate, db:seed |
+
+**Common command categories to detect:**
+
+| Category | Common Names | Skill Name |
+|----------|--------------|------------|
+| **Build** | build, compile, bundle, pack | run-build |
+| **Test** | test, test:unit, test:integration, test:e2e, spec | run-tests |
+| **Lint** | lint, eslint, pylint, rubocop, clippy | run-lint |
+| **Format** | format, prettier, fmt, black, gofmt | run-format |
+| **Type Check** | typecheck, tsc, mypy, type-check | run-typecheck |
+| **Dev Server** | dev, start, serve, watch | run-dev |
+| **Database** | db:migrate, migrate, db:seed, seed, db:reset | run-db-migrate, run-db-seed |
+| **Docker** | docker:build, docker:up, docker:down, compose | run-docker |
+| **Deploy** | deploy, release, publish | run-deploy |
+| **Clean** | clean, reset, purge | run-clean |
+| **Generate** | generate, codegen, gen | run-generate |
+
+For each command found:
+- Record the exact command syntax
+- Identify any required environment or flags
+- Note if it has watch/CI variants
+
+Store results internally as:
+```json
+{
+  "detectedPatterns": {
+    "controller": { "count": 12, "location": "src/controllers/", "example": "UserController.ts" },
+    "service": { "count": 8, "location": "src/services/", "example": "AuthService.ts" },
+    "component": { "count": 25, "location": "src/components/", "example": "Button.tsx" }
+  },
+  "detectedCommands": {
+    "build": { "source": "package.json", "command": "npm run build", "variants": ["build:prod", "build:dev"] },
+    "test": { "source": "package.json", "command": "npm test", "variants": ["test:unit", "test:e2e"] },
+    "lint": { "source": "package.json", "command": "npm run lint", "variants": ["lint:fix"] },
+    "format": { "source": "package.json", "command": "npm run format", "variants": [] }
+  }
+}
+```
+
+Only include patterns/commands that are actually detected.
+
 ### Step 2: Gather User Preferences (interactive via AskUserQuestion)
 
 **2a. If config exists:**
@@ -201,10 +324,46 @@ fi
 - "Generate/update CLAUDE.md? This will analyze your codebase to document structure and conventions."
   - Options: "Yes (recommended)", "Skip"
 
-**2h. Confirm project-specific skills:**
-- Present proposed skills based on detected project type (see skill table in configure-project/SKILL.md)
-- "These project-specific skills were detected for your {project-type} project: {skill-list}. Confirm or customize?"
-  - Options: "Use these (recommended)", "Customize", "Skip skill generation"
+**2h. Review detected patterns for skill generation:**
+
+Present ONLY patterns that were actually detected in steps 1g and 1h.
+
+**Part 1: Architectural patterns (create-* skills)**
+
+"I analyzed your codebase and found these architectural patterns:
+
+| Pattern | Files Found | Location | Example |
+|---------|-------------|----------|---------|
+| Controller | 12 files | src/controllers/ | UserController.ts |
+| Service | 8 files | src/services/ | AuthService.ts |
+| Component | 25 files | src/components/ | Button.tsx |
+
+Which patterns would you like `create-*` skills generated for?"
+
+- Options: Multi-select checkboxes for each detected pattern (use AskUserQuestion with multiSelect: true)
+- Include descriptions like: "Controller (12 files) - Generate `create-controller` skill"
+- Plus "Other" option for patterns not detected but desired
+
+**Part 2: Command skills (run-* skills)**
+
+"I also found these runnable commands:
+
+| Command | Source | Full Command | Variants |
+|---------|--------|--------------|----------|
+| build | package.json | npm run build | build:prod, build:dev |
+| test | package.json | npm test | test:unit, test:e2e |
+| lint | package.json | npm run lint | lint:fix |
+| format | Makefile | make format | - |
+
+Which commands would you like `run-*` skills generated for?"
+
+- Options: Multi-select checkboxes for each detected command
+- Include descriptions like: "test - Generate `run-tests` skill"
+- Plus "Other" option for commands not detected
+
+If no patterns/commands detected:
+- Inform user: "No common patterns detected. Would you like to specify patterns manually?"
+- Allow manual entry of pattern names/locations or command names
 
 ### Step 3: Create Feature Spec
 
@@ -260,18 +419,59 @@ Analyze the codebase and generate modular documentation:
 - If CLAUDE.md already exists, preserve user-written custom sections
 
 ### Requirement 3: Generate Project-Specific Skills
-Generate the following skills in `.claude/skills/`:
-{List of confirmed skills, e.g.:}
-- create-component: Creates a React component following project conventions
-- create-hook: Creates a custom React hook following project conventions
-- create-context: Creates a React context provider following project conventions
 
-Each skill should:
+#### 3a. Create-* Skills (Architectural Patterns)
+
+Generate skills based on detected file patterns:
+
+| Pattern | Files | Location | Skill Name | Generate |
+|---------|-------|----------|------------|----------|
+| Controller | {count} | {location} | create-controller | ✓ |
+| Service | {count} | {location} | create-service | ✓ |
+| Component | {count} | {location} | create-component | ✓ |
+| {pattern} | {count} | {location} | create-{pattern} | ✗ (user skipped) |
+
+{Include only patterns where user selected "Generate = ✓"}
+
+For each selected pattern skill:
+1. Analyze 2-3 existing files from the pattern location
+2. Extract naming conventions, file structure, imports
+3. Generate SKILL.md with project-specific template
+
+Each create-* skill should:
 - Follow standard SKILL.md frontmatter pattern
+- Set `user-invocable: true` so users can invoke directly (e.g., `/create-controller UserController`)
+- Set `model: haiku` for fast, cheap pattern-following
 - Derive patterns from existing code in the project
 - Include file naming and location conventions
 - Include template/pattern based on existing examples
 
+#### 3b. Run-* Skills (Command Skills)
+
+Generate skills based on detected commands:
+
+| Command | Source | Full Command | Skill Name | Generate |
+|---------|--------|--------------|------------|----------|
+| build | {source} | {command} | run-build | ✓ |
+| test | {source} | {command} | run-tests | ✓ |
+| lint | {source} | {command} | run-lint | ✓ |
+| {command} | {source} | {full-command} | run-{command} | ✗ (user skipped) |
+
+{Include only commands where user selected "Generate = ✓"}
+
+For each selected command skill:
+1. Document the exact command and any variants
+2. Include common flags and options
+3. Document expected output and error handling
+
+Each run-* skill should:
+- Follow standard SKILL.md frontmatter pattern
+- Set `user-invocable: true` so users can invoke directly (e.g., `/run-tests`, `/run-lint`)
+- Set `model: haiku` for simple command execution
+- Include the exact command syntax
+- Document any environment requirements
+- Include common options/flags
+
 ## Acceptance Criteria
 - [ ] `.claude/.5/config.json` exists with correct values (no `steps` array)
 - [ ] `.5/` directory created
@@ -339,8 +539,27 @@ User: "Yes"
 Claude: "Generate CLAUDE.md with codebase analysis?"
 User: "Yes"
 
-Claude: "Proposed skills for Next.js: create-page, create-api-route, create-component. Confirm?"
-User: "Use these"
+Claude: "I analyzed your codebase and found these patterns:
+| Pattern | Files | Location | Example |
+|---------|-------|----------|---------|
+| Component | 25 files | src/components/ | Button.tsx |
+| Hook | 8 files | src/hooks/ | useAuth.ts |
+| API Route | 12 files | pages/api/ | users.ts |
+| Page | 15 files | pages/ | index.tsx |
+
+Which patterns would you like `create-*` skills generated for?"
+User: [Selects Component, Hook, API Route]
+
+Claude: "I also found these runnable commands:
+| Command | Source | Full Command |
+|---------|--------|--------------|
+| build | package.json | npm run build |
+| test | package.json | npm test |
+| lint | package.json | npm run lint |
+| typecheck | package.json | npm run typecheck |
+
+Which commands would you like `run-*` skills generated for?"
+User: [Selects test, lint]
 
 Claude: [Writes .5/CONFIGURE/feature.md]
 Claude: "Configuration feature planned at `.5/CONFIGURE/feature.md`"

package/src/commands/5/plan-feature.md

@@ -101,9 +101,14 @@ Use Task tool with subagent_type=Explore for complex exploration.
 
 **Goal:** Understand what already exists so you can ask informed questions.
 
-### Step 4: Intensive Collaboration (5-10 Questions)
+### Step 4: Intensive Collaboration (5-10 Questions, ONE AT A TIME)
 
-**CRITICAL:** After exploring the codebase, engage in intensive Q&A using the AskUserQuestion tool. Ask 5-10 clarifying questions based on your findings. This is NOT optional.
+**CRITICAL:** After exploring the codebase, engage in intensive Q&A. This is NOT optional.
+
+- Ask 5-10 clarifying questions using AskUserQuestion
+- **ONE question at a time** - wait for answer before next question
+- Do NOT list multiple questions in one message
+- Do NOT skip to creating feature.md before asking at least 5 questions
 
 **Question categories to explore:**
 
@@ -154,7 +159,7 @@ Use Task tool with subagent_type=Explore for complex exploration.
 - "Could we use existing Z component instead?"
 - "Is a full factory needed or just simple creation?"
 
-Use AskUserQuestion to present options and trade-offs. Multiple questions can be asked in batches.
+**Ask questions ONE AT A TIME.** Use AskUserQuestion for each question. For clarifying questions, provide 2-4 options where meaningful. Wait for the user's answer before asking the next question. Open questions (like feature description) can use free text.
 
 ### Step 5: Determine Feature Name
 

package/src/commands/5/plan-implementation.md

@@ -39,7 +39,9 @@ Understand the project structure:
 
 This is a quick scan, not deep analysis. The executor agent will do detailed pattern matching.
 
-### Step 3: Ask 2-3 Technical Questions
+### Step 3: Ask 2-3 Technical Questions (ONE AT A TIME)
+
+**CRITICAL:** Ask questions ONE AT A TIME. Wait for the user's answer before asking the next question.
 
 Use AskUserQuestion to clarify:
 - Data layer decisions (if applicable)
@@ -48,7 +50,11 @@ Use AskUserQuestion to clarify:
 - Software Architecture
 - Testing behaviour
 
-Keep it brief. Don't over-question. Don't ask feature questions already answered in the plan-feature phase. 
+Keep it brief. Don't over-question. Don't ask feature questions already answered in the plan-feature phase.
+
+- **ONE question at a time** - wait for answer before next question
+- Do NOT list multiple questions in one message
+- Do NOT skip to creating plan.md before asking your questions 
 
 ### Step 4: Design Components
 
@@ -212,3 +218,5 @@ Components in the same step run in parallel. Structure your plan accordingly:
 - Don't over-analyze the codebase - the executor will do detailed pattern matching
 - Don't ask more than 3 questions
 - Don't create unnecessary sequential steps - group independent work together
+- **Don't skip to implementation** - This command ONLY creates the plan
+- **Don't batch questions** - Ask one question at a time

package/src/commands/5/quick-implement.md

@@ -84,6 +84,8 @@ feature_name="${TICKET_ID}-${slug}"
 - Which existing patterns to follow?
 - Any edge cases to handle?
 
+**Ask questions ONE AT A TIME.** Wait for the user's answer before asking the next question. Do NOT list multiple questions in one message.
+
 ### Step 5: Create Plan
 
 Write plan to `.5/${feature_name}/plan.md` using the template structure.

package/src/hooks/check-updates.js

@@ -9,20 +9,20 @@ process.stdin.on('data', (chunk) => {
   inputData += chunk;
 });
 
-process.stdin.on('end', () => {
+process.stdin.on('end', async () => {
   try {
     // Parse hook input (contains workspace info)
     const hookData = JSON.parse(inputData);
     const workspaceDir = hookData.workingDirectory || process.cwd();
 
-    checkForUpdates(workspaceDir);
+    await checkForUpdates(workspaceDir);
   } catch (e) {
     // Silent failure - don't block on errors
     process.exit(0);
   }
 });
 
-function checkForUpdates(workspaceDir) {
+async function checkForUpdates(workspaceDir) {
   const versionFile = path.join(workspaceDir, '.claude', '.5', 'version.json');
 
   // Check if version.json exists
@@ -57,38 +57,53 @@ function checkForUpdates(workspaceDir) {
 
   // Compare versions
   const installed = versionData.installedVersion;
-  const packageVersion = getPackageVersion(workspaceDir);
+  const latestVersion = await getLatestVersion();
 
-  if (!packageVersion || installed === packageVersion) {
+  if (!latestVersion || installed === latestVersion) {
     // No update available
     process.exit(0);
   }
 
-  // Check if update is available (installed < package)
-  if (compareVersions(installed, packageVersion) < 0) {
+  // Check if update is available (installed < latest)
+  if (compareVersions(installed, latestVersion) < 0) {
     // Show update notification
-    console.log(`\n\x1b[34mℹ\x1b[0m Update available: ${installed} → ${packageVersion}`);
+    console.log(`\n\x1b[34mℹ\x1b[0m Update available: ${installed} → ${latestVersion}`);
     console.log(`  Run: \x1b[1mnpx 5-phase-workflow --upgrade\x1b[0m\n`);
   }
 
   process.exit(0);
 }
 
-// Get package version from local package.json
-function getPackageVersion(workspaceDir) {
-  // Try to find package.json in node_modules/5-phase-workflow
-  const pkgPath = path.join(workspaceDir, 'node_modules', '5-phase-workflow', 'package.json');
-
-  if (fs.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      return pkg.version;
-    } catch (e) {
-      return null;
-    }
-  }
-
-  return null;
+// Get latest version from npm registry
+async function getLatestVersion() {
+  return new Promise((resolve) => {
+    const https = require('https');
+    const req = https.get(
+      'https://registry.npmjs.org/5-phase-workflow/latest',
+      { timeout: 3000 },
+      (res) => {
+        if (res.statusCode !== 200) {
+          resolve(null);
+          return;
+        }
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          try {
+            const pkg = JSON.parse(data);
+            resolve(pkg.version);
+          } catch (e) {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
 }
 
 // Compare semver versions

package/src/skills/configure-project/SKILL.md

@@ -250,75 +250,231 @@ If CLAUDE.md already exists:
 
 ## C. Generate Project-Specific Skills
 
+**Reads:** Pattern selections from feature spec (`.5/CONFIGURE/feature.md`)
+
 **Creates:** SKILL.md files in `.claude/skills/{name}/SKILL.md`
 
-Each skill follows the standard frontmatter pattern and contains instructions derived from analyzing the actual project structure (reads existing files to derive patterns/templates).
-
-### Skill Detection by Project Type
-
-| Project Type | Skills |
-|---|---|
-| Next.js | create-page, create-api-route, create-component |
-| NestJS | create-module, create-service, create-controller |
-| Express | create-route, create-middleware, create-service |
-| React | create-component, create-hook, create-context |
-| Django | create-model, create-view, create-serializer |
-| Flask | create-blueprint, create-model |
-| Java (Gradle/Maven) | create-entity, create-service, create-controller, create-repository |
-| Rust | create-module |
-| Go | create-handler, create-service |
-| Rails | create-model, create-controller |
-| Generic | create-module |
-
-### Skill Generation Process
-
-For each skill to generate:
-1. Identify existing examples of that pattern in the codebase (e.g., find existing components for `create-component`)
-2. Read 1-2 examples to extract the project's conventions and structure
-3. Create a SKILL.md that instructs the agent to follow those conventions
-4. Each generated SKILL.md should include:
-   - Standard frontmatter (name, description, allowed-tools, model: sonnet, context: fork, user-invocable: false)
-   - What the skill creates
-   - File naming and location conventions (derived from existing code)
-   - Template/pattern to follow (derived from existing code)
-   - Checklist of what to include
-
-### Example Generated Skill
+### Pattern-Based Skill Generation
+
+Skills are determined by what patterns exist in the codebase (detected during `/5:configure`) and what the user selected—NOT by project type.
+
+For EACH pattern selected by the user in the feature spec:
+
+1. **Find examples** - Read 2-3 files from the pattern's location
+2. **Extract conventions:**
+   - File naming (PascalCase, kebab-case, suffix patterns)
+   - Directory structure (flat, nested, co-located tests)
+   - Import patterns (absolute, relative, aliases)
+   - Export patterns (default, named, barrel files)
+   - Common boilerplate (decorators, annotations, base classes)
+3. **Generate SKILL.md** with:
+   - Detected conventions as instructions
+   - Template derived from actual code
+   - Checklist based on common elements found
+
+### Skill Template Structure
+
+For each skill, create `.claude/skills/create-{pattern}/SKILL.md`:
 
 ```yaml
 ---
-name: create-component
-description: Creates a React component following project conventions.
+name: create-{pattern}
+description: Creates a {Pattern} following project conventions at {location}.
 allowed-tools: Read, Write, Glob, Grep
-model: sonnet
+model: haiku
 context: fork
-user-invocable: false
+user-invocable: true
 ---
 ```
 
 ```markdown
-# Create Component
+# Create {Pattern}
 
 ## What This Skill Creates
-A React component following this project's conventions.
+A {pattern} following this project's conventions.
 
-## Conventions (from project analysis)
-- Location: `src/components/{ComponentName}/`
-- Files: `index.tsx`, `{ComponentName}.tsx`, `{ComponentName}.test.tsx`
-- Style: CSS Modules at `{ComponentName}.module.css`
-- Exports: Named export from component file, re-exported from index
+## Detected Conventions
+- **Location:** {detected-location}
+- **Naming:** {detected-naming-pattern}
+- **Structure:** {detected-structure}
+- **Imports:** {detected-import-pattern}
 
 ## Template
-{Derived from existing components in the project}
+Based on {example-file}, new {patterns} should follow:
+
+\`\`\`{language}
+{template-derived-from-analysis}
+\`\`\`
 
 ## Checklist
-- [ ] Component file created
-- [ ] Props interface defined
-- [ ] Test file created
-- [ ] Index file with re-export
-- [ ] Follows naming conventions
+- [ ] File created at correct location
+- [ ] Naming convention followed
+- [ ] Required imports added
+- [ ] {pattern-specific-items}
+```
+
+### Pattern to Skill Name Mapping
+
+| Detected Pattern | Skill Name |
+|------------------|------------|
+| **Core Architecture** | |
+| controller | create-controller |
+| service | create-service |
+| repository | create-repository |
+| model/entity | create-model |
+| handler | create-handler |
+| **Data Transfer** | |
+| dto | create-dto |
+| request | create-request |
+| response | create-response |
+| mapper | create-mapper |
+| validator | create-validator |
+| schema | create-schema |
+| **Frontend** | |
+| component | create-component |
+| hook | create-hook |
+| context | create-context |
+| store | create-store |
+| page | create-page |
+| layout | create-layout |
+| **API/Routes** | |
+| api-route | create-api-route |
+| middleware | create-middleware |
+| guard | create-guard |
+| interceptor | create-interceptor |
+| filter | create-filter |
+| **Testing** | |
+| test | create-test |
+| spec | create-spec |
+| fixture | create-fixture |
+| factory | create-factory |
+| mock | create-mock |
+| **Utilities** | |
+| util | create-util |
+| helper | create-helper |
+| constant | create-constant |
+| type | create-type |
+| config | create-config |
+| **Framework-Specific** | |
+| module | create-module |
+| pipe | create-pipe |
+| decorator | create-decorator |
+| blueprint | create-blueprint |
+| view | create-view |
+| serializer | create-serializer |
+| **Background/Async** | |
+| job | create-job |
+| worker | create-worker |
+| event | create-event |
+| listener | create-listener |
+| command | create-command |
+| **Database** | |
+| migration | create-migration |
+| seed | create-seed |
+| **Error Handling** | |
+| exception | create-exception |
+| error | create-error |
+
+### Why `user-invocable: true`
+
+Generated skills are user-invocable so users can invoke them directly:
+- `/create-controller UserController`
+- `/create-component Button`
+- `/create-service AuthService`
+
+This is more useful than internal-only skills.
+
+### Why `model: haiku`
+
+Pattern-following is simple once conventions are documented:
+- Faster and cheaper than sonnet
+- Deep analysis already happened during generation
+- The skill just needs to follow the documented template
+
+---
+
+## C2. Generate Command Skills (run-*)
+
+**Reads:** Command selections from feature spec (`.5/CONFIGURE/feature.md`)
+
+**Creates:** SKILL.md files in `.claude/skills/run-{command}/SKILL.md`
+
+### Command-Based Skill Generation
+
+For EACH command selected by the user in the feature spec:
+
+1. **Read the source** - Check package.json scripts, Makefile, etc.
+2. **Document the command:**
+   - Exact command syntax
+   - Available variants (e.g., test:unit, test:e2e)
+   - Common flags and options
+   - Expected output format
+3. **Generate SKILL.md** with:
+   - Command execution instructions
+   - Output parsing guidance
+   - Error handling patterns
+
+### Command Skill Template Structure
+
+For each skill, create `.claude/skills/run-{command}/SKILL.md`:
+
+```yaml
+---
+name: run-{command}
+description: Runs {command} for this project using {source}.
+allowed-tools: Bash
+model: haiku
+context: fork
+user-invocable: true
+---
+```
+
+```markdown
+# Run {Command}
+
+## What This Skill Does
+Executes the project's {command} command.
+
+## Command
+\`\`\`bash
+{exact-command}
+\`\`\`
+
+## Variants
+{if variants exist}
+- `{variant1}` - {description}
+- `{variant2}` - {description}
+
+## Common Options
+- `--watch` - Run in watch mode (if available)
+- `--coverage` - Generate coverage report (for tests)
+- `--fix` - Auto-fix issues (for lint/format)
+
+## Expected Output
+{describe what success/failure looks like}
+
+## Error Handling
+- If command fails, report the error output
+- Common issues: {list common problems and solutions}
 ```
 
+### Command to Skill Name Mapping
+
+| Detected Command | Skill Name |
+|------------------|------------|
+| build | run-build |
+| test, spec | run-tests |
+| lint, eslint | run-lint |
+| format, prettier | run-format |
+| typecheck, tsc | run-typecheck |
+| dev, start | run-dev |
+| db:migrate, migrate | run-migrate |
+| db:seed, seed | run-seed |
+| docker:build | run-docker-build |
+| docker:up, compose up | run-docker-up |
+| clean | run-clean |
+| generate, codegen | run-generate |
+
 ---
 
 ## Output Contract
@@ -336,7 +492,8 @@ Component B (Documentation): SUCCESS - Created 7 documentation files + index
   - .5/INTEGRATIONS.md (PostgreSQL, 2 APIs, GitHub Actions)
   - .5/CONCERNS.md (3 TODO items, 1 deprecated dependency)
   - CLAUDE.md (index with references)
-Component C (Skills): SUCCESS - Generated 3 skills (create-component, create-hook, create-context)
+Component C (Pattern Skills): SUCCESS - Generated 3 create-* skills (create-component, create-hook, create-context)
+Component D (Command Skills): SUCCESS - Generated 2 run-* skills (run-tests, run-lint)
 ```
 
 Or on failure:
@@ -350,6 +507,8 @@ Component B (Documentation): FAILED - Unable to read template files
 
 - DO NOT overwrite existing user-written CLAUDE.md sections
 - DO NOT generate skills for patterns that don't exist in the project
+- DO NOT generate command skills for commands that don't exist in the project
 - DO NOT include `steps` in config.json
 - DO NOT hardcode conventions - always derive from actual project analysis
 - DO NOT generate empty or placeholder skill files
+- DO NOT assume command syntax - always read from actual config files (package.json, Makefile, etc.)