kiro-agents 1.0.1 → 1.1.0

package/README.md

@@ -14,13 +14,29 @@ kiro-agents is a steering document system that extends Kiro IDE with:
 
 ## Installation
 
+### Option 1: Global Installation (npm)
+
 ```bash
 npx kiro-agents
 # or
 bunx kiro-agents
 ```
 
-This installs steering documents to `~/.kiro/steering/` that enhance Kiro's AI capabilities.
+This installs steering documents to `~/.kiro/steering/` (global, available in all workspaces).
+
+### Option 2: Workspace Installation (Kiro Power)
+
+1. Open Kiro IDE
+2. Open Powers panel (Ghosty icon ⚡)
+3. Click "Add power from GitHub"
+4. Enter: `https://github.com/theadd/kiro-agents`
+5. Click Install
+
+This installs to `.kiro/powers/kiro-agents/` (workspace-specific).
+
+**Differences:**
+- **npm**: Global installation, available in all workspaces
+- **Power**: Workspace-specific, auto-updates, better Kiro integration
 
 ## Core Features
 
@@ -34,8 +50,8 @@ Create specialized AI agents for different tasks. Each agent has:
 - Integration with other agents
 
 **Commands:**
-- `/agents` - Interactive agent management (create, activate, manage agents)
-- `/agent {name}` - Activate specific agent directly
+- `/agents` - Interactive agent management (visual menu)
+- `/agents {name}` - Activate specific agent directly
 
 **Example workflow:**
 ```
@@ -68,9 +84,9 @@ Switch between interaction styles based on your needs:
 - Property-based testing focus
 
 **Commands:**
-- `/modes` - Interactive mode management
-- `/mode vibe` - Switch to flexible development
-- `/mode spec` - Switch to structured planning
+- `/modes` - Interactive mode management (visual menu)
+- `/modes vibe` - Switch to flexible development
+- `/modes spec` - Switch to structured planning
 
 ### Strict Mode
 
@@ -82,6 +98,7 @@ Precision mode for experimental or critical development:
 - Ideal for architectural decisions
 
 **Commands:**
+- `/strict` - Interactive control (visual buttons)
 - `/strict on` - Activate precision mode
 - `/strict off` - Return to normal mode
 
@@ -98,33 +115,59 @@ This design reduces decision fatigue and maintains context during long conversat
 
 ## How It Works
 
-kiro-agents installs markdown files to `~/.kiro/steering/` that Kiro loads as steering documents. These documents:
+kiro-agents provides steering documents that Kiro loads to enhance AI capabilities:
 
-1. Define new slash commands (`/agent`, `/mode`, `/strict`, etc.)
-2. Provide protocols for AI behavior
-3. Enable agent and mode systems
-4. Optimize interactions for reduced cognitive load
+**npm installation:**
+- Installs to `~/.kiro/steering/` (global)
+- Available in all workspaces
+- Manual updates via re-running npx/bunx
 
-The system adds minimal overhead to initial context while enabling progressive enhancement through agent creation.
+**Power installation:**
+- Installs to `.kiro/powers/kiro-agents/` (workspace)
+- Auto-updates from GitHub
+- Better integration with Kiro ecosystem
+- Keyword-based activation
+
+Both methods provide:
+1. New slash commands (`/agents`, `/modes`, `/strict`)
+2. Protocols for AI behavior
+3. Agent and mode systems
+4. Optimized interactions for reduced cognitive load
+
+The system adds minimal overhead while enabling progressive enhancement.
 
 ## File Structure After Installation
 
+**npm installation** (`~/.kiro/steering/`):
 ```
 ~/.kiro/steering/
-├── agent-system.md              # Core agent system
-├── modes-system.md              # Mode switching system
+├── agent-system.md
+├── modes-system.md
 └── agent-system/
-    ├── strict-mode.md           # Precision mode
-    ├── kiro-spec-mode.md        # Spec mode protocols
-    ├── kiro-vibe-mode.md        # Vibe mode protocols
+    ├── strict-mode.md
+    ├── kiro-spec-mode.md
+    ├── kiro-vibe-mode.md
     ├── interactions/
