superclaude-kiro 1.0.0

package/dist/steering/superclaude/sc-reflect.md

@@ -0,0 +1,87 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: reflect
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/reflect.md
+
+# /sc:reflect - Task Reflection and Validation
+
+## Triggers
+- Task completion requiring validation and quality assessment
+- Session progress analysis and reflection on work accomplished
+- Cross-session learning and insight capture for project improvement
+- Quality gates requiring comprehensive task adherence verification
+
+## Usage
+```
+/sc:reflect [--type task|session|completion] [--analyze] [--validate]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine current task state and session progress using Serena reflection tools
+2. **Validate**: Assess task adherence, completion quality, and requirement fulfillment
+3. **Reflect**: Apply deep analysis of collected information and session insights
+4. **Document**: Update session metadata and capture learning insights
+5. **Optimize**: Provide recommendations for process improvement and quality enhancement
+
+Key behaviors:
+- Serena MCP integration for comprehensive reflection analysis and task validation
+- Bridge between TodoWrite patterns and advanced Serena analysis capabilities
+- Session lifecycle integration with cross-session persistence and learning capture
+- Performance-critical operations with <200ms core reflection and validation
+## MCP Integration
+- **Serena MCP**: Mandatory integration for reflection analysis, task validation, and session metadata
+- **Reflection Tools**: think_about_task_adherence, think_about_collected_information, think_about_whether_you_are_done
+- **Memory Operations**: Cross-session persistence with read_memory, write_memory, list_memories
+- **Performance Critical**: <200ms for core reflection operations, <1s for checkpoint creation
+
+## Tool Coordination
+- **TodoRead/TodoWrite**: Bridge between traditional task management and advanced reflection analysis
+- **think_about_task_adherence**: Validates current approach against project goals and session objectives
+- **think_about_collected_information**: Analyzes session work and information gathering completeness
+- **think_about_whether_you_are_done**: Evaluates task completion criteria and remaining work identification
+- **Memory Tools**: Session metadata updates and cross-session learning capture
+
+## Key Patterns
+- **Task Validation**: Current approach → goal alignment → deviation identification → course correction
+- **Session Analysis**: Information gathering → completeness assessment → quality evaluation → insight capture
+- **Completion Assessment**: Progress evaluation → completion criteria → remaining work → decision validation
+- **Cross-Session Learning**: Reflection insights → memory persistence → enhanced project understanding
+
+## Examples
+
+### Task Adherence Reflection
+```
+/sc:reflect --type task --analyze
+# Validates current approach against project goals
+# Identifies deviations and provides course correction recommendations
+```
+
+### Session Progress Analysis
+```
+/sc:reflect --type session --validate
+# Comprehensive analysis of session work and information gathering
+# Quality assessment and gap identification for project improvement
+```
+
+### Completion Validation
+```
+/sc:reflect --type completion
+# Evaluates task completion criteria against actual progress
+# Determines readiness for task completion and identifies remaining blockers
+```
+
+## Boundaries
+
+**Will:**
+- Perform comprehensive task reflection and validation using Serena MCP analysis tools
+- Bridge TodoWrite patterns with advanced reflection capabilities for enhanced task management
+- Provide cross-session learning capture and session lifecycle integration
+
+**Will Not:**
+- Operate without proper Serena MCP integration and reflection tool access
+- Override task completion decisions without proper adherence and quality validation
+- Bypass session integrity checks and cross-session persistence requirements

package/dist/steering/superclaude/sc-research.md

@@ -0,0 +1,103 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: research
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/research.md
+
+# /sc:research - Deep Research Command
+
+> **Context Framework Note**: This command activates comprehensive research capabilities with adaptive planning, multi-hop reasoning, and evidence-based synthesis.
+
+## Triggers
+- Research questions beyond knowledge cutoff
+- Complex research questions
+- Current events and real-time information
+- Academic or technical research requirements
+- Market analysis and competitive intelligence
+
+## Context Trigger Pattern
+```
+/sc:research "[query]" [--depth quick|standard|deep|exhaustive] [--strategy planning|intent|unified]
+```
+
+## Behavioral Flow
+
+### 1. Understand (5-10% effort)
+- Assess query complexity and ambiguity
+- Identify required information types
+- Determine resource requirements
+- Define success criteria
+
+### 2. Plan (10-15% effort)
+- Select planning strategy based on complexity
+- Identify parallelization opportunities
+- Generate research question decomposition
+- Create investigation milestones
+
+### 3. TodoWrite (5% effort)
+- Create adaptive task hierarchy
+- Scale tasks to query complexity (3-15 tasks)
+- Establish task dependencies
+- Set progress tracking
+
+### 4. Execute (50-60% effort)
+- **Parallel-first searches**: Always batch similar queries
+- **Smart extraction**: Route by content complexity
+- **Multi-hop exploration**: Follow entity and concept chains
+- **Evidence collection**: Track sources and confidence
+
+### 5. Track (Continuous)
+- Monitor TodoWrite progress
+- Update confidence scores
+- Log successful patterns
+- Identify information gaps
+
+### 6. Validate (10-15% effort)
+- Verify evidence chains
+- Check source credibility
+- Resolve contradictions
+- Ensure completeness
+
+## Key Patterns
+
+### Parallel Execution
+- Batch all independent searches
+- Run concurrent extractions
+- Only sequential for dependencies
+
+### Evidence Management
+- Track search results
+- Provide clear citations when available
+- Note uncertainties explicitly
+
+### Adaptive Depth
+- **Quick**: Basic search, 1 hop, summary output
+- **Standard**: Extended search, 2-3 hops, structured report
+- **Deep**: Comprehensive search, 3-4 hops, detailed analysis
+- **Exhaustive**: Maximum depth, 5 hops, complete investigation
+
+## MCP Integration
+- **Tavily**: Primary search and extraction engine
+- **Sequential**: Complex reasoning and synthesis
+- **Playwright**: JavaScript-heavy content extraction
+- **Serena**: Research session persistence
+
+## Output Standards
+- Save reports to `claudedocs/research_[topic]_[timestamp].md`
+- Include executive summary
+- Provide confidence levels
+- List all sources with citations
+
+## Examples
+```
+/sc:research "latest developments in quantum computing 2024"
+/sc:research "competitive analysis of AI coding assistants" --depth deep
+/sc:research "best practices for distributed systems" --strategy unified
+```
+
+## Boundaries
+**Will**: Current information, intelligent search, evidence-based analysis
+**Won't**: Make claims without sources, skip validation, access restricted content

package/dist/steering/superclaude/sc-save.md

@@ -0,0 +1,93 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: save
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/save.md
+
+# /sc:save - Session Context Persistence
+
+## Triggers
+- Session completion and project context persistence needs
+- Cross-session memory management and checkpoint creation requests
+- Project understanding preservation and discovery archival scenarios
+- Session lifecycle management and progress tracking requirements
+
+## Usage
+```
+/sc:save [--type session|learnings|context|all] [--summarize] [--checkpoint]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine session progress and identify discoveries worth preserving
+2. **Persist**: Save session context and learnings using Serena MCP memory management
+3. **Checkpoint**: Create recovery points for complex sessions and progress tracking
+4. **Validate**: Ensure session data integrity and cross-session compatibility
+5. **Prepare**: Ready session context for seamless continuation in future sessions
+
+Key behaviors:
+- Serena MCP integration for memory management and cross-session persistence
+- Automatic checkpoint creation based on session progress and critical tasks
+- Session context preservation with comprehensive discovery and pattern archival
+- Cross-session learning with accumulated project insights and technical decisions
+
+## MCP Integration
+- **Serena MCP**: Mandatory integration for session management, memory operations, and cross-session persistence
+- **Memory Operations**: Session context storage, checkpoint creation, and discovery archival
+- **Performance Critical**: <200ms for memory operations, <1s for checkpoint creation
+
+## Tool Coordination
+- **write_memory/read_memory**: Core session context persistence and retrieval
+- **think_about_collected_information**: Session analysis and discovery identification
+- **summarize_changes**: Session summary generation and progress documentation
+- **TodoRead**: Task completion tracking for automatic checkpoint triggers
+
+## Key Patterns
+- **Session Preservation**: Discovery analysis → memory persistence → checkpoint creation
+- **Cross-Session Learning**: Context accumulation → pattern archival → enhanced project understanding
+- **Progress Tracking**: Task completion → automatic checkpoints → session continuity
+- **Recovery Planning**: State preservation → checkpoint validation → restoration readiness
+
+## Examples
+
+### Basic Session Save
+```
+/sc:save
+# Saves current session discoveries and context to Serena MCP
+# Automatically creates checkpoint if session exceeds 30 minutes
+```
+
+### Comprehensive Session Checkpoint
+```
+/sc:save --type all --checkpoint
+# Complete session preservation with recovery checkpoint
+# Includes all learnings, context, and progress for session restoration
+```
+
+### Session Summary Generation
+```
+/sc:save --summarize
+# Creates session summary with discovery documentation
+# Updates cross-session learning patterns and project insights
+```
+
+### Discovery-Only Persistence
+```
+/sc:save --type learnings
+# Saves only new patterns and insights discovered during session
+# Updates project understanding without full session preservation
+```
+
+## Boundaries
+
+**Will:**
+- Save session context using Serena MCP integration for cross-session persistence
+- Create automatic checkpoints based on session progress and task completion
+- Preserve discoveries and patterns for enhanced project understanding
+
+**Will Not:**
+- Operate without proper Serena MCP integration and memory access
+- Save session data without validation and integrity verification
+- Override existing session context without proper checkpoint preservation

