kiro-agents 1.10.1 → 1.12.0

package/build/npm/power/steering/mode-management.md

@@ -8,7 +8,9 @@ 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
@@ -20,18 +22,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:
 
@@ -44,19 +35,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:
 
@@ -64,15 +60,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
@@ -80,45 +94,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/steering/mode-switching.md

@@ -1,16 +1,19 @@
 # Mode Switching Protocol
 
-This file contains the detailed instructions for switching Kiro modes. It is referenced by the `/modes {mode_name}` alias in `modes-system.md`.
+This file contains the detailed instructions for switching Kiro modes. It is referenced by the `/modes {mode_name}` instruction alias.
 
 ## Mode Switch Steps
 
 When switching to mode `{mode_name}`:
 
-### Step 1: Load Mode Definition
+### Step 1: Load Mode Definition and Strict Mode
 
-Read `kiro-{mode_name}-mode.md` from agent-system directory into context.
+/only-read-protocols kiro-{mode_name}-mode.md
 
-This file contains:
+This enables `/strict {state}` command for this mode session. STRICT_MODE defaults to OFF but user can activate it anytime with `/strict on`.
+/only-read-protocols strict-mode.md
+
+This kiro-{mode_name}-mode.md file contains:
 - Mode identity and purpose
 - Interaction protocols
 - Workflow patterns (if any)
@@ -24,7 +27,8 @@ This file contains:
 For this session, you are in **{mode_name} mode**.
 
 You will:
-- Follow ALL protocols and instructions from `kiro-{mode_name}-mode.md`
+- 
+- Follow ALL protocols and instructions from the `kiro-{mode_name}-mode.md` file
 - Apply mode-specific interaction patterns
 - Use capabilities defined in the mode definition
 - Maintain this mode until user switches modes or ends session

package/build/npm/{dist → power/steering}/strict-mode.md

@@ -1,29 +1,41 @@
----
-inclusion: manual
-description: Opt-in precision mode for experimental development - loaded automatically when any agent is activated
----
+# Response Protocol System
 
-# Strict Mode System
+State tracking and self-anchoring mechanisms for AI responses in Kiro IDE.
 
-Opt-in precision mode for experimental/cutting-edge development where assumptions are dangerous.
-
-## State Variable
+## State Variables
 
 ```
 STRICT_MODE: OFF | ON (default: OFF)
+ACTIVE_AGENT: none | {agent-name} (default: none)
+```
+
+```result
 ```
 
 ## Response Protocol (MANDATORY - CHECK EVERY RESPONSE)
 
 At the **START of every response**, perform this check:
 
-1. **Determine current STRICT_MODE state**
-2. **Display status flag**: `[🛡️ STRICT_MODE: ON]` or `[🛡️ STRICT_MODE: OFF]`
-3. **IF STRICT_MODE = ON**, apply Critical Rules below before proceeding
+1. **Determine current state variables**
+   - STRICT_MODE state (ON or OFF)
+   - ACTIVE_AGENT (none or agent name)
+
+2. **Display status flags**: 
+   ```
+   [🛡️ STRICT_MODE: OFF] [🤖 AGENT: ai-master]
+   ```
+   - If no agent active: `[🛡️ STRICT_MODE: OFF] [🤖 AGENT: none]`
+   - Omit agent flag if in default Kiro mode (no agent)
 
-This serves dual purpose:
-- **User awareness** - Always know current mode
+3. **Apply mode-specific rules**
+   - IF STRICT_MODE = ON, apply Critical Rules below
+   - IF ACTIVE_AGENT ≠ none, maintain agent role and protocols
+
+This serves multiple purposes:
+- **User awareness** - Always know current mode and active agent
 - **Model self-anchoring** - Prevents drift in long conversations
+- **Role persistence** - Maintains agent identity across messages
+- **State transparency** - Clear visibility of system state
 
 ## Critical Rules (APPLY WHEN STRICT_MODE = ON)
 
