@rembr/vscode 1.0.0 → 2.0.0

package/CHANGELOG.md

@@ -1,10 +1,66 @@
 # Changelog
 
-All notable changes to @rembr/client will be documented in this file.
+All notable changes to @rembr/vscode will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0] - 2026-01-10
+
+### Added
+
+#### Complete RLM Agent System
+- **Custom Agents**: `@rlm` (basic decomposition) and `@ralph-rlm` (acceptance-driven quality)
+- **Skills**: RLM orchestration patterns with quality validation
+  - `rlm-orchestration/SKILL.md` - Basic RLM decomposition patterns
+  - `ralph-rlm-orchestration/SKILL.md` - Acceptance-driven loop patterns
+- **Prompts**: Quick-start commands for Chat interface
+  - `/rlm-analyze` - Start basic RLM analysis
+  - `/ralph-analyze` - Start acceptance-driven analysis  
+  - `/rlm-plan` - Generate decomposition plan only
+  - `/ralph-plan` - Define acceptance criteria only
+- **Instructions**: Specialized guidance for agents
+  - `rembr-integration.instructions.md` - Memory storage patterns
+  - `code-investigation.instructions.md` - Code search best practices
+
+#### Agent Architecture
+- **Basic RLM**: Fast task decomposition with single-pass completion
+- **Ralph-RLM**: Iterative quality loops with acceptance criteria validation
+- **Handoffs**: Seamless transitions between agent modes
+- **Stuck Detection**: Auto-regenerates plans when blocked (Ralph-RLM)
+- **Memory Categories**: Specialized storage (goals, context, facts, learning)
+
+#### Enhanced Setup
+- Updated installer copies complete `.github/` structure
+- VS Code settings requirements check
+- Migration guide for v1.x users
+- Backwards compatibility with existing recursive-analyst agent
+
+### Changed
+
+#### Breaking Changes
+- **Package Scope**: Renamed from `@rembr/client` to `@rembr/vscode`
+- **Architecture**: Agent-based system replaces simple auto-detection
+- **File Structure**: Complete `.github/` directory with agents, skills, prompts, instructions
+- **Usage**: Chat agents (`@rlm`, `@ralph-rlm`) replace automatic pattern recognition
+
+#### Improved
+- **Token Efficiency**: Up to 52% reduction with quality improvements
+- **Quality Assurance**: Ralph-RLM ensures acceptance criteria are met
+- **Developer Experience**: Explicit agent selection vs automatic detection
+- **Documentation**: Comprehensive examples and workflow guides
+
+### Migration from v1.x
+
+1. Backup existing `.github/` files
+2. Run `rembr-vscode-setup` to install v2.0 structure
+3. Copy custom configurations to new format
+4. Enable required VS Code settings:
+   - `github.copilot.chat.codeGeneration.useInstructionFiles: true`
+   - `chat.agent.enabled: true` 
+   - `chat.useAgentSkills: true`
+5. Test with `/rlm-analyze` to verify setup
+
 ## [1.0.0] - 2026-01-06
 
 ### Added

package/README.md

@@ -1,8 +1,8 @@
 # @rembr/vscode
 
-**Recursive Language Model (RLM) patterns for VS Code and GitHub Copilot**
+**Recursive Language Model (RLM) Integration for VS Code and GitHub Copilot**
 
-Transform your AI-assisted development with automatic task decomposition, achieving **51% token efficiency** improvements for complex coding tasks.
+Complete RLM setup with custom agents, skills, prompts, and semantic memory integration. Choose between **basic RLM** for fast decomposition or **Ralph-RLM** for acceptance-driven quality assurance.
 
 ## Quick Start
 
@@ -13,227 +13,339 @@ rembr-vscode-setup
 
 **What happens next?**
 
-✅ GitHub Copilot automatically detects complex tasks  
-✅ Recursive decomposition with focused subagents  
-✅ Semantic memory integration via rembr MCP  
-✅ 51% reduction in token usage for complex requests  
-✅ Complete documentation and workflow helpers  
+✅ **Custom Agents** - `@rlm` and `@ralph-rlm` agents for task orchestration  
+✅ **Skill System** - RLM orchestration skills teach decomposition patterns  
+✅ **Chat Prompts** - `/rlm-analyze`, `/ralph-analyze` for quick starts  
+✅ **Memory Integration** - Persistent context via rembr MCP  
+✅ **Token Efficiency** - 51% reduction for complex tasks  
 
