kiro-agents 1.10.0 → 1.11.0

package/build/npm/dist/modes.md

@@ -8,13 +8,17 @@ keywords: ["modes", "vibe", "spec", "workflow", "interactive"]
 
 You are now in **mode management** using chit-chat interaction protocol.
 
+/only-read-protocols chit-chat.md
+
 ## Mode Management Steps
 
 When entering mode management:
 
 ### Step 1: Load Chit-Chat Mode
 
-Apply protocols from `chit-chat.md` steering document:
+/only-read-protocols chit-chat.md
+
+Apply protocols from chit-chat.md:
 - Use diff blocks to show progress
 - Provide numbered choice lists (4-6 options)
 - Maintain single focus per message
@@ -26,18 +30,7 @@ Begin with a diff block showing:
   ⏳ Mode selection
 ```
 
-### Step 2: Detect Available Modes
-
-Scan agent-system directory for `kiro-*-mode.md` files:
-- Extract mode names from filenames (remove `kiro-` prefix and `-mode.md` suffix)
-- Read frontmatter for descriptions
-- Identify current mode from context (if any)
-
-**Available Kiro modes:**
-- **vibe** - Flexible, conversational development assistance
-- **spec** - Structured feature development with requirements, design, and tasks
-
-### Step 3: Present Mode Selection
+### Step 2: Present Mode Selection
 
 Use this response structure:
 
@@ -50,19 +43,24 @@ Use this response structure:
 
 **Available Kiro modes:**
 
-- **vibe** - Flexible, conversational development assistance
-- **spec** - Structured feature development with requirements, design, and tasks
+- **vibe** - Flexible, conversational development assistance (with vibe tools)
+- **spec** - Structured feature development with requirements, design, and tasks (with spec tools)
+- **as-vibe** - Vibe interaction style (keeps current tools)
+- **as-spec** - Spec interaction style (keeps current tools)
 
 **What would you like to do?**
 
-1. **Switch to vibe mode** - Flexible development and quick iterations
-2. **Switch to spec mode** - Structured feature planning and implementation
-3. **View mode details** - See full mode capabilities and protocols
-4. **Mode comparison** - Understand differences between modes
-5. **Stay in current mode** - Continue with current mode
-6. **Help** - Learn about mode system
+1. **Switch to vibe mode** - Flexible development with vibe tools
+2. **Switch to spec mode** - Structured development with spec tools
+3. **Switch to as-vibe mode** - Vibe interaction style (keeps current tools)
+4. **Switch to as-spec mode** - Spec interaction style (keeps current tools)
+5. **Switch to spec-as-vibe mode** - Spec tools with vibe interaction style
+6. **View mode details** - See full mode capabilities and protocols
+7. **Mode comparison** - Understand differences between modes
+8. **Stay in current mode** - Continue with current mode
+9. **Help** - Learn about mode system
 
-### Step 4: Handle User Choice
+### Step 3: Handle User Choice
 
 Based on user selection:
 
@@ -70,15 +68,33 @@ Based on user selection:
 
 - Execute `/modes vibe` command
 - Load vibe mode protocols
-- Begin flexible interaction
+- Begin flexible interaction with vibe tools
 
 #### Option 2 - Switch to spec
 
 - Execute `/modes spec` command
 - Load spec mode protocols
-- Begin structured workflow
+- Begin structured workflow with spec tools
+
+#### Option 3 - Switch to as-vibe
+
+- Execute `/modes as-vibe` command
+- Load as-vibe mode protocols
+- Begin flexible interaction (keeps current tools)
+
+#### Option 4 - Switch to as-spec
+
+- Execute `/modes as-spec` command
+- Load as-spec mode protocols
+- Begin structured interaction (keeps current tools)
+
+#### Option 5 - Switch to spec-as-vibe
+
+- Execute `/spec-as-vibe` command
+- Load spec tools with vibe interaction style
+- Begin flexible interaction with spec capabilities
 
-#### Option 3 - View mode details
+#### Option 6 - View mode details
 
 - Show numbered list of modes
 - User selects mode to view
@@ -86,45 +102,57 @@ Based on user selection:
 - Explain capabilities and use cases
 - Offer to switch to that mode
 
-#### Option 4 - Mode comparison
+#### Option 7 - Mode comparison
 
-- Show side-by-side comparison:
-  - **Vibe Mode**: Flexible, conversational, quick iterations, no formal workflow
-  - **Spec Mode**: Structured workflow with requirements → design → tasks, approval gates
+- Show comprehensive comparison:
+  - **Vibe Mode**: Flexible, conversational, quick iterations, no formal workflow (with vibe tools)
+  - **Spec Mode**: Structured workflow with requirements → design → tasks, approval gates (with spec tools)
+  - **As-Vibe Mode**: Flexible interaction style but keeps current tools
+  - **As-Spec Mode**: Structured interaction style but keeps current tools
 - Explain when to use each mode:
-  - Use vibe for: Quick fixes, exploration, prototyping, iterative development
-  - Use spec for: Complex features, team collaboration, formal planning, documentation
+  - Use vibe for: Quick fixes, exploration, prototyping, iterative development (need vibe tools)
+  - Use spec for: Complex features, team collaboration, formal planning, documentation (need spec tools)
+  - Use as-vibe for: Flexible interaction with current tools (agent superpowers + vibe style)
+  - Use as-spec for: Structured interaction with current tools (agent superpowers + spec methodology)
 - Highlight key differences:
-  - Workflow: None vs. Structured phases
-  - Approval: Direct changes vs. Approval gates
-  - Documentation: Minimal vs. Comprehensive
+  - **Tools**: vibe/spec change tools, as-vibe/as-spec keep current tools
+  - **Interaction**: vibe/as-vibe flexible, spec/as-spec structured
+  - **Use case**: Combine agent capabilities with desired interaction style
 - Help user choose appropriate mode
 
-#### Option 5 - Stay in current mode
+#### Option 8 - Stay in current mode
 
 - Confirm staying in current mode
 - Return to normal interaction
 - Preserve current state
 
-#### Option 6 - Help
+#### Option 9 - Help
 
 Explain mode system:
-- **What are modes?** - Different interaction styles for different workflows
+- **What are modes?** - Different interaction styles and tool sets for different workflows
 - **How to switch?** - Use `/modes {name}` or `/modes` for interactive menu
+- **Mode types:**
+  - **Full modes** (vibe/spec): Change both tools and interaction style
+  - **Role modes** (as-vibe/as-spec): Change only interaction style, keep current tools
 - **Mode benefits:**
-  - Vibe: Fast iteration, flexible approach
-  - Spec: Structured planning, comprehensive documentation
+  - Vibe: Fast iteration, flexible approach (with vibe tools)
+  - Spec: Structured planning, comprehensive documentation (with spec tools)
+  - As-Vibe: Flexible interaction with current tools (agent superpowers + vibe style)
+  - As-Spec: Structured interaction with current tools (agent superpowers + spec methodology)
 - **Mode coordination:**
   - Modes can be combined with agents
   - File changes preserved when switching
   - Workflow state resets when switching
+  - Role modes enable "agent superpowers" - specialized tools with preferred interaction style
 - **Usage examples:**
   - Quick bug fix → Use vibe mode
   - New feature with requirements → Use spec mode
+  - Agent with spec tools but want flexibility → Use as-vibe mode
+  - Agent with vibe tools but want structure → Use as-spec mode
   - Refactoring existing code → Use vibe mode
   - Team feature with documentation → Use spec mode
 
-### Step 5: Maintain Chit-Chat Mode
+### Step 4: Maintain Chit-Chat Mode
 
 Continue using diff blocks and numbered choices throughout mode management session.
 

package/build/npm/power/POWER.md

@@ -28,6 +28,14 @@ Protocols are detailed, step-by-step instruction documents that guide AI through
 
 This power provides the following protocols as steering files:
 
+### Core Protocols
+
+- **strict-mode** - Precision mode for experimental/cutting-edge development
+  - Blocks execution on ambiguous input
+  - Mandatory clarification before proceeding
+  - Prevents assumption propagation
+  - Opt-in via `/strict on` command
+
 ### Agent System Protocols
 
 - **agent-activation** - Protocol for activating and assuming agent roles

package/build/npm/power/steering/agent-activation.md

@@ -17,7 +17,32 @@ This file contains:
 - Examples and best practices
 - Integration requirements
 
-**Also load `strict-mode.md` steering document** to enable `/strict {state}` command for this agent session. STRICT_MODE defaults to OFF but user can activate it anytime with `/strict on`.
+This enables `/strict {state}` command for this agent session. STRICT_MODE defaults to OFF but user can activate it anytime with `/strict on`.
+/only-read-protocols strict-mode.md
+
+### Step 1.5: Manage Chit-Chat Protocol
+
+**Scan the agent definition for chit-chat protocol usage indicators:**
+
+Check if the agent definition contains ANY of these patterns (case-insensitive):
+- `**Response Style:** Chit-chat`
+- `**Response Style:** Chit-chat mode`
+- `chit-chat protocol`
+- `chit-chat interaction`
+- Section header containing "Chit-Chat" (e.g., "## Chit-Chat Mode Support")
+
+**If ANY indicator is found:**
+```
+/only-read-protocols chit-chat.md
+```
+
+**Chit-chat protocol is active** for this agent session.
+
+**If NO indicators are found:**
+
+**Chit-chat protocol is inactive** for this agent session.
+
+If chit-chat.md is in context from a previous session, its patterns do not apply. Follow the agent's defined interaction protocol instead.
 
 ### Step 2: Assume Agent Role
 
@@ -34,16 +59,18 @@ You will:
 
 Start interaction according to **{agent_name}**'s protocols defined in the `.md` file.
 
-If the agent uses **chit-chat mode**:
+**If chit-chat protocol is active:**
 - Begin with diff block showing current state
 - Provide numbered choice list (4-6 options, up to 16 if needed)
 - Maintain single focus per message
 - Use visual formatting (bold, code blocks)
+- Follow all chit-chat protocols (STOP system, context references, etc.)
 
-Otherwise:
+**If chit-chat protocol is inactive:**
 - Begin according to the agent's defined interaction protocol
 - Follow agent-specific response structure
 - Apply agent-specific formatting rules
+- Do NOT use chit-chat patterns (diff blocks, numbered choices, etc.)
 
 ---
 

package/build/npm/power/steering/agent-creation.md

@@ -2,24 +2,288 @@
 
 This file contains the detailed instructions for creating new agents. It is referenced during agent creation workflow in agent management mode.
 
-## Agent Creation Steps
+## Creation Methods
 
-When creating a new agent:
+When creating a new agent, offer multiple methods based on user experience level:
 
-### Step 1: Initialize Creation Wizard
+1. **Quick Start** - Choose from predefined templates (fastest)
+2. **Project-Specific** - AI-suggested agents for current workspace
+3. **Explore Roles** - Browse agents by domain and role
+4. **Guided Wizard** - Step-by-step interactive creation (full control)
+5. **Natural Language** - Describe agent in plain English (most intuitive)
 
-Use chit-chat mode for the creation process:
+## Method Selection
+
+When user initiates agent creation:
+
+### Step 1: Present Creation Methods
+
+Use chit-chat protocol for the creation process:
+
+```diff
+  👉 Agent Creation
+  ⏳ Choose creation method
+```
+
+**How would you like to create your agent?**
+
+1. **Quick Start** - Choose from predefined agent templates
+   → Fastest, no configuration needed
+   → Best for: Common use cases, getting started quickly
+
+2. **Project-Specific** - AI suggests agents for your workspace
+   → Analyzes your project and recommends relevant agents
+   → Best for: Project-specific needs, contextual recommendations
+
+3. **Explore Roles** - Browse agents by domain and role
+   → Discover what's possible, organized by industry/function
+   → Best for: Exploring options, learning about agent types
+
+4. **Guided Wizard** - Step-by-step interactive creation
+   → Full control, guided process
+   → Best for: Custom agents, specific requirements
+
+5. **Natural Language** - Describe what you need
+   → "I need an agent that helps with React performance"
+   → Best for: Quick creation, intuitive interface
+
+6. **Cancel** - Exit without creating agent
+
+**Choose a number (1-6):**
+
+### Step 2: Execute Selected Method
+
+Based on user choice, execute the appropriate creation method:
+
+---
+
+## Method 1: Quick Start (Predefined Templates)
+
+### Step 2.1: Load Template List
+
+Read predefined templates from embedded list:
+
+**Predefined Agent Templates:**
+
+1. **Full-Stack Developer**
+   "Expert in complete web development stack including frontend (React, Vue), backend (Node.js, Python), databases (PostgreSQL, MongoDB), and deployment (Docker, CI/CD)."
+
+2. **Code Reviewer**
+   "Specialized in code review with focus on code quality, security vulnerabilities, performance issues, best practices, and maintainability. Provides constructive feedback with actionable suggestions."
+
+3. **API Architect**
+   "Expert in designing and implementing RESTful and GraphQL APIs with focus on scalability, security, documentation (OpenAPI), versioning, and best practices."
+
+4. **Frontend Specialist**
+   "Specialized in modern frontend development with React, TypeScript, state management, CSS/styling, accessibility (WCAG), and performance optimization (Core Web Vitals)."
+
+5. **DevOps Engineer**
+   "Expert in containerization (Docker), orchestration (Kubernetes), CI/CD pipelines (GitHub Actions, GitLab CI), infrastructure as code (Terraform), and monitoring (Prometheus, Grafana)."
+
+6. **Testing Specialist**
+   "Specialized in comprehensive testing strategies including unit tests (Jest, pytest), integration tests, E2E tests (Playwright, Cypress), test-driven development (TDD), and test automation."
+
+7. **Database Expert**
+   "Expert in database design, optimization, migrations, query performance, indexing strategies, and working with both SQL (PostgreSQL, MySQL) and NoSQL (MongoDB, Redis) databases."
+
+8. **Security Auditor**
+   "Specialized in application security with focus on OWASP Top 10, vulnerability assessment, secure coding practices, authentication/authorization, and security testing (SAST, DAST)."
+
+9. **Technical Writer**
+   "Expert in creating clear technical documentation including API references, user guides, tutorials, README files, architecture documentation, and maintaining documentation systems."
+
+10. **Performance Optimizer**
+    "Specialized in application performance optimization including profiling, bottleneck identification, caching strategies, database optimization, and frontend performance (bundle size, loading times)."
+
+11. **UI/UX Designer**
+    "Expert in user interface and experience design with focus on user research, wireframing, prototyping (Figma), design systems, accessibility, and usability testing."
+
+12. **Data Analyst**
+    "Specialized in data analysis, visualization (charts, dashboards), SQL queries, statistical analysis, reporting, and deriving actionable insights from data."
+
+### Step 2.2: Present Templates
+
+```diff
+  👉 Agent Creation - Quick Start
+  ⏳ Choose template
+```
+
+**Choose from predefined agent templates:**
+
+[Display templates 1-12 with numbers]
+
+**Type number to select template, or 'back' to choose different method:**
+
+### Step 2.3: Confirm and Customize
+
+User selects template (e.g., "4" for Frontend Specialist).
+
+```diff
+  👉 Agent Creation - Quick Start
+  ⏳ Customize template
+```
+
+**Selected template:** Frontend Specialist
+
+**Default name:** `frontend-specialist`
+**Description:** "Specialized in modern frontend development with React, TypeScript, state management, CSS/styling, accessibility (WCAG), and performance optimization (Core Web Vitals)."
+
+**Customize? (optional)**
+
+1. **Use as-is** - Create agent with default settings
+2. **Change name** - Customize agent name
+3. **Edit description** - Modify description
+4. **Back** - Choose different template
+
+### Step 2.4: Generate Agent
+
+Use the template's description to generate complete agent definition following the standard agent structure (see Step 3 below).
+
+---
+
+## Method 2: Project-Specific (AI Analysis)
+
+### Step 2.1: Analyze Workspace
+
+```diff
+  👉 Agent Creation - Project Analysis
+  ⏳ Analyzing your workspace...
+```
+
+**Analyzing project structure and technologies...**
+
+Execute analysis:
+1. Read `package.json`, `requirements.txt`, `Cargo.toml`, etc.
+2. Scan directory structure (src/, tests/, docs/, etc.)
+3. Identify frameworks and libraries
+4. Read README.md and documentation
+5. Check for CI/CD configs, Docker files, etc.
+
+### Step 2.2: Generate Recommendations
+
+Based on analysis, generate 5-8 relevant agent suggestions.
+
+```diff
+  👉 Agent Creation - Project Analysis
+  ⏳ Recommendations
+```
+
+**Based on your project (React + TypeScript + Node.js + PostgreSQL):**
+
+**Recommended agents:**
+
+1. ⭐ **React TypeScript Specialist**
+   "Expert in React with TypeScript, hooks, component patterns, and type-safe development."
+
+2. ⭐ **API Developer**
+   "Specialized in Node.js backend development, RESTful APIs, Express, and database integration."
+
+3. ⭐ **Database Expert**
+   "Expert in PostgreSQL schema design, query optimization, migrations, and ORMs."
+
+4. **Testing Engineer**
+   "Specialized in Jest, React Testing Library, and E2E testing with Playwright."
+
+5. **DevOps Engineer**
+   "Expert in Docker, CI/CD, and deployment automation for Node.js applications."
+
+**Type number to select, or 'back' to choose different method:**
+
+### Step 2.3: Customize and Generate
+
+Follow same customization flow as Quick Start (Step 2.3-2.4 above).
+
+---
+
+## Method 3: Explore Roles (Domain Browser)
+
+### Step 2.1: Present Domains
+
+```diff
+  👉 Agent Creation - Explore Roles
+  ⏳ Choose domain
+```
+
+**Explore agent roles by domain:**
+
+1. 💻 **Software Development**
+   Frontend, Backend, DevOps, Testing, Security
+
+2. 🎨 **Creative & Design**
+   UI/UX, Content Writing, Branding, Video Production
+
+3. 💼 **Business & Finance**
+   Marketing, Sales, Strategy, Finance, HR
+
+4. 🏥 **Healthcare & Medicine**
+   Clinical, Research, Administration, Public Health
+
+5. 🔬 **Science & Research**
+   Data Science, Research Methods, Lab Management
+
+6. ⚖️ **Legal & Compliance**
+   Legal Research, Contract Review, Compliance
+
+7. 🏗️ **Engineering & Architecture**
+   Civil, Mechanical, Electrical, Architecture
+
+8. 🌾 **Agriculture & Food**
+   Farming, Food Science, Culinary
+
+[More domains available - type 'more' to see all]
+
+**Type number to explore domain, or 'back' to choose different method:**
+
+### Step 2.2: Present Roles in Domain
+
+User selects domain (e.g., "1" for Software Development).
 
 ```diff