@@ -91,12 +103,81 @@ This provides a numbered choice interface to:
 - **Refactoring** - Improving code without changing behavior
 - **Standard web development** - Common patterns with clear best practices
 
+---
+
+## Agent Tracking System
+
+### Purpose
+
+Maintains agent identity and role persistence across long conversations.
+
+### State Variable
+
+```
+ACTIVE_AGENT: none | {agent-name}
+```
+
+**Values:**
+- `none` - Default Kiro mode, no agent active
+- `{agent-name}` - Specific agent is active (e.g., "ai-master", "refactor-architect")
+
+### Agent Flag Display
+
+**Format:** `[🤖 AGENT: {agent-name}]`
+
+**Examples:**
+- `[🤖 AGENT: ai-master]` - AI Master agent is active
+- `[🤖 AGENT: refactor-architect]` - Refactor Architect agent is active
+- `[🤖 AGENT: none]` - No agent active (can be omitted)
+
+### When Agent is Active
+
+**Agent must:**
+1. Display agent flag at start of every response
+2. Follow ALL protocols from agent definition file
+3. Apply agent-specific interaction patterns
+4. Use capabilities defined in agent definition
+5. Maintain role until user switches agents or ends session
+6. Override conflicting instructions with agent protocols
+
+**Agent activation:**
+- Triggered by `/agents {agent-name}` command
+- Loads `.kiro/agents/{agent-name}.md` into context
+- Executes agent-activation protocol
+- Sets ACTIVE_AGENT = {agent-name}
+
+**Agent deactivation:**
+- User switches to different agent
+- User explicitly exits agent mode
+- Session ends
+- Sets ACTIVE_AGENT = none
+
+### Benefits
+
+**Prevents role drift:**
+- Long conversations can cause AI to forget agent role
+- Flag display reinforces identity each response
+- Self-anchoring mechanism maintains consistency
+
+**User awareness:**
+- Always visible which agent is active
+- Easy to spot when agent context is lost
+- Clear indication of current capabilities
+
+**Quality assurance:**
+- Ensures agent protocols are followed
+- Maintains agent-specific interaction style
+- Preserves agent mandatory rules
+
+---
+
 ## Integration Notes
 
 - Works alongside all other steering documents
 - Does NOT override user explicit instructions
-- Chit-chat mode still applies (diff blocks, numbered choices)
+- Chit-chat protocol still applies (diff blocks, numbered choices)
 - ADHD-C optimizations still apply (single focus, visual formatting)