-## How It Works
+## Agent Modes
+
+| Agent | Description | Best For | Exit Condition |
+|-------|-------------|----------|----------------|
+| `@rlm` | Basic RLM - fast decomposition | Quick analysis, bug investigation | Task complete |
+| `@ralph-rlm` | Acceptance-driven loops | Security audits, quality-critical | All criteria met |
+
+### Basic RLM Flow
+```
+User Task → Decompose → Investigate Subtasks → Synthesize Results
+              ↓
+         Store in Rembr (context, facts, learning)
+```
+
+### Ralph-RLM Flow  
+```
+User Task → Define Criteria → LOOP until ALL met:
+                ↓              ├── Load criteria
+            Store in Rembr     ├── Validate findings
+            (goals category)   ├── Update status
+                               ├── Check stuck
+                               └── Regenerate if needed
+```
+
+## Usage Examples
+
+### Using Custom Agents
+
+Select the agent from the agent picker in Chat view:
+
+```
+@rlm Analyze the authentication system and identify all password handling
+```
+
+```
+@ralph-rlm Audit the API endpoints for OWASP Top 10 vulnerabilities
+```
+
+### Using Chat Prompts
+
+Type `/` followed by prompt name:
 
-### Before: Traditional Approach
 ```
-User: "Implement rate limiting for payment service with Redis, auth, monitoring, and tests"
+/rlm-analyze Investigate how user sessions are managed across services
+```
 
-Copilot: [Loads entire codebase context → 12,847 tokens → Single massive response]
-Result: Incomplete implementation, missing edge cases, 4 revisions needed
+```
+/ralph-analyze Perform security audit of payment processing flow
 ```
 
-### After: RLM Patterns
 ```
-User: "Implement rate limiting for payment service with Redis, auth, monitoring, and tests"
+/rlm-plan Generate decomposition plan for rate limiting implementation
+```
 
-Copilot: [Auto-detects complexity → Spawns focused subagents]
-├── L1-Analysis: Analyze payment endpoints (280 tokens)
-├── L1-Design: Design Redis strategy (180 tokens)  
-├── L1-Implementation: Build middleware (350 tokens)
-└── L1-Monitoring: Add metrics/tests (120 tokens)
+### Example Workflows
 
-Result: Complete implementation, 6,241 tokens (51% reduction), 1 revision
+#### Quick Codebase Analysis
+```
+@rlm Analyze the authentication system and find all places where passwords are validated
 ```
 
-The installer automatically configures:
+**Output:**
+- L1-Auth: Authentication middleware analysis
+- L1-Validation: Password validation logic  
+- L1-Security: Hash verification patterns
+- L1-Session: Session management review
 
-### 🧠 GitHub Copilot Integration
-- **`.github/copilot-instructions.md`** - Auto-detection triggers for complex tasks
-- **`.github/agents/recursive-analyst.agent.md`** - Specialized RLM agent
-- **Pattern Recognition** - Automatically identifies when to decompose tasks
+#### Security Audit with Validation
+```
+@ralph-rlm Audit the API endpoints for OWASP Top 10 vulnerabilities
+
+Acceptance Criteria:
+✓ Input validation checked
+✓ Authentication flaws identified  
+✓ Sensitive data exposure reviewed
+✓ XML/XXE injection tested
+✓ Access control verified
+✓ Security misconfiguration found
+✓ XSS vulnerabilities checked
+✓ Deserialization flaws tested
+✓ Component vulnerabilities identified
+✓ Logging/monitoring gaps found
+```
 
