claude-flow 2.7.0-alpha → 2.7.0-alpha.10

package/dist/src/reasoningbank/reasoningbank-adapter.js

@@ -0,0 +1,283 @@
+import * as ReasoningBank from 'agentic-flow/reasoningbank';
+import { v4 as uuidv4 } from 'uuid';
+let backendInitialized = false;
+let initPromise = null;
+const queryCache = new Map();
+const CACHE_SIZE = 100;
+const CACHE_TTL = 60000;
+async function ensureInitialized() {
+    if (backendInitialized) {
+        return true;
+    }
+    if (initPromise) {
+        return initPromise;
+    }
+    initPromise = (async ()=>{
+        try {
+            await ReasoningBank.initialize();
+            backendInitialized = true;
+            console.log('[ReasoningBank] Node.js backend initialized successfully');
+            return true;
+        } catch (error) {
+            console.error('[ReasoningBank] Backend initialization failed:', error);
+            throw new Error(`Failed to initialize ReasoningBank: ${error.message}`);
+        }
+    })();
+    return initPromise;
+}
+export async function initializeReasoningBank() {
+    await ensureInitialized();
+    return true;
+}
+export async function storeMemory(key, value, options = {}) {
+    await ensureInitialized();
+    try {
+        const memoryId = options.id || uuidv4();
+        const memory = {
+            id: memoryId,
+            type: 'reasoning_memory',
+            pattern_data: {
+                title: key,
+                content: value,
+                domain: options.namespace || 'default',
+                agent: options.agent || 'memory-agent',
+                task_type: options.type || 'fact',
+                original_key: key,
+                original_value: value,
+                namespace: options.namespace || 'default'
+            },
+            confidence: options.confidence || 0.8,
+            usage_count: 0
+        };
+        ReasoningBank.db.upsertMemory(memory);
+        try {
+            const embedding = await ReasoningBank.computeEmbedding(value);
+            ReasoningBank.db.upsertEmbedding({
+                id: memoryId,
+                model: 'text-embedding-3-small',
+                dims: embedding.length,
+                vector: embedding
+            });
+        } catch (embeddingError) {
+            console.warn('[ReasoningBank] Failed to generate embedding:', embeddingError.message);
+        }
+        queryCache.clear();
+        return memoryId;
+    } catch (error) {
+        console.error('[ReasoningBank] storeMemory failed:', error);
+        throw new Error(`Failed to store memory: ${error.message}`);
+    }
+}
+export async function queryMemories(searchQuery, options = {}) {
+    const cached = getCachedQuery(searchQuery, options);
+    if (cached) {
+        return cached;
+    }
+    await ensureInitialized();
+    const limit = options.limit || 10;
+    const namespace = options.namespace || options.domain || 'default';
+    try {
+        const results = await ReasoningBank.retrieveMemories(searchQuery, {
+            domain: namespace,
+            agent: options.agent || 'query-agent',
+            k: limit,
+            minConfidence: options.minConfidence || 0.3
+        });
+        const memories = results.map((memory)=>({
+                id: memory.id,
+                key: memory.title || 'unknown',
+                value: memory.content || memory.description || '',
+                namespace: namespace,
+                confidence: memory.components?.reliability || 0.8,
+                usage_count: memory.usage_count || 0,
+                created_at: memory.created_at || new Date().toISOString(),
+                score: memory.score || 0,
+                _pattern: memory
+            }));
+        if (memories.length === 0) {
+            console.warn('[ReasoningBank] Semantic search returned 0 results, trying database fallback');
+            const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({
+                domain: namespace,
+                minConfidence: options.minConfidence || 0.3
+            });
+            const fallbackMemories = fallbackResults.slice(0, limit).map((memory)=>({
+                    id: memory.id,
+                    key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',
+                    value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',
+                    namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',
+                    confidence: memory.confidence || 0.8,
+                    usage_count: memory.usage_count || 0,
+                    created_at: memory.created_at || new Date().toISOString()
+                }));
+            setCachedQuery(searchQuery, options, fallbackMemories);
+            return fallbackMemories;
+        }
+        setCachedQuery(searchQuery, options, memories);
+        return memories;
+    } catch (error) {
+        console.warn('[ReasoningBank] Query failed, trying database fallback:', error.message);
+        try {
+            const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({
+                domain: namespace,
+                minConfidence: options.minConfidence || 0.3
+            });
+            const fallbackMemories = fallbackResults.slice(0, limit).map((memory)=>({
+                    id: memory.id,
+                    key: memory.pattern_data?.title || 'unknown',
+                    value: memory.pattern_data?.content || '',
+                    namespace: memory.pattern_data?.domain || 'default',
+                    confidence: memory.confidence || 0.8,
+                    usage_count: memory.usage_count || 0,
+                    created_at: memory.created_at || new Date().toISOString()
+                }));
+            setCachedQuery(searchQuery, options, fallbackMemories);
+            return fallbackMemories;
+        } catch (fallbackError) {
+            console.error('[ReasoningBank] All query methods failed:', fallbackError);
+            return [];
+        }
+    }
+}
+export async function listMemories(options = {}) {
+    await ensureInitialized();
+    const limit = options.limit || 10;
+    const namespace = options.namespace;
+    try {
+        let memories;
+        if (namespace && namespace !== 'default') {
+            const allMemories = ReasoningBank.db.getAllActiveMemories();
+            memories = allMemories.filter((m)=>m.pattern_data?.domain === namespace).slice(0, limit);
+        } else {
+            memories = ReasoningBank.db.getAllActiveMemories().slice(0, limit);
+        }
+        return memories.map((memory)=>({
+                id: memory.id,
+                key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',
+                value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',
+                namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',
+                confidence: memory.confidence || 0.8,
+                usage_count: memory.usage_count || 0,
+                created_at: memory.created_at || new Date().toISOString()
+            }));
+    } catch (error) {
+        console.error('[ReasoningBank] listMemories failed:', error);
+        return [];
+    }
+}
+export async function getStatus() {
+    await ensureInitialized();
+    try {
+        const db = ReasoningBank.db.getDb();
+        const patterns = db.prepare("SELECT COUNT(*) as count FROM patterns WHERE type = 'reasoning_memory'").get();
+        const embeddings = db.prepare("SELECT COUNT(*) as count FROM pattern_embeddings").get();
+        const trajectories = db.prepare("SELECT COUNT(*) as count FROM task_trajectories").get();
+        const links = db.prepare("SELECT COUNT(*) as count FROM pattern_links").get();
+        const avgConf = db.prepare("SELECT AVG(confidence) as avg FROM patterns WHERE type = 'reasoning_memory'").get();
+        const domains = db.prepare("SELECT COUNT(DISTINCT json_extract(pattern_data, '$.domain')) as count FROM patterns WHERE type = 'reasoning_memory'").get();
+        return {
+            total_memories: patterns.count || 0,
+            total_categories: domains.count || 0,
+            storage_backend: 'SQLite (Node.js)',
+            database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db',
+            performance: 'SQLite with persistent storage',
+            avg_confidence: avgConf.avg || 0.8,
+            total_embeddings: embeddings.count || 0,
+            total_trajectories: trajectories.count || 0,
+            total_links: links.count || 0
+        };
+    } catch (error) {
+        console.error('[ReasoningBank] getStatus failed:', error);
+        return {
+            total_memories: 0,
+            error: error.message
+        };
+    }
+}
+export async function checkReasoningBankTables() {
+    try {
+        await ensureInitialized();
+        const db = ReasoningBank.db.getDb();
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'pattern%'").all();
+        const tableNames = tables.map((t)=>t.name);
+        const requiredTables = [
+            'patterns',
+            'pattern_embeddings',
+            'pattern_links',
+            'task_trajectories'
+        ];
+        const missingTables = requiredTables.filter((t)=>!tableNames.includes(t));
+        return {
+            exists: true,
+            existingTables: tableNames,
+            missingTables: missingTables,
+            requiredTables: requiredTables,
+            backend: 'SQLite (Node.js)',
+            note: missingTables.length > 0 ? 'Some tables are missing - run migrations' : 'All tables present'
+        };
+    } catch (error) {
+        return {
+            exists: false,
+            existingTables: [],
+            missingTables: [],
+            requiredTables: [],
+            error: error.message
+        };
+    }
+}
+export async function migrateReasoningBank() {
+    try {
+        await ReasoningBank.db.runMigrations();
+        return {
+            success: true,
+            message: 'Database migrations completed successfully',
+            migrated: true,
+            database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db'
+        };
+    } catch (error) {
+        return {
+            success: false,
+            message: `Migration failed: ${error.message}`,
+            error: error.message
+        };
+    }
+}
+function getCachedQuery(searchQuery, options) {
+    const cacheKey = JSON.stringify({
+        searchQuery,
+        options
+    });
+    const cached = queryCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        return cached.results;
+    }
+    return null;
+}
+function setCachedQuery(searchQuery, options, results) {
+    const cacheKey = JSON.stringify({
+        searchQuery,
+        options
+    });
+    if (queryCache.size >= CACHE_SIZE) {
+        const firstKey = queryCache.keys().next().value;
+        queryCache.delete(firstKey);
+    }
+    queryCache.set(cacheKey, {
+        results,
+        timestamp: Date.now()
+    });
+}
+export function cleanup() {
+    try {
+        if (backendInitialized) {
+            ReasoningBank.clearEmbeddingCache();
+            ReasoningBank.db.closeDb();
+            backendInitialized = false;
+            initPromise = null;
+            console.log('[ReasoningBank] Database connection closed');
+        }
+    } catch (error) {
+        console.error('[ReasoningBank] Cleanup failed:', error.message);
+    }
+}
+
+//# sourceMappingURL=reasoningbank-adapter.js.map

