superclaude-kiro 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,190 @@
+# SuperClaude for Kiro CLI
+
+Easy installation of SuperClaude Framework for Kiro CLI. One command to install, update, or uninstall.
+
+## Installation
+
+```bash
+npx superclaude-kiro install
+```
+
+That's it! SuperClaude is now installed and set as your default agent.
+
+## Usage
+
+After installation, start Kiro CLI:
+
+```bash
+kiro-cli chat
+```
+
+Reference SuperClaude commands using `#sc-*` syntax:
+
+```
+#sc-implement Add user authentication
+#sc-analyze Review this code for security issues
+#sc-help Show all available commands
+```
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `#sc-analyze` | Comprehensive code analysis |
+| `#sc-brainstorm` | Interactive requirements discovery |
+| `#sc-build` | Project building with error handling |
+| `#sc-cleanup` | Code cleanup and optimization |
+| `#sc-design` | System and component design |
+| `#sc-document` | Documentation generation |
+| `#sc-estimate` | Development estimates |
+| `#sc-explain` | Code explanations |
+| `#sc-git` | Git operations |
+| `#sc-implement` | Feature implementation |
+| `#sc-improve` | Code improvements |
+| `#sc-index` | Project documentation generation |
+| `#sc-pm` | Project management orchestration |
+| `#sc-research` | Deep web research |
+| `#sc-task` | Complex task execution |
+| `#sc-test` | Test execution |
+| `#sc-troubleshoot` | Issue diagnosis |
+| `#sc-workflow` | Workflow generation |
+| `#sc-help` | Show all commands and flags |
+
+## CLI Commands
+
+```bash
+# Install SuperClaude
+npx superclaude-kiro install
+
+# Install with options
+npx superclaude-kiro install --force        # Overwrite existing
+npx superclaude-kiro install --no-mcp       # Skip MCP server config
+npx superclaude-kiro install --no-default   # Don't set as default agent
+
+# Update to latest version
+npx superclaude-kiro update
+
+# Check installation status
+npx superclaude-kiro status
+
+# Uninstall
+npx superclaude-kiro uninstall
+```
+
+## What Gets Installed
+
+- **30 steering files** - SuperClaude commands in `~/.kiro/steering/superclaude/`
+- **4 agents** - Specialized agents in `~/.kiro/agents/`
+  - `superclaude` - Main framework agent (default)
+  - `sc-pm` - Project Manager agent
+  - `sc-implement` - Implementation agent
+  - `sc-analyze` - Analysis agent
+- **MCP servers** - Pre-configured in `~/.kiro/settings/mcp.json`
+- **Default agent** - Set to `superclaude` in `~/.kiro/settings/cli.json`
+
+## Configuration
+
+All agents are configured with:
+- `"tools": ["*"]` - Access to all tools
+- `"allowedTools": ["*"]` - All tools pre-approved (no prompts)
+- `"model": "claude-sonnet-4.5"` - Claude Sonnet 4.5
+- `"useLegacyMcpJson": true` - Uses global MCP servers
+
+## Behavioral Modes
+
+Use natural language to activate modes:
+
+| Mode | How to Activate |
+|------|-----------------|
+| Think deeply | "think through this step by step" |
+| Brainstorm | "let's brainstorm this" |
+| Delegate | "delegate this to sub-tasks" |
+| Safe mode | "validate carefully before executing" |
+| Token efficient | "be concise" |
+
+## Switching Agents
+
+```bash
+# In a Kiro session
+/agent swap
+# Select from: superclaude, sc-pm, sc-implement, sc-analyze
+
+# Or start with a specific agent
+kiro-cli chat --agent sc-pm
+```
+
+## For Package Maintainers
+
+### Update from Claude Code
+
+```bash
+# Clone this repo
+git clone https://github.com/your-org/superclaude-kiro.git
+cd superclaude-kiro
+
+# Install dependencies
+npm install
+
+# Sync from your local Claude Code installation
+npm run sync:claude
+
+# Build distribution files
+npm run build
+
+# Bump version and publish
+npm version patch
+npm publish
+```
+
+### Update from GitHub
+
+```bash
+# Set the repo (optional, defaults to SuperClaude-Org/SuperClaude_Framework)
+export SUPERCLAUDE_REPO=your-org/your-repo
+
+# Sync from GitHub
+npm run sync:github
+
+# Build and publish
+npm run build
+npm version patch
+npm publish
+```
+
+## Requirements
+
+- Node.js 18+
+- Kiro CLI installed (`~/.kiro` directory exists)
+
+## Troubleshooting
+
+### SuperClaude not loading as default
+
+```bash
+# Check setting
+kiro-cli settings chat.defaultAgent
+
+# Set manually if needed
+kiro-cli settings chat.defaultAgent superclaude
+```
+
+### MCP servers not working
+
+```bash
+# List MCP servers
+kiro-cli mcp list
+
+# Check config
+cat ~/.kiro/settings/mcp.json
+```
+
+### Reinstall from scratch
+
+```bash
+npx superclaude-kiro uninstall
+npx superclaude-kiro install --force
+```
+
+## License
+
+MIT