-### 📡 MCP Memory Integration  
-- **VS Code settings** - REMBR MCP server configuration
-- **Semantic Memory** - Persistent context across sessions
-- **Cross-project Learning** - Reuse patterns between projects
+#### Planning Before Execution
+```
+/rlm-plan Investigate how rate limiting should be implemented across microservices
 
-### 🛠 Workflow Tools
-- **`rlm-helper.js`** - Task coordination and analysis script
-- **`docs/rlm-patterns.md`** - Complete usage guide  
-- **`docs/rlm-benchmarks.md`** - Performance analysis
+Generated Plan:
+1. L1-Analysis: Current rate limiting state
+2. L1-Architecture: Distributed rate limit design
+3. L1-Implementation: Redis-based implementation
+4. L1-Monitoring: Metrics and alerting
+```
+
+Then execute:
+```
+@rlm [paste the generated plan above]
+```
 
 ## Auto-Detection Examples
 
-### ✅ Complex Tasks (Auto-RLM)
-These requests automatically trigger recursive decomposition:
+The system automatically detects when to use RLM patterns:
 
+### ✅ Complex Tasks (Auto-RLM)
 ```javascript
-// Multi-component implementations
+// Multi-component implementations  
 "Implement OAuth2 with JWT refresh tokens, rate limiting, and admin dashboard"
 
-// Cross-service integrations  
+// Cross-service integrations
 "Migrate user service to microservices with message queues and monitoring"
 
-// Architecture changes
-"Refactor monolith payment system for scalability and add caching"
+// Security audits
+"Audit the authentication system for OWASP Top 10 vulnerabilities"
 
-// Analysis + implementation
-"Analyze current auth flow and rebuild with SSO integration"
+// Architecture analysis
+"Analyze the caching layer and identify performance bottlenecks"
 ```
 
 ### 🎯 Simple Tasks (Standard)
-These use traditional single-shot responses:
-
 ```javascript
 // Single file changes
 "Fix this TypeScript type error"
-"Add logging to this function"  
-"Update README with new installation steps"
-"Rename variable from userID to userId"
+"Add logging to this function"
+"Update README with installation steps"
 ```
 
-## Performance Benefits
-
-| Complexity | Traditional Tokens | RLM Tokens | Reduction | Quality Gain |
-|------------|-------------------|------------|-----------|--------------|
-| **High** | 18,400 | 8,800 | **52%** | +2.5 points |
-| **Medium** | 8,200 | 4,900 | **40%** | +1.8 points |
-| **Low** | 2,100 | 2,100 | **0%** | No change |
-
-### Why RLM Works
+## File Structure Installed
 
-1. **Focused Context** - Each subagent receives only relevant code/memories
-2. **Parallel Processing** - Multiple specialized agents work simultaneously  
-3. **Persistent Learning** - Solutions stored in semantic memory for reuse
-4. **Incremental Validation** - Each level validates before proceeding
+```
+your-project/
+├── .github/
+│   ├── copilot-instructions.md    # Repository-wide RLM instructions
+│   ├── agents/
+│   │   ├── rlm.agent.md           # Basic RLM agent
+│   │   └── ralph-rlm.agent.md     # Acceptance-driven agent
+│   ├── skills/
+│   │   ├── rlm-orchestration/
+│   │   │   └── SKILL.md           # RLM skill definition
+│   │   └── ralph-rlm-orchestration/
+│   │       └── SKILL.md           # Ralph-RLM skill definition
+│   ├── prompts/
+│   │   ├── rlm-analyze.prompt.md   # Quick RLM analysis start
+│   │   ├── ralph-analyze.prompt.md # Quick Ralph-RLM start
+│   │   ├── rlm-plan.prompt.md      # Generate plan only
+│   │   └── ralph-plan.prompt.md    # Define criteria only
+│   └── instructions/
+│       ├── rembr-integration.instructions.md    # Memory patterns
+│       └── code-investigation.instructions.md   # Code search patterns
+└── .vscode/
+    └── settings.json              # MCP configuration
+```
 
 ## Memory Categories
 
-RLM automatically organizes knowledge:
+RLM automatically organizes findings in rembr:
 
-- **`facts`** - Code patterns, implementation details, technical specifications
-- **`context`** - Session coordination, task decomposition metadata
-- **`projects`** - High-level summaries, architectural decisions
+| Category | Purpose | Used By |
+|----------|---------|---------|
+| `goals` | Acceptance criteria and validation status | Ralph-RLM |
+| `context` | Task state, decomposition progress | Both |
+| `facts` | Validated findings and discoveries | Both |
+| `learning` | Synthesized insights and patterns | Both |
 