package/dist/src/reasoningbank/reasoningbank-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/reasoningbank/reasoningbank-adapter.js"],"sourcesContent":["/**\n * ReasoningBank Adapter for Claude-Flow (Node.js Backend)\n *\n * Uses agentic-flow@1.5.13 Node.js backend with SQLite for persistent storage\n * Provides semantic search via embeddings and MMR ranking\n *\n * Backend: SQLite with better-sqlite3\n * Features: Persistent storage, semantic search, memory consolidation\n */\n\nimport * as ReasoningBank from 'agentic-flow/reasoningbank';\nimport { v4 as uuidv4 } from 'uuid';\n\n// Backend instance (singleton)\nlet backendInitialized = false;\nlet initPromise = null;\n\n// Query result cache (LRU)\nconst queryCache = new Map();\nconst CACHE_SIZE = 100;\nconst CACHE_TTL = 60000; // 60 seconds\n\n/**\n * Initialize ReasoningBank Node.js backend\n * @returns {Promise<boolean>}\n */\nasync function ensureInitialized() {\n  if (backendInitialized) {\n    return true;\n  }\n\n  if (initPromise) {\n    return initPromise;\n  }\n\n  initPromise = (async () => {\n    try {\n      // Initialize Node.js backend with SQLite database\n      await ReasoningBank.initialize();\n      backendInitialized = true;\n      console.log('[ReasoningBank] Node.js backend initialized successfully');\n      return true;\n    } catch (error) {\n      console.error('[ReasoningBank] Backend initialization failed:', error);\n      throw new Error(`Failed to initialize ReasoningBank: ${error.message}`);\n    }\n  })();\n\n  return initPromise;\n}\n\n/**\n * Initialize ReasoningBank database (Node.js version)\n */\nexport async function initializeReasoningBank() {\n  // Initialize the Node.js backend\n  await ensureInitialized();\n  return true;\n}\n\n/**\n * Store a memory in ReasoningBank (Node.js backend with SQLite)\n *\n * Maps claude-flow memory model to ReasoningBank pattern model:\n * - key -> title\n * - value -> content (searchable text)\n * - namespace -> domain\n * - confidence -> confidence score\n */\nexport async function storeMemory(key, value, options = {}) {\n  await ensureInitialized();\n\n  try {\n    const memoryId = options.id || uuidv4();\n\n    // Map our memory model to ReasoningBank pattern model\n    const memory = {\n      id: memoryId,\n      type: 'reasoning_memory',\n      pattern_data: {\n        title: key,\n        content: value,\n        domain: options.namespace || 'default',\n        agent: options.agent || 'memory-agent',\n        task_type: options.type || 'fact',\n        // Store original values for compatibility\n        original_key: key,\n        original_value: value,\n        namespace: options.namespace || 'default'\n      },\n      confidence: options.confidence || 0.8,\n      usage_count: 0\n    };\n\n    // Store memory using Node.js backend\n    ReasoningBank.db.upsertMemory(memory);\n\n    // Generate and store embedding for semantic search\n    try {\n      const embedding = await ReasoningBank.computeEmbedding(value);\n      ReasoningBank.db.upsertEmbedding({\n        id: memoryId,\n        model: 'text-embedding-3-small', // Default model\n        dims: embedding.length,\n        vector: embedding\n      });\n    } catch (embeddingError) {\n      console.warn('[ReasoningBank] Failed to generate embedding:', embeddingError.message);\n      // Continue without embedding - memory is still stored\n    }\n\n    // Invalidate query cache when new memory is added\n    queryCache.clear();\n\n    return memoryId;\n  } catch (error) {\n    console.error('[ReasoningBank] storeMemory failed:', error);\n    throw new Error(`Failed to store memory: ${error.message}`);\n  }\n}\n\n/**\n * Query memories from ReasoningBank (Node.js backend with semantic search)\n *\n * Uses retrieveMemories for semantic search via embeddings and MMR ranking\n * Fallback to database query if semantic search fails\n */\nexport async function queryMemories(searchQuery, options = {}) {\n  // Check cache first\n  const cached = getCachedQuery(searchQuery, options);\n  if (cached) {\n    return cached;\n  }\n\n  await ensureInitialized();\n  const limit = options.limit || 10;\n  // Accept both 'namespace' and 'domain' for compatibility\n  const namespace = options.namespace || options.domain || 'default';\n\n  try {\n    // Try semantic search first using retrieveMemories\n    const results = await ReasoningBank.retrieveMemories(searchQuery, {\n      domain: namespace,\n      agent: options.agent || 'query-agent',\n      k: limit,\n      minConfidence: options.minConfidence || 0.3\n    });\n\n    // Map backend results to our memory format\n    // retrieveMemories returns: { id, title, content, description, score, components }\n    const memories = results.map(memory => ({\n      id: memory.id,\n      key: memory.title || 'unknown',\n      value: memory.content || memory.description || '',\n      namespace: namespace, // Use the namespace from our query\n      confidence: memory.components?.reliability || 0.8,\n      usage_count: memory.usage_count || 0,\n      created_at: memory.created_at || new Date().toISOString(),\n      score: memory.score || 0,\n      // Include original pattern for debugging\n      _pattern: memory\n    }));\n\n    // If no results, try direct database query as fallback\n    if (memories.length === 0) {\n      console.warn('[ReasoningBank] Semantic search returned 0 results, trying database fallback');\n      const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({\n        domain: namespace,\n        minConfidence: options.minConfidence || 0.3\n      });\n\n      const fallbackMemories = fallbackResults.slice(0, limit).map(memory => ({\n        id: memory.id,\n        key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',\n        value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',\n        namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',\n        confidence: memory.confidence || 0.8,\n        usage_count: memory.usage_count || 0,\n        created_at: memory.created_at || new Date().toISOString()\n      }));\n\n      // Cache and return fallback results\n      setCachedQuery(searchQuery, options, fallbackMemories);\n      return fallbackMemories;\n    }\n\n    // Cache successful results\n    setCachedQuery(searchQuery, options, memories);\n    return memories;\n  } catch (error) {\n    console.warn('[ReasoningBank] Query failed, trying database fallback:', error.message);\n\n    try {\n      // Final fallback: direct database query\n      const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({\n        domain: namespace,\n        minConfidence: options.minConfidence || 0.3\n      });\n\n      const fallbackMemories = fallbackResults.slice(0, limit).map(memory => ({\n        id: memory.id,\n        key: memory.pattern_data?.title || 'unknown',\n        value: memory.pattern_data?.content || '',\n        namespace: memory.pattern_data?.domain || 'default',\n        confidence: memory.confidence || 0.8,\n        usage_count: memory.usage_count || 0,\n        created_at: memory.created_at || new Date().toISOString()\n      }));\n\n      setCachedQuery(searchQuery, options, fallbackMemories);\n      return fallbackMemories;\n    } catch (fallbackError) {\n      console.error('[ReasoningBank] All query methods failed:', fallbackError);\n      return [];\n    }\n  }\n}\n\n/**\n * List all memories (using Node.js backend database query)\n */\nexport async function listMemories(options = {}) {\n  await ensureInitialized();\n  const limit = options.limit || 10;\n  const namespace = options.namespace;\n\n  try {\n    let memories;\n\n    if (namespace && namespace !== 'default') {\n      // Filter by namespace/domain\n      const allMemories = ReasoningBank.db.getAllActiveMemories();\n      memories = allMemories\n        .filter(m => m.pattern_data?.domain === namespace)\n        .slice(0, limit);\n    } else {\n      // Get all active memories\n      memories = ReasoningBank.db.getAllActiveMemories().slice(0, limit);\n    }\n\n    return memories.map(memory => ({\n      id: memory.id,\n      key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',\n      value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',\n      namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',\n      confidence: memory.confidence || 0.8,\n      usage_count: memory.usage_count || 0,\n      created_at: memory.created_at || new Date().toISOString()\n    }));\n  } catch (error) {\n    console.error('[ReasoningBank] listMemories failed:', error);\n    return [];\n  }\n}\n\n/**\n * Get ReasoningBank statistics (Node.js backend)\n */\nexport async function getStatus() {\n  await ensureInitialized();\n\n  try {\n    const db = ReasoningBank.db.getDb();\n\n    // Count patterns\n    const patterns = db.prepare(\"SELECT COUNT(*) as count FROM patterns WHERE type = 'reasoning_memory'\").get();\n    const embeddings = db.prepare(\"SELECT COUNT(*) as count FROM pattern_embeddings\").get();\n    const trajectories = db.prepare(\"SELECT COUNT(*) as count FROM task_trajectories\").get();\n    const links = db.prepare(\"SELECT COUNT(*) as count FROM pattern_links\").get();\n\n    // Get average confidence\n    const avgConf = db.prepare(\"SELECT AVG(confidence) as avg FROM patterns WHERE type = 'reasoning_memory'\").get();\n\n    // Count unique domains\n    const domains = db.prepare(\"SELECT COUNT(DISTINCT json_extract(pattern_data, '$.domain')) as count FROM patterns WHERE type = 'reasoning_memory'\").get();\n\n    return {\n      total_memories: patterns.count || 0,\n      total_categories: domains.count || 0,\n      storage_backend: 'SQLite (Node.js)',\n      database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db',\n      performance: 'SQLite with persistent storage',\n      avg_confidence: avgConf.avg || 0.8,\n      total_embeddings: embeddings.count || 0,\n      total_trajectories: trajectories.count || 0,\n      total_links: links.count || 0\n    };\n  } catch (error) {\n    console.error('[ReasoningBank] getStatus failed:', error);\n    return {\n      total_memories: 0,\n      error: error.message\n    };\n  }\n}\n\n/**\n * Check which ReasoningBank tables are present (Node.js backend)\n */\nexport async function checkReasoningBankTables() {\n  try {\n    await ensureInitialized();\n    const db = ReasoningBank.db.getDb();\n\n    const tables = db.prepare(\"SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'pattern%'\").all();\n    const tableNames = tables.map(t => t.name);\n\n    const requiredTables = ['patterns', 'pattern_embeddings', 'pattern_links', 'task_trajectories'];\n    const missingTables = requiredTables.filter(t => !tableNames.includes(t));\n\n    return {\n      exists: true,\n      existingTables: tableNames,\n      missingTables: missingTables,\n      requiredTables: requiredTables,\n      backend: 'SQLite (Node.js)',\n      note: missingTables.length > 0 ? 'Some tables are missing - run migrations' : 'All tables present'\n    };\n  } catch (error) {\n    return {\n      exists: false,\n      existingTables: [],\n      missingTables: [],\n      requiredTables: [],\n      error: error.message\n    };\n  }\n}\n\n/**\n * Migrate existing database (Node.js backend - run migrations)\n */\nexport async function migrateReasoningBank() {\n  try {\n    await ReasoningBank.db.runMigrations();\n\n    return {\n      success: true,\n      message: 'Database migrations completed successfully',\n      migrated: true,\n      database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db'\n    };\n  } catch (error) {\n    return {\n      success: false,\n      message: `Migration failed: ${error.message}`,\n      error: error.message\n    };\n  }\n}\n\n/**\n * Get cached query results\n */\nfunction getCachedQuery(searchQuery, options) {\n  const cacheKey = JSON.stringify({ searchQuery, options });\n  const cached = queryCache.get(cacheKey);\n\n  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {\n    return cached.results;\n  }\n\n  return null;\n}\n\n/**\n * Set cached query results (LRU eviction)\n */\nfunction setCachedQuery(searchQuery, options, results) {\n  const cacheKey = JSON.stringify({ searchQuery, options });\n\n  // LRU eviction\n  if (queryCache.size >= CACHE_SIZE) {\n    const firstKey = queryCache.keys().next().value;\n    queryCache.delete(firstKey);\n  }\n\n  queryCache.set(cacheKey, {\n    results,\n    timestamp: Date.now()\n  });\n}\n\n/**\n * Close database connection and cleanup resources\n * Should be called when done with ReasoningBank operations\n */\nexport function cleanup() {\n  try {\n    if (backendInitialized) {\n      // Clear embedding cache (prevents memory leaks)\n      ReasoningBank.clearEmbeddingCache();\n\n      // Close database connection\n      ReasoningBank.db.closeDb();\n      backendInitialized = false;\n      initPromise = null;\n      console.log('[ReasoningBank] Database connection closed');\n    }\n  } catch (error) {\n    console.error('[ReasoningBank] Cleanup failed:', error.message);\n  }\n}\n"],"names":["ReasoningBank","v4","uuidv4","backendInitialized","initPromise","queryCache","Map","CACHE_SIZE","CACHE_TTL","ensureInitialized","initialize","console","log","error","Error","message","initializeReasoningBank","storeMemory","key","value","options","memoryId","id","memory","type","pattern_data","title","content","domain","namespace","agent","task_type","original_key","original_value","confidence","usage_count","db","upsertMemory","embedding","computeEmbedding","upsertEmbedding","model","dims","length","vector","embeddingError","warn","clear","queryMemories","searchQuery","cached","getCachedQuery","limit","results","retrieveMemories","k","minConfidence","memories","map","description","components","reliability","created_at","Date","toISOString","score","_pattern","fallbackResults","fetchMemoryCandidates","fallbackMemories","slice","setCachedQuery","fallbackError","listMemories","allMemories","getAllActiveMemories","filter","m","getStatus","getDb","patterns","prepare","get","embeddings","trajectories","links","avgConf","domains","total_memories","count","total_categories","storage_backend","database_path","process","env","CLAUDE_FLOW_DB_PATH","performance","avg_confidence","avg","total_embeddings","total_trajectories","total_links","checkReasoningBankTables","tables","all","tableNames","t","name","requiredTables","missingTables","includes","exists","existingTables","backend","note","migrateReasoningBank","runMigrations","success","migrated","cacheKey","JSON","stringify","now","timestamp","size","firstKey","keys","next","delete","set","cleanup","clearEmbeddingCache","closeDb"],"mappings":"AAUA,YAAYA,mBAAmB,6BAA6B;AAC5D,SAASC,MAAMC,MAAM,QAAQ,OAAO;AAGpC,IAAIC,qBAAqB;AACzB,IAAIC,cAAc;AAGlB,MAAMC,aAAa,IAAIC;AACvB,MAAMC,aAAa;AACnB,MAAMC,YAAY;AAMlB,eAAeC;IACb,IAAIN,oBAAoB;QACtB,OAAO;IACT;IAEA,IAAIC,aAAa;QACf,OAAOA;IACT;IAEAA,cAAc,AAAC,CAAA;QACb,IAAI;YAEF,MAAMJ,cAAcU,UAAU;YAC9BP,qBAAqB;YACrBQ,QAAQC,GAAG,CAAC;YACZ,OAAO;QACT,EAAE,OAAOC,OAAO;YACdF,QAAQE,KAAK,CAAC,kDAAkDA;YAChE,MAAM,IAAIC,MAAM,CAAC,oCAAoC,EAAED,MAAME,OAAO,EAAE;QACxE;IACF,CAAA;IAEA,OAAOX;AACT;AAKA,OAAO,eAAeY;IAEpB,MAAMP;IACN,OAAO;AACT;AAWA,OAAO,eAAeQ,YAAYC,GAAG,EAAEC,KAAK,EAAEC,UAAU,CAAC,CAAC;IACxD,MAAMX;IAEN,IAAI;QACF,MAAMY,WAAWD,QAAQE,EAAE,IAAIpB;QAG/B,MAAMqB,SAAS;YACbD,IAAID;YACJG,MAAM;YACNC,cAAc;gBACZC,OAAOR;gBACPS,SAASR;gBACTS,QAAQR,QAAQS,SAAS,IAAI;gBAC7BC,OAAOV,QAAQU,KAAK,IAAI;gBACxBC,WAAWX,QAAQI,IAAI,IAAI;gBAE3BQ,cAAcd;gBACde,gBAAgBd;gBAChBU,WAAWT,QAAQS,SAAS,IAAI;YAClC;YACAK,YAAYd,QAAQc,UAAU,IAAI;YAClCC,aAAa;QACf;QAGAnC,cAAcoC,EAAE,CAACC,YAAY,CAACd;QAG9B,IAAI;YACF,MAAMe,YAAY,MAAMtC,cAAcuC,gBAAgB,CAACpB;YACvDnB,cAAcoC,EAAE,CAACI,eAAe,CAAC;gBAC/BlB,IAAID;gBACJoB,OAAO;gBACPC,MAAMJ,UAAUK,MAAM;gBACtBC,QAAQN;YACV;QACF,EAAE,OAAOO,gBAAgB;YACvBlC,QAAQmC,IAAI,CAAC,iDAAiDD,eAAe9B,OAAO;QAEtF;QAGAV,WAAW0C,KAAK;QAEhB,OAAO1B;IACT,EAAE,OAAOR,OAAO;QACdF,QAAQE,KAAK,CAAC,uCAAuCA;QACrD,MAAM,IAAIC,MAAM,CAAC,wBAAwB,EAAED,MAAME,OAAO,EAAE;IAC5D;AACF;AAQA,OAAO,eAAeiC,cAAcC,WAAW,EAAE7B,UAAU,CAAC,CAAC;IAE3D,MAAM8B,SAASC,eAAeF,aAAa7B;IAC3C,IAAI8B,QAAQ;QACV,OAAOA;IACT;IAEA,MAAMzC;IACN,MAAM2C,QAAQhC,QAAQgC,KAAK,IAAI;IAE/B,MAAMvB,YAAYT,QAAQS,SAAS,IAAIT,QAAQQ,MAAM,IAAI;IAEzD,IAAI;QAEF,MAAMyB,UAAU,MAAMrD,cAAcsD,gBAAgB,CAACL,aAAa;YAChErB,QAAQC;YACRC,OAAOV,QAAQU,KAAK,IAAI;YACxByB,GAAGH;YACHI,eAAepC,QAAQoC,aAAa,IAAI;QAC1C;QAIA,MAAMC,WAAWJ,QAAQK,GAAG,CAACnC,CAAAA,SAAW,CAAA;gBACtCD,IAAIC,OAAOD,EAAE;gBACbJ,KAAKK,OAAOG,KAAK,IAAI;gBACrBP,OAAOI,OAAOI,OAAO,IAAIJ,OAAOoC,WAAW,IAAI;gBAC/C9B,WAAWA;gBACXK,YAAYX,OAAOqC,UAAU,EAAEC,eAAe;gBAC9C1B,aAAaZ,OAAOY,WAAW,IAAI;gBACnC2B,YAAYvC,OAAOuC,UAAU,IAAI,IAAIC,OAAOC,WAAW;gBACvDC,OAAO1C,OAAO0C,KAAK,IAAI;gBAEvBC,UAAU3C;YACZ,CAAA;QAGA,IAAIkC,SAASd,MAAM,KAAK,GAAG;YACzBhC,QAAQmC,IAAI,CAAC;YACb,MAAMqB,kBAAkBnE,cAAcoC,EAAE,CAACgC,qBAAqB,CAAC;gBAC7DxC,QAAQC;gBACR2B,eAAepC,QAAQoC,aAAa,IAAI;YAC1C;YAEA,MAAMa,mBAAmBF,gBAAgBG,KAAK,CAAC,GAAGlB,OAAOM,GAAG,CAACnC,CAAAA,SAAW,CAAA;oBACtED,IAAIC,OAAOD,EAAE;oBACbJ,KAAKK,OAAOE,YAAY,EAAEC,SAASH,OAAOE,YAAY,EAAEO,gBAAgB;oBACxEb,OAAOI,OAAOE,YAAY,EAAEE,WAAWJ,OAAOE,YAAY,EAAEQ,kBAAkB;oBAC9EJ,WAAWN,OAAOE,YAAY,EAAEG,UAAUL,OAAOE,YAAY,EAAEI,aAAa;oBAC5EK,YAAYX,OAAOW,UAAU,IAAI;oBACjCC,aAAaZ,OAAOY,WAAW,IAAI;oBACnC2B,YAAYvC,OAAOuC,UAAU,IAAI,IAAIC,OAAOC,WAAW;gBACzD,CAAA;YAGAO,eAAetB,aAAa7B,SAASiD;YACrC,OAAOA;QACT;QAGAE,eAAetB,aAAa7B,SAASqC;QACrC,OAAOA;IACT,EAAE,OAAO5C,OAAO;QACdF,QAAQmC,IAAI,CAAC,2DAA2DjC,MAAME,OAAO;QAErF,IAAI;YAEF,MAAMoD,kBAAkBnE,cAAcoC,EAAE,CAACgC,qBAAqB,CAAC;gBAC7DxC,QAAQC;gBACR2B,eAAepC,QAAQoC,aAAa,IAAI;YAC1C;YAEA,MAAMa,mBAAmBF,gBAAgBG,KAAK,CAAC,GAAGlB,OAAOM,GAAG,CAACnC,CAAAA,SAAW,CAAA;oBACtED,IAAIC,OAAOD,EAAE;oBACbJ,KAAKK,OAAOE,YAAY,EAAEC,SAAS;oBACnCP,OAAOI,OAAOE,YAAY,EAAEE,WAAW;oBACvCE,WAAWN,OAAOE,YAAY,EAAEG,UAAU;oBAC1CM,YAAYX,OAAOW,UAAU,IAAI;oBACjCC,aAAaZ,OAAOY,WAAW,IAAI;oBACnC2B,YAAYvC,OAAOuC,UAAU,IAAI,IAAIC,OAAOC,WAAW;gBACzD,CAAA;YAEAO,eAAetB,aAAa7B,SAASiD;YACrC,OAAOA;QACT,EAAE,OAAOG,eAAe;YACtB7D,QAAQE,KAAK,CAAC,6CAA6C2D;YAC3D,OAAO,EAAE;QACX;IACF;AACF;AAKA,OAAO,eAAeC,aAAarD,UAAU,CAAC,CAAC;IAC7C,MAAMX;IACN,MAAM2C,QAAQhC,QAAQgC,KAAK,IAAI;IAC/B,MAAMvB,YAAYT,QAAQS,SAAS;IAEnC,IAAI;QACF,IAAI4B;QAEJ,IAAI5B,aAAaA,cAAc,WAAW;YAExC,MAAM6C,cAAc1E,cAAcoC,EAAE,CAACuC,oBAAoB;YACzDlB,WAAWiB,YACRE,MAAM,CAACC,CAAAA,IAAKA,EAAEpD,YAAY,EAAEG,WAAWC,WACvCyC,KAAK,CAAC,GAAGlB;QACd,OAAO;YAELK,WAAWzD,cAAcoC,EAAE,CAACuC,oBAAoB,GAAGL,KAAK,CAAC,GAAGlB;QAC9D;QAEA,OAAOK,SAASC,GAAG,CAACnC,CAAAA,SAAW,CAAA;gBAC7BD,IAAIC,OAAOD,EAAE;gBACbJ,KAAKK,OAAOE,YAAY,EAAEC,SAASH,OAAOE,YAAY,EAAEO,gBAAgB;gBACxEb,OAAOI,OAAOE,YAAY,EAAEE,WAAWJ,OAAOE,YAAY,EAAEQ,kBAAkB;gBAC9EJ,WAAWN,OAAOE,YAAY,EAAEG,UAAUL,OAAOE,YAAY,EAAEI,aAAa;gBAC5EK,YAAYX,OAAOW,UAAU,IAAI;gBACjCC,aAAaZ,OAAOY,WAAW,IAAI;gBACnC2B,YAAYvC,OAAOuC,UAAU,IAAI,IAAIC,OAAOC,WAAW;YACzD,CAAA;IACF,EAAE,OAAOnD,OAAO;QACdF,QAAQE,KAAK,CAAC,wCAAwCA;QACtD,OAAO,EAAE;IACX;AACF;AAKA,OAAO,eAAeiE;IACpB,MAAMrE;IAEN,IAAI;QACF,MAAM2B,KAAKpC,cAAcoC,EAAE,CAAC2C,KAAK;QAGjC,MAAMC,WAAW5C,GAAG6C,OAAO,CAAC,0EAA0EC,GAAG;QACzG,MAAMC,aAAa/C,GAAG6C,OAAO,CAAC,oDAAoDC,GAAG;QACrF,MAAME,eAAehD,GAAG6C,OAAO,CAAC,mDAAmDC,GAAG;QACtF,MAAMG,QAAQjD,GAAG6C,OAAO,CAAC,+CAA+CC,GAAG;QAG3E,MAAMI,UAAUlD,GAAG6C,OAAO,CAAC,+EAA+EC,GAAG;QAG7G,MAAMK,UAAUnD,GAAG6C,OAAO,CAAC,wHAAwHC,GAAG;QAEtJ,OAAO;YACLM,gBAAgBR,SAASS,KAAK,IAAI;YAClCC,kBAAkBH,QAAQE,KAAK,IAAI;YACnCE,iBAAiB;YACjBC,eAAeC,QAAQC,GAAG,CAACC,mBAAmB,IAAI;YAClDC,aAAa;YACbC,gBAAgBX,QAAQY,GAAG,IAAI;YAC/BC,kBAAkBhB,WAAWM,KAAK,IAAI;YACtCW,oBAAoBhB,aAAaK,KAAK,IAAI;YAC1CY,aAAahB,MAAMI,KAAK,IAAI;QAC9B;IACF,EAAE,OAAO5E,OAAO;QACdF,QAAQE,KAAK,CAAC,qCAAqCA;QACnD,OAAO;YACL2E,gBAAgB;YAChB3E,OAAOA,MAAME,OAAO;QACtB;IACF;AACF;AAKA,OAAO,eAAeuF;IACpB,IAAI;QACF,MAAM7F;QACN,MAAM2B,KAAKpC,cAAcoC,EAAE,CAAC2C,KAAK;QAEjC,MAAMwB,SAASnE,GAAG6C,OAAO,CAAC,8EAA8EuB,GAAG;QAC3G,MAAMC,aAAaF,OAAO7C,GAAG,CAACgD,CAAAA,IAAKA,EAAEC,IAAI;QAEzC,MAAMC,iBAAiB;YAAC;YAAY;YAAsB;YAAiB;SAAoB;QAC/F,MAAMC,gBAAgBD,eAAehC,MAAM,CAAC8B,CAAAA,IAAK,CAACD,WAAWK,QAAQ,CAACJ;QAEtE,OAAO;YACLK,QAAQ;YACRC,gBAAgBP;YAChBI,eAAeA;YACfD,gBAAgBA;YAChBK,SAAS;YACTC,MAAML,cAAclE,MAAM,GAAG,IAAI,6CAA6C;QAChF;IACF,EAAE,OAAO9B,OAAO;QACd,OAAO;YACLkG,QAAQ;YACRC,gBAAgB,EAAE;YAClBH,eAAe,EAAE;YACjBD,gBAAgB,EAAE;YAClB/F,OAAOA,MAAME,OAAO;QACtB;IACF;AACF;AAKA,OAAO,eAAeoG;IACpB,IAAI;QACF,MAAMnH,cAAcoC,EAAE,CAACgF,aAAa;QAEpC,OAAO;YACLC,SAAS;YACTtG,SAAS;YACTuG,UAAU;YACV1B,eAAeC,QAAQC,GAAG,CAACC,mBAAmB,IAAI;QACpD;IACF,EAAE,OAAOlF,OAAO;QACd,OAAO;YACLwG,SAAS;YACTtG,SAAS,CAAC,kBAAkB,EAAEF,MAAME,OAAO,EAAE;YAC7CF,OAAOA,MAAME,OAAO;QACtB;IACF;AACF;AAKA,SAASoC,eAAeF,WAAW,EAAE7B,OAAO;IAC1C,MAAMmG,WAAWC,KAAKC,SAAS,CAAC;QAAExE;QAAa7B;IAAQ;IACvD,MAAM8B,SAAS7C,WAAW6E,GAAG,CAACqC;IAE9B,IAAIrE,UAAUa,KAAK2D,GAAG,KAAKxE,OAAOyE,SAAS,GAAGnH,WAAW;QACvD,OAAO0C,OAAOG,OAAO;IACvB;IAEA,OAAO;AACT;AAKA,SAASkB,eAAetB,WAAW,EAAE7B,OAAO,EAAEiC,OAAO;IACnD,MAAMkE,WAAWC,KAAKC,SAAS,CAAC;QAAExE;QAAa7B;IAAQ;IAGvD,IAAIf,WAAWuH,IAAI,IAAIrH,YAAY;QACjC,MAAMsH,WAAWxH,WAAWyH,IAAI,GAAGC,IAAI,GAAG5G,KAAK;QAC/Cd,WAAW2H,MAAM,CAACH;IACpB;IAEAxH,WAAW4H,GAAG,CAACV,UAAU;QACvBlE;QACAsE,WAAW5D,KAAK2D,GAAG;IACrB;AACF;AAMA,OAAO,SAASQ;IACd,IAAI;QACF,IAAI/H,oBAAoB;YAEtBH,cAAcmI,mBAAmB;YAGjCnI,cAAcoC,EAAE,CAACgG,OAAO;YACxBjI,qBAAqB;YACrBC,cAAc;YACdO,QAAQC,GAAG,CAAC;QACd;IACF,EAAE,OAAOC,OAAO;QACdF,QAAQE,KAAK,CAAC,mCAAmCA,MAAME,OAAO;IAChE;AACF"}