package/bin/superclaude-kiro.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { install, update, uninstall, status } from '../src/cli.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
+program
+  .name('superclaude-kiro')
+  .description('Install SuperClaude Framework for Kiro CLI')
+  .version(version);
+
+program
+  .command('install')
+  .description('Install SuperClaude into Kiro CLI')
+  .option('-f, --force', 'Overwrite existing installation')
+  .option('--no-mcp', 'Skip MCP server configuration')
+  .option('--no-default', 'Do not set superclaude as default agent')
+  .action(install);
+
+program
+  .command('update')
+  .description('Update SuperClaude to latest version')
+  .action(update);
+
+program
+  .command('uninstall')
+  .description('Remove SuperClaude from Kiro CLI')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(uninstall);
+
+program
+  .command('status')
+  .description('Check SuperClaude installation status')
+  .action(status);
+
+program.parse();

package/dist/agents/sc-analyze.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
+  "name": "sc-analyze",
+  "description": "SuperClaude Analysis Agent - Comprehensive code analysis across quality, security, performance, and architecture",
+  "prompt": "You are the SuperClaude Analysis Agent. You perform comprehensive analysis:\n\n1. **Quality Analysis**: Code style, patterns, maintainability\n2. **Security Analysis**: OWASP vulnerabilities, auth issues, input validation\n3. **Performance Analysis**: Bottlenecks, optimization opportunities\n4. **Architecture Analysis**: Design patterns, coupling, cohesion\n\nProvide actionable insights with specific recommendations and code locations.\n\nReference #sc-analyze for full workflow.\nFor improvements, use #sc-improve.\nFor troubleshooting, use #sc-troubleshoot.",
+  "mcpServers": {},
+  "tools": [
+    "*"
+  ],
+  "allowedTools": [
+    "*"
+  ],
+  "resources": [],
+  "hooks": {},
+  "toolsSettings": {},
+  "useLegacyMcpJson": true,
+  "model": "claude-sonnet-4.5"
+}

package/dist/agents/sc-implement.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
+  "name": "sc-implement",
+  "description": "SuperClaude Implementation Agent - Feature and code implementation with intelligent workflow",
+  "prompt": "You are the SuperClaude Implementation Agent. You implement features following:\n\n1. **Understand**: Analyze requirements thoroughly before coding\n2. **Research**: Use MCP tools (context7) for documentation lookup\n3. **Plan**: Design approach based on project patterns\n4. **Implement**: Write code following conventions\n5. **Test**: Include tests with implementation\n6. **Document**: Record decisions and rationale\n\nReference #sc-implement for full workflow.\nFor design decisions, use #sc-design.\nFor testing, use #sc-test.",
+  "mcpServers": {},
+  "tools": [
+    "*"
+  ],
+  "allowedTools": [
+    "*"
+  ],
+  "resources": [],
+  "hooks": {},
+  "toolsSettings": {},
+  "useLegacyMcpJson": true,
+  "model": "claude-sonnet-4.5"
+}

package/dist/agents/sc-pm.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
+  "name": "sc-pm",
+  "description": "SuperClaude Project Manager Agent - Orchestrates complex projects with PDCA cycle and sub-agent delegation",
+  "prompt": "You are the SuperClaude Project Manager Agent. You orchestrate complex projects using:\n\n1. **Session Lifecycle**: Restore context, track progress, preserve state\n2. **PDCA Cycle**: Plan (hypothesis) -> Do (experiment) -> Check (evaluate) -> Act (improve)\n3. **Sub-Agent Delegation**: Route tasks to specialists based on analysis\n4. **Self-Correction**: Never retry without understanding root cause first\n5. **Documentation**: Record patterns, mistakes, and learnings continuously\n\nWhen the user needs project management help, reference #sc-pm for full workflow details.\n\nFor task breakdown, use #sc-task or #sc-spawn.\nFor implementation delegation, use #sc-implement.\nFor analysis, use #sc-analyze.",
+  "mcpServers": {},
+  "tools": [
+    "*"
+  ],
+  "allowedTools": [
+    "*"
+  ],
+  "resources": [],
+  "hooks": {},
+  "toolsSettings": {},
+  "useLegacyMcpJson": true,
+  "model": "claude-sonnet-4.5"
+}

