monomind 1.15.6 → 1.16.0

package/packages/@monomind/cli/dist/src/commands/memory.js

@@ -1,6 +1,6 @@
 /**
  * CLI Memory Command
- * Memory operations for AgentDB integration
+ * Memory operations for LanceDB integration
  */
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
@@ -8,9 +8,9 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { configManager } from '../services/config-file-manager.js';
 // Memory backends
 const BACKENDS = [
-    { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with pure-JS HNSW indexing' },
+    { value: 'lancedb', label: 'LanceDB', hint: 'Vector database with ANN indexing' },
     { value: 'sqlite', label: 'SQLite', hint: 'Lightweight local storage' },
-    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
+    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + LanceDB (recommended)' },
     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' }
 ];
 // Store command
@@ -447,29 +447,29 @@ function formatRelativeTime(isoDate) {
 // Edit command
 const editCommand = {
     name: 'edit',
-    description: 'Edit a memory entry (AgentDB, Memory Palace, or knowledge chunk)',
+    description: 'Edit a memory entry (LanceDB, Memory Palace, or knowledge chunk)',
     options: [
-        { name: 'key', short: 'k', description: 'Storage key (AgentDB)', type: 'string' },
-        { name: 'namespace', short: 'n', description: 'Memory namespace (AgentDB)', type: 'string', default: 'default' },
+        { name: 'key', short: 'k', description: 'Storage key', type: 'string' },
+        { name: 'namespace', short: 'n', description: 'Memory namespace', type: 'string', default: 'default' },
         { name: 'value', description: 'New value/content', type: 'string' },
-        { name: 'source', short: 's', description: 'Source to edit: agentdb, palace, knowledge', type: 'string', default: 'agentdb', choices: ['agentdb', 'palace', 'knowledge'] },
+        { name: 'source', short: 's', description: 'Source to edit: lancedb, palace, knowledge', type: 'string', default: 'lancedb', choices: ['lancedb', 'palace', 'knowledge'] },
         { name: 'id', description: 'Entry ID (palace/knowledge)', type: 'string' }
     ],
     examples: [
-        { command: 'monomind memory edit -k "pattern/auth" --value "updated content"', description: 'Edit AgentDB entry' },
+        { command: 'monomind memory edit -k "pattern/auth" --value "updated content"', description: 'Edit LanceDB entry' },
         { command: 'monomind memory edit --source palace --id "abc123" --value "new content"', description: 'Edit Memory Palace drawer' },
         { command: 'monomind memory edit --source knowledge --id "chunk-42" --value "updated"', description: 'Edit knowledge chunk' }
     ],
     action: async (ctx) => {
-        const source = ctx.flags.source || 'agentdb';
+        const source = ctx.flags.source || 'lancedb';
         let value = ctx.flags.value || ctx.args[0];
         const fs = await import('fs');
         const path = await import('path');
-        if (source === 'agentdb') {
+        if (source === 'lancedb') {
             const key = ctx.flags.key;
             const namespace = ctx.flags.namespace || 'default';
             if (!key) {
-                output.printError('Key is required for AgentDB edit. Use --key or -k');
+                output.printError('Key is required for lancedb edit. Use --key or -k');
                 return { success: false, exitCode: 1 };
             }
             if (!value && ctx.interactive) {
@@ -666,28 +666,28 @@ const templatesCommand = {
 const deleteCommand = {
     name: 'delete',
     aliases: ['rm'],
-    description: 'Delete a memory entry (AgentDB, Memory Palace, or knowledge chunk)',
+    description: 'Delete a memory entry (LanceDB, Memory Palace, or knowledge chunk)',
     options: [
         {
             name: 'key',
             short: 'k',
-            description: 'Storage key (AgentDB)',
+            description: 'Storage key',
             type: 'string'
         },
         {
             name: 'namespace',
             short: 'n',
-            description: 'Memory namespace (AgentDB)',
+            description: 'Memory namespace',
             type: 'string',
             default: 'default'
         },
         {
             name: 'source',
             short: 's',
-            description: 'Source to delete from: agentdb, palace, knowledge',
+            description: 'Source to delete from: lancedb, palace, knowledge',
             type: 'string',
-            default: 'agentdb',
-            choices: ['agentdb', 'palace', 'knowledge']
+            default: 'lancedb',
+            choices: ['lancedb', 'palace', 'knowledge']
         },
         {
             name: 'id',
@@ -703,15 +703,15 @@ const deleteCommand = {
         }
     ],
     examples: [
-        { command: 'monomind memory delete -k "mykey"', description: 'Delete AgentDB entry' },
+        { command: 'monomind memory delete -k "mykey"', description: 'Delete memory entry' },
         { command: 'monomind memory delete -k "lesson" -n "lessons"', description: 'Delete from specific namespace' },
         { command: 'monomind memory delete --source palace --id "abc123"', description: 'Delete Memory Palace drawer' },
         { command: 'monomind memory delete --source knowledge --id "chunk-42" -f', description: 'Delete knowledge chunk (no confirm)' }
     ],
     action: async (ctx) => {
-        const source = ctx.flags.source || 'agentdb';
+        const source = ctx.flags.source || 'lancedb';
         const force = ctx.flags.force;
-        if (source === 'agentdb') {
+        if (source === 'lancedb') {
             const key = ctx.flags.key || ctx.args[0];
             const namespace = ctx.flags.namespace || 'default';
             if (!key) {
@@ -1213,9 +1213,9 @@ const exportCommand = {
         {
             name: 'format',
             short: 'f',
-            description: 'Export format (json, csv, binary)',
+            description: 'Export format (json, csv, binary, okf)',
             type: 'string',
-            choices: ['json', 'csv', 'binary'],
+            choices: ['json', 'csv', 'binary', 'okf'],
             default: 'json'
         },
         {
@@ -1233,7 +1233,8 @@ const exportCommand = {
     ],
     examples: [
         { command: 'monomind memory export -o ./backup.json', description: 'Export all to JSON' },
-        { command: 'monomind memory export -o ./data.csv -f csv', description: 'Export to CSV' }
+        { command: 'monomind memory export -o ./data.csv -f csv', description: 'Export to CSV' },
+        { command: 'monomind memory export -o ./knowledge -f okf', description: 'Export as OKF bundle (directory of .md files)' }
     ],
     action: async (ctx) => {
         const outputPath = ctx.flags.output;
@@ -1243,6 +1244,44 @@ const exportCommand = {
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Exporting memory to ${outputPath}...`);
+        // OKF bundle: native export — directory of .md files with YAML frontmatter
+        if (format === 'okf') {
+            try {
+                const fs = await import('fs');
+                const path = await import('path');
+                const { listEntries, getEntry } = await import('../memory/memory-initializer.js');
+                const namespace = ctx.flags.namespace;
+                const listed = await listEntries({ namespace, limit: 10000 });
+                if (!listed.success) {
+                    output.printError(`Failed to list entries: ${listed.error}`);
+                    return { success: false, exitCode: 1 };
+                }
+                let written = 0;
+                for (const entry of listed.entries) {
+                    const got = await getEntry({ key: entry.key, namespace: entry.namespace });
+                    if (!got.found || !got.entry)
+                        continue;
+                    const { key, namespace: ns, content, tags, createdAt } = got.entry;
+                    const safeKey = key.replace(/[/\\:*?"<>|]/g, '-');
+                    const dir = path.join(outputPath, ns);
+                    fs.mkdirSync(dir, { recursive: true });
+                    const yamlEscape = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+                    const tagsLine = tags.length > 0 ? `tags: [${tags.join(', ')}]\n` : '';
+                    const md = `---\ntype: Memory\nkey: "${yamlEscape(key)}"\nnamespace: "${yamlEscape(ns)}"\n${tagsLine}timestamp: ${createdAt}\n---\n\n${content}`;
+                    fs.writeFileSync(path.join(dir, `${safeKey}.md`), md, 'utf-8');
+                    written++;
+                }
+                output.printSuccess(`Exported ${written} entries to ${outputPath}`);
+                if (listed.total > 10000) {
+                    output.printInfo(`Note: only first 10000 of ${listed.total} entries exported`);
+                }
+                return { success: true, data: { written, outputPath } };
+            }
+            catch (error) {
+                output.printError(`OKF export error: ${String(error)}`);
+                return { success: false, exitCode: 1 };
+            }
+        }
         try {
             const result = await callMCPTool('memory_export', {
                 outputPath,
@@ -1307,6 +1346,77 @@ const importCommand = {
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Importing memory from ${inputPath}...`);
+        // OKF bundle: native import — detect directory of .md files with YAML frontmatter
+        const fsCheck = await import('fs');
+        const isDir = fsCheck.existsSync(inputPath) && fsCheck.statSync(inputPath).isDirectory();
+        if (isDir) {
+            try {
+                const fs = await import('fs');
+                const path = await import('path');
+                const { storeEntry } = await import('../memory/memory-initializer.js');
+                function parseOkfFrontmatter(raw) {
+                    if (!raw.startsWith('---\n'))
+                        return { meta: {}, body: raw };
+                    const end = raw.indexOf('\n---\n', 4);
+                    if (end === -1)
+                        return { meta: {}, body: raw };
+                    const meta = {};
+                    for (const line of raw.slice(4, end).split('\n')) {
+                        const colon = line.indexOf(':');
+                        if (colon <= 0)
+                            continue;
+                        const k = line.slice(0, colon).trim();
+                        const rawV = line.slice(colon + 1).trim();
+                        const isQuoted = rawV.startsWith('"') && rawV.endsWith('"') && rawV.length >= 2;
+                        const v = isQuoted ? rawV.slice(1, -1).replace(/\\(["\\])/g, '$1') : rawV;
+                        if (v.startsWith('[') && v.endsWith(']')) {
+                            meta[k] = v.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+                        }
+                        else {
+                            meta[k] = v;
+                        }
+                    }
+                    return { meta, body: raw.slice(end + 5) };
+                }
+                function findMdFiles(dir) {
+                    const results = [];
+                    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                        const full = path.join(dir, entry.name);
+                        if (entry.isDirectory())
+                            results.push(...findMdFiles(full));
+                        else if (entry.name.endsWith('.md'))
+                            results.push(full);
+                    }
+                    return results;
+                }
+                const overrideNs = ctx.flags.namespace;
+                const merge = ctx.flags.merge ?? true;
+                const files = findMdFiles(inputPath);
+                let imported = 0, skipped = 0;
+                const start = Date.now();
+                for (const file of files) {
+                    const raw = fs.readFileSync(file, 'utf-8');
+                    const { meta, body } = parseOkfFrontmatter(raw);
+                    const key = meta['key'] || path.basename(file, '.md');
+                    const ns = overrideNs || meta['namespace'] || path.basename(path.dirname(file));
+                    const tags = Array.isArray(meta['tags']) ? meta['tags'] : meta['tags'] ? [meta['tags']] : [];
+                    const result = await storeEntry({ key, value: body.trim(), namespace: ns, tags, upsert: !merge });
+                    if (result.success)
+                        imported++;
+                    else
+                        skipped++;
+                }
+                output.printSuccess(`Imported ${imported} entries from ${inputPath}`);
+                if (skipped > 0)
+                    output.printInfo(`Skipped ${skipped} entries (duplicates or errors)`);
+                output.printInfo(`Duration: ${Date.now() - start}ms`);
+                return { success: true, data: { imported, skipped } };
+            }
+            catch (error) {
+                output.printError(`OKF import error: ${String(error)}`);
+                return { success: false, exitCode: 1 };
+            }
+        }
         try {
             const result = await callMCPTool('memory_import', {
                 inputPath,
@@ -1342,7 +1452,7 @@ const initMemoryCommand = {
         {
             name: 'backend',
             short: 'b',
-            description: 'Backend type: hybrid (default), sqlite, or agentdb',
+            description: 'Backend type: hybrid (default), sqlite, or lancedb',
             type: 'string',
             default: 'hybrid'
         },
@@ -1380,7 +1490,7 @@ const initMemoryCommand = {
     ],
     examples: [
         { command: 'monomind memory init', description: 'Initialize hybrid backend with all features' },
-        { command: 'monomind memory init -b agentdb', description: 'Initialize AgentDB backend' },
+        { command: 'monomind memory init -b lancedb', description: 'Initialize LanceDB backend' },
         { command: 'monomind memory init -p ./data/memory.db --force', description: 'Reinitialize at custom path' },
         { command: 'monomind memory init --verbose --verify', description: 'Initialize with full verification' }
     ],
@@ -1447,7 +1557,7 @@ const initMemoryCommand = {
                 const { activated, failed, initTimeMs } = result.controllers;
                 if (activated.length > 0 || failed.length > 0) {
                     const controllerLines = [
-                        output.bold('AgentDB Controllers:'),
+                        output.bold('Memory Controllers:'),
                         `  Activated: ${activated.length}  Failed: ${failed.length}  Init: ${Math.round(initTimeMs)}ms`,
                     ];
                     if (verbose && activated.length > 0) {
@@ -1586,11 +1696,11 @@ export const memoryCommand = {
         output.printList([
             `${output.highlight('init')}        - Initialize memory database (sql.js)`,
             `${output.highlight('store')}       - Store data in memory`,
-            `${output.highlight('edit')}        - Edit an entry (AgentDB, palace, knowledge)`,
+            `${output.highlight('edit')}        - Edit an entry (LanceDB, palace, knowledge)`,
             `${output.highlight('retrieve')}    - Retrieve data from memory`,
             `${output.highlight('search')}      - Semantic/vector search`,
             `${output.highlight('list')}        - List memory entries`,
-            `${output.highlight('delete')}      - Delete an entry (AgentDB, palace, knowledge)`,
+            `${output.highlight('delete')}      - Delete an entry (LanceDB, palace, knowledge)`,
             `${output.highlight('templates')}   - Show best-practice entry templates`,
             `${output.highlight('stats')}       - Show statistics`,
             `${output.highlight('configure')}   - Configure backend`,

package/packages/@monomind/cli/dist/src/commands/migrate.js

@@ -292,7 +292,7 @@ const runCommand = {
                                 }
                             }
                             output.printSuccess(`Memory files backed up (${jsonFiles.length} JSON, ${hasDb ? '1 DB' : '0 DB'}).`);
-                            output.printInfo('Run "monomind memory init --force" to import v2 memory into v1 AgentDB.');
+                            output.printInfo('Run "monomind memory init --force" to import v2 memory into v1 LanceDB.');
                         }
                         migrated.push('memory');
                     }
@@ -775,7 +775,7 @@ function formatMigrationStatus(status) {
 function getMigrationSteps(target) {
     const allSteps = [
         { name: 'Configuration Files', description: 'Migrate config schema to v1 format', source: './monomind.json', dest: './monomind.config.json' },
-        { name: 'Memory Backend', description: 'Upgrade to hybrid backend with AgentDB', source: './.monomind/memory', dest: './data/memory' },
+        { name: 'Memory Backend', description: 'Upgrade to hybrid backend with LanceDB', source: './.monomind/memory', dest: './data/memory' },
         { name: 'Agent Definitions', description: 'Convert agent configs to v1 format', source: './.monomind/agents', dest: './packages/agents' },
         { name: 'Hook Registry', description: 'Migrate hooks to v1 hook system', source: './src/hooks', dest: './packages/hooks' },
         { name: 'Workflow Definitions', description: 'Convert workflows to event-sourced format', source: './.monomind/workflows', dest: './data/workflows' },

package/packages/@monomind/cli/dist/src/commands/neural.js

@@ -56,7 +56,7 @@ const statusCommand = {
                         component: 'Pattern Index',
                         status: hnswStatus.available ? output.success('Ready') : output.dim('Empty'),
                         details: hnswStatus.available
-                            ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim (pure-JS HNSW via AgentDB)`
+                            ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim (ANN via LanceDB)`
                             : 'No vectors indexed yet',
                     },
                     {

package/packages/@monomind/cli/dist/src/commands/swarm.js

@@ -271,7 +271,7 @@ const initCommand = {
             output.writeln(output.dim('  Initializing memory namespace...'));
             output.writeln(output.dim('  Setting up communication channels...'));
             if (v1Mode) {
-                output.writeln(output.dim('  Configuring AgentDB integration (pure-JS HNSW)...'));
+                output.writeln(output.dim('  Configuring LanceDB integration (ANN)....'));
                 output.writeln(output.dim('  Initializing keyword routing + outcome measurement...'));
             }
             output.writeln();

package/packages/@monomind/cli/dist/src/config-adapter.js

@@ -30,8 +30,8 @@ export function systemConfigToMonomindConfig(systemConfig) {
             backend: normalizeMemoryBackend(systemConfig.memory?.type),
             persistPath: systemConfig.memory?.path || './data/memory',
             cacheSize: systemConfig.memory?.maxSize ?? 1000000,
-            enableHNSW: systemConfig.memory?.agentdb?.indexType === 'hnsw',
-            vectorDimension: systemConfig.memory?.agentdb?.dimensions ?? 384, // Match all-MiniLM-L6-v2 output (#1395 Bug 5)
+            enableHNSW: systemConfig.memory?.lancedb?.indexType === 'hnsw',
+            vectorDimension: systemConfig.memory?.lancedb?.dimensions ?? 384,
         },
         // MCP configuration
         mcp: {
@@ -114,12 +114,10 @@ export function configToSystemConfig(config) {
             type: denormalizeMemoryBackend(config.memory.backend),
             path: config.memory.persistPath,
             maxSize: config.memory.cacheSize,
-            agentdb: {
+            lancedb: {
                 dimensions: config.memory.vectorDimension,
                 indexType: config.memory.enableHNSW ? 'hnsw' : 'flat',
-                efConstruction: 200,
-                m: 16,
-                quantization: 'none',
+                nProbes: 20,
             },
         },
         mcp: {
@@ -182,11 +180,13 @@ function normalizeMemoryBackend(backend) {
     switch (backend) {
         case 'memory':
         case 'sqlite':
-        case 'agentdb':
+        case 'lancedb':
         case 'hybrid':
             return backend;
+        case 'agentdb':
+            return 'lancedb'; // legacy alias
         case 'redis':
-            return 'memory'; // Redis maps to memory for CLI purposes
+            return 'memory';
         default:
             return 'hybrid';
     }

package/packages/@monomind/cli/dist/src/index.js

@@ -287,7 +287,7 @@ export class CLI {
         this.output.writeln(this.output.bold('V1 FEATURES:'));
         this.output.printList([
             '15-agent hierarchical mesh coordination',
-            'AgentDB with pure-JS HNSW indexing',
+            'LanceDB with ANN vector indexing',
             'Keyword routing + route-outcome measurement',
             'Unified SwarmCoordinator engine',
             'Event-sourced state management',

package/packages/@monomind/cli/dist/src/init/claudemd-generator.js

@@ -176,7 +176,7 @@ function cliCommandsTable() {
 | \`init\` | 4 | Project initialization |
 | \`agent\` | 8 | Agent lifecycle management |
 | \`swarm\` | 6 | Multi-agent swarm coordination |
-| \`memory\` | 11 | AgentDB memory with HNSW search |
+| \`memory\` | 11 | LanceDB memory with ANN search |
 | \`task\` | 6 | Task creation and lifecycle |
 | \`session\` | 7 | Session state management |
 | \`hooks\` | 17 | Self-learning hooks + 12 workers |
@@ -350,7 +350,7 @@ function intelligenceSystem() {
 
 - **Keyword routing**: Deterministic task→agent routing via \`createKeywordRouter\`
 - **Outcome measurement**: Route and command outcomes are recorded and scored to surface routing accuracy over time
-- **Pattern search**: Pure-JS HNSW vector search via AgentDB for finding similar past patterns
+- **Pattern search**: LanceDB ANN vector search for finding similar past patterns
 
 Routing and learning are JS-only — no native engine is required. Outcomes
 feed back into the recorded metrics so routing quality is measured, not assumed.`;

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -64,13 +64,13 @@ const SKILLS_MAP = {
         'hive-mind-advanced',
     ],
     browser: ['agent-browser-testing'],
-    agentdb: [
-        'agentdb-advanced',
-        'agentdb-learning',
-        'agentdb-memory-patterns',
-        'agentdb-optimization',
-        'agentdb-vector-search',
-        'reasoningbank-agentdb',
+    memory: [
+        'memory-advanced',
+        'memory-learning',
+        'memory-patterns',
+        'memory-optimization',
+        'memory-vector-search',
+        'memory-reasoningbank',
         'reasoningbank-intelligence',
     ],
     github: [
@@ -1028,8 +1028,8 @@ async function copySkills(targetDir, options, result) {
     else {
         if (skillsConfig.core)
             skillsToCopy.push(...SKILLS_MAP.core);
-        if (skillsConfig.agentdb)
-            skillsToCopy.push(...SKILLS_MAP.agentdb);
+        if (skillsConfig.memory)
+            skillsToCopy.push(...SKILLS_MAP.memory);
         if (skillsConfig.github)
             skillsToCopy.push(...SKILLS_MAP.github);
         if (skillsConfig.browser)
@@ -1416,7 +1416,7 @@ async function writeStatusline(targetDir, options, result) {
             }
         }
     }
-    // ALWAYS generate statusline.cjs — the generated version includes AgentDB
+    // ALWAYS generate statusline.cjs — the generated version includes
     // vectors/size, tests, ADRs, hooks, and integration stats that the
     // pre-installed static copy in the npm package lacks.
     // This must overwrite any copy from writeHelpers() which copies the legacy file.
@@ -1670,7 +1670,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
 Monomind is a domain-driven design architecture for multi-agent AI coordination with:
 
 - **15-Agent Swarm Coordination** with hierarchical and mesh topologies
-- **HNSW Vector Search** - pure-JS indexed pattern retrieval via AgentDB
+- **ANN Vector Search** - indexed pattern retrieval via LanceDB
 - **Keyword Routing** - deterministic task→agent routing with outcome measurement
 - **Byzantine Fault Tolerance** - Queen-led consensus mechanisms
 - **MCP Server Integration** - Model Context Protocol support
@@ -1769,7 +1769,7 @@ npx monomind@latest swarm monitor
 | \`init\` | 4 | Project initialization |
 | \`agent\` | 8 | Agent lifecycle management |
 | \`swarm\` | 6 | Multi-agent coordination |
-| \`memory\` | 11 | AgentDB with HNSW search |
+| \`memory\` | 11 | LanceDB with ANN vector search |
 | \`mcp\` | 9 | MCP server management |
 | \`task\` | 6 | Task assignment |
 | \`session\` | 7 | Session persistence |
@@ -1787,7 +1787,7 @@ npx monomind@latest swarm monitor
 | \`security\` | 6 | Security scanning |
 | \`performance\` | 5 | Profiling & benchmarks |
 | \`providers\` | 5 | AI provider config |
-| \`plugins\` | 5 | Plugin management |
+
 | \`deployment\` | 5 | Deploy management |
 | \`embeddings\` | 4 | Vector embeddings |
 | \`claims\` | 4 | Authorization |
@@ -1874,7 +1874,7 @@ npx monomind@latest doctor --fix
 
 ### Intelligence System
 - **Keyword routing**: Deterministic task→agent routing with outcome measurement
-- **HNSW pattern search**: Pure-JS indexed vector search via AgentDB
+- **ANN pattern search**: Indexed vector search via LanceDB
 - **ReasoningBank**: Stores learned patterns and trajectories for retrieval
 - **Int8 Quantization**: ~4x memory reduction for stored embeddings
 
@@ -1959,7 +1959,7 @@ npx monomind@latest hive-mind consensus --propose "task"
 
 | Metric | Target | Status |
 |--------|--------|--------|
-| HNSW Search | Indexed vector search | ✅ Implemented (pure-JS via AgentDB) |
+| ANN Search | Indexed vector search | ✅ Implemented (LanceDB) |
 | Memory Reduction | 50-75% | ✅ Implemented (~4x via Int8 quantization) |
 | Pattern Learning | Recorded + retrievable | ✅ Implemented (ReasoningBank) |
 | MCP Response | <100ms | ✅ Achieved |
@@ -1978,7 +1978,7 @@ npx monomind@latest hive-mind consensus --propose "task"
 | Package | Version | Purpose |
 |---------|---------|---------|
 | agentic-flow | 3.0.0-alpha.1 | Core coordination + ReasoningBank + Router |
-| agentdb | 3.0.0-alpha.10 | Vector database + 8 controllers |
+| @lancedb/lancedb | latest | Vector database (ANN search) |
 
 ### Optional Integrations
 | Package | Command |

package/packages/@monomind/cli/dist/src/init/shared-instructions-generator.d.ts

@@ -3,7 +3,7 @@
  *
  * Auto-detects project profile and generates:
  * 1. .agents/shared_instructions.md  — prepended to every agent prompt
- * 2. Memory seeds — pre-loaded into AgentDB so agents start with project best practices
+ * 2. Memory seeds — pre-loaded into LanceDB so agents start with project best practices
  */
 import type { InitResult } from './types.js';
 export interface ProjectProfile {

package/packages/@monomind/cli/dist/src/init/shared-instructions-generator.js

@@ -3,7 +3,7 @@
  *
  * Auto-detects project profile and generates:
  * 1. .agents/shared_instructions.md  — prepended to every agent prompt
- * 2. Memory seeds — pre-loaded into AgentDB so agents start with project best practices
+ * 2. Memory seeds — pre-loaded into LanceDB so agents start with project best practices
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';

package/packages/@monomind/cli/dist/src/init/statusline-generator.d.ts

@@ -18,7 +18,7 @@ import type { InitOptions } from './types.js';
  * 🏗️  DDD Domains    [●●○○○]  2/5    ⚡ HNSW 150x
  * 🤖 Swarm  ◉ [ 5/15]  👥 2    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
  * 🔧 Architecture    ADRs ●71%  │  DDD ● 13%  │  Security ●CLEAN
- * 📊 AgentDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
+ * 📊 LanceDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
  */
 export declare function generateStatuslineScript(options: InitOptions): string;
 export declare function generateStatuslineHook(options: InitOptions): string;

package/packages/@monomind/cli/dist/src/init/statusline-generator.js

@@ -17,7 +17,7 @@
  * 🏗️  DDD Domains    [●●○○○]  2/5    ⚡ HNSW 150x
  * 🤖 Swarm  ◉ [ 5/15]  👥 2    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
  * 🔧 Architecture    ADRs ●71%  │  DDD ● 13%  │  Security ●CLEAN
- * 📊 AgentDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
+ * 📊 LanceDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
  */
 export function generateStatuslineScript(options) {
     const maxAgents = options.runtime.maxAgents;
@@ -313,7 +313,7 @@ function getLearningStats() {
     path.join(CWD, '.monomind', 'memory.db'),
     path.join(CWD, '.claude', 'memory.db'),
     path.join(CWD, 'data', 'memory.db'),
-    path.join(CWD, '.agentdb', 'memory.db'),
+    path.join(CWD, '.swarm', 'lancedb'),
   ];
 
   for (const dbPath of memoryPaths) {
@@ -461,7 +461,7 @@ function getSwarmStatus() {
 function getSystemMetrics() {
   const memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
   const learning = getLearningStats();
-  const agentdb = getAgentDBStats();
+  const lancedbStats = getMemoryStats();
 
   // Intelligence from learning.json
   const learningData = readJSON(path.join(CWD, '.monomind', 'metrics', 'learning.json'));
@@ -473,7 +473,7 @@ function getSystemMetrics() {
   } else {
     // Use actual vector/entry counts — 2000 entries = 100%
     const fromPatterns = learning.patterns > 0 ? Math.min(100, Math.floor(learning.patterns / 20)) : 0;
-    const fromVectors = agentdb.vectorCount > 0 ? Math.min(100, Math.floor(agentdb.vectorCount / 20)) : 0;
+    const fromVectors = lancedbStats.vectorCount > 0 ? Math.min(100, Math.floor(lancedbStats.vectorCount / 20)) : 0;
     intelligencePct = Math.max(fromPatterns, fromVectors);
   }
 
@@ -590,8 +590,8 @@ function getActiveAgent() {
   } catch { return null; }
 }
 
-// AgentDB stats — count real entries, not file-size heuristics
-function getAgentDBStats() {
+// Memory (LanceDB) stats — count real entries
+function getMemoryStats() {
   let vectorCount = 0;
   let dbSizeKB = 0;
   let namespaces = 0;
@@ -1067,7 +1067,7 @@ function generateDashboard() {
   const system      = getSystemMetrics();
   const adrs        = getADRStatus();
   const hooks       = getHooksStatus();
-  const agentdb     = getAgentDBStats();
+  const lancedbStats = getMemoryStats();
   const tests       = getTestStats();
   const session     = getSessionStats();
   const integration = getIntegrationStatus();
@@ -1188,7 +1188,7 @@ function generateJSON() {
     system:     getSystemMetrics(),
     adrs:       getADRStatus(),
     hooks:      getHooksStatus(),
-    agentdb:    getAgentDBStats(),
+    lancedb: getMemoryStats(),
     tests:      getTestStats(),
     git:        { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
     lastUpdated: new Date().toISOString(),

package/packages/@monomind/cli/dist/src/init/types.d.ts

@@ -66,8 +66,8 @@ export interface HooksConfig {
 export interface SkillsConfig {
     /** Include core skills (swarm, sparc, mastermind, monodesign, monomotion) */
     core: boolean;
-    /** Include AgentDB skills */
-    agentdb: boolean;
+    /** Include memory/LanceDB skills */
+    memory: boolean;
     /** Include GitHub integration skills */
     github: boolean;
     /** Include browser automation skills */
@@ -194,7 +194,7 @@ export interface RuntimeConfig {
     /** Maximum agents */
     maxAgents: number;
     /** Memory backend */
-    memoryBackend: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
+    memoryBackend: 'memory' | 'sqlite' | 'lancedb' | 'hybrid';
     /** Enable HNSW indexing */
     enableHNSW: boolean;
     /** Enable neural learning */

package/packages/@monomind/cli/dist/src/init/types.js

@@ -73,7 +73,7 @@ export const DEFAULT_INIT_OPTIONS = {
     },
     skills: {
         core: true,
-        agentdb: true,
+        memory: true,
         github: true,
         browser: true,
         advanced: true,
@@ -164,7 +164,7 @@ export const MINIMAL_INIT_OPTIONS = {
     },
     skills: {
         core: true,
-        agentdb: false,
+        memory: false,
         github: false,
         browser: false,
         advanced: false,
@@ -220,7 +220,7 @@ export const FULL_INIT_OPTIONS = {
     },
     skills: {
         core: true,
-        agentdb: true,
+        memory: true,
         github: true,
         browser: true,
         advanced: true,