-    │   ├── chit-chat.md         # Interactive workflows
-    │   └── interaction-styles.md
     └── tools/
-        └── client-tools.md
 ```
 
-Files are set to read-only after installation to prevent accidental modifications.
+**Power installation** (`.kiro/powers/kiro-agents/`):
+```
+.kiro/powers/kiro-agents/
+├── POWER.md                     # Power metadata
+├── mcp.json                     # MCP server config (empty for now)
+└── steering/
+    ├── agent-system.md          # Core system (always loaded)
+    ├── agents.md                # Interactive menu (manual)
+    ├── modes-system.md          # Core system (always loaded)
+    ├── modes.md                 # Interactive menu (manual)
+    ├── strict-mode.md           # Core system (always loaded)
+    ├── strict.md                # Interactive control (manual)
+    ├── interactions/            # Interaction patterns
+    └── modes/                   # Mode definitions
+```
+
+npm files are read-only after installation. Power files managed by Kiro.
 
 ## Usage Examples
 

package/{bin → build/npm/bin}/cli.js

@@ -25,16 +25,18 @@ import { existsSync, chmodSync, constants } from "fs";
 import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
-var INSTALL_DIR = join(homedir(), ".kiro", "steering");
+var INSTALL_DIR = join(homedir(), ".kiro", "steering", "kiro-agents");
 var FILES_TO_INSTALL = [
   "agent-system.md",
   "modes-system.md",
-  "agent-system/strict-mode.md",
-  "agent-system/kiro-spec-mode.md",
-  "agent-system/kiro-vibe-mode.md",
-  "agent-system/interactions/chit-chat.md",
-  "agent-system/interactions/interaction-styles.md",
-  "agent-system/tools/client-tools.md"
+  "strict-mode.md",
+  "agents.md",
+  "modes.md",
+  "strict.md",
+  "interactions/chit-chat.md",
+  "interactions/interaction-styles.md",
+  "modes/kiro-spec-mode.md",
+  "modes/kiro-vibe-mode.md"
 ];
 async function setWritable(filePath) {
   try {
@@ -63,8 +65,14 @@ async function installFile(relativePath) {
   console.log(`✅ Installed: ${relativePath}`);
 }
 async function install() {
-  console.log(`\uD83D\uDCE6 Installing kiro-agents to ~/.kiro/steering/
+  console.log(`\uD83D\uDCE6 Installing kiro-agents to ~/.kiro/steering/kiro-agents/
 `);
+  if (existsSync(INSTALL_DIR)) {
+    console.log(`\uD83D\uDDD1️  Removing existing installation...
+`);
+    const { rmSync } = await import("fs");
+    rmSync(INSTALL_DIR, { recursive: true, force: true });
+  }
   for (const file of FILES_TO_INSTALL) {
     await installFile(file);
   }