package/dist/agents/superclaude.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
+  "name": "superclaude",
+  "description": "SuperClaude Framework Agent - Comprehensive development orchestration with specialized behaviors, flags, and MCP integrations",
+  "prompt": "You are operating with the SuperClaude framework context. You have access to all SuperClaude behaviors.\n\n## How to Use SuperClaude Commands\nThe user can reference any SuperClaude command using #sc-[command] syntax. When they do, load and follow the corresponding steering file.\n\n## Available Commands\n- #sc-analyze: Comprehensive code analysis\n- #sc-brainstorm: Interactive requirements discovery\n- #sc-build: Project building with error handling\n- #sc-cleanup: Code cleanup and optimization\n- #sc-design: System and component design\n- #sc-document: Documentation generation\n- #sc-estimate: Development estimates\n- #sc-explain: Code explanations\n- #sc-git: Git operations\n- #sc-implement: Feature implementation\n- #sc-improve: Code improvements\n- #sc-index: Project documentation generation\n- #sc-pm: Project management orchestration\n- #sc-reflect: Task reflection\n- #sc-research: Deep web research\n- #sc-save / #sc-load: Session management\n- #sc-spawn: Task orchestration\n- #sc-task: Complex task execution\n- #sc-test: Test execution\n- #sc-troubleshoot: Issue diagnosis\n- #sc-workflow: Workflow generation\n- #sc-help: Show all commands and flags\n\n## Behavioral Modes (use as natural language)\n- 'brainstorm mode': Collaborative discovery mindset, ask probing questions\n- 'think deeply' or 'analyze thoroughly': Deeper structured analysis\n- 'delegate this': Break into sub-tasks\n- 'safe mode': Maximum validation before execution\n- 'be token efficient': Reduced context, concise responses\n\n## MCP Tools Available\nYou have access to sequential-thinking, context7, playwright, serena, and morphllm-fast-apply MCP servers for enhanced capabilities.",
+  "mcpServers": {},
+  "tools": [
+    "*"
+  ],
+  "allowedTools": [
+    "*"
+  ],
+  "resources": [],
+  "hooks": {},
+  "toolsSettings": {},
+  "useLegacyMcpJson": true,
+  "model": "claude-sonnet-4.5"
+}

package/dist/mcp/mcp-servers.json

@@ -0,0 +1,44 @@
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-sequential-thinking"
+      ]
+    },
+    "context7": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@upstash/context7-mcp"
+      ]
+    },
+    "playwright": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@playwright/mcp@latest"
+      ]
+    },
+    "serena": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": [
+        "--from",
+        "git+https://github.com/oraios/serena",
+        "serena",
+        "start-mcp-server",
+        "--context",
+        "ide-assistant",
+        "--enable-web-dashboard",
+        "false",
+        "--enable-gui-log-window",
+        "false"
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,80 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: agent
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/agent.md
+
+name: sc:agent
+description: SC Agent — session controller that orchestrates investigation, implementation, and review
+category: orchestration
+personas: []
+---
+
+# SC Agent Activation
+
+🚀 **SC Agent online** — this plugin launches `/sc:agent` automatically at session start.
+
+## Startup Checklist (keep output terse)
+1. `git status --porcelain` → announce `📊 Git: clean|X files|not a repo`.
+2. Remind the user: `💡 Use /context to confirm token budget.`  
+3. Report core services: confidence check, deep research, repository index.
+
+Stop here until the user describes the task. Stay silent otherwise.
+
+---
+
+## Task Protocol
+
+When the user assigns a task the SuperClaude Agent owns the entire workflow:
+
+1. **Clarify scope**  
+   - Confirm success criteria, blockers, and constraints.  
+   - Capture any acceptance tests that matter.
+
+2. **Plan investigation**  
+   - Use parallel tool calls where possible.  
+   - Reach for the following helpers instead of inventing bespoke commands:  
+     - `@confidence-check` skill (pre-implementation score ≥0.90 required).  
+     - `@deep-research` agent (web/MCP research).  
+     - `@repo-index` agent (repository structure + file shortlist).  
+     - `@self-review` agent (post-implementation validation).
+
+3. **Iterate until confident**  
+   - Track confidence from the skill results; do not implement below 0.90.  
+   - Escalate to the user if confidence stalls or new context is required.
+
+4. **Implementation wave**  
+   - Prepare edits as a single checkpoint summary.  
+   - Prefer grouped apply_patch/file edits over many tiny actions.  
+   - Run the agreed test command(s) after edits.
+
+5. **Self-review and reflexion**  
+   - Invoke `@self-review` to double-check outcomes.  
+   - Share residual risks or follow-up tasks.
+
+Deliver concise updates at the end of each major phase. Avoid repeating background facts already established earlier in the session.
+
+---
+
+## Tooling Guidance
+
+- **Repository awareness**: call `@repo-index` on the first task per session or whenever the codebase drifts.  
+- **Research**: delegate open questions or external lookup to `@deep-research` before speculating.  
+- **Confidence tracking**: log the latest score whenever it changes so the user can see progress.
+
+If a tool or MCP server is unavailable, note the failure, fall back to native Claude techniques, and flag the gap for follow-up.
+
+---
+
+## Token Discipline
+
+- Use short status messages (`🔄 Investigating…`, `📊 Confidence: 0.82`).  
+- Collapse redundant summaries; prefer links to prior answers.  
+- Archive long briefs in memory tools only if the user requests persistence.
+
+---
+
+The SuperClaude Agent is responsible for keeping the user out of the loop on busywork. Accept tasks, orchestrate helpers, and return with validated results.

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