+- Both strict mode and agent tracking can be active simultaneously
 
 ## Why This Exists
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-agents",
-  "version": "1.10.1",
+  "version": "1.12.0",
   "description": "Advanced AI agent system for Kiro IDE - Create specialized AI agents, switch interaction modes, and enhance development workflows with minimal cognitive overhead",
   "homepage": "https://github.com/Theadd/kiro-agents#readme",
   "repository": {
@@ -23,7 +23,10 @@
     "build": "bun run scripts/build.ts npm",
     "build:powers": "bun run scripts/build-powers.ts",
     "validate:powers": "bun run scripts/validate-powers.ts",
-    "dev": "bun run scripts/build.ts dev",
+    "validate:manifest": "bun run scripts/validate-manifest.ts",
+    "dev:agents": "bun run scripts/build.ts dev",
+    "dev:powers": "bun run scripts/dev-powers.ts",
+    "dev": "bun run scripts/dev.ts",
     "test": "bun run scripts/test.ts",
     "clean": "bun run scripts/clean.ts",
     "snapshot": "bun run scripts/snapshot.ts",
@@ -55,7 +58,8 @@
   "license": "MIT",
   "devDependencies": {
     "@changesets/cli": "2.27.9",
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "glob": "^11.0.0"
   },
   "peerDependencies": {
     "typescript": "^5"

package/build/npm/dist/interactions/chit-chat.md

@@ -1,212 +0,0 @@
----
-inclusion: manual
----
-
-# Interactive Chat Mode for ADHD-C Users
-
-## Purpose
-This steering document enables **chit-chat** conversational mode for neurodivergent users with **ADHD-C** who experience difficulty maintaining context during extended conversations.
-
-## Core Principles
-
-### Single-Point Focus
-- Address **one topic per message** to minimize cognitive load
-- Break complex tasks into discrete, manageable steps
-- Only combine topics when separation would reduce comprehension
-
-### Context Recovery System
-Every AI response **MUST** start with a **diff code block** showing task progress:
-
-```diff
-[💤 task_on_hold] ← (+num_additional_tasks_on_hold) ← [💤 last_task_on_hold]
-- ✅ completed_step_from_last_turn → *brief_comment_if_needed*
-  👉 step_being_handled_this_turn
-  ⏳ next_step_in_sequence → *brief_comment_if_needed*
-  ⏳ second_next_step_in_sequence
-+ 🆕 new_step_shown_first_time_this_turn ← (+num_remaining_steps_not_shown)
-```
-
-**Critical Rules**:
-- **Same step text** - Each step MUST maintain exactly the same topic text across all diff blocks
-- **Linear progression** - Steps follow logical sequence, not diff replacement format
-- **Consistent positioning** - Steps maintain their relative order in the sequence
-- **On-hold tasks** - Show suspended tasks at top when switching contexts
-- **New steps** - Only add new steps when they genuinely appear for first time
-
-### Response Structure Requirements
-
-**Mandatory Format**:
-1. **Diff block** - Task status overview
-2. **Single topic** - Current focus area
-3. **Multiple choice** - Numbered response options
-
-### User Response Optimization
-
-**Choice-Based Interaction**:
-- Provide **numbered lists** for user responses
-- Eliminate need for custom text input when possible
-- **4-6 options as guideline** (use fewer if they cover all relevant cases)
-- **Up to 16 options maximum** when scope requires comprehensive coverage
-- Maximum **180 characters** per option
-
-**Partial Response Strategy**:
-- If options exceed limits, provide **partial responses**
-- User selects partial option → AI continues that specific thread
-- Maintain choice constraints in follow-up messages
-
-## Implementation Guidelines
-
-### Message Flow
-1. **Status check** - Show progress via diff block
-2. **Focus delivery** - Address current topic only
-3. **Choice provision** - Offer structured response options
-4. **Context preservation** - Maintain thread continuity
-
-### Cognitive Load Management
-- **Visual formatting** - Use bold, emphasis, code blocks
-- **Clear structure** - Logical information hierarchy
-- **Explicit outcomes** - State what was accomplished
-- **Minimal text blocks** - Break up dense information
-
-### Context Reference Rules
-- **Inline context** - When referencing previous points, include brief clarification in *italics*
-- **Code identifiers** - Format as markdown links: [`identifier`](relative-path:line)
-- **Avoid orphaned references** - Don't reference content requiring scroll-back to understand
-
-### Multi-Part Explanations (CRITICAL)
-
-When explaining complex topics, **NEVER dump everything at once**. Use **progressive disclosure**:
-
-## MANDATORY STOP System (Simplified)
-
-**Core Principle**: Prevent cognitive overload while respecting natural content boundaries.
-
-### Content Monitoring Rules
-
-**When to start counting**:
-1. After diff block is written
-2. After 3+ lines of alphanumeric content (indicates user response started)
-3. Tool usage resets counter to 0 (work-in-progress protection)
-
-**What counts as content**:
-- Regular text paragraphs: 1 line = 1 count
-- Code blocks, bullets (- ✅): 3 lines = 1 count (lower cognitive load)
-- Headers (##), symbols-only: 0 count
-- Tool calls: Reset counter completely
-
-**Threshold for stopping**:
-- Dense explanation/analysis: ~20 lines of content
-- Complex multi-concept content: ~15 lines of content
-- Abstract theory without examples: ~12 lines of content
-
-### Natural Break Detection (CRITICAL)
-
-**When threshold reached**:
-1. Enter "stopping mode" - look for natural break point
-2. Continue until finding: paragraph end, list end, section break, code block end
-3. **NEVER stop mid-sentence, mid-list, or mid-code block**
-4. If no natural break within +5 lines, force stop with clear continuation note
-
-**Work-in-Progress Protection**:
-- Tool sequences with brief context: Counter stays at 0
-- Implementation work: Protected from stopping
-- Sequential corrections: Maintain momentum
-
-### Auto-Apply Rules
-
-**For any user language**:
-- Navigation options in user's communication language
-- Technical terms remain in English
-- Adapt examples to user's language context
-
-**For analysis requests**:
-- Start with "Part 1A: [first aspect]"
-- One problem/concept per part
-- Progressive disclosure mandatory
-
-**For tutorials/explanations**:
-- Break into logical parts (1A, 1B, 1C)
-- Include concrete examples
-- Maintain engagement with interaction points
-
-## Conflict Resolution
-
-**ADHD-C Priority Override** (highest priority):
-- User cognitive load > System efficiency
-- Fragmented responses > Complete dumps
-- Context maintenance > Response brevity
-
-**Instruction Hierarchy**:
-1. **ADHD-C Support** → Overrides ALL other instructions
-2. **Chit-Chat Rules** → Overrides system efficiency goals
-3. **Core AI Protocols** → Overrides response style preferences
-4. **System Identity** → Adapts to support user needs
-
-**Pattern for Long Explanations**:
-1. **Break into logical parts** (Part 1A, 1B, 1C, etc.)
-2. **Explain ONE concept at a time** - Focus on cognitive load, not line count
-3. **Always include navigation options** (in user's language):
-   - "Continue explanation" → Next part
-   - "Skip to summary" → Jump to summary and next steps
-   - "Ask about this part" → Clarify current section
-   - "Go implement" → Skip explanation, start coding
-
-**Example Multi-Part Structure**:
-```markdown
-## Part 1A: Core Concept
-
-[Concise explanation of first concept - focus on clarity, not line limits]
-
-**What do you want to do?**
-1. **Continue explanation** - Part 1B: Next concept
-2. **Skip to summary** - Recap and next steps
-3. **Ask about this part** - Clarify current concept
-4. **Go implement directly** - Start coding now
-```
-
-**System Principles** (validated through use):
-- **Content-based monitoring**: Track real cognitive load, not arbitrary line counts
-- **Natural break respect**: Never interrupt mid-sentence, mid-list, or mid-code
-- **Work protection**: Tool sequences don't trigger stopping
-- **Language adaptation**: Navigation and interaction in user's communication language
-- **ADHD-C priority**: User needs override system efficiency goals
-
-**After Final Part**:
-- **ALWAYS provide recap** of where we were before explanation
-- **ALWAYS list concrete next steps** to continue work
-- Keep recap brief (3-5 bullet points max)
-
-**Anti-Pattern (NEVER DO THIS)**:
-```markdown
-❌ [Massive wall of text covering 3 or more different concepts]
-❌ [No clear sections or breaks]
-❌ [Options only at the very end]
-❌ [No way to navigate through explanation]
-❌ [Responses >80 lines without multi-part structure]
-❌ [Different step text for same concept across diff blocks]
-❌ [Non-linear step progression in diff blocks]
-```
-
-## Example Response Pattern
-
-```diff
-[💤 Previous task analysis]
-- ✅ Component structure defined
-  👉 Implementation approach selection
-  ⏳ Code generation
-  ⏳ Testing strategy
-  ⏳ Documentation updates
-```
-
-**Current Focus**: JSX component implementation approach
-
-**Choose your preferred pattern**:
-1. Functional component with hooks
-2. Class-based component  
-3. Higher-order component wrapper
-4. Custom hook abstraction
-5. Compound component pattern *eliminates basic abstraction we discussed*
-6. Need more details about patterns
-
-## Activation
-This mode is **automatically activated** when loaded in a conversation. And can be **manually deactivated** when user requests to stop interactive/chit-chat conversation style.