package/dist/src/utils/metrics-reader.js

@@ -166,14 +166,4 @@ export class MetricsReader {
     }
 }
 
-//# sourceMappingURL=metrics-reader.js.map               processCount: 0,
-                orchestratorRunning: false,
-                port: null,
-                connections: 0
-            };
-        }
-    }
-};
-export { MetricsReader };
-
 //# sourceMappingURL=metrics-reader.js.map

package/docker-test/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}

package/docker-test/.claude-flow/metrics/performance.json

@@ -0,0 +1,87 @@
+{
+  "startTime": 1760388535754,
+  "sessionId": "session-1760388535754",
+  "lastActivity": 1760388535754,
+  "sessionDuration": 0,
+  "totalTasks": 1,
+  "successfulTasks": 1,
+  "failedTasks": 0,
+  "totalAgents": 0,
+  "activeAgents": 0,
+  "neuralEvents": 0,
+  "memoryMode": {
+    "reasoningbankOperations": 0,
+    "basicOperations": 0,
+    "autoModeSelections": 0,
+    "modeOverrides": 0,
+    "currentMode": "auto"
+  },
+  "operations": {
+    "store": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "retrieve": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "query": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "list": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "delete": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "search": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "init": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    }
+  },
+  "performance": {
+    "avgOperationDuration": 0,
+    "minOperationDuration": null,
+    "maxOperationDuration": null,
+    "slowOperations": 0,
+    "fastOperations": 0,
+    "totalOperationTime": 0
+  },
+  "storage": {
+    "totalEntries": 0,
+    "reasoningbankEntries": 0,
+    "basicEntries": 0,
+    "databaseSize": 0,
+    "lastBackup": null,
+    "growthRate": 0
+  },
+  "errors": {
+    "total": 0,
+    "byType": {},
+    "byOperation": {},
+    "recent": []
+  },
+  "reasoningbank": {
+    "semanticSearches": 0,
+    "sqlFallbacks": 0,
+    "embeddingGenerated": 0,
+    "consolidations": 0,
+    "avgQueryTime": 0,
+    "cacheHits": 0,
+    "cacheMisses": 0
+  }
+}