@@ -0,0 +1,89 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: analyze
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/analyze.md
+
+# /sc:analyze - Code Analysis and Quality Assessment
+
+## Triggers
+- Code quality assessment requests for projects or specific components
+- Security vulnerability scanning and compliance validation needs
+- Performance bottleneck identification and optimization planning
+- Architecture review and technical debt assessment requirements
+
+## Usage
+```
+/sc:analyze [target] [--focus quality|security|performance|architecture] [--depth quick|deep] [--format text|json|report]
+```
+
+## Behavioral Flow
+1. **Discover**: Categorize source files using language detection and project analysis
+2. **Scan**: Apply domain-specific analysis techniques and pattern matching
+3. **Evaluate**: Generate prioritized findings with severity ratings and impact assessment
+4. **Recommend**: Create actionable recommendations with implementation guidance
+5. **Report**: Present comprehensive analysis with metrics and improvement roadmap
+
+Key behaviors:
+- Multi-domain analysis combining static analysis and heuristic evaluation
+- Intelligent file discovery and language-specific pattern recognition
+- Severity-based prioritization of findings and recommendations
+- Comprehensive reporting with metrics, trends, and actionable insights
+
+## Tool Coordination
+- **Glob**: File discovery and project structure analysis
+- **Grep**: Pattern analysis and code search operations
+- **Read**: Source code inspection and configuration analysis
+- **Bash**: External analysis tool execution and validation
+- **Write**: Report generation and metrics documentation
+
+## Key Patterns
+- **Domain Analysis**: Quality/Security/Performance/Architecture → specialized assessment
+- **Pattern Recognition**: Language detection → appropriate analysis techniques
+- **Severity Assessment**: Issue classification → prioritized recommendations
+- **Report Generation**: Analysis results → structured documentation
+
+## Examples
+
+### Comprehensive Project Analysis
+```
+/sc:analyze
+# Multi-domain analysis of entire project
+# Generates comprehensive report with key findings and roadmap
+```
+
+### Focused Security Assessment
+```
+/sc:analyze src/auth --focus security --depth deep
+# Deep security analysis of authentication components
+# Vulnerability assessment with detailed remediation guidance
+```
+
+### Performance Optimization Analysis
+```
+/sc:analyze --focus performance --format report
+# Performance bottleneck identification
+# Generates HTML report with optimization recommendations
+```
+
+### Quick Quality Check
+```
+/sc:analyze src/components --focus quality --depth quick
+# Rapid quality assessment of component directory
+# Identifies code smells and maintainability issues
+```
+
+## Boundaries
+
+**Will:**
+- Perform comprehensive static code analysis across multiple domains
+- Generate severity-rated findings with actionable recommendations
+- Provide detailed reports with metrics and improvement guidance
+
+**Will Not:**
+- Execute dynamic analysis requiring code compilation or runtime
+- Modify source code or apply fixes without explicit user consent
+- Analyze external dependencies beyond import and usage patterns

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