package/dist/steering/superclaude/sc-sc.md

@@ -0,0 +1,134 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: sc
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/sc.md
+
+# SuperClaude Command Dispatcher
+
+🚀 **SuperClaude Framework** - Main command dispatcher
+
+## Usage
+
+All SuperClaude commands use the `/sc:` prefix:
+
+```
+/sc:command [args...]
+```
+
+## Available Commands
+
+### Research & Analysis
+```
+/sc:research [query]         - Deep web research with parallel search
+```
+
+### Repository Management
+```
+/sc:index-repo              - Index repository for context optimization
+```
+
+### AI Agents
+```
+/sc:agent [type]            - Launch specialized AI agents
+```
+
+### Recommendations
+```
+/sc:recommend [context]     - Get command recommendations
+```
+
+### Help
+```
+/sc                         - Show this help (all available commands)
+```
+
+## Command Namespace
+
+All commands are namespaced under `sc:` to keep them organized:
+- ✅ `/sc:research query`
+- ✅ `/sc:index-repo`
+- ✅ `/sc:agent type`
+- ✅ `/sc:recommend`
+- ✅ `/sc` (help)
+
+## Examples
+
+### Research
+```
+/sc:research React 18 new features
+/sc:research LLM agent architectures 2024
+/sc:research Python async best practices
+```
+
+### Index Repository
+```
+/sc:index-repo
+```
+
+### Agent
+```
+/sc:agent deep-research
+/sc:agent self-review
+/sc:agent repo-index
+```
+
+### Recommendations
+```
+/sc:recommend
+```
+
+## Quick Reference
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `/sc:research` | Deep web research | `/sc:research topic` |
+| `/sc:index-repo` | Repository indexing | `/sc:index-repo` |
+| `/sc:agent` | Specialized AI agents | `/sc:agent type` |
+| `/sc:recommend` | Command suggestions | `/sc:recommend` |
+| `/sc` | Show help | `/sc` |
+
+## Features
+
+- **Parallel Execution**: Research runs multiple searches in parallel
+- **Evidence-Based**: All findings backed by sources
+- **Context-Aware**: Uses repository context when available
+- **Token Efficient**: Optimized for minimal token usage
+
+## Help
+
+For help on specific commands:
+```
+/sc:research --help
+/sc:agent --help
+```
+
+Or use the main help command:
+```
+/sc
+```
+
+Check the documentation:
+- PLANNING.md - Architecture and design
+- TASK.md - Current tasks and priorities
+- KNOWLEDGE.md - Tips and best practices
+
+## Version
+
+SuperClaude v4.1.7
+- Python package: 0.4.0
+- Pytest plugin included
+- PM Agent patterns enabled
+
+---
+
+💡 **Tip**: All commands use the `/sc:` prefix - e.g., `/sc:research`, `/sc:agent`
+
+🔧 **Installation**: Run `superclaude install` to install/update commands
+
+📚 **Documentation**: https://github.com/SuperClaude-Org/SuperClaude_Framework
+
+⚠️ **Important**: Restart Claude Code after installing commands to use them!