@@ -74,6 +82,8 @@ async function install() {
 \uD83D\uDCC1 Files installed to: ${INSTALL_DIR}`);
   console.log(`
 \uD83D\uDCA1 Files are set to read-only. To modify them, change permissions first.`);
+  console.log(`
+\uD83D\uDD04 To update, simply run 'npx kiro-agents' again.`);
 }
 install().catch((error) => {
   console.error("❌ Installation failed:", error);

package/{dist → build/npm/dist}/agent-system.md

@@ -47,7 +47,7 @@ When processing instructions, if you encounter an XML structure `<alias>` with v
 ### Command 1: Activate Specific Agent
 
 <alias>
-  <trigger>/agent {agent_name}</trigger>
+  <trigger>/agents {agent_name}</trigger>
   <definition>
 ## Agent Activation: {agent_name}
 
@@ -100,148 +100,16 @@ Otherwise:
 
 ### Command 2: Interactive Agent Management
 
-<alias>
-  <trigger>/agents</trigger>
-  <definition>
-## Agent Management Mode
-
-You are now in **agent management mode** using chit-chat interaction protocol.
-
-### Step 1: Load Chit-Chat Mode
-
-Apply protocols from `chit-chat.md` steering document:
-- Use diff blocks to show progress
-- Provide numbered choice lists (4-6 options, up to 16 if needed)
-- Maintain single focus per message
-- Use visual formatting (bold, code blocks, lists)
-- Optimize for ADHD-C (minimal cognitive load)
-
-### Step 2: Auto-Setup and Scan Agents Directory
-
-**First, check if `.kiro/agents/` directory exists:**
+For interactive agent management, use the `/agents` slash command (without parameters).
+This provides a visual interface for:
+- Viewing all available agents
+- Creating new agents
+- Managing existing agents
+- Viewing agent details
 
-If directory doesn't exist OR directory is empty:
-1. Create `.kiro/agents/` directory if missing
-2. Create `kiro-master.md` agent automatically using the enhanced description from "Available Agents" section
-3. Show diff block indicating setup completion
-4. Continue to Step 3 with kiro-master as available agent
-
-If directory exists with agents:
-- List all available agents from `.kiro/agents/` directory
-- Find all `*.md` files
-- Extract agent names from filenames
-- Read frontmatter metadata for descriptions
-- Categorize by agent type if metadata available
-
-### Step 3: Present Agent Selection
-
-Use this response structure:
-
-```diff
-  👉 Agent management mode
-  ⏳ Agent selection or management
-```
-
-**Current Focus**: Agent selection and management
-
-**Available agents in `.kiro/agents/`:**
-
-[List each agent with format:]
-- **{agent-name}** - {description from frontmatter or .md}
-
-**What would you like to do?**
-
-1. **Activate agent** - Choose agent to activate immediately
-2. **Create new agent** - Start agent creation wizard
-3. **Manage existing agent** - Modify agent configuration
-4. **View agent details** - Show full agent definition
-5. **List all commands** - Show available slash commands
-6. **Agent system help** - Explain how agents work
-7. **Exit** - Return to normal mode
-
-### Step 4: Handle User Choice
-
-Based on user selection:
-
-**Option 1 - Activate agent:**
-- Show numbered list of available agents
-- User selects agent by number
-- Execute `/agent {selected_agent_name}` command
-- Agent activates immediately
-
-**Option 2 - Create new agent:**
-- Start agent creation workflow (similar to kiro-master)
-- Ask for agent type (code-focused, documentation, testing, etc.)
-- Collect agent name, description, capabilities
-- Generate `.md` file with all agent definition
-- Offer to activate new agent
-
-**Option 3 - Manage existing agent:**
-- Show numbered list of available agents
-- User selects agent to manage
-- Offer management options:
-  - Modify capabilities
-  - Update instructions
-  - Change interaction protocol
-  - Add/remove integrations
-  - Delete agent
-
-**Option 4 - View agent details:**
-- Show numbered list of available agents
-- User selects agent to view
-- Display full `.md` content with formatting
-- Show agent protocols and capabilities summary
-- Offer to activate or manage agent
-
-**Option 5 - List all commands:**
-- Show all available slash commands in the system
-- Display command syntax and brief description
-- Group by category (agents, modes, utilities)
-- Format as table for quick reference:
-
-```
-Available Commands:
-
-AGENT COMMANDS
-  /agent {name}     Activate specific agent
-  /agents           Interactive agent management
-
-MODE COMMANDS (see modes-system.md)
-  /mode {name}      Switch Kiro mode (vibe/spec)
-  /modes            Interactive mode management
-  /strict {state}   Control strict mode (on/off)
-
-Note: Commands are defined in steering documents.
-New commands can be added via Instruction Alias pattern.
-```
-
-**Option 6 - Agent system help:**
-- Explain agent system architecture
-- Show command usage examples
-- Describe agent file structure
-- Explain how to create custom agents
-- Document best practices
-
-**Option 7 - Exit:**
-- Confirm exit from agent management mode
-- Return to normal Kiro interaction
-- Preserve any changes made
-
-### Step 5: Maintain Chit-Chat Mode
-
-Continue using diff blocks and numbered choices throughout agent management session.
-
-After each action:
-- Update diff block with progress
-- Show current focus
-- Provide next action choices
-- Allow going back or canceling
-
----
-
-**Begin agent management mode now.**
-  </definition>
-</alias>
+**Usage:**
+- Interactive: `/agents` (no parameters, loads `agents.md` steering file)
+- Direct: `/agents {name}` (with agent name, uses alias above)
 
 ## Agent Activation Protocol
 
@@ -348,12 +216,13 @@ When `/agents` is executed:
 - Error Handling
 - Success Metrics
 
-## Available Agents
+## Initial Agent
+
+When auto-setup detects no agents exist, it creates the initial agent:
 
-Agents are discovered automatically from `.kiro/agents/` directory.
+**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
 
-**Current agents:**
-- **kiro-master** - Interactive Kiro feature management with CRUD operations for MCP servers, hooks, agents, specs, and steering documents. Includes .kiro/ directory maintenance, steering optimization, refactoring, and comprehensive analysis capabilities
+This description is used when creating `.kiro/agents/kiro-master.md` during auto-setup.
 
 ## Usage Examples
 

package/build/npm/dist/agents.md

@@ -0,0 +1,155 @@
+---
+inclusion: manual
+description: "Interactive agent management interface with visual menu for creating, activating, and managing AI agents"
+keywords: ["agents", "management", "create", "activate", "interactive"]
+---
+
+# Agent Management
+
+You are now in **agent management mode** using chit-chat interaction protocol.
+
+## Step 1: Load Chit-Chat Mode
+
+Apply protocols from `chit-chat.md` steering document:
+- Use diff blocks to show progress
+- Provide numbered choice lists (4-6 options, up to 16 if needed)
+- Maintain single focus per message
+- Use visual formatting (bold, code blocks, lists)
+- Optimize for ADHD-C (minimal cognitive load)
+
+## Step 2: Auto-Setup and Scan Agents Directory
+
+**CRITICAL: You MUST execute `listDirectory` tool on `.kiro/agents/` to get the actual list of agents.**
+
+**DO NOT rely on open editor files or context - always scan the directory explicitly.**
+
+**First, execute `listDirectory` on `.kiro/agents/`:**
+
+If directory doesn't exist OR directory is empty:
+1. Create `.kiro/agents/kiro-master.md` agent automatically using the description from "Initial Agent" section
+2. Show diff block indicating setup completion
+3. Continue to Step 3 with kiro-master as available agent
+
+If directory exists with agents:
+1. **Execute `listDirectory` tool** to get complete list of `.md` files
+2. Extract agent names from filenames (remove `.md` extension)
+3. Read frontmatter metadata for descriptions
+4. Categorize by agent type if metadata available
+5. **List ALL agents found** - do not filter or assume based on context
+
+## Step 3: Present Agent Selection
+
+Use this response structure:
+
+```diff
+  👉 Agent management mode
+  ⏳ Agent selection or management
+```
+
+**Current Focus**: Agent selection and management
+
+**Available agents in `.kiro/agents/`:**
+
+[List each agent with format:]
+- **{agent-name}** - {description from frontmatter or .md}
+
+**What would you like to do?**
+
+1. **Activate agent** - Choose agent to activate immediately
+2. **Create new agent** - Start agent creation wizard
+3. **Manage existing agent** - Modify agent configuration
+4. **View agent details** - Show full agent definition
+5. **List all commands** - Show available slash commands
+6. **Agent system help** - Explain how agents work
+7. **Exit** - Return to normal mode
+
+## Step 4: Handle User Choice
+
+Based on user selection:
+
+**Option 1 - Activate agent:**
+- Show numbered list of available agents
+- User selects agent by number
+- Execute `/agents {selected_agent_name}` command
+- Agent activates immediately
+
+**Option 2 - Create new agent:**
+- Start agent creation workflow
+- Ask for agent type (code-focused, documentation, testing, etc.)
+- Collect agent name, description, capabilities
+- Generate `.md` file with all agent definition
+- Offer to activate new agent
+
+**Option 3 - Manage existing agent:**
+- Show numbered list of available agents
+- User selects agent to manage
+- Offer management options:
+  - Modify capabilities
+  - Update instructions
+  - Change interaction protocol
+  - Add/remove integrations
+  - Delete agent
+
+**Option 4 - View agent details:**
+- Show numbered list of available agents
+- User selects agent to view
+- Display full `.md` content with formatting
+- Show agent protocols and capabilities summary
+- Offer to activate or manage agent
+
+**Option 5 - List all commands:**
+- Show all available slash commands in the system
+- Display command syntax and brief description
+- Group by category (agents, modes, utilities)
+- Format as table for quick reference:
+
+```
+Available Commands:
+
+AGENT COMMANDS
+  /agents {name}    Activate specific agent
+  /agents           Interactive agent management
+
+MODE COMMANDS (see modes-system.md)
+  /modes {name}     Switch Kiro mode (vibe/spec)
+  /modes            Interactive mode management
+  /strict {state}   Control strict mode (on/off)
+  /strict           Interactive strict mode control
+
+Note: Commands are defined in steering documents.
+New commands can be added via Instruction Alias pattern.
+```
+
+**Option 6 - Agent system help:**
+- Explain agent system architecture
+- Show command usage examples
+- Describe agent file structure
+- Explain how to create custom agents
+- Document best practices
+
+**Option 7 - Exit:**
+- Confirm exit from agent management mode
+- Return to normal Kiro interaction
+- Preserve any changes made
+
+## Step 5: Maintain Chit-Chat Mode
+
+Continue using diff blocks and numbered choices throughout agent management session.
+
+After each action:
+- Update diff block with progress
+- Show current focus
+- Provide next action choices
+- Allow going back or canceling
+
+## Initial Agent
+
+When auto-setup detects no agents exist, create the initial agent:
+
+**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
+
+This description is used when creating `.kiro/agents/kiro-master.md` during auto-setup.
+
+---
+
+**Begin agent management mode now.**

package/{dist → build/npm/dist}/modes-system.md

@@ -17,7 +17,7 @@ Mode switching system for Kiro that enables different interaction styles and wor
 ### Command 1: Switch Kiro Mode
 
 <alias>
-  <trigger>/mode {mode_name}</trigger>
+  <trigger>/modes {mode_name}</trigger>
   <definition>
 ## Mode Switch: {mode_name}
 
@@ -106,106 +106,16 @@ Start interaction according to **{mode_name} mode**'s protocols.
 
 ### Command 2: Interactive Mode Management
 
-<alias>
-  <trigger>/modes</trigger>
-  <definition>
-## Mode Management
-
-You are now in **mode management** using chit-chat interaction protocol.
-
-### Step 1: Load Chit-Chat Mode
-
-Apply protocols from `chit-chat.md` steering document:
-- Use diff blocks to show progress
-- Provide numbered choice lists (4-6 options)
-- Maintain single focus per message
-- Use visual formatting (bold, code blocks, lists)
-
-### Step 2: Detect Available Modes
-
-Scan agent-system directory for `kiro-*-mode.md` files:
-- Extract mode names from filenames
-- Read frontmatter for descriptions
-- Identify current mode from context
-
-### Step 3: Present Mode Selection
-
-Use this response structure:
-
-```diff
-  👉 Mode management
-  ⏳ Mode selection
-```
-
-**Current mode:** [current_mode]
-
-**Available Kiro modes:**
-
-- **vibe** - Flexible, conversational development assistance
-- **spec** - Structured feature development with requirements, design, and tasks
-
-**What would you like to do?**
+For interactive mode management, use the `/modes` slash command (without parameters).
+This provides a visual interface for:
+- Viewing available modes
+- Comparing modes
+- Switching modes
+- Getting help
 
-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
-
-### Step 4: Handle User Choice
-
-Based on user selection:
-
-**Option 1 - Switch to vibe:**
-- Execute `/mode vibe` command
-- Load vibe mode protocols
-- Begin flexible interaction
-
-**Option 2 - Switch to spec:**
-- Execute `/mode spec` command
-- Load spec mode protocols
-- Begin structured workflow
-
-**Option 3 - View mode details:**
-- Show numbered list of modes
-- User selects mode to view
-- Display full mode definition
-- Explain capabilities and use cases
-- Offer to switch to that mode
-
-**Option 4 - Mode comparison:**
-- Show side-by-side comparison
-- Explain when to use each mode
-- Highlight key differences
-- Help user choose appropriate mode
-
-**Option 5 - Stay in current mode:**
-- Confirm staying in current mode
-- Return to normal interaction
-- Preserve current state
-
-**Option 6 - Help:**
-- Explain mode system
-- Show switching commands
-- Describe mode benefits
-- Provide usage examples
-
-### Step 5: Maintain Chit-Chat Mode
-
-Continue using diff blocks and numbered choices throughout mode management.
-
-After each action:
-- Update diff block with progress
-- Show current focus
-- Provide next action choices
-- Allow going back or canceling
-
----
-
-**Begin mode management now.**
-  </definition>
-</alias>
+**Usage:**
+- Interactive: `/modes` (no parameters, loads `modes.md` steering file)
+- Direct: `/modes {name}` (with mode name, uses alias above)
 
 ## Mode Activation Protocol
 

package/build/npm/dist/modes.md

@@ -0,0 +1,101 @@
+---
+inclusion: manual
+description: "Interactive mode management interface for switching between vibe and spec interaction styles"
+keywords: ["modes", "vibe", "spec", "workflow", "interactive"]
+---
+
+# Mode Management
+
+You are now in **mode management** using chit-chat interaction protocol.
+
+## Step 1: Load Chit-Chat Mode
+
+Apply protocols from `chit-chat.md` steering document:
+- Use diff blocks to show progress
+- Provide numbered choice lists (4-6 options)
+- Maintain single focus per message
+- Use visual formatting (bold, code blocks, lists)
+
+## Step 2: Detect Available Modes
+
+Scan agent-system directory for `kiro-*-mode.md` files:
+- Extract mode names from filenames
+- Read frontmatter for descriptions
+- Identify current mode from context
+
+## Step 3: Present Mode Selection
+
+Use this response structure:
+
+```diff
+  👉 Mode management
+  ⏳ Mode selection
+```
+
+**Current mode:** [current_mode]
+
+**Available Kiro modes:**
+
+- **vibe** - Flexible, conversational development assistance
+- **spec** - Structured feature development with requirements, design, and tasks
+
+**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
+
+## Step 4: Handle User Choice
+
+Based on user selection:
+
+**Option 1 - Switch to vibe:**
+- Execute `/modes vibe` command
+- Load vibe mode protocols
+- Begin flexible interaction
+
+**Option 2 - Switch to spec:**
+- Execute `/modes spec` command
+- Load spec mode protocols
+- Begin structured workflow
+
+**Option 3 - View mode details:**
+- Show numbered list of modes
+- User selects mode to view
+- Display full mode definition
+- Explain capabilities and use cases
+- Offer to switch to that mode
+
+**Option 4 - Mode comparison:**
+- Show side-by-side comparison
+- Explain when to use each mode
+- Highlight key differences
+- Help user choose appropriate mode
+
+**Option 5 - Stay in current mode:**
+- Confirm staying in current mode
+- Return to normal interaction
+- Preserve current state
+
+**Option 6 - Help:**
+- Explain mode system
+- Show switching commands
+- Describe mode benefits
+- Provide usage examples
+
+## Step 5: Maintain Chit-Chat Mode
+
+Continue using diff blocks and numbered choices throughout mode management.
+
+After each action:
+- Update diff block with progress
+- Show current focus
+- Provide next action choices
+- Allow going back or canceling
+
+---
+
+**Begin mode management now.**

package/{dist/agent-system → build/npm/dist}/strict-mode.md

@@ -46,7 +46,9 @@ This serves dual purpose:
 - File locations not specified
 - Breaking changes implications
 
-## Activation Command
+## Activation Commands
+
+### Command 1: Direct State Change
 
 <alias>
   <trigger>/strict {state}</trigger>
@@ -57,6 +59,18 @@ State changed. Response Protocol now applies.
   </definition>
 </alias>
 
+### Command 2: Interactive Control
+
+For interactive strict mode control, use the `/strict` slash command (without parameters).
+This provides a visual interface with buttons to:
+- Enable strict mode
+- Disable strict mode
+- Learn more about strict mode
+
+**Usage:**
+- Interactive: `/strict` (no parameters, loads `strict.md` steering file with userInput buttons)
+- Direct: `/strict on` or `/strict off` (with state)
+
 ## Use Case Guidelines
 
 ### When to Activate STRICT_MODE

package/build/npm/dist/strict.md

@@ -0,0 +1,109 @@
+---
+inclusion: manual
+description: "Interactive strict mode control with visual buttons for enabling/disabling precision mode"
+keywords: ["strict", "precision", "mode", "control"]
+---
+
+# Strict Mode Control
+
+Interactive control for STRICT_MODE using userInput tool.
+
+## Current State Check
+
+First, determine the current STRICT_MODE state from context.
+
+## Present Interactive Options
+
+Use userInput tool to show interactive buttons:
+
+```typescript
+userInput({
+  question: `# Strict Mode Control
+
+**Current State**: STRICT_MODE = ${current_state}
+
+Strict mode blocks execution on ambiguous input and requires explicit clarification. Use it for:
+- Experimental projects with cutting-edge technologies
+- Architectural decisions that propagate throughout codebase
+- Breaking changes affecting multiple files/systems
+- New component creation establishing patterns
+- Debugging propagated errors from incorrect assumptions
+
+**What would you like to do?**`,
+  options: [
+    {
+      title: "🟢 Enable Strict Mode",
+      description: "Activate precision mode - blocks execution on ambiguous input, requires explicit clarification",
+      recommended: current_state === "OFF"
+    },
+    {
+      title: "🔴 Disable Strict Mode",
+      description: "Return to normal mode - allows reasonable assumptions, faster iteration",
+      recommended: current_state === "ON"
+    },
+    {
+      title: "ℹ️ Learn More",
+      description: "Understand when and how to use strict mode effectively"
+    },
+    {
+      title: "📊 Check Current State",
+      description: "Show current strict mode configuration and status"
+    }
+  ],
+  reason: "strict-mode-control"
+})
+```
+
+## Handle User Selection
+
+Based on user's choice:
+
+**Enable Strict Mode:**
+- Set STRICT_MODE = ON
+- Confirm activation
+- Show brief reminder of strict mode rules
+- Return to conversation with strict mode active
+
+**Disable Strict Mode:**
+- Set STRICT_MODE = OFF
+- Confirm deactivation
+- Return to normal conversation mode
+
+**Learn More:**
+- Explain strict mode purpose and benefits
+- Show examples of when to use it
+- Describe the critical rules (no assumptions, mandatory clarification, block execution)
+- Provide use case guidelines
+- Offer to enable/disable after explanation
+
+**Check Current State:**
+- Display current STRICT_MODE value
+- Show when it was last changed (if tracked)
+- Explain current behavior
+- Offer to change state
+
+## Quick Reference
+
+**Strict Mode Rules (when ON)**:
+1. **NO ASSUMPTIONS** - Stop immediately if input is ambiguous
+2. **MANDATORY CLARIFICATION** - Ask specific questions to resolve ambiguities
+3. **BLOCK EXECUTION** - Do not execute main task until data is confirmed
+4. **EXPLICIT AUTHORIZATION ONLY** - Proceed only with user confirmation
+
+**When to Use**:
+- Experimental/cutting-edge projects
+- Architectural decisions
+- Breaking changes
+- New component patterns
+- Debugging propagated errors
+
+**When Standard Mode is Fine**:
+- Well-established patterns
+- Simple, clear tasks
+- Documentation work
+- Standard refactoring
+- Common web development patterns
+
+---
+
+**Strict mode control ready.**

package/package.json

@@ -1,19 +1,24 @@
 {
   "name": "kiro-agents",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "AI agent system for Kiro IDE",
   "type": "module",
   "bin": {
-    "kiro-agents": "./bin/cli.js"
+    "kiro-agents": "build/npm/bin/cli.js"
   },
   "files": [
-    "bin",
-    "dist"
+    "build/npm/bin",
+    "build/npm/dist"
   ],
   "scripts": {
-    "build": "bun run scripts/build.ts",
-    "watch": "bun run scripts/build.ts --watch",
-    "clean": "bun run scripts/clean.ts"
+    "build": "bun run scripts/build.ts npm",
+    "build:power": "bun run scripts/build.ts power",
+    "dev": "bun run scripts/build.ts dev",
+    "test": "bun run scripts/test.ts",
+    "clean": "bun run scripts/clean.ts",
+    "snapshot": "bun run scripts/snapshot.ts",
+    "finalize": "bun run scripts/finalize.ts",
+    "release": "bun run scripts/release.ts"
   },
   "keywords": [
     "kiro",
@@ -22,6 +27,7 @@
   "author": "R. Beltran",
   "license": "MIT",
   "devDependencies": {
+    "@changesets/cli": "^2.29.8",
     "@types/bun": "latest"
   },
   "peerDependencies": {

package/bin/cli.ts

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { existsSync, chmodSync, constants } from "fs";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const INSTALL_DIR = join(homedir(), ".kiro", "steering");
-
-// Files to install (relative to dist/ in package)
-const FILES_TO_INSTALL = [
-  "agent-system.md",
-  "modes-system.md",
-  "agent-system/strict-mode.md",
-  "agent-system/kiro-spec-mode.md",
-  "agent-system/kiro-vibe-mode.md",
-  "agent-system/interactions/chit-chat.md",
-  "agent-system/interactions/interaction-styles.md",
-  "agent-system/tools/client-tools.md",
-] as const;
-
-async function setWritable(filePath: string): Promise<void> {
-  try {
-    chmodSync(filePath, constants.S_IRUSR | constants.S_IWUSR | constants.S_IRGRP | constants.S_IROTH);
-  } catch (error) {
-    // Ignore errors if file doesn't exist
-  }
-}
-
-async function setReadOnly(filePath: string): Promise<void> {
-  try {
-    chmodSync(filePath, constants.S_IRUSR | constants.S_IRGRP | constants.S_IROTH);
-  } catch (error) {
-    console.warn(`⚠️  Could not set read-only: ${filePath}`);
-  }
-}
-
-async function installFile(relativePath: string): Promise<void> {
-  const destPath = join(INSTALL_DIR, relativePath);
-  
-  // Restore write permissions if file exists
-  if (existsSync(destPath)) {
-    await setWritable(destPath);
-  }
-  
-  // Get source file from package dist/
-  const srcPath = join(__dirname, "..", "dist", relativePath);
-  
-  // Read file using fs for Node.js compatibility
-  const { readFile, writeFile, mkdir } = await import("fs/promises");
-  const content = await readFile(srcPath);
-  
-  // Ensure directory exists
-  const destDir = dirname(destPath);
-  await mkdir(destDir, { recursive: true });
-  
-  // Write file
-  await writeFile(destPath, content);
-  
-  // Set read-only
-  await setReadOnly(destPath);
-  
-  console.log(`✅ Installed: ${relativePath}`);
-}
-
-async function install(): Promise<void> {
-  console.log("📦 Installing kiro-agents to ~/.kiro/steering/\n");
-  
-  // Install all files
-  for (const file of FILES_TO_INSTALL) {
-    await installFile(file);
-  }
-  
-  console.log("\n✨ Installation completed successfully!");
-  console.log(`\n📁 Files installed to: ${INSTALL_DIR}`);
-  console.log("\n💡 Files are set to read-only. To modify them, change permissions first.");
-}
-
-// Main execution
-install().catch((error) => {
-  console.error("❌ Installation failed:", error);
-  process.exit(1);
-});

package/dist/agent-system/tools/client-tools.md

@@ -1,21 +0,0 @@
----
-inclusion: manual
----
-
-# Client Tools
-
-## userInput Tool
-
-```typescript
-userInput({
-  question: "# Markdown works here! 🚀",
-  options: [
-    {
-      title: "🎯 Emoji + text only",  // NO markdown
-      description: "## Full markdown here!",  // YES markdown
-      recommended: true
-    }
-  ],
-  reason: "fix-pbt"  // REQUIRED
-})
-```