kiro-agents 1.12.0 → 1.13.0

package/README.md

@@ -16,6 +16,7 @@ Build agents for any domain: development, design, business, research, or anythin
 **Additional Features:**
 - 🔄 **Flexible Modes** - Switch between vibe (conversational) and spec (structured) workflows
 - 🎯 **Strict Mode** - Precision mode that blocks execution on ambiguous input
+- 🧠 **Reflection System** - Agents learn from experience with persistent memory across sessions
 
 ## Installation
 
@@ -84,6 +85,7 @@ Agents you create are saved as `.md` files in `.kiro/agents/`. Edit them like an
 - **[Getting Started](docs/GETTING_STARTED.md)** - Step-by-step onboarding guide
 - **[Architecture Overview](docs/ARCHITECTURE.md)** - System design and component relationships
 - **[Creating Powerful Agents](docs/user-guide/creating-powerful-agents.md)** - Layered architecture guide
+- **[Reflection System](docs/user-guide/reflection-system.md)** - Persistent memory for agents
 - **[Design Rationale](docs/design/)** - Protocol system, interaction patterns, neurodivergent accessibility
 - **[Contributing](CONTRIBUTING.md)** - Development workflow, build system, testing, versioning
 

package/build/npm/bin/cli.js

@@ -33,7 +33,8 @@ var STEERING_FILES = [
   "aliases.md",
   "agents.md",
   "modes.md",
-  "strict.md"
+  "strict.md",
+  "reflect.md"
 ];
 var POWER_FILES = [
   "POWER.md",
@@ -46,6 +47,7 @@ var POWER_FILES = [
   "steering/kiro-spec-mode.md",
   "steering/kiro-as-vibe-mode.md",
   "steering/kiro-as-spec-mode.md",
+  "steering/explainability-protocol.md",
   "steering/chit-chat.md",
   "steering/agent-management.md",
   "steering/agent-creation.md",

package/build/npm/dist/agents.md

@@ -13,11 +13,10 @@ keywords: ["agents", "management", "create", "activate", "interactive"]
 If the user's message contains `/agents {agent_name}` with a specific agent name (e.g., `/agents kiro-master`):
 
 1. **DO NOT execute the interactive management flow below**
-2. **INSTEAD, execute the instruction alias for agent activation:**
-   - Read `.kiro/agents/{agent_name}.md` into context
-   - /protocols agent-activation.md
-   - Follow all steps from the "Agent Activation Steps" section in agent-activation.md
-   - Use `{agent_name}` as the agent identifier throughout the protocol
+2. **INSTEAD, execute the instruction alias:**
+   ```
+   /agents {agent_name}
+   ```
 3. **Stop processing this document** - The agent activation protocol takes over
 
 **Only continue with interactive management flow below if user typed `/agents` without parameters.**
@@ -34,11 +33,23 @@ You are now in **agent management mode** using chit-chat interaction protocol.
 
 ## Initial Agent
 
-When auto-setup detects no agents exist, create the initial agent:
+When auto-setup detects no agents exist:
 
-**kiro-master** - Interactive Kiro feature management with CRUD operations for MCP servers, hooks, agents, specs, powers, and steering documents. Includes .kiro/ directory maintenance, steering optimization, refactoring, and comprehensive analysis capabilities
+1. **Load agent definition structure:**
+   ```
+   /only-read-protocols agent-creation.md
+   ```
 
-This description is used when creating `.kiro/agents/kiro-master.md` during auto-setup.
+2. **Create `.kiro/agents/kiro-master.md`** using the agent definition structure from agent-creation.md Step 3, with:
+   
+   **kiro-master** - Interactive Kiro feature management with CRUD operations for MCP servers, hooks, agents, specs, powers, and steering documents. Includes .kiro/ directory maintenance, steering optimization, refactoring, and comprehensive analysis capabilities
+
+3. **Validate** the created agent file has:
+   - Valid YAML frontmatter
+   - All required sections from agent-creation.md Step 3
+   - Proper markdown formatting
+
+This ensures the initial agent follows the standard agent definition structure.
 
 ---
 

package/build/npm/dist/reflect.md

@@ -0,0 +1,158 @@
+---
+inclusion: manual
+description: "Reflection system commands for capturing and managing agent insights"
+keywords: ["reflect", "insights", "learning", "reflection"]
+---
+
+# Reflection System
+
+Commands for managing the AI reflection system that captures insights, patterns, decisions, and learnings.
+
+## Commands
+
+### /reflect - Enable Reflection (Session-Temporary)
+
+**Usage:** `/reflect`
+
+**Behavior:**
+
+Enables reflection system for the currently active agent (session-temporary).
+
+**If agent already has Reflections section:**
+- Confirm it's already enabled
+- Show reflection status
+- Continue
+
+**If agent lacks Reflections section:**
+- Add Reflections section temporarily for this session
+- Include all 4 tiers (Universal, Category, Agent-Specific, Project)
+- Reflection active while using this agent
+- Removed when session ends or agent changes
+- Next session: agent returns to original state
+
+**Reflections section added (temporary):**
+
+````markdown
+## Reflections
+
+This agent records insights, patterns, and learnings in its dedicated reflection files.
+
+### Universal Insights
+
+#[[file:.ai-storage/reflections/approved/universal.md:insights]]
+
+### Category Insights ({agent-category})
+
+#[[file:.ai-storage/reflections/approved/categories/{agent-category}.md:insights]]
+
+### Agent-Specific Insights
+
+#[[file:.ai-storage/reflections/approved/agents/{agent-name}.md:insights]]
+
+### Project Insights
+
+#[[file:.ai-storage/reflections/approved/project.md:insights]]
+````
+
+**Note:** Replace `{agent-category}` and `{agent-name}` with actual values from agent definition.
+
+**After enabling:**
+
+```diff
+✅ REFLECTION ENABLED (Session-Temporary)
+
+Agent: {agent-name}
+Category: {agent-category}
+
+Reflection files:
+- Universal: .ai-storage/reflections/approved/universal.md
+- Category: .ai-storage/reflections/approved/categories/{agent-category}.md
+- Agent: .ai-storage/reflections/approved/agents/{agent-name}.md
+- Project: .ai-storage/reflections/approved/project.md
+
+Draft file:
+- .ai-storage/reflections/drafts/agents/{agent-name}.md
+
+You can now capture insights during work. Use /agents reflection-curator to review drafts.
+```
+
+**Use case:** Quick testing, one-off reflection capture, temporary enablement.
+
+---
+
+### /reflect review - Review Draft Insights
+
+**Usage:** `/reflect review`
+
+**Behavior:**
+
+Activates reflection-curator agent and starts draft review workflow.
+
+**Equivalent to:**
+```
+/agents reflection-curator
+```
+
+Then curator agent automatically starts review workflow.
+
+**Use case:** Review pending draft insights and approve them to appropriate tiers.
+
+---
+
+## Reflection System Overview
+
+### Purpose
+
+Enable agents to capture and reuse knowledge across sessions:
+- **Insights** - General knowledge, preferences, standards
+- **Patterns** - Reusable approaches, workflows, solutions
+- **Decisions** - Important choices and their rationale
+- **Learnings** - Lessons from successes or failures
+
+### Workflow
+
+1. **Agent captures insight** → Writes to draft file
+2. **User reviews drafts** → `/reflect review`
+3. **Curator validates** → Checks quality, assigns tier
+4. **Insight approved** → Moves to approved file
+5. **Agents use insights** → Load via file references
+
+### Insight Tiers
+
+**Universal** - Used by ALL agents  
+**Category** - Used by agent type (architects, developers, etc.)  
+**Agent-Specific** - Used by one agent only  
+**Project** - About this specific project
+
+### Storage Location
+
+```
+.ai-storage/reflections/
+├── drafts/        - Pending insights
+└── approved/      - Approved insights by tier
+```
+
+### On-Demand Creation
+
+No initialization required! Files created automatically when:
+- Agent records first insight
+- Curator approves insight
+- Agent loads reflections
+
+## Related Commands
+
+```
+/reflect              Enable reflection (session-temporary)
+/reflect review       Review draft insights
+/agents reflection-curator   Activate curator agent
+```
+
+## Learn More
+
+- **README:** `.ai-storage/README.md` - Complete system documentation
+- **Curator Agent:** `.kiro/agents/reflection-curator.md`
+- **Proposal:** `proposals/ai-managed-storage-and-reflection-system-v2.md`
+
+---
+
+**Start capturing insights with `/reflect` and review them with `/reflect review`.**

package/build/npm/power/steering/explainability-protocol.md

@@ -0,0 +1,630 @@
+---
+name: explainability-protocol
+description: Comprehensive protocol for transparent, interpretable AI reasoning and decision-making
+version: 1.0.0
+---
+
+# Explainability Protocol
+
+Protocol for making AI reasoning transparent, interpretable, and trustworthy. Provides mechanisms for explaining decisions, documenting assumptions, quantifying confidence, and handling uncertainty.
+
+## Core Principles
+
+1. **Transparency First** - Make reasoning visible and understandable
+2. **Explicit Assumptions** - Document all assumptions and limitations
+3. **Quantified Confidence** - Indicate certainty levels in outputs
+4. **Traceable Decisions** - Show how inputs lead to outputs
+5. **Error Clarity** - Explain what went wrong and why
+6. **Alternative Analysis** - Show options considered and rejection rationale
+7. **Human-Readable** - Present logic in accessible language
+8. **Continuous Learning** - Capture insights for future improvement
+
+## Transparency Mechanisms
+
+### 1. Reasoning Transparency
+
+**Purpose:** Make AI decision-making processes visible and understandable
+
+**Implementation:**
+- Break down complex reasoning into clear, sequential steps
+- Show intermediate conclusions and how they connect
+- Document reasoning patterns for future reference
+- Make implicit logic explicit
+- Use visual formatting (numbered steps, bullet points, diagrams)
+
+**Example:**
+```
+Decision: Recommend protocol splitting
+
+Reasoning:
+1. Current protocol is 3K tokens
+2. Users only need one section at a time
+3. Lazy loading would reduce overhead by 67%
+4. Modular structure improves maintainability
+5. No backward compatibility issues identified
+→ Conclusion: Split protocol into 6 smaller files
+```
+
+### 2. Confidence & Uncertainty
+
+**Purpose:** Quantify certainty in AI outputs and communicate limitations
+
+**Implementation:**
+- Provide confidence scores for recommendations (High/Medium/Low or %)
+- Communicate when AI is uncertain or making assumptions
+- Explain limitations and edge cases
+- Use qualifiers: "likely", "possibly", "uncertain", "confident"
+- Ask clarifying questions when ambiguous
+
+**Confidence Levels:**
+- **High (90%+):** Based on verified facts, documented behavior, or clear patterns
+- **Medium (60-89%):** Based on reasonable inference, common patterns, or partial information
+- **Low (<60%):** Based on assumptions, incomplete information, or uncertain patterns
+
+**Example:**
+```
+Recommendation: Use lazy loading pattern
+Confidence: High (95%)
+
+Rationale:
+- Pattern is documented in INSTALLED-ARCHITECTURE.md ✓
+- Successfully used in 3 other protocols ✓
+- No known edge cases or limitations ✓
+- Backward compatible ✓
+```
+
+### 3. Decision Tracing
+
+**Purpose:** Track how inputs lead to specific outputs
+
+**Implementation:**
+- Show decision trees and reasoning paths
+- Document why certain approaches were chosen
+- Make protocol selection logic visible
+- Explain precedence and conflict resolution
+- Link decisions to specific inputs or requirements
+
+**Decision Tree Format:**
+```
+Input: User requests protocol optimization
+
+├─ Analyze current state
+│  ├─ Protocol size: 3K tokens
+│  ├─ Usage pattern: One section at a time
+│  └─ Loading: All upfront (inefficient)
+│
+├─ Identify options
+│  ├─ Option A: Compress content (saves ~20%)
+│  ├─ Option B: Split into modules (saves ~67%)
+│  └─ Option C: Keep as-is (no savings)
+│
+├─ Evaluate tradeoffs
+│  ├─ Option A: Minimal savings, maintains structure
+│  ├─ Option B: Maximum savings, requires refactoring
+│  └─ Option C: No benefits
+│
+└─ Select optimal solution
+   └─ Option B: Split into modules
+      Reason: Highest savings, acceptable refactoring cost
+```
+
+### 4. Error Transparency
+
+**Purpose:** Identify where and why AI makes mistakes
+
+**Implementation:**
+- Provide clear error messages with full context
+- Explain what went wrong and why
+- Offer multiple interpretations for ambiguous input
+- Ask clarifying questions when uncertain
+- Document error patterns for improvement
+- Show recovery strategies
+
+**Error Explanation Format:**
+```
+Error: Cannot load protocol "agent-creation-wizard.md"
+
+Context:
+- Command: /agents → Create new agent → Method 4
+- Expected: Load agent-creation-wizard.md from kiro-protocols
+- Actual: File not found
+
+Root Cause:
+- Protocol file doesn't exist yet (not implemented)
+- agent-creation.md references it but file is missing
+
+Recovery Options:
+1. Use different creation method (1, 2, 3, or 5)
+2. Create protocol file manually
+3. Fall back to natural language method
+
+Recommendation: Option 1 (use Method 5: Natural Language)
+Confidence: High - Method 5 is implemented and tested
+```
+
+### 5. Human-Readable Outputs
+
+**Purpose:** Present AI logic in accessible language
+
+**Implementation:**
+- Use clear, concise language (avoid jargon when possible)
+- Provide concrete examples from actual context
+- Use visual formatting (diff blocks, numbered choices, code blocks)
+- Show before/after comparisons
+- Structure complex information with headers and sections
+- Use analogies and metaphors when helpful
+
+**Formatting Guidelines:**
+- **Diff blocks:** Progress tracking and state changes
+- **Numbered lists:** Sequential steps or options
+- **Code blocks:** Technical details, file paths, commands
+- **Tables:** Comparisons and structured data
+- **Bold/Italic:** Emphasis and clarification
+- **Whitespace:** Separate concepts, reduce cognitive load
+
+### 6. Counterfactual Explanations
+
+**Purpose:** Show what would change outcomes
+
+**Implementation:**
+- Explain alternative approaches considered
+- Document why certain options were rejected
+- Provide "what if" scenarios
+- Help users understand tradeoffs
+- Show sensitivity to input changes
+
+**Counterfactual Format:**
+```
+Chosen Approach: Split protocol into 6 modules
+
+Alternative Considered: Compress existing protocol
+
+Why Rejected:
+- Compression saves only ~20% vs 67% for splitting
+- Doesn't address lazy loading opportunity
+- Still loads all content upfront
+- Harder to maintain compressed content
+
+What If Analysis:
+- If protocol was <1K tokens → Compression would be sufficient
+- If users needed all sections → Splitting would add overhead
+- If backward compatibility was critical → Compression safer
+```
+
+### 7. Reflection & Learning
+
+**Purpose:** Analyze outcomes to improve future performance
+
+**Implementation:**
+- Capture brilliant AI-generated suggestions
+- Document successful reasoning patterns
+- Learn from errors and edge cases
+- Build knowledge base of effective approaches
+- Identify patterns in successful vs unsuccessful interactions
+- Save "aha moments" and insights
+
+**Learning Capture Format:**
+```
+Insight: Protocol splitting pattern
+
+Context: agent-creation.md optimization
+
+What Worked:
+- Modular structure reduced token overhead by 67%
+- Lazy loading improved user experience
+- Maintenance became easier (edit one module)
+- Pattern applicable to other large protocols
+
+Pattern Identified:
+When protocol >2K tokens AND users only need one section at a time
+→ Split into modules with lazy loading
+
+Future Applications:
+- mode-management.md (similar structure)
+- agent-management.md (multiple workflows)
+- Any protocol with distinct, independent sections
+
+Confidence: High - Pattern validated through implementation
+```
+
+### 8. Self-Correction & Validation
+
+**Purpose:** Detect and fix errors autonomously
+
+**Implementation:**
+- Validate proposals against documentation
+- Check consistency and coherence
+- Identify conflicts and contradictions
+- Ensure logical soundness of recommendations
+- Cross-reference with verified sources
+- Test assumptions before proceeding
+
+**Validation Checklist:**
+```
+Before presenting recommendation:
+
+□ Verified against INSTALLED-ARCHITECTURE.md (or relevant docs)
+□ Checked for internal consistency
+□ Identified potential conflicts
+□ Validated assumptions
+□ Considered edge cases
+□ Estimated confidence level
+□ Documented limitations
+□ Prepared alternative options
+```
+
+### 9. Decision Conflict Resolution
+
+**Purpose:** Handle contradictory outputs transparently
+
+**Implementation:**
+- Explain priority hierarchies
+- Document conflict resolution logic
+- Show why certain decisions override others
+- Make precedence rules explicit
+- Provide rationale for resolution
+
+**Conflict Resolution Format:**
+```
+Conflict Detected:
+- Protocol A suggests: Load all content upfront
+- Protocol B suggests: Use lazy loading
+
+Priority Hierarchy:
+1. User Experience (reduce cognitive load)
+2. Token Efficiency (minimize context overhead)
+3. Backward Compatibility (don't break existing)
+4. Implementation Simplicity (easier to maintain)
+
+Resolution:
+Choose Protocol B (lazy loading)
+
+Rationale:
+- Aligns with priorities #1 and #2 (higher priority)
+- No backward compatibility issues (#3 satisfied)
+- Implementation complexity acceptable (#4 trade-off)
+
+Confidence: High - Clear priority alignment
+```
+
+## Implementation Guidelines
+
+### When to Apply Explainability
+
+**Always:**
+- Making recommendations or proposals
+- Handling errors or unexpected behavior
+- Dealing with ambiguous input
+- Making assumptions
+- Choosing between alternatives
+- Explaining complex concepts
+
+**Especially Important:**
+- High-stakes decisions (architectural changes, breaking changes)
+- Uncertain situations (incomplete information, ambiguous requirements)
+- Error debugging (understanding what went wrong)
+- Learning opportunities (capturing insights for future)
+
+### How to Apply Explainability
+
+1. **Before Acting:**
+   - Identify what needs explanation
+   - Determine appropriate transparency level
+   - Choose relevant mechanisms
+
+2. **During Execution:**
+   - Document reasoning as you go
+   - Make assumptions explicit
+   - Show decision points
+   - Quantify confidence
+
+3. **After Completion:**
+   - Validate explanations are clear
+   - Capture insights and patterns
+   - Document for future reference
+
+### Integration with Other Protocols
+
+**Chit-Chat Protocol:**
+- Use diff blocks for progress tracking
+- Use numbered choices for decision points
+- Maintain single focus per message
+- Apply STOP system for long explanations
+
+**Strict Mode:**
+- Increase explainability when STRICT_MODE = ON
+- Provide more detailed reasoning
+- Document all assumptions explicitly
+- Ask clarifying questions proactively
+
+**Agent Protocols:**
+- Apply agent-specific explainability patterns
+- Adapt transparency level to agent's domain
+- Use domain-appropriate examples
+- Maintain agent's interaction style
+
+## Explainability Patterns Library
+
+### Pattern 1: Command Flow Tracing
+
+**Use Case:** Explaining how commands execute
+
+**Template:**
+```
+Command: {user_input}
+
+Execution Flow:
+Step 1: {action}
+├─ {detail}
+├─ {detail}
+└─ {result}
+
+Step 2: {action}
+├─ {detail}
+└─ {result}
+
+...
+
+Result: {final_outcome}
+Files Loaded: {list}
+Context Impact: {token_estimate}
+```
+
+### Pattern 2: Protocol Loading Explanation
+
+**Use Case:** Explaining why protocols are loaded
+
+**Template:**
+```
+Protocol Loaded: {protocol_name}
+
+Trigger: {what_caused_loading}
+Purpose: {why_needed}
+Content: {what_it_provides}
+Token Impact: +{tokens}
+Alternative: {if_not_loaded}
+```
+
+### Pattern 3: Decision Justification
+
+**Use Case:** Explaining why certain improvements are proposed
+
+**Template:**
+```
+Recommendation: {proposal}
+Confidence: {level} ({percentage})
+
+Analysis:
+- Current State: {description}
+- Issues: {problems_identified}
+- Options: {alternatives_considered}
+- Tradeoffs: {pros_and_cons}
+
+Selected Approach: {chosen_option}
+Rationale: {why_chosen}
+Expected Impact: {benefits}
+Risks: {potential_issues}
+```
+
+### Pattern 4: Assumption Documentation
+
+**Use Case:** Making assumptions explicit
+
+**Template:**
+```
+Assumption: {what_is_assumed}
+Basis: {why_assuming}
+Confidence: {level}
+Impact if Wrong: {consequences}
+Validation: {how_to_verify}
+```
+
+### Pattern 5: Alternative Analysis
+
+**Use Case:** Showing options considered
+
+**Template:**
+```
+Options Considered:
+
+Option A: {description}
+├─ Pros: {benefits}
+├─ Cons: {drawbacks}
+└─ Confidence: {level}
+
+Option B: {description}
+├─ Pros: {benefits}
+├─ Cons: {drawbacks}
+└─ Confidence: {level}
+
+Selected: Option {X}
+Reason: {justification}
+```
+
+### Pattern 6: Error Context
+
+**Use Case:** Providing full context for errors
+
+**Template:**
+```
+Error: {error_message}
+
+Context:
+- What: {what_was_attempted}
+- Expected: {expected_outcome}
+- Actual: {actual_outcome}
+
+Root Cause: {why_it_failed}
+
+Recovery Options:
+1. {option_1} - {description}
+2. {option_2} - {description}
+3. {option_3} - {description}
+
+Recommendation: {best_option}
+Confidence: {level}
+```
+
+### Pattern 7: Impact Estimation
+
+**Use Case:** Quantifying expected benefits and costs
+
+**Template:**
+```
+Proposal: {change_description}
+
+Expected Impact:
+
+Benefits:
+- {benefit_1}: {quantification}
+- {benefit_2}: {quantification}
+- {benefit_3}: {quantification}
+
+Costs:
+- {cost_1}: {quantification}
+- {cost_2}: {quantification}
+
+Net Impact: {overall_assessment}
+Confidence: {level}
+Timeframe: {when_realized}
+```
+
+### Pattern 8: Conflict Resolution Transparency
+
+**Use Case:** Showing how precedence rules are applied
+
+**Template:**
+```
+Conflict: {description}
+
+Competing Options:
+- Option A: {description} (from {source})
+- Option B: {description} (from {source})
+
+Priority Rules:
+1. {rule_1}
+2. {rule_2}
+3. {rule_3}
+
+Resolution: {chosen_option}
+Rationale: {why_based_on_priorities}
+Confidence: {level}
+```
+
+### Pattern 9: Uncertainty Handling
+
+**Use Case:** Asking clarifying questions when ambiguous
+
+**Template:**
+```
+Ambiguity Detected: {what_is_unclear}
+
+Possible Interpretations:
+1. {interpretation_1}
+2. {interpretation_2}
+3. {interpretation_3}
+
+Clarifying Questions:
+1. {question_1}
+2. {question_2}
+
+Once clarified, I can: {what_will_do_next}
+```
+
+### Pattern 10: Insight Capture
+
+**Use Case:** Documenting brilliant suggestions
+
+**Template:**
+```
+Insight: {insight_title}
+
+Context: {when_discovered}
+
+Discovery:
+{what_was_learned}
+
+Pattern:
+{generalizable_pattern}
+
+Applications:
+- {use_case_1}
+- {use_case_2}
+- {use_case_3}
+
+Confidence: {level}
+Value: {why_important}
+```
+
+## Integration Instructions
+
+### For Agent Definitions
+
+Add to **Mandatory Protocols** section:
+
+```markdown
+### N. Explainability & Transparency
+
+**Rule:** Make all reasoning, decisions, and assumptions transparent
+
+**Rationale:** Users need to understand and trust AI decisions; transparent reasoning enables debugging and learning
+
+**Implementation:**
+/only-read-protocols explainability-protocol.md
+
+Apply transparency mechanisms from the protocol:
+- Document reasoning steps
+- Quantify confidence levels
+- Make assumptions explicit
+- Show alternatives considered
+- Provide error context
+- Capture insights
+```
+
+### For Steering Documents
+
+Reference when explainability is needed:
+
+```markdown
+For transparent decision-making, load explainability protocol:
+/only-read-protocols explainability-protocol.md
+```
+
+### For Workflows
+
+Integrate explainability steps:
+
+```markdown
+### Workflow: {Name}
+
+**Steps:**
+
+1. {Step 1}
+   - Apply explainability: Document reasoning
+   
+2. {Step 2}
+   - Apply explainability: Quantify confidence
+   
+3. {Step 3}
+   - Apply explainability: Show alternatives
+```
+
+## Success Metrics
+
+Explainability is successful when:
+
+- **Reasoning is transparent** - Users can follow decision paths
+- **Confidence is appropriate** - Certainty levels match actual reliability
+- **Errors are debuggable** - Users can understand and fix issues
+- **Assumptions are explicit** - No hidden assumptions or implicit logic
+- **Alternatives are explained** - Users understand why certain options were chosen
+- **Trust is built** - Users feel confident in AI recommendations
+- **Learning occurs** - Insights are captured and applied to future interactions
+
+## Notes
+
+- This protocol can be loaded on-demand when explainability is needed
+- Reduces token overhead by avoiding duplication across agents
+- Provides consistent explainability patterns across all agents
+- Can be updated once to improve all agents using it
+- Works alongside chit-chat, strict mode, and agent-specific protocols

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-agents",
-  "version": "1.12.0",
+  "version": "1.13.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": {