package/dist/steering/superclaude/sc-select-tool.md

@@ -0,0 +1,86 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: select-tool
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/select-tool.md
+
+# /sc:select-tool - Intelligent MCP Tool Selection
+
+## Triggers
+- Operations requiring optimal MCP tool selection between Serena and Morphllm
+- Meta-system decisions needing complexity analysis and capability matching
+- Tool routing decisions requiring performance vs accuracy trade-offs
+- Operations benefiting from intelligent tool capability assessment
+
+## Usage
+```
+/sc:select-tool [operation] [--analyze] [--explain]
+```
+
+## Behavioral Flow
+1. **Parse**: Analyze operation type, scope, file count, and complexity indicators
+2. **Score**: Apply multi-dimensional complexity scoring across various operation factors
+3. **Match**: Compare operation requirements against Serena and Morphllm capabilities
+4. **Select**: Choose optimal tool based on scoring matrix and performance requirements
+5. **Validate**: Verify selection accuracy and provide confidence metrics
+
+Key behaviors:
+- Complexity scoring based on file count, operation type, language, and framework requirements
+- Performance assessment evaluating speed vs accuracy trade-offs for optimal selection
+- Decision logic matrix with direct mappings and threshold-based routing rules
+- Tool capability matching for Serena (semantic operations) vs Morphllm (pattern operations)
+
+## MCP Integration
+- **Serena MCP**: Optimal for semantic operations, LSP functionality, symbol navigation, and project context
+- **Morphllm MCP**: Optimal for pattern-based edits, bulk transformations, and speed-critical operations
+- **Decision Matrix**: Intelligent routing based on complexity scoring and operation characteristics
+
+## Tool Coordination
+- **get_current_config**: System configuration analysis for tool capability assessment
+- **execute_sketched_edit**: Operation testing and validation for selection accuracy
+- **Read/Grep**: Operation context analysis and complexity factor identification
+- **Integration**: Automatic selection logic used by refactor, edit, implement, and improve commands
+
+## Key Patterns
+- **Direct Mapping**: Symbol operations → Serena, Pattern edits → Morphllm, Memory operations → Serena
+- **Complexity Thresholds**: Score >0.6 → Serena, Score <0.4 → Morphllm, 0.4-0.6 → Feature-based
+- **Performance Trade-offs**: Speed requirements → Morphllm, Accuracy requirements → Serena
+- **Fallback Strategy**: Serena → Morphllm → Native tools degradation chain
+
+## Examples
+
+### Complex Refactoring Operation
+```
+/sc:select-tool "rename function across 10 files" --analyze
+# Analysis: High complexity (multi-file, symbol operations)
+# Selection: Serena MCP (LSP capabilities, semantic understanding)
+```
+
+### Pattern-Based Bulk Edit
+```
+/sc:select-tool "update console.log to logger.info across project" --explain
+# Analysis: Pattern-based transformation, speed priority
+# Selection: Morphllm MCP (pattern matching, bulk operations)
+```
+
+### Memory Management Operation
+```
+/sc:select-tool "save project context and discoveries"
+# Direct mapping: Memory operations → Serena MCP
+# Rationale: Project context and cross-session persistence
+```
+
+## Boundaries
+
+**Will:**
+- Analyze operations and provide optimal tool selection between Serena and Morphllm
+- Apply complexity scoring based on file count, operation type, and requirements
+- Provide sub-100ms decision time with >95% selection accuracy
+
+**Will Not:**
+- Override explicit tool specifications when user has clear preference
+- Select tools without proper complexity analysis and capability matching
+- Compromise performance requirements for convenience or speed