-## Usage Examples
+## Performance Benefits
 
-### Automatic Pattern Recognition
+| Complexity | Traditional | RLM Tokens | Reduction | Quality |
+|------------|-------------|------------|-----------|---------|
+| **High** | 18,400 | 8,800 | **52%** | +2.5 pts |
+| **Medium** | 8,200 | 4,900 | **40%** | +1.8 pts |
+| **Low** | 2,100 | 2,100 | **0%** | No change |
 
-```bash
-# Analyze any task for RLM suitability
-node rlm-helper.js "implement microservice with auth and monitoring"
+### Why RLM Works
 
-# Output:
-# 🧠 RLM PATTERN DETECTED - Complex task requiring decomposition
-# 📋 Generated TaskId: microservice-20260107-abc12  
-# 🔍 Key Concepts: microservice, auth, monitoring, api, service
-# 🏗️ Suggested Decomposition:
-#    1. L1-Analysis: Analyze current architecture and requirements
-#    2. L1-Design: Design service interfaces and auth strategy
-#    3. L1-Implementation: Build core service and endpoints
-#    4. L1-Monitoring: Add logging, metrics, and health checks
-```
+1. **Focused Context** - Each subagent gets only relevant code/memories
+2. **Iterative Validation** - Ralph-RLM ensures quality criteria are met
+3. **Persistent Learning** - Solutions stored for future reference
+4. **Stuck Detection** - Automatically regenerates plans if blocked
 
-### Memory Integration
+## Agent Handoffs
 
-```javascript
-// RLM automatically stores and retrieves context
-search_memory({ 
-  query: "rate limiting patterns express", 
-  category: "facts",
-  limit: 5 
-});
+Agents support workflow transitions:
 
-// Find related implementations
-find_similar_memories({
-  memory_id: "auth-implementation-xyz",
-  min_similarity: 0.8,
-  limit: 3
-});
+```
+@rlm Can you switch to Ralph-RLM for higher quality validation?
+→ Hands off to @ralph-rlm with current context
+
+@ralph-rlm This looks good, switch to basic RLM for faster completion  
+→ Hands off to @rlm with findings so far
 ```
 
 ## Configuration
 
-### Set API Key
+### 1. Set API Key
+
+Configure your rembr API key in VS Code settings:
 
-After installation, configure your rembr API key:
+1. Get key: [rembr.ai/dashboard/settings](https://rembr.ai/dashboard/settings)
+2. VS Code: `Cmd+,` → Extensions → MCP → `rembr.env.REMBR_API_KEY`
+3. Reload: `Cmd+Shift+P` → "Developer: Reload Window"
 
-1. **Get API Key**: Visit [rembr.ai/dashboard/settings](https://rembr.ai/dashboard/settings)
-2. **VS Code Settings**: `Cmd+,` → Extensions → MCP → `rembr.env.REMBR_API_KEY`
-3. **Reload VS Code**: `Cmd+Shift+P` → "Developer: Reload Window"
+### 2. Enable Required Settings
 
-### Customize Patterns
+Ensure these VS Code settings are enabled:
+
+```json
+{
+  "github.copilot.chat.codeGeneration.useInstructionFiles": true,
+  "chat.agent.enabled": true,
+  "chat.useAgentSkills": true
+}
+```
 
-Edit `.github/copilot-instructions.md` to adjust:
-- Auto-detection triggers
-- Decomposition strategies
-- Memory categories  
-- Subagent specializations
+### 3. MCP Server Configuration
+
+The installer adds to `.vscode/settings.json`:
+
+```json
+{
+  "mcp": {
+    "mcpServers": {
+      "rembr": {
+        "command": "npx",
+        "args": ["@rembr/mcp-client"],
+        "env": {
+          "REMBR_API_KEY": "${REMBR_API_KEY}",
+          "REMBR_PROJECT_ID": "${REMBR_PROJECT_ID}"
+        }
+      }
+    }
+  }
+}
+```
 
 ## Advanced Usage
 
-### Custom Agents
+### Custom Agent Creation
 
 Create domain-specific agents in `.github/agents/`:
 
 ```markdown
 ---
