# Install claude-flow with ReasoningBank support
npm install claude-flow@latest

# Initialize memory system
npx claude-flow agent memory init

# Verify installation
npx claude-flow agent memory status

# Initialize memory (creates .swarm/memory.db)
npx claude-flow@latest agent memory init

# Run agent with memory enabled
npx claude-flow@latest agent run coder "Build REST API" --enable-memory

# Check learning progress
npx claude-flow@latest agent memory status

# Check agentic-flow version (should be 1.4.11)
npm list agentic-flow

# Test ReasoningBank commands
npx agentic-flow reasoningbank help

# Run interactive demo (23% → 98% success improvement)
npx claude-flow agent memory demo

# Initialize ReasoningBank database
claude-flow agent memory init

# Output:
# 🧠 Initializing ReasoningBank memory system...
# Database: .swarm/memory.db
# ✅ Database initialized successfully!

# First execution (no prior memories)
claude-flow agent run coder "Build REST API with auth" --enable-memory

# Second execution (learns from first attempt)
claude-flow agent run coder "Add JWT authentication" --enable-memory --memory-domain api

# Third execution (retrieves top 5 relevant memories)
claude-flow agent run coder "Implement OAuth2 flow" --enable-memory --memory-k 5

# Check current memory statistics
claude-flow agent memory status

# Output:
# 📊 ReasoningBank Status
# • Total memories: 15
# • Average confidence: 0.87
# • Total embeddings: 15
# • Total trajectories: 8

# List memories for specific domain
claude-flow agent memory list --domain api --limit 10

# Consolidate memories (deduplicate + prune low quality)
claude-flow agent memory consolidate

# Output:
# 🧠 Consolidating ReasoningBank memories...
# Pruned 3 low-quality memories
# Deduplicated 2 similar memories
# ✅ Memory consolidation complete!

# Anthropic (highest quality, learns best patterns)
claude-flow agent run coder "Build API" --enable-memory --provider anthropic

# OpenRouter (99% cost savings, still learns)
claude-flow agent run coder "Add endpoints" --enable-memory --provider openrouter

# ONNX (free local, learns from local patterns)
claude-flow agent run coder "Write tests" --enable-memory --provider onnx

# Gemini (free tier, learns efficiently)
claude-flow agent run coder "Document code" --enable-memory --provider gemini

# Custom database location
claude-flow agent run coder "Build feature" \
  --enable-memory \
  --memory-db ./project/.memory/db.sqlite

# Domain-specific memory with high k
claude-flow agent run coder "Security audit" \
  --enable-memory \
  --memory-domain security \
  --memory-k 10

# Disable learning (retrieve only, don't store new memories)
claude-flow agent run coder "Quick fix" \
  --enable-memory \
  --no-memory-learning

# High confidence threshold (only use very reliable memories)
claude-flow agent run coder "Critical bug fix" \
  --enable-memory \
  --memory-min-confidence 0.9

┌─────────────┐
│  1. RETRIEVE │  Fetch top-k relevant memories
└──────┬──────┘  (similarity 65%, recency 15%,
       │          reliability 20%, diversity -10%)
       ▼
┌─────────────┐
│  2. EXECUTE  │  Run agent task with memory context
└──────┬──────┘  (memories guide decision-making)
       │
       ▼
┌─────────────┐
│  3. JUDGE    │  LLM-as-judge evaluates outcome
└──────┬──────┘  (success/failure + confidence score)
       │
       ▼
┌─────────────┐
│  4. DISTILL  │  Extract generalizable patterns
└──────┬──────┘  (store for future retrieval)
       │
       └──────► Back to RETRIEVE (next task)

score(m, q) = α·sim(embed(m), embed(q))     # 65% - Semantic similarity
            + β·recency(m)                   # 15% - Time decay
            + γ·reliability(m)               # 20% - Success rate
            - δ·diversity_penalty(m, M)      # 10% - Avoid redundancy

Default: α=0.65, β=0.15, γ=0.20, δ=0.10

# Run all ReasoningBank integration tests
npm test tests/integration/reasoningbank-integration.test.js

# Test categories:
# ✅ CLI Memory Commands (4 tests)
# ✅ Agent Execution with Memory (3 tests)
# ✅ SDK Integration (2 tests)
# ✅ Agentic-Flow Dependency (2 tests)
# ✅ End-to-End Workflow (1 test)
# ✅ Performance Requirements (2 tests)

# 1. Initialize memory
claude-flow agent memory init

# 2. Run demo (shows learning progression)
claude-flow agent memory demo

# 3. Check status
claude-flow agent memory status

# 4. List memories
claude-flow agent memory list --limit 10