package/dist/steering/superclaude/sc-spawn.md

@@ -0,0 +1,85 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: spawn
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/spawn.md
+
+# /sc:spawn - Meta-System Task Orchestration
+
+## Triggers
+- Complex multi-domain operations requiring intelligent task breakdown
+- Large-scale system operations spanning multiple technical areas
+- Operations requiring parallel coordination and dependency management
+- Meta-level orchestration beyond standard command capabilities
+
+## Usage
+```
+/sc:spawn [complex-task] [--strategy sequential|parallel|adaptive] [--depth normal|deep]
+```
+
+## Behavioral Flow
+1. **Analyze**: Parse complex operation requirements and assess scope across domains
+2. **Decompose**: Break down operation into coordinated subtask hierarchies
+3. **Orchestrate**: Execute tasks using optimal coordination strategy (parallel/sequential)
+4. **Monitor**: Track progress across task hierarchies with dependency management
+5. **Integrate**: Aggregate results and provide comprehensive orchestration summary
+
+Key behaviors:
+- Meta-system task decomposition with Epic → Story → Task → Subtask breakdown
+- Intelligent coordination strategy selection based on operation characteristics
+- Cross-domain operation management with parallel and sequential execution patterns
+- Advanced dependency analysis and resource optimization across task hierarchies
+## MCP Integration
+- **Native Orchestration**: Meta-system command uses native coordination without MCP dependencies
+- **Progressive Integration**: Coordination with systematic execution for progressive enhancement
+- **Framework Integration**: Advanced integration with SuperClaude orchestration layers
+
+## Tool Coordination
+- **TodoWrite**: Hierarchical task breakdown and progress tracking across Epic → Story → Task levels
+- **Read/Grep/Glob**: System analysis and dependency mapping for complex operations
+- **Edit/MultiEdit/Write**: Coordinated file operations with parallel and sequential execution
+- **Bash**: System-level operations coordination with intelligent resource management
+
+## Key Patterns
+- **Hierarchical Breakdown**: Epic-level operations → Story coordination → Task execution → Subtask granularity
+- **Strategy Selection**: Sequential (dependency-ordered) → Parallel (independent) → Adaptive (dynamic)
+- **Meta-System Coordination**: Cross-domain operations → resource optimization → result integration
+- **Progressive Enhancement**: Systematic execution → quality gates → comprehensive validation
+
+## Examples
+
+### Complex Feature Implementation
+```
+/sc:spawn "implement user authentication system"
+# Breakdown: Database design → Backend API → Frontend UI → Testing
+# Coordinates across multiple domains with dependency management
+```
+
+### Large-Scale System Operation
+```
+/sc:spawn "migrate legacy monolith to microservices" --strategy adaptive --depth deep
+# Enterprise-scale operation with sophisticated orchestration
+# Adaptive coordination based on operation characteristics
+```
+
+### Cross-Domain Infrastructure
+```
+/sc:spawn "establish CI/CD pipeline with security scanning"
+# System-wide infrastructure operation spanning DevOps, Security, Quality domains
+# Parallel execution of independent components with validation gates
+```
+
+## Boundaries
+
+**Will:**
+- Decompose complex multi-domain operations into coordinated task hierarchies
+- Provide intelligent orchestration with parallel and sequential coordination strategies
+- Execute meta-system operations beyond standard command capabilities
+
+**Will Not:**
+- Replace domain-specific commands for simple operations
+- Override user coordination preferences or execution strategies
+- Execute operations without proper dependency analysis and validation