-name: Payment Service Expert
-description: Specialized in payment processing and financial integrations  
-tools:
-  - rembr/*
-  - codebase
-model: Claude Sonnet 4
+name: Security Auditor
+description: Specialized in security analysis with OWASP Top 10 focus
+instructions: |
+  Use Ralph-RLM patterns for security audits.
+  Always define comprehensive acceptance criteria.
+  Check for: injection, auth, exposure, XXE, access control,
+  misconfiguration, XSS, deserialization, components, logging.
 ---
-
-You handle payment system tasks using RLM patterns.
-Auto-decompose into: security, processing, webhooks, compliance.
 ```
 
-### Manual Subagent Spawning
-
-For fine-grained control:
+### Memory Search Patterns
 
 ```javascript
-// Spawn specialized subagent
-runSubagent({
-  description: "Implement Redis rate limiting middleware",
-  prompt: `
-    ## Task  
-    Create express-rate-limit middleware with Redis store
-    
-    ## Context from Memory
-    ${await search_memory({query: "rate limiting redis patterns"})}
-    
-    ## Storage Instructions
-    Store findings with metadata: {"taskId": "rate-limit-20260107", "area": "middleware"}
-  `
+// Find related implementations
+search_memory({
+  query: "rate limiting middleware express redis",
+  category: "facts",
+  limit: 5
+});
+
+// Get similar solutions
+find_similar_memories({
+  memory_id: "auth-jwt-implementation-abc",
+  min_similarity: 0.8
 });
 ```
 
-## Troubleshooting
+### Skill Development
 
-### Memory Not Persisting
-```bash
-# Check MCP connection
-curl -H "X-API-Key: YOUR_KEY" https://rembr.ai/health
+Skills teach agents how to orchestrate tasks:
 
-# Verify VS Code settings  
-code ~/.vscode/settings.json
+```markdown
+# RLM Orchestration Skill
+
+## When to use
+- Complex tasks requiring decomposition
+- Multi-component implementations
+- Cross-system analysis
+
+## How to decompose
+1. Analyze task complexity
+2. Identify major components  
+3. Create focused subtasks
+4. Store context in rembr
+5. Synthesize findings
 ```
 
-### Auto-Detection Not Working
+## Troubleshooting
+
+### Agent not appearing
+- Check `.github/agents/*.agent.md` exists
+- Verify VS Code version ≥1.106
+- Run "Chat: Configure Custom Agents" from Command Palette
+
+### Skills not loading
+- Ensure `chat.useAgentSkills` is enabled
+- Check `.github/skills/*/SKILL.md` structure
+- Skills load automatically based on prompt match
+
+### Memory connection issues
+- Verify MCP configuration in settings
+- Check environment variables
+- Test rembr connection: `curl -H "X-API-Key: YOUR_KEY" https://rembr.ai/health`
+
+### Auto-detection not working
 1. Ensure `.github/copilot-instructions.md` exists in project root
 2. Restart GitHub Copilot: `Cmd+Shift+P` → "GitHub Copilot: Restart Extension"
-3. Use more explicit complexity indicators in your requests
+3. Use explicit complexity indicators in requests
+
+## Migration from v1.x
+
+If upgrading from v1.x:
+
+1. **Backup**: Save existing `.github/` files
+2. **Install**: Run `rembr-vscode-setup` again
+3. **Migrate**: Copy custom configurations to new structure
+4. **Test**: Try `/rlm-analyze` to verify setup
 
