kiro-spec-engine 1.3.0 → 1.4.1

package/README.md

@@ -1,470 +1,327 @@
-# kiro-spec-engine
+# kse - Kiro Spec Engine
 
 [![npm version](https://badge.fury.io/js/kiro-spec-engine.svg)](https://badge.fury.io/js/kiro-spec-engine)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-**Kiro Spec Engine** - A spec-driven rules engine with quality enhancement powered by Ultrawork spirit.
-
-> 🔥 Transform your development workflow with structured specs, steering rules, and relentless quality pursuit.
+**A context provider for AI coding tools** - Structure your project requirements, design, and tasks so AI assistants can help you build better software.
 
 English | [简体中文](README.zh.md)
 
-## 🎯 What is Kiro Spec Engine?
-
-Kiro Spec Engine (KSE) is a **spec-driven rules engine** that brings structure, quality, and the **Ultrawork spirit** to your development process. It's not just a tool—it's a methodology for building software with clarity and excellence.
-
-### Core Concept: Spec-Driven Rules Engine
-
-At its heart, KSE is a **rules engine** that operates on **specs**:
-
-- **Specs** define what you want to build (Requirements → Design → Tasks)
-- **Steering rules** guide how AI assistants should help you build it
-- **Ultrawork spirit** ensures professional-grade quality at every stage
-
-### Key Features
+---
 
-- ✅ **Spec-Driven Development**: Structured Requirements → Design → Tasks workflow
-- ✅ **Steering Rules System**: Control AI behavior with project-specific rules
-- ✅ **Multi-User Collaboration**: Personal workspaces, task claiming, team coordination
-- ✅ **Cross-Tool Compatibility**: Export context for Claude Code, Cursor, Codex, etc.
-- ✅ **Watch Mode Automation**: Automatic file monitoring and workflow execution
-- ✅ **Manual Workflows**: Step-by-step guides for common tasks
-- ✅ **Tool Detection**: Auto-detect IDE and suggest appropriate automation
-- ✅ **Quality Assessment**: Automatic document quality scoring (0-10 scale)
-- ✅ **Intelligent Enhancement**: Auto-identify and apply improvements with Ultrawork
-- ✅ **Professional Standards**: Ensure production-ready documentation
-- ✅ **Multi-language Support**: English and Chinese interfaces
-- ✅ **CLI Interface**: Easy-to-use command-line tools
+## What is kse?
 
-## 🚀 Quick Start
+**kse (Kiro Spec Engine) is a context management system for AI-assisted development.** It helps you organize project information into structured "Specs" (Requirements → Design → Tasks) that AI tools can understand and use effectively.
 
-### Installation
+Think of kse as a **librarian for your AI assistant** - it organizes and presents project context so your AI tool knows exactly what you're building, why, and how.
 
-Install globally via npm:
+### How it Works
 
-```bash
-npm install -g kiro-spec-engine
+```mermaid
+graph LR
+    A[You create Specs] --> B[kse organizes context]
+    B --> C[AI tool reads context]
+    C --> D[AI generates better code]
 ```
 
-Or use the short alias:
+1. **You create Specs** - Write requirements, design, and tasks in structured markdown files
+2. **kse organizes context** - Exports formatted context optimized for AI tools
+3. **AI tool reads context** - Your AI assistant understands your project structure
+4. **AI generates better code** - Code that matches your design and requirements
 
-```bash
-npm install -g kiro-spec-engine
-# Creates both 'kiro-spec-engine' and 'kse' commands
-```
+### What kse is NOT
 
-### Initialize a Project
+- ❌ **Not a code generator** - kse doesn't write code; your AI tool does
+- ❌ **Not an IDE** - kse works alongside your existing development tools
+- ❌ **Not AI-specific** - Works with Claude, Cursor, Windsurf, Copilot, and any AI tool
+- ❌ **Not a replacement for documentation** - It's a structured way to organize project context
 
-```bash
-# Initialize in current directory
-kiro-spec-engine init
+### Who Should Use kse?
 
-# Or specify project name
-kiro-spec-engine init "My Awesome Project"
+- ✅ Developers using AI coding assistants (Claude, Cursor, Copilot, etc.)
+- ✅ Teams wanting structured project documentation
+- ✅ Anyone building features that need clear requirements and design
+- ✅ Projects that benefit from spec-driven development
 
-# Use Chinese interface
-kiro-spec-engine --lang zh init
+---
 
-# Use short alias
-kse init
-```
+## Quick Start (5 Minutes)
 
-### Create and Enhance Your First Spec
+### Step 1: Install kse (30 seconds)
 
 ```bash
-# Create a new spec
-kse create-spec 01-00-user-authentication
-
-# Write your basic requirements.md file
-# Then enhance it with Ultrawork
-kse enhance requirements .kiro/specs/01-00-user-authentication/requirements.md
+npm install -g kiro-spec-engine
 ```
 
-## 📋 Commands
-
-### Project Management
-
+Verify installation:
 ```bash
-# Initialize project
-kse init [project-name]
-
-# Adopt existing project
-kse adopt                    # Interactive adoption
-kse adopt --auto             # Skip confirmations
-kse adopt --dry-run          # Show what would change
-kse adopt --mode fresh       # Force specific mode
-
-# Upgrade project version
-kse upgrade                  # Interactive upgrade
-kse upgrade --auto           # Skip confirmations
-kse upgrade --dry-run        # Show upgrade plan
-kse upgrade --to 1.2.0       # Upgrade to specific version
-
-# Rollback to previous state
-kse rollback                 # Interactive rollback
-kse rollback --auto          # Skip confirmations
-kse rollback --backup <id>   # Restore specific backup
-
-# Check project status
-kse status
-
-# Create new spec
-kse create-spec <spec-name>
-
-# System diagnostics
-kse doctor
-
-# Set language
-kse --lang zh <command>  # Chinese
-kse --lang en <command>  # English (default)
+kse --version
 ```
 
-### Multi-User Collaboration
+### Step 2: Adopt kse in Your Project (1 minute)
 
-```bash
-# Initialize personal workspace
-kse workspace init
-kse workspace init --user=alice
-
-# Synchronize workspace with team
-kse workspace sync
-
-# List all workspaces
-kse workspace list
-
-# Claim a task
-kse task claim <spec-name> <task-id>
-kse task claim 01-00-user-auth 1.1 --force
-
-# Unclaim a task
-kse task unclaim <spec-name> <task-id>
-
-# List claimed tasks
-kse task list <spec-name>
-```
-
-### Cross-Tool Support
+Navigate to your project directory and run:
 
 ```bash
-# Export spec context for AI tools
-kse context export <spec-name>
-kse context export 01-00-user-auth --steering --steering-files=CORE_PRINCIPLES.md
-
-# Generate task-specific prompt
-kse prompt generate <spec-name> <task-id>
-kse prompt generate 01-00-user-auth 1.1 --tool=claude-code
-kse prompt generate 01-00-user-auth 1.2 --tool=cursor --max-length=5000
+cd your-project
+kse adopt
 ```
 
-### Watch Mode (Automation)
+This creates a `.kiro/` directory with:
+- `specs/` - Where your Specs live
+- `steering/` - Rules for AI behavior (optional)
+
+### Step 3: Create Your First Spec (2 minutes)
 
 ```bash
-# Initialize watch configuration
-kse watch init
-kse watch init --force  # Overwrite existing config
-
-# Start watch mode
-kse watch start
-kse watch start --config custom-config.json
-kse watch start --patterns "**/*.md,**/*.js"
-
-# Stop watch mode
-kse watch stop
-
-# Check watch mode status
-kse watch status
-
-# View execution logs
-kse watch logs
-kse watch logs --tail 100
-kse watch logs --follow
-
-# View automation metrics
-kse watch metrics
-kse watch metrics --format json
-
-# List available presets
-kse watch presets
-
-# Install a preset
-kse watch install auto-sync
-kse watch install prompt-regen
-kse watch install context-export
-kse watch install test-runner
+kse create-spec 01-00-user-login
 ```
 
-### Manual Workflows
+This creates three files in `.kiro/specs/01-00-user-login/`:
 
-```bash
-# List available workflows
-kse workflows
-
-# Show workflow details
-kse workflows show task-sync
-kse workflows show context-export
-kse workflows show prompt-generation
+**requirements.md** - What you're building:
+```markdown
+# User Login Feature
 
-# Open full workflows guide
-kse workflows guide
+## User Stories
+- As a user, I want to log in with email and password
+- As a user, I want to see an error if credentials are wrong
 
-# Mark workflow as complete
-kse workflows complete task-sync
+## Acceptance Criteria
+- WHEN user enters valid credentials THEN they are logged in
+- WHEN user enters invalid credentials THEN they see an error message
 ```
 
-### Document Enhancement
+**design.md** - How you'll build it:
+```markdown
+# Design
 
-```bash
-# Enhance requirements document
-kse enhance requirements <file>
+## API Design
+- POST /api/auth/login
+- Request: { email: string, password: string }
+- Response: { token: string } or { error: string }
 
-# Enhance design document (requires requirements file)
-kse enhance design <design-file> --requirements <requirements-file>
-
-# Check tasks completion
-kse enhance tasks <tasks-file>
+## Components
+- AuthController - handles login logic
+- validateEmail() - validates email format
+- validatePassword() - checks password requirements
 ```
 
-### Examples
-
-```bash
-# Full workflow example
-kse init "E-commerce Platform"
-kse create-spec 01-00-user-auth
-# Edit .kiro/specs/01-00-user-auth/requirements.md
-kse enhance requirements .kiro/specs/01-00-user-auth/requirements.md
-# Edit .kiro/specs/01-00-user-auth/design.md  
-kse enhance design .kiro/specs/01-00-user-auth/design.md --requirements .kiro/specs/01-00-user-auth/requirements.md
+**tasks.md** - Step-by-step implementation:
+```markdown
+- [ ] 1.1 Create AuthController class
+- [ ] 1.2 Implement email validation
+- [ ] 1.3 Implement password validation
+- [ ] 1.4 Implement login endpoint
+- [ ] 1.5 Write unit tests
 ```
 
-## 📊 Quality Standards
-
-### Requirements Stage (0-10 scoring)
-- **Basic Structure** (2pts): Overview, user stories, functional requirements, non-functional requirements
-- **EARS Format** (2pts): WHEN...THEN acceptance criteria
-- **User Stories** (2pts): "As a...I want...So that" format
-- **Acceptance Criteria** (2pts): Complete acceptance criteria definitions
-- **Non-functional Requirements** (1pt): Performance, security, usability, etc.
-- **Constraints** (1pt): Technical constraints, resource constraints, etc.
+### Step 4: Let Your AI Tool Use the Spec (1 minute)
 
-### Design Stage (0-10 scoring)
-- **Basic Structure** (2pts): System overview, architecture design, component design, interface design
-- **Requirements Traceability** (2pts): Bidirectional traceability from requirements to design
-- **Architecture Diagrams** (1.5pts): Mermaid diagrams or other design diagrams
-- **Technology Selection** (1.5pts): Technology stack choices and rationale
-- **Non-functional Design** (1.5pts): Performance design, security design, scalability
-- **Interface Definition** (1.5pts): API design, data structure definitions
+Now your AI tool can access the Spec to generate better code.
 
-### Tasks Stage
-- **Completion Analysis**: Statistics on completed, in-progress, not-started tasks
-- **Priority Identification**: Identify priorities based on keywords and task numbers
-- **Ultrawork Motivation**: Provide Sisyphus spirit motivation and suggestions
-- **Next Steps Guidance**: Suggest specific execution strategies
+**For AI tools with command execution (Cursor, Windsurf, Claude Desktop):**
 
-## 🔄 Project Adoption and Upgrade
+Just tell your AI:
+```
+"I have a Spec at 01-00-user-login. Please implement task 1.1"
+```
 
-### Adopting Existing Projects
+The AI will:
+1. Execute `kse context export 01-00-user-login`
+2. Read the Spec (requirements, design, tasks)
+3. Generate code that follows your design
+4. Update task status automatically
 
-KSE can intelligently adopt existing projects with three modes:
+**For web-based AI tools (ChatGPT, Claude web):**
 
-**Fresh Adoption** (no `.kiro/` directory):
 ```bash
-kse adopt
-# Creates complete .kiro/ structure from scratch
-```
+# Export context once
+kse context export 01-00-user-login
 
-**Partial Adoption** (`.kiro/` exists but incomplete):
-```bash
-kse adopt
-# Preserves existing specs/ and steering/
-# Adds missing components
-```
+# Copy to clipboard
+cat .kiro/specs/01-00-user-login/context-export.md | pbcopy  # macOS
+type .kiro\specs\01-00-user-login\context-export.md | clip  # Windows
 
-**Full Adoption** (complete `.kiro/` from older version):
-```bash
-kse adopt
-# Upgrades components to current version
-# Preserves all user content
-# Creates backup before changes
+# Paste into AI tool and say:
+"Here's my Spec. Please implement task 1.1"
 ```
 
-### Upgrading to New Versions
+**The key insight:** You stay in your AI tool. The AI reads the Spec and generates code that matches your design.
 
-When a new version of KSE is released:
+### Step 5: Next Steps (30 seconds)
 
-```bash
-# Check current version
-kse --version
+- 📖 Read the [Quick Start Guide](docs/quick-start.md) for detailed examples
+- 🔧 Check your tool's integration guide: [Cursor](docs/tools/cursor-guide.md) | [Claude](docs/tools/claude-guide.md) | [Windsurf](docs/tools/windsurf-guide.md)
+- 💡 Learn about [Integration Modes](docs/integration-modes.md)
 
-# Upgrade to latest version
-kse upgrade
+---
 
-# Upgrade to specific version
-kse upgrade --to 1.2.0
+## Core Concepts
 
-# Preview upgrade plan
-kse upgrade --dry-run
-```
+### Specs
 
-**Incremental Upgrades**: KSE automatically handles version gaps by upgrading through intermediate versions (e.g., 1.0.0 → 1.1.0 → 1.2.0).
+A **Spec** is a structured description of a feature or project component. Each Spec contains:
 
-### Rollback and Safety
+- **Requirements** (`requirements.md`) - What you're building and why
+- **Design** (`design.md`) - How you'll build it (architecture, APIs, components)
+- **Tasks** (`tasks.md`) - Step-by-step implementation checklist
 
-All destructive operations create automatic backups:
+### Context Export
 
-```bash
-# List available backups
-kse rollback
-
-# Restore from specific backup
-kse rollback --backup adopt-2026-01-23-100000
+**Context export** transforms your Spec into a format optimized for AI tools. It includes:
+- All requirements, design decisions, and tasks
+- Project structure and conventions
+- Steering rules (optional) for AI behavior
 
-# Quick rollback (interactive)
-kse rollback
-```
+### Integration Modes
 
-**Safety Features**:
-- ✅ Automatic backup before adoption/upgrade
-- ✅ Backup validation and integrity checking
-- ✅ Easy rollback to previous states
-- ✅ Dry-run mode to preview changes
+kse supports three ways to work with AI tools:
 
-## 🤖 Automation and Workflows
+1. **Native Integration** - AI tool directly accesses kse (Kiro IDE)
+2. **Manual Export** - You export and paste context (Claude, ChatGPT, Cursor)
+3. **Watch Mode** - Automatic context updates on file changes (all tools)
 
-### Watch Mode
+Learn more: [Integration Modes Guide](docs/integration-modes.md)
 
-Watch mode provides automatic file monitoring and workflow execution:
+---
 
-**Features**:
-- 📁 **File Monitoring**: Automatically detect file changes
-- ⚡ **Debouncing**: Prevent duplicate executions
-- 🔄 **Retry Logic**: Automatic retry with exponential backoff
-- 📊 **Metrics Tracking**: Track executions, time saved, success rates
-- 📝 **Execution Logging**: Complete audit trail with log rotation
+## Integration with Your AI Tool
 
-**Quick Start**:
-```bash
-# Initialize watch configuration
-kse watch init
+kse works with any AI coding assistant. Choose your tool for specific guidance:
 
-# Install a preset (auto-sync, prompt-regen, context-export, test-runner)
-kse watch install auto-sync
+### Popular AI Tools
 
-# Start watching
-kse watch start
+- **[Cursor](docs/tools/cursor-guide.md)** - IDE with AI pair programming
+- **[Claude Code](docs/tools/claude-guide.md)** - Anthropic's coding assistant
+- **[Windsurf](docs/tools/windsurf-guide.md)** - AI agent with command execution
+- **[Kiro](docs/tools/kiro-guide.md)** - Native integration, no manual export needed
+- **[VS Code + Copilot](docs/tools/vscode-guide.md)** - GitHub Copilot integration
+- **[Generic AI Tools](docs/tools/generic-guide.md)** - Works with any AI assistant
 
-# Check status
-kse watch status
+### Integration Workflow
 
-# View metrics
-kse watch metrics
+```mermaid
+sequenceDiagram
+    participant You
+    participant kse
+    participant AI Tool
+    You->>kse: Create Spec (requirements, design, tasks)
+    You->>kse: Export context
+    kse->>You: context-export.md
+    You->>AI Tool: Provide context
+    AI Tool->>You: Generate code based on Spec
+    You->>kse: Update task status
 ```
 
-**Presets**:
-- `auto-sync`: Automatically sync workspace when tasks.md changes
-- `prompt-regen`: Regenerate prompts when requirements/design change
-- `context-export`: Export context when tasks complete
-- `test-runner`: Run tests when source files change
+---
 
-### Tool Detection
+## Documentation
 
-KSE automatically detects your development environment and suggests appropriate automation:
+### Getting Started
+- 📖 **[Quick Start Guide](docs/quick-start.md)** - Detailed 5-minute tutorial
+- 🤔 **[FAQ](docs/faq.md)** - Frequently asked questions
+- 🔧 **[Troubleshooting](docs/troubleshooting.md)** - Common issues and solutions
 
-```bash
-# During adoption, KSE detects:
-kse adopt
+### Core Guides
+- 📋 **[Spec Workflow](docs/spec-workflow.md)** - Understanding Specs in depth
+- 🔌 **[Integration Modes](docs/integration-modes.md)** - Three ways to integrate kse
+- 📝 **[Command Reference](docs/command-reference.md)** - All kse commands
 
-# Detected: Kiro IDE → Suggests native agent hooks
-# Detected: VS Code/Cursor → Suggests watch mode
-# Detected: Other → Suggests manual workflows
-```
+### Tool-Specific Guides
+- [Cursor Integration](docs/tools/cursor-guide.md)
+- [Claude Code Integration](docs/tools/claude-guide.md)
+- [Windsurf Integration](docs/tools/windsurf-guide.md)
+- [Kiro Integration](docs/tools/kiro-guide.md)
+- [VS Code + Copilot Integration](docs/tools/vscode-guide.md)
+- [Generic AI Tools](docs/tools/generic-guide.md)
 
-### Manual Workflows
+### Examples
+- [API Feature Example](docs/examples/add-rest-api/) - RESTful API Spec
+- [UI Feature Example](docs/examples/add-user-dashboard/) - React dashboard Spec
+- [CLI Feature Example](docs/examples/add-export-command/) - CLI command Spec
 
-For environments without automation, KSE provides step-by-step workflow guides:
+### Advanced Topics
+- [Adoption Guide](docs/adoption-guide.md) - Adopting kse in existing projects
+- [Upgrade Guide](docs/upgrade-guide.md) - Version upgrade instructions
+- [Manual Workflows](docs/manual-workflows-guide.md) - Step-by-step workflows
+- [Developer Guide](docs/developer-guide.md) - Contributing and extending kse
 
-```bash
-# List available workflows
-kse workflows
+### Complete Documentation
+- 📚 **[Documentation Index](docs/README.md)** - All documentation in one place
 
-# View workflow details
-kse workflows show task-sync        # 30-60 seconds
-kse workflows show context-export   # 15-45 seconds
-kse workflows show prompt-generation # 20-30 seconds
+---
 
-# Open complete guide
-kse workflows guide
-```
+## Key Features
 
-**Available Workflows**:
-- **Task Sync**: Keep workspace synchronized with task progress
-- **Context Export**: Export spec context for AI assistants
-- **Prompt Generation**: Generate task-specific prompts
-- **Daily Checklist**: Complete daily workflow routine
-- **Task Completion**: Checklist for completing tasks
-- **Spec Creation**: Checklist for creating new specs
+### Spec-Driven Development
+Structure your work with Requirements → Design → Tasks workflow
 
-## 🛠️ Project Structure
+### Multi-User Collaboration
+- Personal workspaces for team members
+- Task claiming and tracking
+- Workspace synchronization
 
-After initialization, your project will have:
+### Cross-Tool Compatibility
+Export context for Claude Code, Cursor, Windsurf, Copilot, and more
 
-```
-your-project/
-├── .kiro/                          # Kiro core directory
-│   ├── specs/                      # Spec storage
-│   │   └── SPEC_WORKFLOW_GUIDE.md
-│   ├── steering/                   # AI behavior rules (the "rules engine")
-│   │   ├── CORE_PRINCIPLES.md      # Core principles + Ultrawork spirit
-│   │   ├── ENVIRONMENT.md          # Environment configuration
-│   │   ├── CURRENT_CONTEXT.md      # Current context
-│   │   └── RULES_GUIDE.md          # Rules index
-│   ├── tools/                      # Ultrawork tools
-│   │   └── ultrawork_enhancer.py   # Core enhancement tool
-│   └── README.md                   # Kiro system documentation
-└── README.md                       # Project documentation
-```
+### Watch Mode Automation
+Automatic file monitoring and context updates
 
-## 🔥 The Ultrawork Spirit
+### Quality Enhancement
+- Document quality scoring (0-10 scale)
+- Intelligent improvement suggestions
+- Professional standards enforcement
 
-> Inspired by Sisyphus from Greek mythology, who was condemned to push a boulder up a mountain for eternity, only to watch it roll back down each time.
+### Multi-Language Support
+English and Chinese interfaces
 
-The Ultrawork spirit embodies:
+---
 
-- **Relentless Effort**: Never give up when facing challenges
-- **Continuous Improvement**: Always strive for better quality
-- **Professional Standards**: Pursue excellence in every detail (9.0/10 target)
-- **Persistent Execution**: Keep pushing forward until completion
+## Command Overview
 
-Ultrawork is the **quality enhancement philosophy** within Kiro Spec Engine—it's what drives the engine to produce professional-grade results.
+```bash
+# Project setup
+kse adopt                          # Adopt kse in existing project
+kse create-spec <name>             # Create new Spec
 
-## 🌍 Multi-language Support
+# Context management
+kse context export <spec-name>     # Export context for AI tools
+kse prompt generate <spec> <task>  # Generate task-specific prompt
 
-Kiro Spec Engine supports multiple languages out of the box.
+# Task management
+kse task claim <spec> <task-id>    # Claim a task
+kse task list <spec>               # List claimed tasks
 
-### Setting Language
+# Automation
+kse watch start                    # Start watch mode
+kse watch status                   # Check watch status
 
-```bash
-# Using command line option
-kse --lang zh init
+# Project info
+kse status                         # Project status
+kse workflows                      # List available workflows
+```
 
-# Using environment variable
-export KIRO_LANG=zh
-kse init
+See [Command Reference](docs/command-reference.md) for complete documentation.
 
-# Windows
-set KIRO_LANG=zh
-kse init
-```
+---
 
-### Supported Languages
+## Contributing & Support
 
-- 🇺🇸 English (en) - Default
-- 🇨🇳 Simplified Chinese (zh)
+### Getting Help
 
-The tool automatically detects your system language and uses it by default. You can override this with the `--lang` option or `KIRO_LANG` environment variable.
+- 📖 **Documentation**: Start with the [Quick Start Guide](docs/quick-start.md)
+- 🐛 **Bug Reports**: [GitHub Issues](https://github.com/yourusername/kiro-spec-engine/issues)
+- 💬 **Discussions**: [GitHub Discussions](https://github.com/yourusername/kiro-spec-engine/discussions)
+- 📧 **Email**: support@example.com
 
-## 🤝 Contributing
+### Contributing
 
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+We welcome contributions! See our [Contributing Guide](CONTRIBUTING.md) for:
+- Code contributions
+- Documentation improvements
+- Bug reports and feature requests
+- Translation help
 
 ### Development Setup
 
@@ -473,20 +330,18 @@ git clone https://github.com/yourusername/kiro-spec-engine.git
 cd kiro-spec-engine
 npm install
 npm link  # For local development
+npm test  # Run tests
 ```
 
-### Adding New Languages
-
-1. Create a new language file in `locales/` (e.g., `ja.json`)
-2. Copy the structure from `en.json` and translate all text
-3. Add language detection logic in `lib/i18n.js`
-4. Update README documentation
+---
 
-## 📄 License
+## License
 
 MIT License - see [LICENSE](LICENSE) file for details.
 
-## 🙏 Acknowledgments
+---
+
+## Acknowledgments
 
 - Inspired by the **Sisyphus** myth and the concept of noble struggle
 - Built on the foundation of **Kiro** spec-driven development
@@ -494,9 +349,15 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ---
 
-**Start your spec-driven journey today! 🔥**
+**Ready to enhance your AI-assisted development?** 🚀
 
 ```bash
 npm install -g kiro-spec-engine
-kse init
+kse adopt
+kse create-spec 01-00-my-first-feature
 ```
+
+---
+
+**Version**: 1.4.0  
+**Last Updated**: 2026-01-23