agentic-flow 1.4.6 → 1.4.8

package/dist/reasoningbank/core/memory-engine.js

@@ -0,0 +1,335 @@
+/**
+ * ReasoningBank Memory Engine
+ * Implements the 4-phase learning loop: RETRIEVE → JUDGE → DISTILL → CONSOLIDATE
+ */
+import { ReasoningBankDB } from './database.js';
+import { createEmbeddingProvider, cosineSimilarity } from '../utils/embeddings.js';
+import { piiScrubber } from '../utils/pii-scrubber.js';
+export class ReasoningBankEngine {
+    db;
+    embeddings;
+    piiEnabled;
+    weights;
+    defaultK;
+    minConfidence;
+    consolidationThreshold;
+    memoriesSinceConsolidation = 0;
+    constructor(config) {
+        this.db = new ReasoningBankDB(config.dbPath);
+        this.embeddings = createEmbeddingProvider(config.embeddings?.provider || 'hash', {
+            apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
+            model: config.embeddings?.model
+        });
+        this.piiEnabled = config.piiScrub?.enabled !== false;
+        this.weights = {
+            alpha: config.retrieval?.weights?.alpha || 0.65, // Similarity
+            beta: config.retrieval?.weights?.beta || 0.15, // Recency
+            gamma: config.retrieval?.weights?.gamma || 0.20, // Reliability
+            delta: config.retrieval?.weights?.delta || 0.10 // Diversity penalty
+        };
+        this.defaultK = config.retrieval?.k || 3;
+        this.minConfidence = config.retrieval?.minConfidence || 0.3;
+        this.consolidationThreshold = config.consolidation?.scheduleEvery || 20;
+    }
+    /**
+     * Phase 1: RETRIEVE - Get relevant memories using 4-factor scoring
+     */
+    async retrieve(options) {
+        const k = options.k || this.defaultK;
+        const lambda = options.lambda || 0.9;
+        // Generate query embedding
+        const queryEmbedding = await this.embeddings.generate(options.query);
+        // Get all memories
+        const allMemories = this.db.getAllMemories();
+        const embeddings = this.db.getAllEmbeddings();
+        // Filter by domain if specified
+        let candidates = allMemories;
+        if (options.domain) {
+            candidates = candidates.filter(m => m.pattern_data.domain === options.domain ||
+                m.pattern_data.domain?.startsWith(options.domain + '.'));
+        }
+        // Calculate scores for each candidate
+        const scoredCandidates = [];
+        for (const memory of candidates) {
+            const embedding = embeddings.get(memory.id);
+            if (!embedding)
+                continue;
+            // 1. Similarity score (cosine similarity)
+            const similarity = cosineSimilarity(queryEmbedding, embedding);
+            // 2. Recency score (exponential decay, 30-day half-life)
+            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
+            const recency = Math.exp(-ageDays / 30);
+            // 3. Reliability score (confidence × sqrt(usage/10))
+            const reliability = Math.min(memory.confidence * Math.sqrt(memory.usage_count / 10), 1.0);
+            // Combined score (before diversity penalty)
+            const score = this.weights.alpha * similarity +
+                this.weights.beta * recency +
+                this.weights.gamma * reliability;
+            scoredCandidates.push({
+                ...memory,
+                score,
+                similarity,
+                recency,
+                reliability,
+                diversityPenalty: 0 // Will be calculated in MMR
+            });
+        }
+        // Sort by score
+        scoredCandidates.sort((a, b) => b.score - a.score);
+        // Apply MMR for diversity
+        const selected = this.selectWithMMR(scoredCandidates, queryEmbedding, k, lambda);
+        // Update usage counts
+        for (const memory of selected) {
+            this.db.updateMemoryUsage(memory.id);
+        }
+        // Filter by minimum confidence
+        return selected.filter(m => m.confidence >= this.minConfidence);
+    }
+    /**
+     * MMR (Maximal Marginal Relevance) Selection
+     * Balances relevance and diversity
+     */
+    selectWithMMR(candidates, queryEmbedding, k, lambda) {
+        const selected = [];
+        const remaining = [...candidates];
+        const embeddings = this.db.getAllEmbeddings();
+        while (selected.length < k && remaining.length > 0) {
+            let bestScore = -Infinity;
+            let bestIndex = -1;
+            for (let i = 0; i < remaining.length; i++) {
+                const candidate = remaining[i];
+                const candidateEmbedding = embeddings.get(candidate.id);
+                if (!candidateEmbedding)
+                    continue;
+                // Relevance to query
+                const relevance = candidate.score;
+                // Maximum similarity to already selected
+                let maxSimilarity = 0;
+                if (selected.length > 0) {
+                    for (const selectedMemory of selected) {
+                        const selectedEmbedding = embeddings.get(selectedMemory.id);
+                        if (selectedEmbedding) {
+                            const sim = cosineSimilarity(candidateEmbedding, selectedEmbedding);
+                            maxSimilarity = Math.max(maxSimilarity, sim);
+                        }
+                    }
+                }
+                // MMR score
+                const mmrScore = lambda * relevance - (1 - lambda) * maxSimilarity;
+                if (mmrScore > bestScore) {
+                    bestScore = mmrScore;
+                    bestIndex = i;
+                }
+            }
+            if (bestIndex >= 0) {
+                selected.push(remaining[bestIndex]);
+                remaining.splice(bestIndex, 1);
+            }
+            else {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+     * Phase 2: JUDGE - Evaluate task outcome
+     */
+    async judge(trajectory) {
+        // Simple heuristic judge (can be upgraded to LLM)
+        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
+        // Heuristics for success/failure
+        const errorKeywords = ['error', 'failed', 'exception', 'timeout', 'unauthorized', 'forbidden'];
+        const successKeywords = ['success', 'completed', 'ok', '200', 'done'];
+        const lowerTrajectory = scrubbed.toLowerCase();
+        const hasError = errorKeywords.some(kw => lowerTrajectory.includes(kw));
+        const hasSuccess = successKeywords.some(kw => lowerTrajectory.includes(kw));
+        if (hasSuccess && !hasError) {
+            return { label: 'Success', confidence: 0.8, rationale: 'Success keywords found' };
+        }
+        else if (hasError && !hasSuccess) {
+            return { label: 'Failure', confidence: 0.8, rationale: 'Error keywords found' };
+        }
+        else if (hasSuccess && hasError) {
+            return { label: 'Success', confidence: 0.5, rationale: 'Mixed signals' };
+        }
+        else {
+            return { label: 'Failure', confidence: 0.5, rationale: 'No clear indicators' };
+        }
+    }
+    /**
+     * Phase 3: DISTILL - Extract patterns from trajectory
+     */
+    async distill(taskId, trajectory, verdict, domain) {
+        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
+        // Store trajectory
+        this.db.insertTrajectory({
+            task_id: taskId,
+            trajectory: scrubbed,
+            verdict: verdict.label,
+            confidence: verdict.confidence
+        });
+        // Extract pattern based on verdict
+        const pattern = verdict.label === 'Success'
+            ? this.extractSuccessPattern(scrubbed, domain)
+            : this.extractFailureGuardrail(scrubbed, domain);
+        // Store as memory
+        const memoryId = this.db.insertMemory({
+            title: pattern.title,
+            description: pattern.description,
+            content: pattern.content,
+            confidence: verdict.confidence,
+            usage_count: 0,
+            pattern_data: {
+                domain,
+                success_pattern: verdict.label === 'Success',
+                failure_guardrail: verdict.label === 'Failure'
+            }
+        });
+        // Generate and store embedding
+        const embedding = await this.embeddings.generate(pattern.content);
+        this.db.insertEmbedding(memoryId, embedding);
+        this.memoriesSinceConsolidation++;
+        return memoryId;
+    }
+    extractSuccessPattern(trajectory, domain) {
+        // Extract key steps from successful execution
+        const lines = trajectory.split('\n').filter(l => l.trim());
+        const keySteps = lines.slice(0, 5).join('\n');
+        return {
+            title: `Success pattern for ${domain}`,
+            description: `Successful execution strategy`,
+            content: `Successful approach:\n${keySteps}`
+        };
+    }
+    extractFailureGuardrail(trajectory, domain) {
+        // Extract error information
+        const lines = trajectory.split('\n').filter(l => l.trim());
+        const errorInfo = lines.find(l => l.toLowerCase().includes('error') ||
+            l.toLowerCase().includes('failed')) || 'Unknown error';
+        return {
+            title: `Failure guardrail for ${domain}`,
+            description: `Prevention strategy for common failures`,
+            content: `Avoid: ${errorInfo}\nRecommend: Check prerequisites and retry with backoff`
+        };
+    }
+    /**
+     * Phase 4: CONSOLIDATE - Deduplicate and prune
+     */
+    async consolidate(options) {
+        const startTime = Date.now();
+        const dedupeThreshold = options?.dedupeThreshold || 0.95;
+        const maxAgeDays = options?.prune?.maxAgeDays || 90;
+        const minConfidence = options?.prune?.minConfidence || 0.3;
+        const unusedDays = options?.prune?.unusedDays || 30;
+        // Find and merge duplicates
+        const duplicates = this.db.findDuplicates(dedupeThreshold);
+        for (const [id1, id2] of duplicates) {
+            const mem1 = this.db.getMemory(id1);
+            const mem2 = this.db.getMemory(id2);
+            if (mem1 && mem2) {
+                // Keep the one with higher confidence and usage
+                const keepId = mem1.confidence > mem2.confidence ||
+                    (mem1.confidence === mem2.confidence && mem1.usage_count > mem2.usage_count)
+                    ? id1 : id2;
+                const deleteId = keepId === id1 ? id2 : id1;
+                this.db.deleteMemory(deleteId);
+            }
+        }
+        // Prune old or low-quality memories
+        const allMemories = this.db.getAllMemories();
+        let pruned = 0;
+        for (const memory of allMemories) {
+            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
+            const lastUsedDays = ageDays; // Simplified: assume last used = created
+            const shouldPrune = ageDays > maxAgeDays ||
+                memory.confidence < minConfidence ||
+                (memory.usage_count === 0 && lastUsedDays > unusedDays);
+            if (shouldPrune) {
+                this.db.deleteMemory(memory.id);
+                pruned++;
+            }
+        }
+        // Detect contradictions (simplified)
+        const contradictions = 0; // TODO: Implement semantic contradiction detection
+        this.memoriesSinceConsolidation = 0;
+        return {
+            processed: allMemories.length,
+            duplicates: duplicates.length,
+            contradictions,
+            pruned,
+            durationMs: Date.now() - startTime
+        };
+    }
+    /**
+     * High-level task execution with full learning loop
+     */
+    async runTask(options) {
+        // Phase 1: RETRIEVE
+        const memories = await this.retrieve({
+            query: options.query,
+            domain: options.domain
+        });
+        // EXECUTE
+        const result = await options.executeFn(memories);
+        // Phase 2: JUDGE
+        const verdict = await this.judge(result.log);
+        // Phase 3: DISTILL
+        await this.distill(options.taskId, result.log, verdict, options.domain);
+        // Phase 4: CONSOLIDATE (if threshold reached)
+        if (this.memoriesSinceConsolidation >= this.consolidationThreshold) {
+            await this.consolidate();
+        }
+        return {
+            success: result.success,
+            summary: `Task ${options.taskId}: ${verdict.label} (confidence: ${verdict.confidence})`,
+            memories,
+            verdict
+        };
+    }
+    /**
+     * MaTTS: Memory-aware Test-Time Scaling (Parallel)
+     */
+    async mattsParallel(options) {
+        const runs = await Promise.all(Array.from({ length: options.k }, async (_, i) => {
+            const memories = await this.retrieve({
+                query: options.query,
+                domain: options.domain
+            });
+            const result = await options.executeFn(memories);
+            const verdict = await this.judge(result.log);
+            this.db.insertMattsRun({
+                task_id: options.taskId,
+                run_index: i,
+                result: result.log,
+                verdict: verdict.label,
+                confidence: verdict.confidence
+            });
+            return { result, verdict };
+        }));
+        // Calculate consensus
+        const successes = runs.filter(r => r.verdict.label === 'Success').length;
+        const avgConfidence = runs.reduce((sum, r) => sum + r.verdict.confidence, 0) / runs.length;
+        const consensusVerdict = {
+            label: successes > runs.length / 2 ? 'Success' : 'Failure',
+            confidence: avgConfidence
+        };
+        return {
+            success: consensusVerdict.label === 'Success',
+            summary: `MaTTS Parallel: ${successes}/${runs.length} successes, consensus: ${consensusVerdict.label}`,
+            memories: [],
+            verdict: consensusVerdict
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return this.db.getStats();
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}

package/dist/reasoningbank/types/index.js

@@ -0,0 +1,5 @@
+/**
+ * ReasoningBank Type Definitions
+ * Based on arXiv:2509.25140 (Google DeepMind)
+ */
+export {};

package/dist/utils/reasoningbankCommands.js

@@ -1,58 +1,57 @@
-// ReasoningBank CLI command handlers
+/**
+ * ReasoningBank CLI Commands
+ * Handles demo, test, init, benchmark, status, consolidate, list
+ */
 import { spawn } from 'child_process';
-import { resolve } from 'path';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 export async function handleReasoningBankCommand(subcommand) {
-    const rbPath = resolve(process.cwd(), 'src/reasoningbank');
-    switch (subcommand) {
-        case 'demo':
-            console.log('\n🎯 Running ReasoningBank Demo Comparison...\n');
-            console.log('This demo shows ReasoningBank learning from experience:');
-            console.log('• Traditional: 0% success, repeats mistakes');
-            console.log('• ReasoningBank: 100% success, learns & improves\n');
-            await runScript(`${rbPath}/demo-comparison.ts`);
-            break;
-        case 'test':
-            console.log('\n🧪 Running ReasoningBank Validation Tests...\n');
-            await runScript(`${rbPath}/test-validation.ts`);
-            console.log('\n');
-            await runScript(`${rbPath}/test-retrieval.ts`);
-            console.log('\n');
-            await runScript(`${rbPath}/test-integration.ts`);
-            break;
-        case 'init':
-            console.log('\n📦 Initializing ReasoningBank Database...\n');
-            console.log('Creating memory database at .swarm/memory.db\n');
-            await runBashCommand('mkdir -p .swarm');
-            await runBashCommand('sqlite3 .swarm/memory.db < src/reasoningbank/migrations/000_base_schema.sql');
-            await runBashCommand('sqlite3 .swarm/memory.db < src/reasoningbank/migrations/001_reasoningbank_schema.sql');
-            console.log('✅ ReasoningBank database initialized!\n');
-            break;
-        case 'benchmark':
-            console.log('\n⚡ Running ReasoningBank Performance Benchmarks...\n');
-            await runScript(`${rbPath}/benchmark.ts`);
-            break;
-        case 'status':
-            console.log('\n📊 ReasoningBank Memory Statistics\n');
-            await runBashCommand(`sqlite3 .swarm/memory.db "SELECT
-        (SELECT COUNT(*) FROM reasoning_memory) as total_memories,
-        (SELECT COUNT(*) FROM reasoning_memory WHERE confidence > 0.7) as high_confidence,
-        (SELECT COUNT(*) FROM task_trajectory) as total_tasks,
-        (SELECT AVG(confidence) FROM reasoning_memory) as avg_confidence;"`);
-            console.log('\n');
-            break;
-        case 'help':
-        default:
-            printReasoningBankHelp();
-            break;
+    const args = process.argv.slice(4); // Get args after 'reasoningbank <subcommand>'
+    try {
+        switch (subcommand) {
+            case 'demo':
+                await runExternalScript('../reasoningbank/demo-comparison.js');
+                break;
+            case 'test':
+                await runExternalScript('../reasoningbank/test-validation.js');
+                break;
+            case 'init':
+                await initDatabase();
+                break;
+            case 'benchmark':
+                await runExternalScript('../reasoningbank/benchmark.js');
+                break;
+            case 'status':
+                await showStatus();
+                break;
+            case 'consolidate':
+                await runConsolidation();
+                break;
+            case 'list':
+                await listMemories(args);
+                break;
+            case 'help':
+            default:
+                printHelp();
+                break;
+        }
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
     }
 }
-async function runScript(scriptPath) {
+async function runExternalScript(relativePath) {
+    const scriptPath = join(__dirname, relativePath);
     return new Promise((resolve, reject) => {
-        const proc = spawn('npx', ['tsx', scriptPath], {
+        const child = spawn('node', [scriptPath], {
             stdio: 'inherit',
-            shell: true
+            cwd: process.cwd()
         });
-        proc.on('close', (code) => {
+        child.on('exit', (code) => {
             if (code === 0) {
                 resolve();
             }
@@ -60,77 +59,145 @@ async function runScript(scriptPath) {
                 reject(new Error(`Script exited with code ${code}`));
             }
         });
-        proc.on('error', (err) => {
-            reject(err);
+        child.on('error', (error) => {
+            reject(error);
         });
     });
 }
-async function runBashCommand(command) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn(command, {
-            stdio: 'inherit',
-            shell: true
-        });
-        proc.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Command exited with code ${code}`));
-            }
-        });
-        proc.on('error', (err) => {
-            reject(err);
-        });
-    });
+async function initDatabase() {
+    console.log('\n🔧 Initializing ReasoningBank Database');
+    console.log('═'.repeat(50));
+    const { initialize } = await import('../reasoningbank/index.js');
+    console.log('\nInitializing database with migrations...\n');
+    await initialize();
+    console.log('\n✅ Database initialized successfully!');
+    console.log('\nSchema created:');
+    console.log('  • patterns (reasoning memories)');
+    console.log('  • pattern_embeddings');
+    console.log('  • pattern_links');
+    console.log('  • task_trajectories');
+    console.log('  • matts_runs');
+    console.log('  • consolidation_runs');
+    console.log('  • metrics_log\n');
+}
+async function showStatus() {
+    console.log('\n📊 ReasoningBank Status');
+    console.log('═'.repeat(50));
+    const { db } = await import('../reasoningbank/index.js');
+    const dbInstance = db.getDb();
+    const stats = {
+        totalMemories: dbInstance.prepare("SELECT COUNT(*) as count FROM patterns WHERE type = 'reasoning_memory'").get(),
+        avgConfidence: dbInstance.prepare("SELECT AVG(confidence) as avg FROM patterns WHERE type = 'reasoning_memory'").get(),
+        totalEmbeddings: dbInstance.prepare('SELECT COUNT(*) as count FROM pattern_embeddings').get(),
+        totalTrajectories: dbInstance.prepare('SELECT COUNT(*) as count FROM task_trajectories').get()
+    };
+    console.log(`\n📈 Statistics:`);
+    console.log(`  • Total memories: ${stats.totalMemories.count}`);
+    console.log(`  • Average confidence: ${stats.avgConfidence.avg?.toFixed(2) || 'N/A'}`);
+    console.log(`  • Total embeddings: ${stats.totalEmbeddings.count}`);
+    console.log(`  • Total trajectories: ${stats.totalTrajectories.count}\n`);
 }
-function printReasoningBankHelp() {
+async function runConsolidation() {
+    console.log('\n🔄 Running Memory Consolidation');
+    console.log('═'.repeat(50));
+    console.log('\nDeduplicating and pruning memories...\n');
+    const { consolidate } = await import('../reasoningbank/index.js');
+    const startTime = Date.now();
+    const result = await consolidate();
+    const duration = Date.now() - startTime;
+    console.log('✅ Consolidation complete!\n');
+    console.log(`📊 Results:`);
+    console.log(`  • Memories processed: ${result.itemsProcessed}`);
+    console.log(`  • Duplicates found: ${result.duplicatesFound}`);
+    console.log(`  • Contradictions found: ${result.contradictionsFound}`);
+    console.log(`  • Pruned: ${result.itemsPruned}`);
+    console.log(`  • Duration: ${result.durationMs}ms\n`);
+}
+async function listMemories(args) {
+    const { db } = await import('../reasoningbank/index.js');
+    const dbInstance = db.getDb();
+    // Parse arguments
+    const sortBy = args.includes('--sort') ? args[args.indexOf('--sort') + 1] : 'created_at';
+    const limit = args.includes('--limit') ? parseInt(args[args.indexOf('--limit') + 1], 10) : 10;
+    console.log('\n📚 Memory Bank Contents');
+    console.log('═'.repeat(50));
+    console.log(`\nShowing top ${limit} memories (sorted by ${sortBy})\n`);
+    let orderBy = 'created_at DESC';
+    if (sortBy === 'confidence') {
+        orderBy = 'confidence DESC';
+    }
+    else if (sortBy === 'usage') {
+        orderBy = 'usage_count DESC';
+    }
+    const memories = dbInstance.prepare(`
+    SELECT
+      id,
+      json_extract(pattern_data, '$.title') as title,
+      json_extract(pattern_data, '$.description') as description,
+      json_extract(pattern_data, '$.domain') as domain,
+      confidence,
+      usage_count,
+      created_at
+    FROM patterns
+    WHERE type = 'reasoning_memory'
+    ORDER BY ${orderBy}
+    LIMIT ?
+  `).all(limit);
+    if (memories.length === 0) {
+        console.log('No memories found. Run `npx agentic-flow reasoningbank demo` to create some!\n');
+        return;
+    }
+    for (let i = 0; i < memories.length; i++) {
+        const mem = memories[i];
+        console.log(`${i + 1}. ${mem.title}`);
+        console.log(`   Confidence: ${parseFloat(mem.confidence).toFixed(2)} | Usage: ${mem.usage_count} | Created: ${mem.created_at}`);
+        console.log(`   Domain: ${mem.domain}`);
+        console.log(`   ${mem.description}`);
+        console.log('');
+    }
+}
+function printHelp() {
     console.log(`
-🧠 ReasoningBank - Memory System that Learns from Experience
+🧠 ReasoningBank - Closed-loop memory system for AI agents
 
 USAGE:
-  npx agentic-flow reasoningbank <command>
+  npx agentic-flow reasoningbank <COMMAND>
 
 COMMANDS:
-  demo        Run interactive demo showing 0% → 100% success transformation
-  test        Run comprehensive validation suite (27 tests)
-  init        Initialize ReasoningBank database (.swarm/memory.db)
-  benchmark   Run performance benchmarks (retrieval, insertion, etc.)
-  status      Show memory statistics and database status
-  help        Show this help message
+  demo          Run interactive demo showing learning progression
+  test          Run validation test suite
+  init          Initialize database schema
+  benchmark     Run performance benchmarks
+  status        Show memory statistics
+  consolidate   Run memory consolidation now
+  list          List memories with options
+  help          Show this help message
+
+LIST OPTIONS:
+  --sort <field>    Sort by: confidence, usage, created_at (default)
+  --limit <n>       Show top N memories (default: 10)
 
 EXAMPLES:
-  # See the transformation from traditional to learning agents
+  # Run demo to see 0% → 100% success transformation
   npx agentic-flow reasoningbank demo
 
-  # Validate installation and run all tests
-  npx agentic-flow reasoningbank test
-
-  # Setup database for first-time use
+  # Initialize database
   npx agentic-flow reasoningbank init
 
-  # Check memory bank statistics
-  npx agentic-flow reasoningbank status
+  # Run validation tests
+  npx agentic-flow reasoningbank test
 
-FEATURES:
-  ✅ Learns from both successes and failures
-  ✅ 100% success rate after learning (vs 0% for traditional)
-  ✅ 46% faster execution over time
-  ✅ Knowledge transfers across similar tasks
-  ✅ Zero manual intervention needed
+  # Show current statistics
+  npx agentic-flow reasoningbank status
 
-REQUIREMENTS:
-  • SQLite3 (for database operations)
-  • ANTHROPIC_API_KEY (optional, for LLM-based learning)
+  # Consolidate memories (dedupe + prune)
+  npx agentic-flow reasoningbank consolidate
 
-  Without API key: Uses heuristic fallbacks (70% accuracy)
-  With API key: Uses LLM-based judgment (95% accuracy)
+  # List top 10 memories by confidence
+  npx agentic-flow reasoningbank list --sort confidence --limit 10
 
-DOCUMENTATION:
-  • Full README: src/reasoningbank/README.md
-  • Demo Report: docs/REASONINGBANK-DEMO.md
-  • Integration: docs/REASONINGBANK-CLI-INTEGRATION.md
-  • Paper: https://arxiv.org/html/2509.25140v1
+  # List top 5 most used memories
+  npx agentic-flow reasoningbank list --sort usage --limit 5
 
 For more information: https://github.com/ruvnet/agentic-flow
   `);