# 5. Run agent with memory
claude-flow agent run coder "Build calculator" --enable-memory --provider onnx

# 6. Verify memory was created
claude-flow agent memory status  # Should show 1+ memories

// Agent execution options with memory support
interface AgentExecutionOptions {
  agent: string;
  task: string;
  provider?: 'anthropic' | 'openrouter' | 'onnx' | 'gemini';
  model?: string;

  // ReasoningBank memory options (NEW)
  enableMemory?: boolean;           // Enable learning
  memoryDatabase?: string;          // DB path
  memoryRetrievalK?: number;        // Top-k (default: 3)
  memoryLearning?: boolean;         // Post-task learning
  memoryDomain?: string;            // Domain filter
  memoryMinConfidence?: number;     // Min confidence (0-1)
  memoryTaskId?: string;            // Custom task ID
}

// Execution result with memory metrics
interface AgentExecutionResult {
  success: boolean;
  output: string;
  duration: number;
  agent: string;
  task: string;

  // ReasoningBank metrics (NEW)
  memoryEnabled?: boolean;          // Was memory used?
  memoriesRetrieved?: number;       // How many retrieved?
  memoriesUsed?: string[];          // Memory IDs applied
  memoryLearned?: boolean;          // New memories created?
  memoryVerdict?: 'success' | 'failure';
  memoryConfidence?: number;        // Judge confidence
  newMemoryIds?: string[];          // New memory IDs
}

import { AgentExecutor } from 'claude-flow';

const executor = new AgentExecutor();

// Initialize memory
await executor.initializeMemory('.swarm/memory.db');

// Execute agent with memory
const result = await executor.execute({
  agent: 'coder',
  task: 'Build REST API',
  provider: 'anthropic',
  enableMemory: true,
  memoryDomain: 'api',
  memoryRetrievalK: 5,
});

console.log(`Success: ${result.success}`);
console.log(`Duration: ${result.duration}ms`);
console.log(`Memories retrieved: ${result.memoriesRetrieved}`);
console.log(`Memories used: ${result.memoriesUsed?.join(', ')}`);
console.log(`New memories: ${result.newMemoryIds?.length}`);

// Get memory statistics
const stats = await executor.getMemoryStats();
console.log(stats);

// Consolidate memories
await executor.consolidateMemories();

# Required for LLM-based judge/distill
export ANTHROPIC_API_KEY=sk-ant-...

# Optional: Real embeddings (falls back to hash-based)
export OPENAI_API_KEY=sk-...

# Enable ReasoningBank by default
export REASONINGBANK_ENABLED=true

# Custom database path
export CLAUDE_FLOW_DB_PATH=.swarm/memory.db

# node_modules/agentic-flow/src/reasoningbank/config/reasoningbank.yaml

retrieval:
  k: 3                          # Top-k memories
  min_confidence: 0.5           # Confidence threshold
  use_mmr: true                 # Maximal Marginal Relevance

scoring:
  similarity_weight: 0.65       # Semantic similarity
  recency_weight: 0.15          # Time decay
  reliability_weight: 0.20      # Success rate
  diversity_penalty: 0.10       # Redundancy penalty

consolidation:
  dedup_threshold: 0.95         # Similarity for deduplication
  prune_threshold: 0.30         # Min confidence to keep
  auto_consolidate: false       # Auto-run after N memories

# Error: Database file not found
# Solution: Initialize first
claude-flow agent memory init

# Error: EACCES: permission denied
# Solution: Check directory permissions
chmod 755 .swarm/
chmod 644 .swarm/memory.db

# Warning: ANTHROPIC_API_KEY not set
# Solution: Memory still works, but judge/distill use fallbacks
export ANTHROPIC_API_KEY=sk-ant-...

# Or use ONNX provider (no API key needed)
claude-flow agent run coder "task" --enable-memory --provider onnx

# Check memory statistics
claude-flow agent memory status

# If Total memories = 0, learning might be disabled
# Enable learning explicitly:
claude-flow agent run coder "task" --enable-memory --memory-learning true

# If confidence is low, consolidate:
claude-flow agent memory consolidate

# 1. Use domain filters to improve relevance
claude-flow agent run coder "API task" --enable-memory --memory-domain api

# 2. Increase k for complex tasks
claude-flow agent run coder "Complex feature" --enable-memory --memory-k 10

# 3. Consolidate regularly (dedup + prune)
claude-flow agent memory consolidate

# 4. Use appropriate provider for task
claude-flow agent run coder "Quick fix" --enable-memory --provider onnx  # Fast
claude-flow agent run coder "Critical bug" --enable-memory --provider anthropic  # Best