package/docker-test/.claude-flow/metrics/task-metrics.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "cmd-hooks-1760388535858",
+    "type": "hooks",
+    "success": true,
+    "duration": 8.673302000000035,
+    "timestamp": 1760388535866,
+    "metadata": {}
+  }
+]

package/docker-test/Dockerfile.reasoningbank-test

@@ -0,0 +1,21 @@
+FROM node:20-slim
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    python3 \
+    make \
+    g++ \
+    sqlite3 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /test
+
+# Install claude-flow@alpha from npm
+RUN npm install -g claude-flow@alpha
+
+# Create test script
+COPY reasoningbank-validation.mjs /test/
+
+# Run test
+CMD ["node", "/test/reasoningbank-validation.mjs"]

package/docker-test/reasoningbank-validation.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+/**
+ * Docker Validation Test for ReasoningBank Semantic Search
+ * Tests claude-flow@alpha with agentic-flow@1.5.13 Node.js backend
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+
+const execAsync = promisify(exec);
+
+async function validateReasoningBank() {
+  console.log('🐳 Docker Validation: ReasoningBank Semantic Search');
+  console.log('📦 Testing: claude-flow@alpha (from npm)\n');
+
+  const results = {
+    passed: [],
+    failed: [],
+    warnings: []
+  };
+
+  try {
+    // Test 1: Verify installation
+    console.log('1️⃣ Verifying installation...');
+    try {
+      const { stdout: version } = await execAsync('npx claude-flow@alpha --version');
+      console.log(`   ✅ Version: ${version.trim()}`);
+      results.passed.push('Installation verified');
+    } catch (error) {
+      console.error(`   ❌ Installation failed: ${error.message}`);
+      results.failed.push('Installation');
+      throw error;
+    }
+
+    // Test 2: Initialize ReasoningBank memory (explicit mode)
+    console.log('\n2️⃣ Initializing ReasoningBank memory...');
+    try {
+      const { stdout } = await execAsync('npx claude-flow@alpha memory init --reasoningbank');
+      console.log(`   ${stdout.trim()}`);
+      results.passed.push('ReasoningBank initialization');
+    } catch (error) {
+      console.error(`   ❌ Init failed: ${error.message}`);
+      results.failed.push('ReasoningBank initialization');
+    }
+
+    // Test 3: Store test memories (with ReasoningBank mode)
+    console.log('\n3️⃣ Storing test memories to ReasoningBank...');
+    const testMemories = [
+      { key: 'docker-auth', value: 'Implement JWT authentication with Docker secrets', namespace: 'security' },
+      { key: 'docker-api', value: 'Create containerized REST API with health checks', namespace: 'backend' },
+      { key: 'docker-db', value: 'Setup PostgreSQL database container with volumes', namespace: 'backend' }
+    ];
+
+    for (const mem of testMemories) {
+      try {
+        await execAsync(`npx claude-flow@alpha memory store "${mem.key}" "${mem.value}" --namespace ${mem.namespace} --reasoningbank`);
+        console.log(`   ✅ Stored: ${mem.key}`);
+      } catch (error) {
+        console.error(`   ❌ Failed to store ${mem.key}: ${error.message}`);
+        results.failed.push(`Store memory: ${mem.key}`);
+      }
+    }
+    results.passed.push('Memory storage with ReasoningBank (3 entries)');
+
+    // Test 4: Verify database exists
+    console.log('\n4️⃣ Verifying database creation...');
+    const dbPath = '.swarm/memory.db';
+    if (existsSync(dbPath)) {
+      console.log(`   ✅ Database created: ${dbPath}`);
+      results.passed.push('Database persistence');
+    } else {
+      console.error(`   ❌ Database not found: ${dbPath}`);
+      results.failed.push('Database persistence');
+    }
+
+    // Test 5: Query memories (semantic search with ReasoningBank)
+    console.log('\n5️⃣ Testing ReasoningBank semantic search...');
+    try {
+      const { stdout } = await execAsync('npx claude-flow@alpha memory query "authentication" --namespace security --limit 5 --reasoningbank');
+      if (stdout.includes('No results found')) {
+        console.warn('   ⚠️  No results from semantic search (embeddings may need API key)');
+        results.warnings.push('Semantic search returned no results');
+      } else {
+        console.log('   ✅ ReasoningBank semantic search working');
+        results.passed.push('ReasoningBank semantic search');
+      }
+    } catch (error) {
+      console.error(`   ❌ Query failed: ${error.message}`);
+      results.failed.push('ReasoningBank semantic search');
+    }
+
+    // Test 6: List memories (ReasoningBank mode)
+    console.log('\n6️⃣ Listing ReasoningBank memories...');
+    try {
+      const { stdout } = await execAsync('npx claude-flow@alpha memory list --limit 10 --reasoningbank');
+      console.log(stdout.trim());
+      if (stdout.includes('security') || stdout.includes('backend')) {
+        console.log('   ✅ ReasoningBank memory listing working');
+        results.passed.push('ReasoningBank memory listing');
+      } else {
+        console.warn('   ⚠️  Unexpected list output');
+        results.warnings.push('ReasoningBank listing format');
+      }
+    } catch (error) {
+      console.error(`   ❌ List failed: ${error.message}`);
+      results.failed.push('ReasoningBank memory listing');
+    }
+
+    // Test 7: ReasoningBank status
+    console.log('\n7️⃣ Checking ReasoningBank status...');
+    try {
+      const { stdout } = await execAsync('npx claude-flow@alpha memory status --reasoningbank');
+      console.log(stdout.trim());
+      if (stdout.includes('SQLite') || stdout.includes('memory.db') || stdout.includes('ReasoningBank')) {
+        console.log('   ✅ Status reporting ReasoningBank Node.js backend');
+        results.passed.push('ReasoningBank status (Node.js backend)');
+      } else {
+        console.warn('   ⚠️  Backend type unclear in status');
+        results.warnings.push('ReasoningBank backend detection');
+      }
+    } catch (error) {
+      console.error(`   ❌ Status failed: ${error.message}`);
+      results.failed.push('ReasoningBank status');
+    }
+
+    // Test 8: Database inspection
+    console.log('\n8️⃣ Inspecting database structure...');
+    try {
+      const { stdout } = await execAsync('sqlite3 .swarm/memory.db "SELECT name FROM sqlite_master WHERE type=\'table\' ORDER BY name;"');
+      const tables = stdout.trim().split('\n');
+      console.log(`   ✅ Found ${tables.length} tables: ${tables.join(', ')}`);
+
+      if (tables.includes('patterns') && tables.includes('pattern_embeddings')) {
+        console.log('   ✅ Required tables present');
+        results.passed.push('Database schema');
+      } else {
+        console.error('   ❌ Missing required tables');
+        results.failed.push('Database schema');
+      }
+    } catch (error) {
+      console.error(`   ❌ Database inspection failed: ${error.message}`);
+      results.failed.push('Database inspection');
+    }
+
+    // Test 9: Count stored patterns
+    console.log('\n9️⃣ Counting stored patterns...');
+    try {
+      const { stdout } = await execAsync('sqlite3 .swarm/memory.db "SELECT COUNT(*) FROM patterns WHERE type=\'reasoning_memory\';"');
+      const count = parseInt(stdout.trim());
+      console.log(`   ✅ Total patterns: ${count}`);
+      if (count >= 3) {
+        results.passed.push(`Pattern storage (${count} entries)`);
+      } else {
+        console.warn(`   ⚠️  Expected 3+ patterns, found ${count}`);
+        results.warnings.push('Pattern count lower than expected');
+      }
+    } catch (error) {
+      console.error(`   ❌ Count failed: ${error.message}`);
+      results.failed.push('Pattern counting');
+    }
+
+  } catch (error) {
+    console.error('\n❌ Fatal error during validation:', error.message);
+  }
+
+  // Print summary
+  console.log('\n' + '='.repeat(60));
+  console.log('📊 VALIDATION SUMMARY');
+  console.log('='.repeat(60));
+
+  console.log(`\n✅ Passed (${results.passed.length}):`);
+  results.passed.forEach(test => console.log(`   • ${test}`));
+
+  if (results.warnings.length > 0) {
+    console.log(`\n⚠️  Warnings (${results.warnings.length}):`);
+    results.warnings.forEach(test => console.log(`   • ${test}`));
+  }
+
+  if (results.failed.length > 0) {
+    console.log(`\n❌ Failed (${results.failed.length}):`);
+    results.failed.forEach(test => console.log(`   • ${test}`));
+  }
+
+  const successRate = (results.passed.length / (results.passed.length + results.failed.length) * 100).toFixed(1);
+  console.log(`\n📈 Success Rate: ${successRate}%`);
+
+  if (results.failed.length === 0) {
+    console.log('\n✅ ALL TESTS PASSED! ReasoningBank semantic search is working!');
+    process.exit(0);
+  } else {
+    console.log('\n❌ SOME TESTS FAILED - Review errors above');
+    process.exit(1);
+  }
+}
+
+// Run validation
+validateReasoningBank().catch(err => {
+  console.error('💥 Validation failed:', err);
+  process.exit(1);
+});

package/docs/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}