feat: add Discuss and Explore subagents for dynamic critique and code exploration

- Implement Discuss Subagent for multi-perspective critique with dynamic perspectives. - Create Explore Subagent for shared codebase exploration with centralized caching. - Add tests for CcwToolsMcpCard component to ensure enabled tools are preserved on config save. - Introduce SessionPreviewPanel component for previewing and selecting sessions for Memory V2 extraction. - Develop CommandCreateDialog component for creating/importing commands with import and CLI generate modes.
2026-03-01 09:33:25 +08:00 · 2026-02-27 17:25:52 +08:00
parent 3db74cc7b0
commit 3b92bfae8c
45 changed files with 6508 additions and 128 deletions
--- a/.claude/skills/command-generator/SKILL.md
+++ b/.claude/skills/command-generator/SKILL.md
@@ -0,0 +1,190 @@
+---
+name: command-generator
+description: Command file generator - 5 phase workflow for creating Claude Code command files with YAML frontmatter. Generates .md command files for project or user scope. Triggers on "create command", "new command", "command generator".
+allowed-tools: Read, Write, Edit, Bash, Glob
+---
+
+# Command Generator
+
+CLI-based command file generator producing Claude Code command .md files through a structured 5-phase workflow. Supports both project-level (`.claude/commands/`) and user-level (`~/.claude/commands/`) command locations.
+
+## Architecture Overview
+
+```
+-----------------------------------------------------------+
+|                    Command Generator                        |
+|                                                            |
+|  Input: skillName, description, location, [group], [hint]  |
+|                         |                                  |
+|  +-------------------------------------------------+      |
+|  |  Phase 1-5: Sequential Pipeline                 |      |
+|  |                                                 |      |
+|  |  [P1] --> [P2] --> [P3] --> [P4] --> [P5]      |      |
+|  |  Param   Target   Template  Content   File     |      |
+|  |  Valid   Path     Loading   Format    Gen      |      |
+|  +-------------------------------------------------+      |
+|                         |                                  |
+|  Output: {scope}/.claude/commands/{group}/{name}.md       |
+|                                                            |
+-----------------------------------------------------------+
+```
+
+## Key Design Principles
+
+1. **Single Responsibility**: Generates one command file per invocation
+2. **Scope Awareness**: Supports project and user-level command locations
+3. **Template-Driven**: Uses consistent template for all generated commands
+4. **Validation First**: Validates all required parameters before file operations
+5. **Non-Destructive**: Warns if command file already exists
+
+---
+
+## Execution Flow
+
+```
+Phase 1: Parameter Validation
+   - Ref: phases/01-parameter-validation.md
+   - Validate: skillName (required), description (required), location (required)
+   - Optional: group, argumentHint
+   - Output: validated params object
+
+Phase 2: Target Path Resolution
+   - Ref: phases/02-target-path-resolution.md
+   - Resolve: location -> target commands directory
+   - Support: project (.claude/commands/) vs user (~/.claude/commands/)
+   - Handle: group subdirectory if provided
+   - Output: targetPath string
+
+Phase 3: Template Loading
+   - Ref: phases/03-template-loading.md
+   - Load: templates/command-md.md
+   - Template contains YAML frontmatter with placeholders
+   - Output: templateContent string
+
+Phase 4: Content Formatting
+   - Ref: phases/04-content-formatting.md
+   - Substitute: {{name}}, {{description}}, {{group}}, {{argumentHint}}
+   - Handle: optional fields (group, argumentHint)
+   - Output: formattedContent string
+
+Phase 5: File Generation
+   - Ref: phases/05-file-generation.md
+   - Check: file existence (warn if exists)
+   - Write: formatted content to target path
+   - Output: success confirmation with file path
+```
+
+## Usage Examples
+
+### Basic Command (Project Scope)
+```javascript
+Skill(skill="command-generator", args={
+  skillName: "deploy",
+  description: "Deploy application to production environment",
+  location: "project"
+})
+// Output: .claude/commands/deploy.md
+```
+
+### Grouped Command with Argument Hint
+```javascript
+Skill(skill="command-generator", args={
+  skillName: "create",
+  description: "Create new issue from GitHub URL or text",
+  location: "project",
+  group: "issue",
+  argumentHint: "[-y|--yes] <github-url | text-description> [--priority 1-5]"
+})
+// Output: .claude/commands/issue/create.md
+```
+
+### User-Level Command
+```javascript
+Skill(skill="command-generator", args={
+  skillName: "global-status",
+  description: "Show global Claude Code status",
+  location: "user"
+})
+// Output: ~/.claude/commands/global-status.md
+```
+
+---
+
+## Reference Documents by Phase
+
+### Phase 1: Parameter Validation
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/01-parameter-validation.md](phases/01-parameter-validation.md) | Validate required parameters | Phase 1 execution |
+
+### Phase 2: Target Path Resolution
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/02-target-path-resolution.md](phases/02-target-path-resolution.md) | Resolve target directory | Phase 2 execution |
+
+### Phase 3: Template Loading
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/03-template-loading.md](phases/03-template-loading.md) | Load command template | Phase 3 execution |
+| [templates/command-md.md](templates/command-md.md) | Command file template | Template reference |
+
+### Phase 4: Content Formatting
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/04-content-formatting.md](phases/04-content-formatting.md) | Format content with params | Phase 4 execution |
+
+### Phase 5: File Generation
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/05-file-generation.md](phases/05-file-generation.md) | Write final file | Phase 5 execution |
+
+### Design Specifications
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [specs/command-design-spec.md](specs/command-design-spec.md) | Command design guidelines | Understanding best practices |
+
+---
+
+## Output Structure
+
+### Generated Command File
+
+```markdown
+---
+name: {skillName}
+description: {description}
+{group} {argumentHint}
+---
+
+# {skillName} Command
+
+## Overview
+{Auto-generated placeholder for command overview}
+
+## Usage
+{Auto-generated placeholder for usage examples}
+
+## Execution Flow
+{Auto-generated placeholder for execution steps}
+```
+
+---
+
+## Error Handling
+
+| Error | Stage | Action |
+|-------|-------|--------|
+| Missing skillName | Phase 1 | Error: "skillName is required" |
+| Missing description | Phase 1 | Error: "description is required" |
+| Missing location | Phase 1 | Error: "location is required (project or user)" |
+| Invalid location | Phase 2 | Error: "location must be 'project' or 'user'" |
+| Template not found | Phase 3 | Error: "Command template not found" |
+| File exists | Phase 5 | Warning: "Command file already exists, will overwrite" |
+| Write failure | Phase 5 | Error: "Failed to write command file" |
+
+---
+
+## Related Skills
+
+- **skill-generator**: Create complete skills with phases, templates, and specs
+- **flow-coordinator**: Orchestrate multi-step command workflows
--- a/.claude/skills/command-generator/phases/01-parameter-validation.md
+++ b/.claude/skills/command-generator/phases/01-parameter-validation.md
@@ -0,0 +1,174 @@
+# Phase 1: Parameter Validation
+
+Validate all required parameters for command generation.
+
+## Objective
+
+Ensure all required parameters are provided before proceeding with command generation:
+- **skillName**: Command identifier (required)
+- **description**: Command description (required)
+- **location**: Target scope - "project" or "user" (required)
+- **group**: Optional grouping subdirectory
+- **argumentHint**: Optional argument hint string
+
+## Input
+
+Parameters received from skill invocation:
+- `skillName`: string (required)
+- `description`: string (required)
+- `location`: "project" | "user" (required)
+- `group`: string (optional)
+- `argumentHint`: string (optional)
+
+## Validation Rules
+
+### Required Parameters
+
+```javascript
+const requiredParams = {
+  skillName: {
+    type: 'string',
+    minLength: 1,
+    pattern: /^[a-z][a-z0-9-]*$/,  // lowercase, alphanumeric, hyphens
+    error: 'skillName must be lowercase alphanumeric with hyphens, starting with a letter'
+  },
+  description: {
+    type: 'string',
+    minLength: 10,
+    error: 'description must be at least 10 characters'
+  },
+  location: {
+    type: 'string',
+    enum: ['project', 'user'],
+    error: 'location must be "project" or "user"'
+  }
+};
+```
+
+### Optional Parameters
+
+```javascript
+const optionalParams = {
+  group: {
+    type: 'string',
+    pattern: /^[a-z][a-z0-9-]*$/,
+    default: null,
+    error: 'group must be lowercase alphanumeric with hyphens'
+  },
+  argumentHint: {
+    type: 'string',
+    default: '',
+    error: 'argumentHint must be a string'
+  }
+};
+```
+
+## Execution Steps
+
+### Step 1: Extract Parameters
+
+```javascript
+// Extract from skill args
+const params = {
+  skillName: args.skillName,
+  description: args.description,
+  location: args.location,
+  group: args.group || null,
+  argumentHint: args.argumentHint || ''
+};
+```
+
+### Step 2: Validate Required Parameters
+
+```javascript
+function validateRequired(params, rules) {
+  const errors = [];
+  
+  for (const [key, rule] of Object.entries(rules)) {
+    const value = params[key];
+    
+    // Check existence
+    if (value === undefined || value === null || value === '') {
+      errors.push(`${key} is required`);
+      continue;
+    }
+    
+    // Check type
+    if (typeof value !== rule.type) {
+      errors.push(`${key} must be a ${rule.type}`);
+      continue;
+    }
+    
+    // Check minLength
+    if (rule.minLength && value.length < rule.minLength) {
+      errors.push(`${key} must be at least ${rule.minLength} characters`);
+    }
+    
+    // Check pattern
+    if (rule.pattern && !rule.pattern.test(value)) {
+      errors.push(rule.error);
+    }
+    
+    // Check enum
+    if (rule.enum && !rule.enum.includes(value)) {
+      errors.push(`${key} must be one of: ${rule.enum.join(', ')}`);
+    }
+  }
+  
+  return errors;
+}
+
+const requiredErrors = validateRequired(params, requiredParams);
+if (requiredErrors.length > 0) {
+  throw new Error(`Validation failed:\n${requiredErrors.join('\n')}`);
+}
+```
+
+### Step 3: Validate Optional Parameters
+
+```javascript
+function validateOptional(params, rules) {
+  const warnings = [];
+  
+  for (const [key, rule] of Object.entries(rules)) {
+    const value = params[key];
+    
+    if (value !== null && value !== undefined && value !== '') {
+      if (rule.pattern && !rule.pattern.test(value)) {
+        warnings.push(`${key}: ${rule.error}`);
+      }
+    }
+  }
+  
+  return warnings;
+}
+
+const optionalWarnings = validateOptional(params, optionalParams);
+// Log warnings but continue
+```
+
+### Step 4: Normalize Parameters
+
+```javascript
+const validatedParams = {
+  skillName: params.skillName.trim().toLowerCase(),
+  description: params.description.trim(),
+  location: params.location.trim().toLowerCase(),
+  group: params.group ? params.group.trim().toLowerCase() : null,
+  argumentHint: params.argumentHint ? params.argumentHint.trim() : ''
+};
+```
+
+## Output
+
+```javascript
+{
+  status: 'validated',
+  params: validatedParams,
+  warnings: optionalWarnings
+}
+```
+
+## Next Phase
+
+Proceed to [Phase 2: Target Path Resolution](02-target-path-resolution.md) with `validatedParams`.
--- a/.claude/skills/command-generator/phases/02-target-path-resolution.md
+++ b/.claude/skills/command-generator/phases/02-target-path-resolution.md
@@ -0,0 +1,171 @@
+# Phase 2: Target Path Resolution
+
+Resolve the target commands directory based on location parameter.
+
+## Objective
+
+Determine the correct target path for the command file based on:
+- **location**: "project" or "user" scope
+- **group**: Optional subdirectory for command organization
+- **skillName**: Command filename (with .md extension)
+
+## Input
+
+From Phase 1 validation:
+```javascript
+{
+  skillName: string,      // e.g., "create"
+  description: string,
+  location: "project" | "user",
+  group: string | null,   // e.g., "issue"
+  argumentHint: string
+}
+```
+
+## Path Resolution Rules
+
+### Location Mapping
+
+```javascript
+const locationMap = {
+  project: '.claude/commands',
+  user: '~/.claude/commands'  // Expands to user home directory
+};
+```
+
+### Path Construction
+
+```javascript
+function resolveTargetPath(params) {
+  const baseDir = locationMap[params.location];
+  
+  if (!baseDir) {
+    throw new Error(`Invalid location: ${params.location}. Must be "project" or "user".`);
+  }
+  
+  // Expand ~ to user home if present
+  const expandedBase = baseDir.startsWith('~') 
+    ? path.join(os.homedir(), baseDir.slice(1))
+    : baseDir;
+  
+  // Build full path
+  let targetPath;
+  if (params.group) {
+    // Grouped command: .claude/commands/{group}/{skillName}.md
+    targetPath = path.join(expandedBase, params.group, `${params.skillName}.md`);
+  } else {
+    // Top-level command: .claude/commands/{skillName}.md
+    targetPath = path.join(expandedBase, `${params.skillName}.md`);
+  }
+  
+  return targetPath;
+}
+```
+
+## Execution Steps
+
+### Step 1: Get Base Directory
+
+```javascript
+const location = validatedParams.location;
+const baseDir = locationMap[location];
+
+if (!baseDir) {
+  throw new Error(`Invalid location: ${location}. Must be "project" or "user".`);
+}
+```
+
+### Step 2: Expand User Path (if applicable)
+
+```javascript
+const os = require('os');
+const path = require('path');
+
+let expandedBase = baseDir;
+if (baseDir.startsWith('~')) {
+  expandedBase = path.join(os.homedir(), baseDir.slice(1));
+}
+```
+
+### Step 3: Construct Full Path
+
+```javascript
+let targetPath;
+let targetDir;
+
+if (validatedParams.group) {
+  // Command with group subdirectory
+  targetDir = path.join(expandedBase, validatedParams.group);
+  targetPath = path.join(targetDir, `${validatedParams.skillName}.md`);
+} else {
+  // Top-level command
+  targetDir = expandedBase;
+  targetPath = path.join(targetDir, `${validatedParams.skillName}.md`);
+}
+```
+
+### Step 4: Ensure Target Directory Exists
+
+```javascript
+// Check and create directory if needed
+Bash(`mkdir -p "${targetDir}"`);
+```
+
+### Step 5: Check File Existence
+
+```javascript
+const fileExists = Bash(`test -f "${targetPath}" && echo "EXISTS" || echo "NOT_FOUND"`);
+
+if (fileExists.includes('EXISTS')) {
+  console.warn(`Warning: Command file already exists at ${targetPath}. Will overwrite.`);
+}
+```
+
+## Output
+
+```javascript
+{
+  status: 'resolved',
+  targetPath: targetPath,     // Full path to command file
+  targetDir: targetDir,       // Directory containing command
+  fileName: `${skillName}.md`,
+  fileExists: fileExists.includes('EXISTS'),
+  params: validatedParams     // Pass through to next phase
+}
+```
+
+## Path Examples
+
+### Project Scope (No Group)
+```
+location: "project"
+skillName: "deploy"
+-> .claude/commands/deploy.md
+```
+
+### Project Scope (With Group)
+```
+location: "project"
+skillName: "create"
+group: "issue"
+-> .claude/commands/issue/create.md
+```
+
+### User Scope (No Group)
+```
+location: "user"
+skillName: "global-status"
+-> ~/.claude/commands/global-status.md
+```
+
+### User Scope (With Group)
+```
+location: "user"
+skillName: "sync"
+group: "session"
+-> ~/.claude/commands/session/sync.md
+```
+
+## Next Phase
+
+Proceed to [Phase 3: Template Loading](03-template-loading.md) with `targetPath` and `params`.
--- a/.claude/skills/command-generator/phases/03-template-loading.md
+++ b/.claude/skills/command-generator/phases/03-template-loading.md
@@ -0,0 +1,123 @@
+# Phase 3: Template Loading
+
+Load the command template file for content generation.
+
+## Objective
+
+Load the command template from the skill's templates directory. The template provides:
+- YAML frontmatter structure
+- Placeholder variables for substitution
+- Standard command file sections
+
+## Input
+
+From Phase 2:
+```javascript
+{
+  targetPath: string,
+  targetDir: string,
+  fileName: string,
+  fileExists: boolean,
+  params: {
+    skillName: string,
+    description: string,
+    location: string,
+    group: string | null,
+    argumentHint: string
+  }
+}
+```
+
+## Template Location
+
+```
+.claude/skills/command-generator/templates/command-md.md
+```
+
+## Execution Steps
+
+### Step 1: Locate Template File
+
+```javascript
+// Template is located in the skill's templates directory
+const skillDir = '.claude/skills/command-generator';
+const templatePath = `${skillDir}/templates/command-md.md`;
+```
+
+### Step 2: Read Template Content
+
+```javascript
+const templateContent = Read(templatePath);
+
+if (!templateContent) {
+  throw new Error(`Command template not found at ${templatePath}`);
+}
+```
+
+### Step 3: Validate Template Structure
+
+```javascript
+// Verify template contains expected placeholders
+const requiredPlaceholders = ['{{name}}', '{{description}}'];
+const optionalPlaceholders = ['{{group}}', '{{argumentHint}}'];
+
+for (const placeholder of requiredPlaceholders) {
+  if (!templateContent.includes(placeholder)) {
+    throw new Error(`Template missing required placeholder: ${placeholder}`);
+  }
+}
+```
+
+### Step 4: Store Template for Next Phase
+
+```javascript
+const template = {
+  content: templateContent,
+  requiredPlaceholders: requiredPlaceholders,
+  optionalPlaceholders: optionalPlaceholders
+};
+```
+
+## Template Format Reference
+
+The template should follow this structure:
+
+```markdown
+---
+name: {{name}}
+description: {{description}}
+{{#if group}}group: {{group}}{{/if}}
+{{#if argumentHint}}argument-hint: {{argumentHint}}{{/if}}
+---
+
+# {{name}} Command
+
+[Template content with placeholders]
+```
+
+## Output
+
+```javascript
+{
+  status: 'loaded',
+  template: {
+    content: templateContent,
+    requiredPlaceholders: requiredPlaceholders,
+    optionalPlaceholders: optionalPlaceholders
+  },
+  targetPath: targetPath,
+  params: params
+}
+```
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Template file not found | Throw error with path |
+| Missing required placeholder | Throw error with missing placeholder name |
+| Empty template | Throw error |
+
+## Next Phase
+
+Proceed to [Phase 4: Content Formatting](04-content-formatting.md) with `template`, `targetPath`, and `params`.
--- a/.claude/skills/command-generator/phases/04-content-formatting.md
+++ b/.claude/skills/command-generator/phases/04-content-formatting.md
@@ -0,0 +1,184 @@
+# Phase 4: Content Formatting
+
+Format template content by substituting placeholders with parameter values.
+
+## Objective
+
+Replace all placeholder variables in the template with validated parameter values:
+- `{{name}}` -> skillName
+- `{{description}}` -> description
+- `{{group}}` -> group (if provided)
+- `{{argumentHint}}` -> argumentHint (if provided)
+
+## Input
+
+From Phase 3:
+```javascript
+{
+  template: {
+    content: string,
+    requiredPlaceholders: string[],
+    optionalPlaceholders: string[]
+  },
+  targetPath: string,
+  params: {
+    skillName: string,
+    description: string,
+    location: string,
+    group: string | null,
+    argumentHint: string
+  }
+}
+```
+
+## Placeholder Mapping
+
+```javascript
+const placeholderMap = {
+  '{{name}}': params.skillName,
+  '{{description}}': params.description,
+  '{{group}}': params.group || '',
+  '{{argumentHint}}': params.argumentHint || ''
+};
+```
+
+## Execution Steps
+
+### Step 1: Initialize Content
+
+```javascript
+let formattedContent = template.content;
+```
+
+### Step 2: Substitute Required Placeholders
+
+```javascript
+// These must always be replaced
+formattedContent = formattedContent.replace(/\{\{name\}\}/g, params.skillName);
+formattedContent = formattedContent.replace(/\{\{description\}\}/g, params.description);
+```
+
+### Step 3: Handle Optional Placeholders
+
+```javascript
+// Group placeholder
+if (params.group) {
+  formattedContent = formattedContent.replace(/\{\{group\}\}/g, params.group);
+} else {
+  // Remove group line if not provided
+  formattedContent = formattedContent.replace(/^group: \{\{group\}\}\n?/gm, '');
+  formattedContent = formattedContent.replace(/\{\{group\}\}/g, '');
+}
+
+// Argument hint placeholder
+if (params.argumentHint) {
+  formattedContent = formattedContent.replace(/\{\{argumentHint\}\}/g, params.argumentHint);
+} else {
+  // Remove argument-hint line if not provided
+  formattedContent = formattedContent.replace(/^argument-hint: \{\{argumentHint\}\}\n?/gm, '');
+  formattedContent = formattedContent.replace(/\{\{argumentHint\}\}/g, '');
+}
+```
+
+### Step 4: Handle Conditional Sections
+
+```javascript
+// Remove empty frontmatter lines (caused by missing optional fields)
+formattedContent = formattedContent.replace(/\n{3,}/g, '\n\n');
+
+// Handle {{#if group}} style conditionals
+if (formattedContent.includes('{{#if')) {
+  // Process group conditional
+  if (params.group) {
+    formattedContent = formattedContent.replace(/\{\{#if group\}\}([\s\S]*?)\{\{\/if\}\}/g, '$1');
+  } else {
+    formattedContent = formattedContent.replace(/\{\{#if group\}\}[\s\S]*?\{\{\/if\}\}/g, '');
+  }
+  
+  // Process argumentHint conditional
+  if (params.argumentHint) {
+    formattedContent = formattedContent.replace(/\{\{#if argumentHint\}\}([\s\S]*?)\{\{\/if\}\}/g, '$1');
+  } else {
+    formattedContent = formattedContent.replace(/\{\{#if argumentHint\}\}[\s\S]*?\{\{\/if\}\}/g, '');
+  }
+}
+```
+
+### Step 5: Validate Final Content
+
+```javascript
+// Ensure no unresolved placeholders remain
+const unresolvedPlaceholders = formattedContent.match(/\{\{[^}]+\}\}/g);
+if (unresolvedPlaceholders) {
+  console.warn(`Warning: Unresolved placeholders found: ${unresolvedPlaceholders.join(', ')}`);
+}
+
+// Ensure frontmatter is valid
+const frontmatterMatch = formattedContent.match(/^---\n([\s\S]*?)\n---/);
+if (!frontmatterMatch) {
+  throw new Error('Generated content has invalid frontmatter structure');
+}
+```
+
+### Step 6: Generate Summary
+
+```javascript
+const summary = {
+  name: params.skillName,
+  description: params.description.substring(0, 50) + (params.description.length > 50 ? '...' : ''),
+  location: params.location,
+  group: params.group,
+  hasArgumentHint: !!params.argumentHint
+};
+```
+
+## Output
+
+```javascript
+{
+  status: 'formatted',
+  content: formattedContent,
+  targetPath: targetPath,
+  summary: summary
+}
+```
+
+## Content Example
+
+### Input Template
+```markdown
+---
+name: {{name}}
+description: {{description}}
+{{#if group}}group: {{group}}{{/if}}
+{{#if argumentHint}}argument-hint: {{argumentHint}}{{/if}}
+---
+
+# {{name}} Command
+```
+
+### Output (with all fields)
+```markdown
+---
+name: create
+description: Create structured issue from GitHub URL or text description
+group: issue
+argument-hint: [-y|--yes] <github-url | text-description> [--priority 1-5]
+---
+
+# create Command
+```
+
+### Output (minimal fields)
+```markdown
+---
+name: deploy
+description: Deploy application to production environment
+---
+
+# deploy Command
+```
+
+## Next Phase
+
+Proceed to [Phase 5: File Generation](05-file-generation.md) with `content` and `targetPath`.
--- a/.claude/skills/command-generator/phases/05-file-generation.md
+++ b/.claude/skills/command-generator/phases/05-file-generation.md
@@ -0,0 +1,185 @@
+# Phase 5: File Generation
+
+Write the formatted content to the target command file.
+
+## Objective
+
+Generate the final command file by:
+1. Checking for existing file (warn if present)
+2. Writing formatted content to target path
+3. Confirming successful generation
+
+## Input
+
+From Phase 4:
+```javascript
+{
+  status: 'formatted',
+  content: string,
+  targetPath: string,
+  summary: {
+    name: string,
+    description: string,
+    location: string,
+    group: string | null,
+    hasArgumentHint: boolean
+  }
+}
+```
+
+## Execution Steps
+
+### Step 1: Pre-Write Check
+
+```javascript
+// Check if file already exists
+const fileExists = Bash(`test -f "${targetPath}" && echo "EXISTS" || echo "NOT_FOUND"`);
+
+if (fileExists.includes('EXISTS')) {
+  console.warn(`
+WARNING: Command file already exists at: ${targetPath}
+The file will be overwritten with new content.
+  `);
+}
+```
+
+### Step 2: Ensure Directory Exists
+
+```javascript
+// Get directory from target path
+const targetDir = path.dirname(targetPath);
+
+// Create directory if it doesn't exist
+Bash(`mkdir -p "${targetDir}"`);
+```
+
+### Step 3: Write File
+
+```javascript
+// Write the formatted content
+Write(targetPath, content);
+```
+
+### Step 4: Verify Write
+
+```javascript
+// Confirm file was created
+const verifyExists = Bash(`test -f "${targetPath}" && echo "SUCCESS" || echo "FAILED"`);
+
+if (!verifyExists.includes('SUCCESS')) {
+  throw new Error(`Failed to create command file at ${targetPath}`);
+}
+
+// Verify content was written
+const writtenContent = Read(targetPath);
+if (!writtenContent || writtenContent.length === 0) {
+  throw new Error(`Command file created but appears to be empty`);
+}
+```
+
+### Step 5: Generate Success Report
+
+```javascript
+const report = {
+  status: 'completed',
+  file: {
+    path: targetPath,
+    name: summary.name,
+    location: summary.location,
+    group: summary.group,
+    size: writtenContent.length,
+    created: new Date().toISOString()
+  },
+  command: {
+    name: summary.name,
+    description: summary.description,
+    hasArgumentHint: summary.hasArgumentHint
+  },
+  nextSteps: [
+    `Edit ${targetPath} to add implementation details`,
+    'Add usage examples and execution flow',
+    'Test the command with Claude Code'
+  ]
+};
+```
+
+## Output
+
+### Success Output
+
+```javascript
+{
+  status: 'completed',
+  file: {
+    path: '.claude/commands/issue/create.md',
+    name: 'create',
+    location: 'project',
+    group: 'issue',
+    size: 1234,
+    created: '2026-02-27T12:00:00.000Z'
+  },
+  command: {
+    name: 'create',
+    description: 'Create structured issue from GitHub URL...',
+    hasArgumentHint: true
+  },
+  nextSteps: [
+    'Edit .claude/commands/issue/create.md to add implementation details',
+    'Add usage examples and execution flow',
+    'Test the command with Claude Code'
+  ]
+}
+```
+
+### Console Output
+
+```
+Command generated successfully!
+
+File: .claude/commands/issue/create.md
+Name: create
+Description: Create structured issue from GitHub URL...
+Location: project
+Group: issue
+
+Next Steps:
+1. Edit .claude/commands/issue/create.md to add implementation details
+2. Add usage examples and execution flow
+3. Test the command with Claude Code
+```
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Directory creation failed | Throw error with directory path |
+| File write failed | Throw error with target path |
+| Empty file detected | Throw error and attempt cleanup |
+| Permission denied | Throw error with permission hint |
+
+## Cleanup on Failure
+
+```javascript
+// If any step fails, attempt to clean up partial artifacts
+function cleanup(targetPath) {
+  try {
+    Bash(`rm -f "${targetPath}"`);
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+}
+```
+
+## Completion
+
+The command file has been successfully generated. The skill execution is complete.
+
+### Usage Example
+
+```bash
+# Use the generated command
+/issue:create https://github.com/owner/repo/issues/123
+
+# Or with the group prefix
+/issue:create "Login fails with special chars"
+```
--- a/.claude/skills/command-generator/specs/command-design-spec.md
+++ b/.claude/skills/command-generator/specs/command-design-spec.md
@@ -0,0 +1,160 @@
+# Command Design Specification
+
+Guidelines and best practices for designing Claude Code command files.
+
+## Command File Structure
+
+### YAML Frontmatter
+
+Every command file must start with YAML frontmatter containing:
+
+```yaml
+---
+name: command-name           # Required: Command identifier (lowercase, hyphens)
+description: Description     # Required: Brief description of command purpose
+argument-hint: "[args]"      # Optional: Argument format hint
+allowed-tools: Tool1, Tool2  # Optional: Restricted tool set
+examples:                    # Optional: Usage examples
+  - /command:example1
+  - /command:example2 --flag
+---
+```
+
+### Frontmatter Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | Yes | Command identifier, lowercase with hyphens |
+| `description` | Yes | Brief description, appears in command listings |
+| `argument-hint` | No | Usage hint for arguments (shown in help) |
+| `allowed-tools` | No | Restrict available tools for this command |
+| `examples` | No | Array of usage examples |
+
+## Naming Conventions
+
+### Command Names
+
+- Use lowercase letters only
+- Separate words with hyphens (`create-issue`, not `createIssue`)
+- Keep names short but descriptive (2-3 words max)
+- Use verbs for actions (`deploy`, `create`, `analyze`)
+
+### Group Names
+
+- Groups organize related commands
+- Use singular nouns (`issue`, `session`, `workflow`)
+- Common groups: `issue`, `workflow`, `session`, `memory`, `cli`
+
+### Path Examples
+
+```
+.claude/commands/deploy.md           # Top-level command
+.claude/commands/issue/create.md     # Grouped command
+.claude/commands/workflow/init.md    # Grouped command
+```
+
+## Content Sections
+
+### Required Sections
+
+1. **Overview**: Brief description of command purpose
+2. **Usage**: Command syntax and examples
+3. **Execution Flow**: High-level process diagram
+
+### Recommended Sections
+
+4. **Implementation**: Code examples for each phase
+5. **Error Handling**: Error cases and recovery
+6. **Related Commands**: Links to related functionality
+
+## Best Practices
+
+### 1. Clear Purpose
+
+Each command should do one thing well:
+
+```
+Good: /issue:create - Create a new issue
+Bad:  /issue:manage - Create, update, delete issues (too broad)
+```
+
+### 2. Consistent Structure
+
+Follow the same pattern across all commands in a group:
+
+```markdown
+# All issue commands should have:
+- Overview
+- Usage with examples
+- Phase-based implementation
+- Error handling table
+```
+
+### 3. Progressive Detail
+
+Start simple, add detail in phases:
+
+```
+Phase 1: Quick overview
+Phase 2: Implementation details
+Phase 3: Edge cases and errors
+```
+
+### 4. Reusable Patterns
+
+Use consistent patterns for common operations:
+
+```javascript
+// Input parsing pattern
+const args = parseArguments($ARGUMENTS);
+const flags = parseFlags($ARGUMENTS);
+
+// Validation pattern
+if (!args.required) {
+  throw new Error('Required argument missing');
+}
+```
+
+## Scope Guidelines
+
+### Project Commands (`.claude/commands/`)
+
+- Project-specific workflows
+- Team conventions
+- Integration with project tools
+
+### User Commands (`~/.claude/commands/`)
+
+- Personal productivity tools
+- Cross-project utilities
+- Global configuration
+
+## Error Messages
+
+### Good Error Messages
+
+```
+Error: GitHub issue URL required
+Usage: /issue:create <github-url>
+Example: /issue:create https://github.com/owner/repo/issues/123
+```
+
+### Bad Error Messages
+
+```
+Error: Invalid input
+```
+
+## Testing Commands
+
+After creating a command, test:
+
+1. **Basic invocation**: Does it run without arguments?
+2. **Argument parsing**: Does it handle valid arguments?
+3. **Error cases**: Does it show helpful errors for invalid input?
+4. **Help text**: Is the usage clear?
+
+## Related Documentation
+
+- [SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) - Full skill design specification
+- [../skill-generator/SKILL.md](../skill-generator/SKILL.md) - Meta-skill for creating skills
--- a/.claude/skills/command-generator/templates/command-md.md
+++ b/.claude/skills/command-generator/templates/command-md.md
@@ -0,0 +1,75 @@
+---
+name: {{name}}
+description: {{description}}
+{{#if argumentHint}}argument-hint: {{argumentHint}}
+{{/if}}---
+
+# {{name}} Command
+
+## Overview
+
+[Describe the command purpose and what it does]
+
+## Usage
+
+```bash
+/{{#if group}}{{group}}:{{/if}}{{name}} [arguments]
+```
+
+**Examples**:
+```bash
+# Example 1: Basic usage
+/{{#if group}}{{group}}:{{/if}}{{name}}
+
+# Example 2: With arguments
+/{{#if group}}{{group}}:{{/if}}{{name}} --option value
+```
+
+## Execution Flow
+
+```
+Phase 1: Input Parsing
+   - Parse arguments and flags
+   - Validate input parameters
+
+Phase 2: Core Processing
+   - Execute main logic
+   - Handle edge cases
+
+Phase 3: Output Generation
+   - Format results
+   - Display to user
+```
+
+## Implementation
+
+### Phase 1: Input Parsing
+
+```javascript
+// Parse command arguments
+const args = parseArguments($ARGUMENTS);
+```
+
+### Phase 2: Core Processing
+
+```javascript
+// TODO: Implement core logic
+```
+
+### Phase 3: Output Generation
+
+```javascript
+// TODO: Format and display output
+```
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Invalid input | Show usage and error message |
+| Processing failure | Log error and suggest recovery |
+
+## Related Commands
+
+- [Related command 1]
+- [Related command 2]