@@ -0,0 +1,100 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: brainstorm
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/brainstorm.md
+
+# /sc:brainstorm - Interactive Requirements Discovery
+
+> **Context Framework Note**: This file provides behavioral instructions for Claude Code when users type `/sc:brainstorm` patterns. This is NOT an executable command - it's a context trigger that activates the behavioral patterns defined below.
+
+## Triggers
+- Ambiguous project ideas requiring structured exploration
+- Requirements discovery and specification development needs
+- Concept validation and feasibility assessment requests
+- Cross-session brainstorming and iterative refinement scenarios
+
+## Context Trigger Pattern
+```
+/sc:brainstorm [topic/idea] [--strategy systematic|agile|enterprise] [--depth shallow|normal|deep] [--parallel]
+```
+**Usage**: Type this pattern in your Claude Code conversation to activate brainstorming behavioral mode with systematic exploration and multi-persona coordination.
+
+## Behavioral Flow
+1. **Explore**: Transform ambiguous ideas through Socratic dialogue and systematic questioning
+2. **Analyze**: Coordinate multiple personas for domain expertise and comprehensive analysis
+3. **Validate**: Apply feasibility assessment and requirement validation across domains
+4. **Specify**: Generate concrete specifications with cross-session persistence capabilities
+5. **Handoff**: Create actionable briefs ready for implementation or further development
+
+Key behaviors:
+- Multi-persona orchestration across architecture, analysis, frontend, backend, security domains
+- Advanced MCP coordination with intelligent routing for specialized analysis
+- Systematic execution with progressive dialogue enhancement and parallel exploration
+- Cross-session persistence with comprehensive requirements discovery documentation
+
+## MCP Integration
+- **Sequential MCP**: Complex multi-step reasoning for systematic exploration and validation
+- **Context7 MCP**: Framework-specific feasibility assessment and pattern analysis
+- **Magic MCP**: UI/UX feasibility and design system integration analysis
+- **Playwright MCP**: User experience validation and interaction pattern testing
+- **Morphllm MCP**: Large-scale content analysis and pattern-based transformation
+- **Serena MCP**: Cross-session persistence, memory management, and project context enhancement
+
+## Tool Coordination
+- **Read/Write/Edit**: Requirements documentation and specification generation
+- **TodoWrite**: Progress tracking for complex multi-phase exploration
+- **Task**: Advanced delegation for parallel exploration paths and multi-agent coordination
+- **WebSearch**: Market research, competitive analysis, and technology validation
+- **sequentialthinking**: Structured reasoning for complex requirements analysis
+
+## Key Patterns
+- **Socratic Dialogue**: Question-driven exploration → systematic requirements discovery
+- **Multi-Domain Analysis**: Cross-functional expertise → comprehensive feasibility assessment
+- **Progressive Coordination**: Systematic exploration → iterative refinement and validation
+- **Specification Generation**: Concrete requirements → actionable implementation briefs
+
+## Examples
+
+### Systematic Product Discovery
+```
+/sc:brainstorm "AI-powered project management tool" --strategy systematic --depth deep
+# Multi-persona analysis: architect (system design), analyzer (feasibility), project-manager (requirements)
+# Sequential MCP provides structured exploration framework
+```
+
+### Agile Feature Exploration
+```
+/sc:brainstorm "real-time collaboration features" --strategy agile --parallel
+# Parallel exploration paths with frontend, backend, and security personas
+# Context7 and Magic MCP for framework and UI pattern analysis
+```
+
+### Enterprise Solution Validation
+```
+/sc:brainstorm "enterprise data analytics platform" --strategy enterprise --validate
+# Comprehensive validation with security, devops, and architect personas
+# Serena MCP for cross-session persistence and enterprise requirements tracking
+```
+
+### Cross-Session Refinement
+```
+/sc:brainstorm "mobile app monetization strategy" --depth normal
+# Serena MCP manages cross-session context and iterative refinement
+# Progressive dialogue enhancement with memory-driven insights
+```
+
+## Boundaries
+
+**Will:**
+- Transform ambiguous ideas into concrete specifications through systematic exploration
+- Coordinate multiple personas and MCP servers for comprehensive analysis
+- Provide cross-session persistence and progressive dialogue enhancement
+
+**Will Not:**
+- Make implementation decisions without proper requirements discovery
+- Override user vision with prescriptive solutions during exploration phase
+- Bypass systematic exploration for complex multi-domain projects