-  👉 Agent creation wizard
-  ⏳ Gathering agent information
+  👉 Agent Creation - Explore Roles
+  ⏳ Software Development roles
 ```
 
-**Current Focus**: Creating new agent
+**Software Development agent roles:**
+
+1. **Frontend Developer**
+   "Expert in modern frontend: React, Vue, Angular, TypeScript, CSS, accessibility, performance."
+
+2. **Backend Developer**
+   "Specialized in server-side: APIs, databases, authentication, microservices, serverless."
+
+3. **Full-Stack Developer**
+   "Complete web development: frontend, backend, databases, deployment."
+
+4. **DevOps Engineer**
+   "Expert in: Docker, Kubernetes, CI/CD, infrastructure as code, monitoring."
+
+5. **Mobile Developer**
+   "Specialized in: React Native, Flutter, iOS (Swift), Android (Kotlin)."
+
+6. **QA/Testing Specialist**
+   "Expert in: test strategies, automation, unit/integration/E2E testing, TDD."
+
+7. **Security Engineer**
+   "Specialized in: application security, vulnerability assessment, secure coding, penetration testing."
+
+8. **Data Engineer**
+   "Expert in: data pipelines, ETL, data warehousing, big data technologies."
+
+**Type number to select role, or 'back' to choose different domain:**
+
+### Step 2.3: Customize and Generate
+
+Follow same customization flow as Quick Start (Step 2.3-2.4 above).
+
+---
+
+## Method 4: Guided Wizard (Current System)
+
+### Step 2.1: Agent Type Selection
 
-### Step 2: Collect Agent Information
+**Current system - full control over agent definition.**
 
-Guide user through agent definition with numbered choices:
+Follow existing wizard steps (2.1 through 2.8 below).
 
 #### 2.1: Agent Type Selection
 
@@ -91,7 +355,7 @@ Group by category. Example:
 1. **Formal** - Professional, structured responses
 2. **Casual** - Conversational, friendly tone
 3. **Technical** - Precise, detailed explanations
-4. **Chit-chat mode** - Interactive with diff blocks and numbered choices
+4. **Chit-chat protocol** - Interactive with diff blocks and numbered choices
 
 **Confirmation requirements:**
 - Always confirm before changes
@@ -122,7 +386,90 @@ Example workflow:
 6. Verify tests pass
 7. Document changes
 
-### Step 3: Generate Agent Definition File
+---
+
+## Method 5: Natural Language (AI Generation)
+
+### Step 2.1: Collect Description
+
+```diff
+  👉 Agent Creation - Natural Language
+  ⏳ Describe your agent
+```
+
+**Describe what you need in plain English:**
+
+**Examples:**
+- "I need help optimizing React performance"
+- "An agent that reviews my Python code for security issues"
+- "Someone who can help me write technical documentation"
+- "Expert in PostgreSQL query optimization"
+- "Help me with Docker and Kubernetes deployment"
+
+**Your description:**
+
+### Step 2.2: Analyze and Generate Proposal
+
+User provides description (e.g., "I need help optimizing React performance").
+
+```diff
+  👉 Agent Creation - Natural Language
+  ⏳ Analyzing your request...
+```
+
+**AI analyzes the description and extracts:**
+- Agent type (specialist/generalist/coordinator)
+- Primary domain and focus area
+- Key capabilities needed
+- Suggested name
+- Generated description
+
+**Present proposal:**
+
+```diff
+  👉 Agent Creation - Natural Language
+  ⏳ Review proposal
+```
+
+**I understand you need:**
+
+**Agent Type:** Specialist
+**Primary Domain:** Software Development → Frontend
+**Focus Area:** React Performance Optimization
+
+**Suggested Capabilities:**
+- React profiling and debugging (React DevTools, Profiler API)
+- Performance optimization techniques (memoization, lazy loading)
+- Bundle size optimization (code splitting, tree shaking)
+- Rendering performance (virtual DOM, reconciliation)
+- Core Web Vitals improvement (LCP, FID, CLS)
+- Memory leak detection and prevention
+
+**Suggested Name:** `react-performance-optimizer`
+
+**Generated Description:**
+"Specialized in React performance optimization with expertise in profiling, bundle optimization, rendering performance, and Core Web Vitals improvement. Helps identify bottlenecks and implement performance best practices."
+
+**Does this match what you need?**
+
+1. **Yes, create it** - Generate agent with these capabilities
+2. **Modify name** - Change agent name
+3. **Modify description** - Edit description
+4. **Add more details** - Provide additional context to refine
+5. **Start over** - Try different description
+6. **Back** - Choose different creation method
+
+### Step 2.3: Refine if Needed
+
+If user chooses to modify or add details, iterate on the proposal.
+
+### Step 2.4: Generate Agent
+
+Once confirmed, generate complete agent definition using the AI-analyzed capabilities and description.
+
+---
+
+## Step 3: Generate Agent Definition File
 
 Create `.kiro/agents/{agent-name}.md` with this structure: