sqlew 3.8.1 → 3.9.1

package/README.md

@@ -4,28 +4,27 @@
 [![npm version](https://img.shields.io/npm/v/sqlew.svg)](https://www.npmjs.com/package/sqlew)
 [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
 
-> **SQL Efficient Workflow** - MCP server for efficient context sharing between Claude Code sub-agents
+> **SQL Efficient Workflow** - MCP server Provides consistency and token savings for AI coding 
 
 ## What is sqlew?
 
 **sqlew** is a Model Context Protocol (MCP) server that gives AI agents organizational memory across sessions.
 
-### The Problem
-Without sqlew, every Claude session starts with zero context. You must re-explain decisions, agents can reintroduce bugs, and there's no way to track WHY decisions were made.
+### Concerns About AI Coding
+Every Claude session starts with zero context. You must re-explain decisions, agents can reintroduce bugs, and there's no way to track WHY decisions were made.
 
-It has been possible to keep records using Markdown files. However, large-scale projects or long-term maintenance records tend to generate massive amounts of documentation. This has become a problem, as it causes context rot in AI systems, leading to declining performance.
+It is possible to keep records using Markdown files.
+However, maintaining records for large-scale projects and long-term maintenance generates an enormous volume of documentation.
 
-### The Solution
+This has become problematic because it causes context rotting in AI systems, leading to performance deterioration.
+
+### *sqlew* provides the solution for this problem
 sqlew builds efficient external memory for AI by using relational databases.
 - Records the reasoning behind decisions
 - Enables querying past context
 - Prevents anti-patterns through constraints
 - Eliminates duplicate work via task management
 
-**Example:**
-- Session 1 records "API v1 deprecated".
-- Session 2 (days later) queries and automatically uses v2.
-
 > *This software does not send any data to external networks. We NEVER collect any data or usage statistics. Please use it with complete security.*
 
 ## Why Use sqlew?
@@ -39,24 +38,44 @@ Traditional code analysis like git tells you **WHAT** is done, sqlew adds **WHY*
 ### ⚡ Token Efficiency
 **60-75% token reduction** in multi-session projects through structured data storage and selective querying.
 
-### 🎯 Key Features
-- **5 Specialized Tools**: decisions, tasks, files, constraints, stats
-- **Runtime Reconnection**: Automatic database connection recovery with exponential backoff
-- **Parameter Validation**: Typo detection, required/optional markers, 70-85% more concise error messages
-- **Metadata-Driven**: Tag, layer, scope, and version everything
-- **Decision Context**: Document WHY with rationale, alternatives, and trade-offs
-- **Task Dependencies**: Blocking relationships with circular detection
-- **Auto-File Tracking**: Zero-token task management via file watching
-- **Smart Review Detection**: Quality-based auto-transition to `waiting_review`
-- **Auto-Stale Detection**: Tasks auto-transition when idle
-- **Weekend-Aware Cleanup**: Smart retention during weekends
-- **Batch Operations**: Process up to 50 items atomically
+### 🎯 Key Benefits for Your Development Workflow
+
+#### 🧠 **Context Persistence Across Sessions**
+- **No More Re-Explaining**: AI remembers decisions from weeks ago - no need to re-explain "why we chose PostgreSQL over MongoDB"
+- **Session Continuity**: Pick up exactly where you left off, even after days or weeks
+- **Team Knowledge Sharing**: New team members (or new AI sessions) instantly understand past decisions
+
+#### 🛡️ **Prevents Context Rotting & Inconsistency**
+- **Architectural Constraints**: Define rules once ("always use async/await, never callbacks"), AI follows them forever
+- **Version History**: Track how decisions evolved - see what changed and when
+
+#### 🎯 **Enables Consistent, High-Quality Code**
+- **Bug Prevention**: AI won't reintroduce bugs you already fixed (decisions document "what didn't work")
+- **Pattern Enforcement**: Constraints ensure AI writes code matching your team's style
+- **Context-Aware Suggestions**: AI sees related decisions before creating new ones ("Did you know we already solved this?")
+- **Rationale Documentation**: Every decision includes WHY it was made, preventing cargo-cult programming
+
+#### 📊 **Transparent AI Work Tracking**
+- **Task Dependencies**: AI knows Task B needs Task A completed first
+- **Auto File Watching**: Tasks auto-update when AI edits tracked files (zero manual updates)
+- **Progress Visibility**: See exactly what AI is working on, what's blocked, what's done
+
+#### ⚡ **Efficiency & Reliability**
+- **60-75% Token Reduction**: Structured data beats dumping entire context into prompts
+- **Reduce Context Rot**: No more "this README is 50 pages and AI ignores half of it"
+- **Production-Ready**: 495/495 tests passing (100%), battle-tested on real projects
+
+---
+
+**Technical Features**: 6 specialized MCP tools (decisions, tasks, files, constraints, stats, suggest), smart similarity scoring (0-100 point algorithm), runtime reconnection, parameter validation, metadata-driven organization
 
 See [docs/TASK_OVERVIEW.md](docs/TASK_OVERVIEW.md) and [docs/DECISION_CONTEXT.md](docs/DECISION_CONTEXT.md) for details.
 
 ### 🔖Kanban-style AI Scrum
 ![kanban-style task management](assets/kanban-visualizer.png)
 
+(This visualizer is not included in this package)
+
 ## Installation
 
 ### Requirements
@@ -79,17 +98,39 @@ on `.mcp.json` in your project's root, add these lines:
 ```
 **Recommend to restart claude after initialize**
 
-The first time, sqlew install custom agents and initialize database. Custom agents are not loaded in this time. Please exit claude once, and restart claude again.
+The first time, sqlew initializes database, installs custom agents and slash commands. But agents and commands are not loaded in this time. So, please exit claude once, and restart claude again.
 
 It's Ready!
 
+## 🚀 Quick Start: Slash Commands (Recommended)
+
+**Slash commands are the easiest way to use sqlew!** Just type `/sqw-` in Claude Code to see available commands.
+
+### Most Common Commands
+
+```bash
+# Plan a new feature (architecture + tasks)
+/sqw-plan "Implement user authentication"
+
+# Record a decision (like meeting minutes)
+/sqw-secretary "Use PostgreSQL 15 for production database"
+
+# Implement a feature (creates tasks AND coordinates agents to build it!)
+/sqw-scrum implement JWT authentication
+
+# Search past decisions
+/sqw-research "Why did we choose Knex for migrations?"
+```
+
+**All 6 commands** are installed automatically on first run. See [Slash Commands](#slash-commands) section below for complete guide.
+
+---
+
 **⚠️Note**: Global install (`npm install -g`) is **not recommended** because sqlew requires an independent settings per project. Each project should maintain its own context database in `.sqlew/sqlew.db`.
 
 **Custom database path:** Add path as argument: `"args": ["sqlew", "/path/to/db.db"]`
 **Default location:** `.sqlew/sqlew.db`
 
-### Jetbrains Junie AI
-
 **⚠️ Not Supported:** Junie AI cannot use relative paths in MCP server configurations, which makes it incompatible with sqlew's project-based database model. Each project requires its own isolated database at `.sqlew/sqlew.db`, but Junie AI's global MCP configuration cannot handle per-project database paths.
 
 ## Configuration
@@ -98,11 +139,13 @@ It's Ready!
 
 sqlew supports multiple database backends for different deployment scenarios:
 
-| Database | Use Case | Status |
-|----------|----------|--------|
-| **SQLite** | Development, small projects | ✅ Default |
-| **MySQL 8.0 / MariaDB 10+** | Production, shared environments | ✅ Supported |
-| **PostgreSQL 12+** | Production, enterprise | ✅ v3.8.0+ |
+| Database | Use Case                                     | Status      |
+|----------|----------------------------------------------|-------------|
+| **SQLite** | Personal or small projects                   | ✅ Default   |
+| **MySQL 8.0 / MariaDB 10+** | Production, shared environments, remote work | ✅ Supported |
+| **PostgreSQL 12+** | Production, shared environments, remote work | ✅ Supported |
+
+Of course, it also works with Docker RDB instances.
 
 ### Optional Config File
 
@@ -197,7 +240,7 @@ read sqlew usecases, and plan implementation of feature X using sqlew.
 or invoke Specialized Agent
 
 ```
-plan implementation of feature X with @agent-scrum-master.
+/sqw-plan implementation of feature X .
 ```
 
 Specialized Agents use sqlew more efficiently.
@@ -236,6 +279,71 @@ Savings: Scrum + Architect = 32KB (30%) | Scrum only = 12KB (74%)
 
 **See [docs/SPECIALIZED_AGENTS.md](docs/SPECIALIZED_AGENTS.md) for complete installation guide, usage examples, and customization.**
 
+## Slash Commands
+
+**🎯 Recommended for Human Users** - Slash commands provide guided workflows that are easier than raw MCP tool calls.
+
+Installed automatically to `.claude/commands/` on server startup. Just type `/sqw-` in Claude Code to get started!
+
+### Available Commands
+
+| Command | What It Does | Perfect For |
+|---------|--------------|-------------|
+| **`/sqw-plan`** | Complete feature planning (architecture + tasks) | Starting new features, planning sprints |
+| **`/sqw-secretary`** | Record decisions like meeting minutes | Documenting team decisions, capturing context |
+| **`/sqw-scrum`** | Create tasks AND coordinate agents to implement them | Actually building features end-to-end |
+| **`/sqw-documentor`** | Document architectural decisions with full context | Design reviews, architecture documentation |
+| **`/sqw-research`** | Search past decisions and analyze patterns | Onboarding, understanding past choices |
+| **`/sqw-review`** | Validate code/design against decisions & constraints | Code reviews, ensuring consistency |
+
+### Why Use Slash Commands?
+
+✅ **Guided workflows** - Commands prompt you through the process
+✅ **Agent coordination** - Automatically invokes the right agents
+✅ **Error handling** - Built-in validation and helpful error messages
+✅ **Mode detection** - `/sqw-scrum plan` manages tasks, `/sqw-scrum implement` builds code
+✅ **No MCP knowledge needed** - Just describe what you want in plain English
+
+### Quick Examples
+
+```bash
+# Starting a new feature
+/sqw-plan Add OAuth2 social login with Google and GitHub
+# → Architect documents decisions, Scrum creates tasks
+
+# Recording a decision from today's meeting
+/sqw-secretary Team decided to use PostgreSQL 15 for production
+# → Saves with context, checks for duplicates
+
+# Actually implementing a feature (game changer!)
+/sqw-scrum implement JWT authentication
+# → Creates tasks, coordinates agents, writes code, runs tests
+
+# Finding out why something was done
+/sqw-research Why did we choose Knex over Prisma?
+# → Searches decisions, shows rationale and tradeoffs
+```
+
+### Configuration
+
+All commands install by default. Customize in `.sqlew/config.toml`:
+
+```toml
+[commands]
+plan = true        # Feature planning
+secretary = true   # Record decisions
+scrum = true       # Task management + execution
+documentor = true  # Architecture docs
+research = true    # Search history
+review = true      # Code/design validation
+```
+
+**📚 Complete Guide**: [docs/SLASH_COMMANDS.md](docs/SLASH_COMMANDS.md) - Usage patterns, customization, examples
+
+### Advanced: Direct MCP Tool Access
+
+Power users can still call MCP tools directly. See [Available Tools](#available-tools) section below.
+
 ### Available Tools
 
 | Tool | Purpose | Example Use |
@@ -245,6 +353,7 @@ Savings: Scrum + Architect = 32KB (30%) | Scrum only = 12KB (74%)
 | **task** | Track work | "Implement feature X" |
 | **file** | Track changes | "Modified auth.ts" |
 | **stats** | Database metrics | Get layer summary |
+| **suggest** | Find similar decisions (v3.9.0) | Duplicate detection, pattern search |
 
 
 ## Documentation
@@ -276,6 +385,7 @@ All tools support:
 - [Task Migration](docs/TASK_MIGRATION.md) - Migrate from decision-based tracking
 
 **Advanced Features:**
+- [Decision Intelligence](docs/DECISION_INTELLIGENCE.md) - Three-tier duplicate detection (v3.9.0)
 - [Decision Context](docs/DECISION_CONTEXT.md) - Rich decision documentation
 - [Auto File Tracking](docs/AUTO_FILE_TRACKING.md) - Zero-token task management
 - [Acceptance Criteria](docs/ACCEPTANCE_CRITERIA.md) - All check types
@@ -285,7 +395,7 @@ All tools support:
 - [Configuration](docs/CONFIGURATION.md) - Config file setup, all options
 - [Architecture](docs/ARCHITECTURE.md) - Technical architecture
 
-### For Developers
+### Advanced Usage
 
 - [Configuration Guide](docs/CONFIGURATION.md) - TOML config file setup
 - [CLI Mode Overview](docs/cli/README.md) - Database migration, export/import commands
@@ -314,9 +424,17 @@ Support development via [GitHub Sponsors](https://github.com/sponsors/sin5ddd) -
 
 ## Version
 
-Current version: **3.7.4**
+Current version: **3.9.0**
 See [CHANGELOG.md](CHANGELOG.md) for release history.
 
+**What's New in v3.9.0:**
+- **Decision Intelligence System** - Three-tier duplicate detection (35-44 gentle nudge, 45-59 hard block, 60+ auto-update)
+- **New `suggest` Tool** - Find similar decisions by key, tags, or context
+- **Policy-Based Auto-Triggering** - Automatic suggestions when `suggest_similar=1`
+- **Enhanced Metadata** - Auto-update responses include `duplicate_reason`, `version_info`, `update_command`
+
+See [docs/DECISION_INTELLIGENCE.md](docs/DECISION_INTELLIGENCE.md) for details.
+
 ## License
 
 AGPLv3 - Free to use. Open-source required when embedding or modifying. See [LICENSE](LICENSE) for details.

package/assets/sample-agents/sqlew-architect.md

@@ -96,10 +96,12 @@ decision({ action: "set", key: "auth-method", value: "JWT for API authentication
 // Step 1: See what actions are available
 decision({ action: "help" })
 constraint({ action: "help" })
+suggest({ action: "help" })  // NEW in v3.9.0: Decision Intelligence
 
 // Step 2: Get exact syntax with copy-paste examples
 decision({ action: "example" })  // Shows ALL action examples with correct parameters
 constraint({ action: "example" })
+suggest({ action: "example" })   // Duplicate detection & similarity search patterns
 
 // Step 3: Copy the relevant example, modify values, execute
 // Example from action: "example" output:
@@ -142,7 +144,7 @@ Before executing ANY sqlew tool call:
 - [ ] Does it include `action` parameter?
 - [ ] Did I check `action: "example"` for correct syntax?
 - [ ] Are arrays actually arrays (not comma-separated strings)?
-- [ ] Did I verify parameter names match current API (v3.7.0)?
+- [ ] Did I verify parameter names match current API (v3.9.0)?
 
 ## Your Operational Approach
 
@@ -151,15 +153,66 @@ Before executing ANY sqlew tool call:
 **Trigger**: Whenever an architectural choice is made
 
 **Essential Steps**:
-1. **Identify Decision Point**: What specific question needs answering?
-2. **Analyze Alternatives**: List 2-4 viable options with pros/cons
-3. **Evaluate Tradeoffs**: Consider performance, maintainability, complexity, cost
-4. **Document Rationale**: Explain why chosen option is superior
-5. **Establish Constraints**: Create rules to enforce the decision
-6. **Link Context**: Connect to related decisions, tasks, files
+1. **Check for Duplicates** (NEW v3.9.0): Use `suggest({ action: "check_duplicate", ... })` to detect existing similar decisions
+2. **Identify Decision Point**: What specific question needs answering?
+3. **Analyze Alternatives**: List 2-4 viable options with pros/cons
+4. **Evaluate Tradeoffs**: Consider performance, maintainability, complexity, cost
+5. **Document Rationale**: Explain why chosen option is superior
+6. **Establish Constraints**: Create rules to enforce the decision
+7. **Link Context**: Connect to related decisions, tasks, files
 
 **Get Correct Syntax**: Always use `decision({ action: "example" })` for current parameter format.
 
+### Decision Intelligence & Duplicate Prevention (NEW v3.9.0)
+
+**Purpose**: The `suggest` tool prevents duplicate decisions and maintains consistency by finding similar existing decisions before you create new ones.
+
+**Core Actions**:
+```typescript
+// 1. Check for duplicates before creating a decision
+suggest({
+  action: "check_duplicate",
+  key: "api/authentication/method",
+  min_score: 30  // Relevance threshold (0-100)
+})
+
+// 2. Find decisions by key pattern (wildcard matching)
+suggest({
+  action: "by_key",
+  key: "api/*/latency",  // Finds all API latency decisions
+  limit: 5
+})
+
+// 3. Find decisions by similar tags
+suggest({
+  action: "by_tags",
+  tags: ["security", "authentication"],
+  min_score: 40
+})
+
+// 4. Comprehensive similarity search (key + tags + layer)
+suggest({
+  action: "by_context",
+  key: "database/connection-pooling",
+  tags: ["performance", "database"],
+  layer: "data",
+  min_score: 30,
+  limit: 10
+})
+```
+
+**When to Use suggest**:
+- **Before Creating Decisions**: Always check `check_duplicate` to avoid redundant decisions
+- **During Research**: Use `by_key` or `by_tags` to find related architectural choices
+- **Consistency Validation**: Use `by_context` to ensure new decisions align with existing patterns
+- **Auto-Trigger**: When policies have `suggest_similar=1`, suggestions appear automatically after decision creation
+
+**Best Practices**:
+1. Run `suggest({ action: "check_duplicate", ... })` BEFORE `decision({ action: "set", ... })`
+2. If duplicates found (score > 70), consider updating existing decision instead
+3. If similar decisions found (score 30-70), reference them in rationale
+4. Adjust `min_score` based on strictness (30=lenient, 70=strict)
+
 ### Constraint Creation Protocol
 
 **Trigger**: When a decision needs enforcement
@@ -236,15 +289,16 @@ For high-stakes decisions:
 ## Quality Assurance
 
 Before finalizing architectural documentation:
-1. ✅ Decision has clear rationale explaining "why"
-2. ✅ Alternatives analyzed with objective pros/cons
-3. ✅ Tradeoffs acknowledged (gains vs. sacrifices, short vs. long-term)
-4. ✅ Tags enable future searchability
-5. ✅ Layer and priority correctly assigned
-6. ✅ Related constraints created for enforcement
-7. ✅ Linked to relevant tasks or files
-8. ✅ Extended context added via `add_decision_context` if needed
-9. ✅ All tool calls include `action` parameter (error prevention)
+1. ✅ Checked for duplicate decisions using `suggest({ action: "check_duplicate", ... })` (v3.9.0+)
+2. ✅ Decision has clear rationale explaining "why"
+3. ✅ Alternatives analyzed with objective pros/cons
+4. ✅ Tradeoffs acknowledged (gains vs. sacrifices, short vs. long-term)
+5. ✅ Tags enable future searchability
+6. ✅ Layer and priority correctly assigned
+7. ✅ Related constraints created for enforcement
+8. ✅ Linked to relevant tasks or files
+9. ✅ Extended context added via `add_decision_context` if needed
+10. ✅ All tool calls include `action` parameter (error prevention)
 
 ## Edge Case Handling
 
@@ -257,10 +311,11 @@ Before finalizing architectural documentation:
 
 ## Self-Correction Mechanisms
 
+- **Use `suggest` tool to check for duplicate decisions before creating** (v3.9.0+)
 - Cross-reference new decisions with existing constraints (consistency check)
 - Verify tags match existing taxonomy (searchability)
 - Ensure priority aligns with impact (critical = system breaks, low = preferences)
-- Check if decision already exists (avoid duplicates, use versions instead)
+- Check if decision already exists using `suggest({ action: "check_duplicate", ... })`
 - Validate constraint enforceability (can it be verified?)
 - **Verify all tool calls include `action` parameter before execution**
 

package/assets/sample-agents/sqlew-researcher.md

@@ -55,6 +55,7 @@ You are an expert Context Researcher with deep expertise in querying and analyzi
 ### Sqlew Query Mastery
 You have expert knowledge of sqlew's query capabilities:
 - **Decision Search**: Query by tags, layers, context keys, versions, exact/substring matching
+- **Decision Intelligence** (NEW v3.9.0): Use `suggest` tool for similarity search, duplicate detection, pattern matching
 - **Decision Context**: Retrieve rich context (rationale, alternatives, tradeoffs)
 - **Constraint Analysis**: Retrieve active constraints, understand categories and priorities
 - **Task Analytics**: Analyze task patterns, completion times, dependency chains, stale tasks
@@ -93,12 +94,14 @@ decision({ action: "help" })
 task({ action: "help" })
 constraint({ action: "help" })
 stats({ action: "help" })
+suggest({ action: "help" })  // NEW in v3.9.0: Decision Intelligence
 
 // Step 2: Get exact syntax with copy-paste examples
 decision({ action: "example" })  // Shows ALL action examples with correct parameters
 task({ action: "example" })
 constraint({ action: "example" })
 stats({ action: "example" })
+suggest({ action: "example" })   // Similarity search & pattern matching
 
 // Step 3: Copy the relevant example, modify values, execute
 // Example from action: "example" output:
@@ -143,7 +146,7 @@ Before executing ANY sqlew tool call:
 - [ ] Does it include `action` parameter?
 - [ ] Did I check `action: "example"` for correct syntax?
 - [ ] Are arrays actually arrays (not comma-separated strings)?
-- [ ] Did I verify parameter names match current API (v3.7.0)?
+- [ ] Did I verify parameter names match current API (v3.9.0)?
 
 ## Your Operational Approach
 
@@ -153,11 +156,69 @@ Before executing ANY sqlew tool call:
 - Specific decision: Use exact `key`
 - Topic area: Use `tags` (e.g., "auth", "performance")
 - Architecture layer: Use `layer` (presentation, business, data, infrastructure, cross-cutting)
+- Pattern matching: Use `suggest({ action: "by_key", ... })` for wildcard searches (NEW v3.9.0)
+- Similarity search: Use `suggest({ action: "by_tags", ... })` or `suggest({ action: "by_context", ... })` (NEW v3.9.0)
 - Alternatives analysis: Use `list_decision_contexts`
 - Advanced search: Use `search_advanced` with multiple filters
 
 **Get Correct Syntax**: Always use `decision({ action: "example" })` for current parameter format.
 
+### Similarity Search & Pattern Matching (NEW v3.9.0)
+
+**Purpose**: The `suggest` tool enables intelligent decision discovery through pattern matching, tag similarity, and contextual search.
+
+**Core Research Actions**:
+```typescript
+// 1. Pattern-based key search (wildcard matching)
+suggest({
+  action: "by_key",
+  key: "api/*/latency",  // Matches api/rest/latency, api/graphql/latency, etc.
+  limit: 10
+})
+
+// 2. Tag-based similarity search
+suggest({
+  action: "by_tags",
+  tags: ["security", "authentication", "oauth"],
+  min_score: 30,  // Relevance threshold (0-100)
+  limit: 5
+})
+
+// 3. Comprehensive contextual search (key + tags + layer)
+suggest({
+  action: "by_context",
+  key: "database/connection-pooling",
+  tags: ["performance", "database"],
+  layer: "data",
+  min_score: 40,
+  limit: 10
+})
+
+// 4. Duplicate detection (exact key match with contextual scoring)
+suggest({
+  action: "check_duplicate",
+  key: "api/authentication/jwt-config",
+  min_score: 30
+})
+```
+
+**When to Use suggest vs. decision**:
+- **Use `suggest`**: When you don't know exact key, need wildcard matching, want related decisions by similarity
+- **Use `decision`**: When you know exact key, need version history, or want specific decision details
+
+**Scoring System**:
+- **90-100**: Near-duplicate (same key or very high overlap)
+- **70-89**: Strong similarity (highly related)
+- **50-69**: Moderate similarity (some overlap)
+- **30-49**: Weak similarity (loosely related)
+- **<30**: Not relevant (filtered out by default min_score)
+
+**Best Practices**:
+1. Start with `suggest({ action: "by_key", ... })` if you know partial key pattern
+2. Use `suggest({ action: "by_tags", ... })` when exploring topic areas
+3. Use `suggest({ action: "by_context", ... })` for comprehensive research combining multiple filters
+4. Adjust `min_score` based on research precision needs (30=broad, 70=narrow)
+
 ### Constraint Analysis Protocol
 
 **Use Cases**:

package/assets/sample-agents/sqlew-scrum-master.md

@@ -50,6 +50,7 @@ You have intimate knowledge of sqlew's capabilities:
 - **File Watching**: Monitor file changes using task watchers, track modified files automatically
 - **Agent Attribution**: Simple agent name registry for tracking "who did what"
 - **Decision Context**: Record architectural decisions with rationale, alternatives, and tradeoffs
+- **Decision Intelligence** (NEW v3.9.0): Use `suggest` tool to check for duplicate decisions and find related context
 - **Constraints**: Define and enforce architectural rules and guidelines
 - **Statistics**: Monitor layer summaries, database stats, task board status, activity logs
 
@@ -82,11 +83,13 @@ task({ action: "create", title: "Implement OAuth", priority: 3 })
 task({ action: "help" })
 decision({ action: "help" })
 stats({ action: "help" })
+suggest({ action: "help" })  // NEW in v3.9.0: Decision Intelligence
 
 // Step 2: Get exact syntax with copy-paste examples
 task({ action: "example" })        // Shows ALL task action examples
 decision({ action: "example" })    // Decision documentation templates
 stats({ action: "example" })       // Statistics and monitoring patterns
+suggest({ action: "example" })     // Duplicate detection & similarity search
 
 // Step 3: Copy the relevant example, modify values, execute
 // Example from action: "example" output:
@@ -138,7 +141,7 @@ Before executing ANY sqlew tool call:
 - [ ] Does it include `action` parameter?
 - [ ] Did I check `action: "example"` for correct syntax?
 - [ ] Are data types correct (priority: number, tags: array, atomic: boolean)?
-- [ ] Did I verify parameter names match current API (v3.7.0)?
+- [ ] Did I verify parameter names match current API (v3.9.0)?
 
 ## Your Operational Approach
 
@@ -178,6 +181,7 @@ Before executing ANY sqlew tool call:
 
 ### Decision Documentation
 When architectural choices are made:
+- **Check for duplicates first** (v3.9.0+): Use `suggest({ action: "check_duplicate", ... })` before creating decisions
 - Use `decision({ action: "set", ... })` with rich context
 - Include rationale, alternatives_considered, tradeoffs
 - Tag appropriately for future searchability

package/assets/sample-commands/README.md

@@ -0,0 +1,57 @@
+# Slash Commands for sqlew
+
+This directory contains slash command templates for Claude Code integration with mcp-sqlew.
+
+## Documentation
+
+**For complete installation guide and usage:**
+
+➡️ **[docs/SLASH_COMMANDS.md](../../docs/SLASH_COMMANDS.md)**
+
+## Command Files
+
+- `sqw-documentor.md` - Document architectural decisions
+- `sqw-secretary.md` - Record decisions (meeting minutes)
+- `sqw-plan.md` - Planning workflow (architecture + tasks)
+- `sqw-research.md` - Search decision/task history
+- `sqw-review.md` - Validate architectural consistency
+- `sqw-scrum.md` - Task management + agent coordination
+
+## Quick Install
+
+### Automatic (Recommended)
+
+Commands are automatically installed when the MCP server starts. Configure in `.sqlew/config.toml`:
+
+```toml
+[commands]
+documentor = true
+secretary = true
+plan = true
+research = true
+review = true
+scrum = true
+```
+
+### Manual Installation
+
+```bash
+# Install all enabled commands
+npx mcp-sqlew init-commands
+
+# Install to custom location
+npx mcp-sqlew init-commands --path /custom/path
+```
+
+Commands are installed to `.claude/commands/` in your project directory.
+
+**Usage**: Invoke commands with the `/` prefix: `/sqw-plan`, `/sqw-documentor`, `/sqw-scrum`
+
+See [docs/SLASH_COMMANDS.md](../../docs/SLASH_COMMANDS.md) for detailed usage examples and customization options.
+
+## Links
+
+- [Main README](../../README.md)
+- [Slash Commands Documentation](../../docs/SLASH_COMMANDS.md)
+- [Specialized Agents](../../docs/SPECIALIZED_AGENTS.md)
+- [Project Repository](https://github.com/sin5ddd/mcp-sqlew)