@rembr/vscode 1.0.0 → 2.0.0

package/templates/recursive-analyst.agent.md

@@ -1,18 +1,8 @@
 ---
-name: Recursive Analyst
-description: Analyses and implements complex tasks using recursive decomposition with semantic memory
+name: Recursive Agent
+description: Orchestrates complex tasks using sequential decomposition with semantic memory coordination
 tools:
-  - codebase
-  - editFiles
-  - runInTerminal
-  - runTests
-  - search
-  - fetch
-  - usages
-  - problems
-  - terminalLastCommand
-  - terminalSelection
-  - rembr/*
+  ['execute/runInTerminal', 'execute/runTests', 'read/terminalSelection', 'read/terminalLastCommand', 'read/problems', 'read/readFile', 'edit/editFiles', 'search', 'web/fetch', 'runSubagent', 'rembr/*']
 infer: true
 model: Claude Sonnet 4
 handoffs:
@@ -22,13 +12,15 @@ handoffs:
     send: false
 ---
 
-# Recursive Analyst
+# Sequential Task Orchestrator
 
-You implement the Recursive Language Model (RLM) pattern. You handle arbitrarily complex tasks by:
+You implement the Recursive Language Model (RLM) pattern adapted for VS Code Copilot. You handle arbitrarily complex tasks by:
 1. Never working with more context than necessary
 2. Using rembr to retrieve only relevant prior knowledge
-3. Spawning subagents for focused sub-tasks, each receiving targeted context from rembr
-4. Coordinating subagent results through structured returns
+3. Orchestrating sequential subagents for focused sub-tasks (one level only)
+4. Coordinating subagent results through structured returns and rembr storage
+
+**Platform Limitation**: VS Code Copilot does not support nested subagents. Use sequential decomposition instead of deep recursion.
 
 ## Subagent Contract
 

package/templates/skills/ralph-rlm-orchestration/SKILL.md

@@ -0,0 +1,297 @@
+---
+name: ralph-rlm-orchestration
+description: Use this skill for acceptance-driven coding tasks that must loop until explicit criteria are met. Combines RLM decomposition with Ralph Wiggum's validation loops and stuck detection.
+license: MIT
+---
+
+# Ralph-RLM Orchestration Skill
+
+This skill teaches you how to perform acceptance-driven RLM orchestration where you loop until ALL criteria are explicitly met and validated.
+
+## When to Use This Skill
+
+Activate this skill when:
+- Task has quality requirements that must be validated
+- Completion means meeting specific, measurable criteria
+- You need automatic stuck detection and recovery
+- Quality matters more than speed
+
+## Core Principle
+
+> "The plan is disposable. The acceptance criteria are not."
+> — Ralph Wiggum approach
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────┐
+│                 RALPH-RLM LOOP                       │
+│  ┌────────────────────────────────────────────────┐  │
+│  │ 1. Load criteria from Rembr                    │  │
+│  │ 2. Validate findings against criteria          │  │
+│  │ 3. If ALL met → COMPLETE                       │  │
+│  │ 4. If NOT met → Decompose & investigate        │  │
+│  │ 5. Check stuck condition                       │  │
+│  │ 6. If stuck → Regenerate plan                  │  │
+│  │ 7. Update progress → Loop                      │  │
+│  └────────────────────────────────────────────────┘  │
+│                        ↕                             │
+│  ┌────────────────────────────────────────────────┐  │
+│  │              REMBR MCP                         │  │
+│  │  goals: Acceptance criteria                    │  │
+│  │  context: Progress, iteration state            │  │
+│  │  facts: Validated findings                     │  │
+│  │  learning: Synthesis                           │  │
+│  └────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────┘
+```
+
+## Step-by-Step Process
+
+### Step 1: Define Acceptance Criteria
+
+**Before any work**, derive explicit criteria:
+
+```javascript
+const taskId = `ralph-rlm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+const criteria = [
+  {
+    id: "AC1",
+    criterion: "All authentication endpoints use rate limiting",
+    evidenceRequired: "file:line showing rate limit middleware",
+    status: "pending"
+  },
+  {
+    id: "AC2", 
+    criterion: "Passwords are hashed with bcrypt cost ≥10",
+    evidenceRequired: "file:line showing bcrypt configuration",
+    status: "pending"
+  },
+  {
+    id: "AC3",
+    criterion: "JWT tokens expire within 24 hours",
+    evidenceRequired: "file:line showing token expiration setting",
+    status: "pending"
+  }
+];
+
+await rembr.store({
+  category: "goals",
+  content: JSON.stringify(criteria),
+  metadata: {
+    taskId,
+    level: "L0",
+    type: "acceptance_criteria",
+    progress: { total: 3, met: 0 }
+  }
+});
+```
+
+### Step 2: Initialize Progress Tracking
+
+```javascript
+await rembr.store({
+  category: "context",
+  content: "Starting Ralph-RLM loop",
+  metadata: {
+    taskId,
+    type: "progress",
+    iteration: 1,
+    stuckCount: 0,
+    previousMetCount: 0,
+    status: "running"
+  }
+});
+```
+
+### Step 3: Main Loop
+
+```
+REPEAT:
+  // Load current state
+  criteria = await rembr.search({ taskId, category: "goals" })
+  progress = await rembr.search({ taskId, category: "context", type: "progress" })
+  
+  // Check completion
+  metCount = criteria.filter(c => c.status === "met").length
+  IF metCount === criteria.length:
+    BREAK → COMPLETE
+  
+  // Investigate unmet criteria
+  FOR EACH unmetCriterion:
+    // Store L1 criteria before investigation
+    await storeL1Criteria(unmetCriterion)
+    
+    // Investigate with code tools
+    findings = await investigate(unmetCriterion)
+    
+    // Validate against criterion
+    IF hasValidEvidence(findings, unmetCriterion):
+      await storeFinding(findings)
+      await updateCriterionStatus(unmetCriterion, "met")
+  
+  // Check stuck condition
+  IF metCount === previousMetCount:
+    stuckCount++
+    IF stuckCount >= 3:
+      await regeneratePlan()
+      stuckCount = 0
+  ELSE:
+    stuckCount = 0
+  
+  // Update progress
+  await updateProgress(iteration++, metCount, stuckCount)
+```
+
+### Step 4: Validation Rules
+
+A finding is only valid when:
+
+1. **Specific Evidence**: file:line reference or test output
+2. **Matches Criterion**: Directly addresses the acceptance criterion
+3. **Independently Verifiable**: Another agent could confirm it
+
+```javascript
+function validateFinding(finding, criterion) {
+  return (
+    finding.evidence?.length > 0 &&
+    finding.evidence.every(e => /^[\w/.]+:\d+$/.test(e)) &&
+    finding.criterion === criterion.id
+  );
+}
+```
+
+### Step 5: Stuck Detection & Recovery
+
+```javascript
+async function checkStuck(currentMetCount, previousMetCount, stuckCount) {
+  if (currentMetCount === previousMetCount) {
+    stuckCount++;
+    if (stuckCount >= 3) {
+      console.log("STUCK DETECTED - Regenerating plan");
+      await regeneratePlan();
+      return 0; // Reset stuck count
+    }
+  } else {
+    return 0; // Progress made, reset
+  }
+  return stuckCount;
+}
+
+async function regeneratePlan() {
+  // Load original criteria
+  const criteria = await rembr.search({ category: "goals" });
+  
+  // Analyze what's blocking progress
+  const blockers = analyzeBlockers();
+  
+  // Generate new decomposition approach
+  const newPlan = generateAlternativePlan(criteria, blockers);
+  
+  // Store new plan
+  await rembr.store({
+    category: "context",
+    content: `Regenerated plan: ${JSON.stringify(newPlan)}`,
+    metadata: { type: "plan_regeneration" }
+  });
+}
+```
+
+### Step 6: Synthesis on Completion
+
+```javascript
+async function synthesize(taskId) {
+  // Gather all validated findings
+  const findings = await rembr.search({
+    query: taskId,
+    category: "facts"
+  });
+  
+  // Check for contradictions
+  const contradictions = findContradictions(findings);
+  
+  // Store synthesis
+  await rembr.store({
+    category: "learning",
+    content: `Synthesis: All ${findings.length} criteria met. ${
+      contradictions.length ? `Contradictions: ${contradictions}` : 'No contradictions.'
+    }`,
+    metadata: {
+      taskId,
+      type: "synthesis",
+      status: "complete",
+      criteriaCount: findings.length
+    }
+  });
+}
+```
+
+## Acceptance Criteria Templates
+
+### Security Audit
+```markdown
+- AC1: All user inputs are sanitized before database queries
+- AC2: Authentication uses industry-standard hashing (bcrypt/argon2)
+- AC3: Session tokens have expiration ≤24h
+- AC4: CORS is configured for specific origins only
+- AC5: Sensitive data is encrypted at rest
+```
+
+### Feature Implementation
+```markdown
+- AC1: Feature handles happy path correctly
+- AC2: Feature handles all error cases gracefully
+- AC3: Feature has ≥80% test coverage
+- AC4: Feature is documented in README
+- AC5: Feature follows existing code patterns
+```
+
+### Documentation
+```markdown
+- AC1: All public APIs are documented
+- AC2: All configuration options are explained
+- AC3: Setup instructions are complete and tested
+- AC4: Examples are provided for common use cases
+```
+
+## The 9s (Guardrails)
+
+| Rule | Description |
+|------|-------------|
+| 99 | Evidence required - never claim without proof |
+| 999 | Update progress every iteration |
+| 9999 | Check criteria before claiming completion |
+| 99999 | Store learnings for future reference |
+| 999999 | Regenerate plan if stuck 3+ iterations |
+| 9999999 | Never exit until ALL criteria validated |
+
+## Example: Security Audit with Ralph-RLM
+
+```
+Task: "Audit authentication system for OWASP compliance"
+
+Acceptance Criteria:
+- AC1: No SQL injection vulnerabilities
+- AC2: Passwords hashed with bcrypt cost ≥12
+- AC3: Session tokens use secure random generation
+- AC4: Rate limiting on login endpoints
+- AC5: No sensitive data in logs
+
+Iteration 1:
+- Investigated AC1: Found parameterized queries ✅
+- Investigated AC2: Found bcrypt cost = 10 ❌
+- Progress: 1/5 met
+
+Iteration 2:
+- Investigated AC2 again: Confirmed cost = 10
+- Investigated AC3: Found crypto.randomBytes() ✅
+- Progress: 2/5 met
+
+Iteration 3:
+- Investigated AC4: Found express-rate-limit ✅
+- Investigated AC5: Found password logged! ❌
+- Progress: 3/5 met
+
+[Loop continues until all criteria addressed]
+```

package/templates/skills/rlm-orchestration/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: rlm-orchestration
+description: Use this skill when decomposing complex coding tasks into subagent investigations. Applies RLM (Recursive Language Model) patterns for hierarchical task breakdown with Rembr state coordination.
+license: MIT
+---
+
+# RLM Orchestration Skill
+
+This skill teaches you how to perform Recursive Language Model (RLM) orchestration for complex coding tasks.
+
+## When to Use This Skill
+
+Activate this skill when:
+- Task requires analyzing multiple files or systems
+- Investigation needs structured decomposition
+- Results should be persisted and synthesized
+- Subtasks can be investigated independently
+
+## RLM Architecture
+
+```
+USER TASK
+    ↓
+┌─────────────────────────────────────┐
+│          L0 ORCHESTRATOR            │
+│  - Decompose task                   │
+│  - Store context in Rembr           │
+│  - Coordinate subagents             │
+│  - Synthesize results               │
+└─────────────────────────────────────┘
+    ↓           ↓           ↓
+┌─────────┐ ┌─────────┐ ┌─────────┐
+│ L1 Sub  │ │ L1 Sub  │ │ L1 Sub  │
+│ Agent   │ │ Agent   │ │ Agent   │
+└─────────┘ └─────────┘ └─────────┘
+    ↓           ↓           ↓
+┌─────────────────────────────────────┐
+│            REMBR MCP                │
+│  Persistent State Coordinator       │
+│  - goals, context, facts, learning  │
+└─────────────────────────────────────┘
+```
+
+## Step-by-Step Process
+
+### Step 1: Initialize Task
+
+```javascript
+// Generate unique task ID
+const taskId = `rlm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+// Store in Rembr
+await rembr.store({
+  category: "context",
+  content: `Task: ${taskDescription}`,
+  metadata: {
+    taskId,
+    level: "L0",
+    type: "task_initialization",
+    status: "in_progress"
+  }
+});
+```
+
+### Step 2: Decompose Task
+
+Analyze the task and identify 2-5 independent subtasks:
+
+```markdown
+## Decomposition for: [Task Name]
+
+### Subtask 1: [Name]
+- Focus: [Single clear objective]
+- Scope: [Files/areas to investigate]
+- Output: [Expected finding type]
+
+### Subtask 2: [Name]
+...
+```
+
+### Step 3: Execute Subtasks
+
+For each subtask:
+
+1. **Create Context Snapshot**
+   ```javascript
+   await rembr.store({
+     category: "context",
+     content: `Subtask: ${subtaskDescription}`,
+     metadata: { taskId, level: "L1", subtaskId, parentId: taskId }
+   });
+   ```
+
+2. **Investigate with Code Tools**
+   ```bash
+   # Search for patterns
+   rg "pattern" --type ts
+   
+   # Find relevant files
+   find . -name "*.ts" -path "*auth*"
+   
+   # Extract specific content
+   sed -n '10,50p' src/auth/handler.ts
+   ```
+
+3. **Store Validated Findings**
+   ```javascript
+   await rembr.store({
+     category: "facts",
+     content: `Finding: ${description}`,
+     metadata: {
+       taskId,
+       subtaskId,
+       evidence: ["src/auth/handler.ts:42", "src/auth/config.ts:15"],
+       confidence: 0.95
+     }
+   });
+   ```
+
+### Step 4: Synthesize Results
+
+```javascript
+// Search for all findings
+const findings = await rembr.search({
+  query: taskId,
+  category: "facts"
+});
+
+// Identify patterns
+const patterns = analyzeFindings(findings);
+
+// Store synthesis
+await rembr.store({
+  category: "learning",
+  content: `Synthesis: ${synthesizedResult}`,
+  metadata: {
+    taskId,
+    type: "synthesis",
+    status: "complete",
+    findingCount: findings.length
+  }
+});
+```
+
+## Rembr Categories Reference
+
+| Category | Purpose | Example Content |
+|----------|---------|-----------------|
+| `goals` | Acceptance criteria, objectives | "Must identify all SQL injection points" |
+| `context` | Task state, progress, plans | "Analyzing auth module, iteration 2" |
+| `facts` | Validated findings with evidence | "Found hardcoded secret at config.ts:42" |
+| `learning` | Synthesized insights | "Auth uses 3 different patterns..." |
+
+## Best Practices
+
+1. **Store Early, Store Often**: Put findings in Rembr immediately
+2. **Evidence First**: Always include file:line references
+3. **Focused Subtasks**: One clear objective per subtask
+4. **Progress Updates**: Track state after each major step
+5. **No Speculation**: Only report verified findings
+
+## Example: Security Audit
+
+```
+Task: "Analyze authentication system for vulnerabilities"
+
+Subtask 1: Credential Storage
+- Search: rg "password|secret|key" --type ts
+- Focus: How are credentials stored?
+
+Subtask 2: Session Management  
+- Search: rg "session|token|jwt" --type ts
+- Focus: Session lifecycle and expiration
+
+Subtask 3: Input Validation
+- Search: rg "validate|sanitize|escape" --type ts
+- Focus: Are inputs properly validated?
+
+Synthesis: Combine findings into security assessment
+```

package/templates/aider.conf.yml

@@ -1,52 +0,0 @@
-# Aider configuration with REMBR semantic memory
-
-# REMBR Integration
-# 
-# REMBR provides persistent semantic memory for your coding sessions.
-# While Aider doesn't natively support MCP, you can integrate REMBR via:
-#
-# 1. Manual tool calls in prompts:
-#    "First, search REMBR for authentication patterns, then implement..."
-#
-# 2. External scripts that call the REMBR API:
-#    curl -X POST https://rembr.ai/api/v1/search \
-#      -H "Authorization: Bearer $REMBR_API_KEY" \
-#      -d '{"query": "authentication patterns"}'
-#
-# 3. Pre/post hooks that store session context:
-#    - Before: Retrieve relevant context from REMBR
-#    - After: Store findings and decisions to REMBR
-
-# Model configuration
-model: claude-sonnet-4
-
-# Enable git integration
-auto-commits: true
-dirty-commits: true
-
-# Editor for commit messages
-editor: vim
-
-# Suggested workflow with REMBR:
-#
-# 1. Before starting: Query REMBR for relevant context
-#    $ rembr-query "database migration patterns"
-#
-# 2. During coding: Aider makes changes
-#
-# 3. After completing: Store findings to REMBR
-#    $ rembr-store "Migrated users table to support OAuth. Added provider column."
-#
-# You can create these wrapper scripts to integrate REMBR with Aider.
-
-# Example bash aliases for ~/.bashrc:
-#
-# alias rembr-query='curl -X POST https://rembr.ai/api/v1/search \
-#   -H "Authorization: Bearer $REMBR_API_KEY" \
-#   -H "Content-Type: application/json" \
-#   -d "{\"query\": \"$1\", \"limit\": 5}" | jq -r ".memories[].content"'
-#
-# alias rembr-store='curl -X POST https://rembr.ai/api/v1/memories \
-#   -H "Authorization: Bearer $REMBR_API_KEY" \
-#   -H "Content-Type: application/json" \
-#   -d "{\"content\": \"$1\", \"category\": \"facts\"}"'

package/templates/cursorrules

@@ -1,141 +0,0 @@
-# REMBR - Recursive Language Model with Semantic Memory
-
-You have access to REMBR, a semantic memory system via MCP tools. Use it to implement the Recursive Language Model (RLM) pattern for complex tasks.
-
-## Core Principles
-
-1. **Never work with more context than necessary** - Query REMBR for only relevant prior knowledge
-2. **Break down complex tasks** - Spawn focused subtasks with targeted context
-3. **Store findings persistently** - Save discoveries to REMBR for future sessions
-4. **Coordinate through structured returns** - Each subtask returns a standard result format
-
-## Available REMBR Tools (via MCP)
-
-### Memory Management
-- `store_memory` - Store insights, facts, preferences, project info
-- `search_memory` - Hybrid semantic + text search across memories
-- `list_memories` - Browse recent memories by category
-- `get_memory` - Retrieve specific memory by ID
-- `delete_memory` - Remove outdated memories
-
-### Context Workspaces
-- `create_context` - Create workspace for related memories
-- `add_memory_to_context` - Link memories to contexts
-- `search_context` - Scoped search within a workspace
-- `list_contexts` - View available workspaces
-
-### Snapshots (for subtask handoffs)
-- `create_snapshot` - Immutable memory bundle with TTL
-- `get_snapshot` - Retrieve snapshot by ID
-- `list_snapshots` - View available snapshots
-
-### Insights
-- `get_stats` - Usage and limits
-- `get_context_insights` - Category distribution, patterns
-- `get_memory_graph` - Memory relationships
-- `detect_contradictions` - Find conflicting information
-
-## Memory Categories
-
-Organize memories semantically:
-- **facts** - Concrete information and data
-- **preferences** - User settings and choices
-- **conversations** - Conversation context
-- **projects** - Project-specific information
-- **learning** - Knowledge and insights
-- **goals** - Objectives and targets
-- **context** - Situational context
-- **reminders** - Future actions
-
-## RLM Pattern: Parent-Subtask Protocol
-
-### Before Decomposing
-
-1. Generate unique `taskId` (e.g., `implement-auth-20240106`)
-2. Query REMBR for relevant prior context:
-   ```
-   search_memory({ query: "authentication patterns OAuth JWT", limit: 10 })
-   ```
-3. Identify subtasks and what context each needs
-
-### When Spawning Subtasks
-
-Provide each subtask with:
-```
-## Subtask
-[Specific focused objective]
-
-## Context from REMBR
-[Relevant memories retrieved for this subtask]
-
-## Storage Instructions
-Store findings with:
-- Category: "facts"
-- Metadata: { "taskId": "implement-auth-20240106", "area": "oauth-flow" }
-
-## Return Format
-- Summary: [What you found/did]
-- Findings stored: [Search query to retrieve details]
-- Key points: [Most important items]
-- Status: [complete/partial/blocked]
-```
-
-### After Subtasks Complete
-
-1. Read each subtask's summary and key points
-2. If full details needed, query REMBR:
-   ```
-   search_memory({ query: "implement-auth-20240106 oauth-flow", category: "facts" })
-   ```
-3. Synthesize findings and store to REMBR for future sessions
-
-## Example Usage
-
-### Storing a Discovery
-```
-store_memory({
-  category: "facts",
-  content: "API uses rate limiting: 100 req/min per user via express-rate-limit + Redis",
-  metadata: {
-    taskId: "rate-limit-analysis",
-    area: "api-middleware",
-    file: "src/middleware/rateLimit.ts"
-  }
-})
-```
-
-### Retrieving Context
-```
-search_memory({
-  query: "rate limiting middleware patterns",
-  category: "facts",
-  limit: 5
-})
-```
-
-### Creating a Workspace
-```
-create_context({
-  name: "payment-service-refactor",
-  description: "Refactoring payment service to microservices",
-  category: "projects"
-})
-```
-
-## When to Use REMBR
-
-✅ **Do use** for:
-- Storing architectural decisions
-- Remembering project patterns and conventions
-- Building knowledge across sessions
-- Coordinating complex multi-step tasks
-- Sharing context between subtasks
-
-❌ **Don't use** for:
-- Temporary variables or transient data
-- Information already in the codebase
-- Simple single-step tasks
-
-## API Key Setup
-
-Ensure `REMBR_API_KEY` is set in your Cursor environment settings.