-### Subagent Failures
-- Check task complexity (max 3 decomposition levels)
-- Ensure focused, actionable subtasks
-- Verify proper metadata in memory storage
+The new agent-based system replaces the simpler auto-detection patterns.
 
 ## Getting Support
 
 - **Documentation**: [docs.rembr.ai/rlm-patterns](https://docs.rembr.ai/rlm-patterns)
-- **Examples**: Browse with `search_memory({query: "implementation example"})`
-- **Community**: [GitHub Discussions](https://github.com/rembr-ai/community/discussions)
+- **Examples**: Try `search_memory({query: "implementation example"})`
+- **Community**: [GitHub Discussions](https://github.com/rembr-ai/community/discussions)  
 - **Issues**: [GitHub Issues](https://github.com/rembr-ai/vscode-extension/issues)
 
 ## License
@@ -242,7 +354,8 @@ MIT - see [LICENSE](LICENSE) for details.
 
 ---
 
-**Version**: 1.0.0  
-**Compatibility**: GitHub Copilot, VS Code, Claude Desktop  
-**Memory Backend**: [rembr.ai](https://rembr.ai) (hosted) or self-hosted  
-**Token Efficiency**: Up to 55% reduction for complex development tasks
+**Version**: 2.0.0  
+**Agents**: Basic RLM (`@rlm`) and Ralph-RLM (`@ralph-rlm`)  
+**Skills**: RLM orchestration patterns with quality validation  
+**Memory Backend**: [rembr.ai](https://rembr.ai) semantic memory service  
+**Token Efficiency**: Up to 52% reduction with quality improvements

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const { setup } = require('./setup');
 
-console.log('🫐 REMBR VS Code RLM Pattern Setup');
+console.log('🫐 REMBR VS Code RLM Agent Setup v2.0');
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -9,7 +9,7 @@ const command = args[0];
 switch (command) {
   case 'setup':
   case 'init':
-    console.log('Setting up GitHub Copilot with recursive language model patterns...\n');
+    console.log('Setting up GitHub Copilot with RLM agents, skills, and prompts...\n');
     setup(true);
     break;
   
@@ -17,31 +17,46 @@ switch (command) {
   case '--help':
   case '-h':
     console.log(`
-� REMBR VS Code RLM Patterns - Recursive Language Model setup for GitHub Copilot
+🫐 REMBR VS Code RLM Agent System v2.0
 
 Usage:
-  npx @rembr/vscode setup    Configure RLM patterns in your project
+  npx @rembr/vscode setup    Configure RLM agent system in your project
   npx @rembr/vscode help     Show this help message
 
-What it does:
-  • Adds GitHub Copilot instructions for automatic task decomposition
-  • Creates Recursive Analyst agent for complex tasks
-  • Configures REMBR MCP server for semantic memory
-  • Adds RLM helper scripts and documentation
+What it installs:
+  • Custom Agents: @rlm (fast) and @ralph-rlm (quality-focused)
+  • Skills: RLM orchestration patterns with validation
+  • Prompts: /rlm-analyze, /ralph-analyze, /rlm-plan, /ralph-plan
+  • Instructions: Memory patterns and code investigation guides
+  • MCP Server: Semantic memory integration
+
+Agent Modes:
+  • @rlm: Fast decomposition for quick analysis
+  • @ralph-rlm: Acceptance-driven loops with quality validation
+
+Usage Examples:
+  @rlm Analyze authentication system for security issues
+  @ralph-rlm Audit API endpoints for OWASP Top 10 vulnerabilities
+  /rlm-analyze "investigate rate limiting implementation"
 
 Benefits:
-  • 51% token efficiency improvement for complex tasks
-  • Automatic detection of decomposition-worthy tasks
+  • 52% token efficiency improvement for complex tasks
+  • Quality assurance through acceptance criteria
   • Persistent semantic memory across sessions
-  • Focused subagent coordination
+  • Handoffs between agent modes
+
+Requirements:
+  • VS Code 1.106+ with GitHub Copilot
+  • Settings: chat.agent.enabled, chat.useAgentSkills enabled
 
 Get started:
   1. Run: npx @rembr/vscode setup
   2. Get API key: https://rembr.ai/dashboard/settings
   3. Configure in VS Code: Settings → MCP → rembr.env.REMBR_API_KEY
-  4. Reload VS Code and try a complex task
+  4. Enable required VS Code settings (see output)
+  5. Try: @rlm or /rlm-analyze
 
-Learn more: https://docs.rembr.ai/rlm-patterns
+Learn more: https://docs.rembr.ai/rlm-agents
 `);
     break;
   

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rembr/vscode",
-  "version": "1.0.0",
-  "description": "VS Code setup for REMBR RLM patterns - semantic memory for AI agents with GitHub Copilot recursive workflows",
+  "version": "2.0.0",
+  "description": "VS Code RLM integration - Recursive Language Model patterns with GitHub Copilot agents, skills, and semantic memory",
   "main": "setup.js",
   "bin": {
     "rembr-vscode": "./cli.js"