monomind 1.15.6 → 1.16.0

package/packages/@monomind/cli/README.md

@@ -66,7 +66,7 @@ flowchart TD
     R["Reviewer"]
     M["Growth Marketer"]
     BOARD[("Shared\nTask Board")]
-    MEM[("AgentDB\nMemory")]
+    MEM[("LanceDB\nMemory")]
 
     U --> CO --> RO --> BOSS
     BOSS -->|spawns| W
@@ -126,7 +126,7 @@ Type "go" to save, or describe changes.
 | **Boss agent** | Coordinator type, no supervisor — owns the goal |
 | **Role agents** | Spawned on demand, specialized by task type |
 | **Task board** | Todo → Doing → Done, shared across all agents |
-| **Memory** | All output stored in org-scoped AgentDB namespace |
+| **Memory** | All output stored in org-scoped LanceDB namespace |
 | **Checkpoint** | State saved every 30 min — survives crashes and restarts |
 | **Governance** | `auto` (free), `board` (approve sensitive), `strict` (approve all external actions) |
 
@@ -221,13 +221,13 @@ Open Claude Code. You now have 80+ slash commands available:
 
 ## 🧠 Memory That Persists
 
-Every session, every agent, every org writes to **AgentDB** — a hybrid SQLite + HNSW vector store that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
+Every session, every agent, every org writes to **LanceDB** — a hybrid SQLite + HNSW vector store that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
 
 ```mermaid
 graph TD
     L0["L0 - In-flight\nCurrent session drawers\nephemeral"]
     L1["L1 - Working\nCross-session memory\nBM25 K1=1.5, B=0.75"]
-    L2["L2 - Long-term\nAgentDB + HNSW index\nSemantic search"]
+    L2["L2 - Long-term\nLanceDB + HNSW index\nSemantic search"]
     L3["L3 - Shared\nCross-agent namespace\nFederated swarm reads"]
 
     L0 -->|promoted| L1 --> L2 --> L3
@@ -275,7 +275,7 @@ flowchart LR
     H --> I["route\nlearn\nbuild-agents"]
     H --> T["teammate-idle\ntask-completed"]
 
-    I --> DB[("AgentDB\npatterns.json")]
+    I --> DB[("LanceDB\npatterns.json")]
     DB -->|next session| CE
 ```
 
@@ -358,7 +358,7 @@ graph TD
     CC <-->|"23 tools: monograph, memory, swarm"| MCP
     MCP <--> D
 
-    D --> ADB[("AgentDB\nSQLite + HNSW")]
+    D --> ADB[("LanceDB\nSQLite + HNSW")]
     D --> MG[("Monograph\ncode graph")]
     D --> HK["Hooks\n22 event types"]
     D --> SW["Swarm\n6 topologies\n5 consensus algos"]

package/packages/@monomind/cli/dist/src/__tests__/browse-analyzer.test.js

@@ -38,7 +38,24 @@ function mockPage(url = 'https://linkedin.com/feed', title = 'LinkedIn') {
 describe('analyzePageForAction', () => {
     let analyzePageForAction;
     beforeEach(async () => {
-        mockCreate.mockClear();
+        mockCreate.mockResolvedValue({
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        id: 'linkedin:comment_post',
+                        platform: 'linkedin',
+                        name: 'Comment on Post',
+                        params: ['post_url', 'text'],
+                        steps: [
+                            { type: 'navigate', url: '{{params.post_url}}' },
+                            { type: 'find', selectors: ['.comment-box'], as: 'box' },
+                            { type: 'click', target: '{{box}}' },
+                            { type: 'type', target: '{{box}}', text: '{{params.text}}', humanDelay: true },
+                            { type: 'wait', condition: 'network_idle', timeout: 3000 },
+                        ],
+                    }),
+                }],
+        });
         const mod = await import('@monoes/monobrowse');
         analyzePageForAction = mod.analyzePageForAction;
     });

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

@@ -53,7 +53,7 @@ const AGENT_TYPES = [
     { value: 'optimizer', label: 'Optimizer', hint: 'Performance optimization and bottleneck analysis' },
     { value: 'security-architect', label: 'Security Architect', hint: 'Security architecture and threat modeling' },
     { value: 'security-auditor', label: 'Security Auditor', hint: 'CVE remediation and security testing' },
-    { value: 'memory-specialist', label: 'Memory Specialist', hint: 'AgentDB unification (150x-12,500x faster)' },
+    { value: 'memory-specialist', label: 'Memory Specialist', hint: 'LanceDB ANN search (150x-12,500x faster)' },
     { value: 'swarm-specialist', label: 'Swarm Specialist', hint: 'Unified coordination engine' },
     { value: 'performance-engineer', label: 'Performance Engineer', hint: '2.49x-7.47x optimization targets' },
     { value: 'core-architect', label: 'Core Architect', hint: 'Domain-driven design restructure' },
@@ -918,7 +918,7 @@ function getAgentCapabilities(type) {
         architect: ['system-design', 'pattern-analysis', 'scalability', 'documentation'],
         coordinator: ['task-orchestration', 'agent-management', 'workflow-control'],
         'security-architect': ['threat-modeling', 'security-patterns', 'compliance', 'audit'],
-        'memory-specialist': ['vector-search', 'agentdb', 'caching', 'optimization'],
+        'memory-specialist': ['vector-search', 'lancedb', 'caching', 'optimization'],
         'performance-engineer': ['benchmarking', 'profiling', 'optimization', 'monitoring']
     };
     return capabilities[type] || ['general'];

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

@@ -221,7 +221,7 @@ const learnCommand = {
     action: async (ctx) => {
         const learning = await tryLoadLearning();
         if (!learning) {
-            output.writeln('Learning not available (AgentDB not initialized). Autopilot still works for task completion tracking.');
+            output.writeln('Learning not available (memory backend not initialized). Autopilot still works for task completion tracking.');
             return { success: true };
         }
         const metrics = await learning.getMetrics();

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

@@ -9,7 +9,7 @@ import { output } from '../output.js';
 const TOP_LEVEL_COMMANDS = [
     'swarm', 'agent', 'task', 'session', 'config', 'memory', 'workflow',
     'hive-mind', 'hooks', 'daemon', 'neural', 'security', 'performance',
-    'providers', 'plugins', 'deployment', 'claims', 'embeddings',
+    'providers', 'deployment', 'claims', 'embeddings',
     'doctor', 'completions', 'help', 'version'
 ];
 // Swarm subcommands
@@ -81,10 +81,6 @@ _monomind_completions() {
             COMPREPLY=( $(compgen -W "benchmark profile metrics optimize bottleneck" -- "\${cur}") )
             return 0
             ;;
-        plugins)
-            COMPREPLY=( $(compgen -W "list install uninstall toggle info create" -- "\${cur}") )
-            return 0
-            ;;
         deployment|deploy)
             COMPREPLY=( $(compgen -W "deploy status rollback history environments logs" -- "\${cur}") )
             return 0
@@ -138,7 +134,7 @@ _monomind() {
         'task:Task creation and management'
         'session:Session management'
         'config:Configuration management'
-        'memory:Memory operations with AgentDB'
+        'memory:Memory operations with LanceDB'
         'workflow:Workflow automation'
         'hive-mind:Queen-led consensus coordination'
         'hooks:Self-learning automation hooks'
@@ -147,7 +143,6 @@ _monomind() {
         'security:Security scanning and CVE detection'
         'performance:Performance profiling'
         'providers:AI provider management'
-        'plugins:Plugin management'
         'deployment:Deployment management'
         'claims:Claims-based authorization'
         'embeddings:Vector embeddings'
@@ -273,16 +268,6 @@ _monomind() {
                         'bottleneck:Find bottlenecks'
                     )
                     ;;
-                plugins)
-                    subcommands=(
-                        'list:List plugins'
-                        'install:Install plugin'
-                        'uninstall:Remove plugin'
-                        'toggle:Enable/disable'
-                        'info:Plugin details'
-                        'create:Scaffold plugin'
-                    )
-                    ;;
                 deployment|deploy)
                     subcommands=(
                         'deploy:Deploy to environment'
@@ -379,9 +364,6 @@ complete -c monomind -n "__fish_seen_subcommand_from security" -a "scan cve thre
 # Performance subcommands
 complete -c monomind -n "__fish_seen_subcommand_from performance" -a "benchmark profile metrics optimize bottleneck"
 
-# Plugins subcommands
-complete -c monomind -n "__fish_seen_subcommand_from plugins" -a "list install uninstall toggle info create"
-
 # Deployment subcommands
 complete -c monomind -n "__fish_seen_subcommand_from deployment deploy" -a "deploy status rollback history environments logs"
 
@@ -419,7 +401,6 @@ $script:SubCommands = @{
     'neural' = @('train', 'status', 'patterns', 'predict', 'optimize')
     'security' = @('scan', 'cve', 'threats', 'audit', 'secrets')
     'performance' = @('benchmark', 'profile', 'metrics', 'optimize', 'bottleneck')
-    'plugins' = @('list', 'install', 'uninstall', 'toggle', 'info', 'create')
     'deployment' = @('deploy', 'status', 'rollback', 'history', 'environments', 'logs')
     'deploy' = @('deploy', 'status', 'rollback', 'history', 'environments', 'logs')
     'claims' = @('list', 'check', 'grant', 'revoke', 'roles', 'policies')

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

@@ -146,7 +146,7 @@ const setCommand = {
     ],
     examples: [
         { command: 'monomind config set swarm.maxAgents 20', description: 'Set max agents' },
-        { command: 'monomind config set -k memory.backend -v agentdb', description: 'Set memory backend' }
+        { command: 'monomind config set -k memory.backend -v lancedb', description: 'Set memory backend' }
     ],
     action: async (ctx) => {
         const key = (ctx.flags.key || ctx.args[0] || '').slice(0, 256);

package/packages/@monomind/cli/dist/src/commands/hive-mind.js

@@ -370,7 +370,7 @@ const initCommand = {
         },
         {
             name: 'memory-backend',
-            description: 'Memory backend (agentdb, sqlite, hybrid)',
+            description: 'Memory backend (lancedb, sqlite, hybrid)',
             type: 'string',
             default: 'hybrid'
         }

package/packages/@monomind/cli/dist/src/commands/hooks-coverage-commands.js

@@ -1049,8 +1049,8 @@ export const statuslineCommand = {
             }
             catch { /* ignore */ }
         }
-        // Get AgentDB stats (matching statusline-generator.ts paths)
-        const agentdbStats = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
+        // Get memory backend stats
+        const memoryStats = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
         // Check for direct database files first
         const dbPaths = [
             path.join(process.cwd(), '.swarm', 'memory.db'),
@@ -1058,30 +1058,30 @@ export const statuslineCommand = {
             path.join(process.cwd(), '.claude', 'memory.db'),
             path.join(process.cwd(), 'data', 'memory.db'),
             path.join(process.cwd(), 'memory.db'),
-            path.join(process.cwd(), '.agentdb', 'memory.db'),
-            path.join(process.cwd(), '.monomind', 'memory', 'agentdb.db'),
+            path.join(process.cwd(), ".swarm", "lancedb"),
+            path.join(process.cwd(), ".monomind", "memory", "lancedb"),
         ];
         for (const dbPath of dbPaths) {
             if (fs.existsSync(dbPath)) {
                 try {
                     const stats = fs.statSync(dbPath);
-                    agentdbStats.dbSizeKB = Math.round(stats.size / 1024);
-                    agentdbStats.vectorCount = Math.floor(agentdbStats.dbSizeKB / 2);
-                    agentdbStats.hasHnsw = agentdbStats.vectorCount > 100;
+                    memoryStats.dbSizeKB = Math.round(stats.size / 1024);
+                    memoryStats.vectorCount = Math.floor(memoryStats.dbSizeKB / 2);
+                    memoryStats.hasHnsw = memoryStats.vectorCount > 100;
                     break;
                 }
                 catch { /* ignore */ }
             }
         }
-        // Check for AgentDB directories if no direct db found
-        if (agentdbStats.vectorCount === 0) {
-            const agentdbDirs = [
-                path.join(process.cwd(), '.monomind', 'agentdb'),
-                path.join(process.cwd(), '.swarm', 'agentdb'),
-                path.join(process.cwd(), 'data', 'agentdb'),
-                path.join(process.cwd(), '.agentdb'),
+        // Check for LanceDB directories if no direct db found
+        if (memoryStats.vectorCount === 0) {
+            const lancedbDirs = [
+                path.join(process.cwd(), ".monomind", "lancedb"),
+                path.join(process.cwd(), ".swarm", "lancedb"),
+                path.join(process.cwd(), "data", "lancedb"),
+                path.join(process.cwd(), ".swarm", "lancedb"),
             ];
-            for (const dir of agentdbDirs) {
+            for (const dir of lancedbDirs) {
                 if (fs.existsSync(dir)) {
                     try {
                         const files = fs.readdirSync(dir);
@@ -1089,12 +1089,12 @@ export const statuslineCommand = {
                             if (f.endsWith('.db') || f.endsWith('.sqlite')) {
                                 const filePath = path.join(dir, f);
                                 const fileStat = fs.statSync(filePath);
-                                agentdbStats.dbSizeKB += Math.round(fileStat.size / 1024);
+                                memoryStats.dbSizeKB += Math.round(fileStat.size / 1024);
                             }
                         }
-                        agentdbStats.vectorCount = Math.floor(agentdbStats.dbSizeKB / 2);
-                        agentdbStats.hasHnsw = agentdbStats.vectorCount > 100;
-                        if (agentdbStats.vectorCount > 0)
+                        memoryStats.vectorCount = Math.floor(memoryStats.dbSizeKB / 2);
+                        memoryStats.hasHnsw = memoryStats.vectorCount > 100;
+                        if (memoryStats.vectorCount > 0)
                             break;
                     }
                     catch { /* ignore */ }
@@ -1109,14 +1109,14 @@ export const statuslineCommand = {
         ];
         for (const hnswPath of hnswPaths) {
             if (fs.existsSync(hnswPath)) {
-                agentdbStats.hasHnsw = true;
+                memoryStats.hasHnsw = true;
                 try {
                     const hnswFiles = fs.readdirSync(hnswPath);
                     const indexFile = hnswFiles.find(f => f.endsWith('.index'));
                     if (indexFile) {
                         const indexStat = fs.statSync(path.join(hnswPath, indexFile));
                         const hnswVectors = Math.floor(indexStat.size / 512);
-                        agentdbStats.vectorCount = Math.max(agentdbStats.vectorCount, hnswVectors);
+                        memoryStats.vectorCount = Math.max(memoryStats.vectorCount, hnswVectors);
                     }
                 }
                 catch { /* ignore */ }
@@ -1125,15 +1125,15 @@ export const statuslineCommand = {
         }
         // Check for vectors.json file
         const vectorsPath = path.join(process.cwd(), '.monomind', 'vectors.json');
-        if (fs.existsSync(vectorsPath) && agentdbStats.vectorCount === 0) {
+        if (fs.existsSync(vectorsPath) && memoryStats.vectorCount === 0) {
             try {
                 if (fs.statSync(vectorsPath).size <= 8_388_608) {
                     const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
                     if (Array.isArray(data)) {
-                        agentdbStats.vectorCount = data.length;
+                        memoryStats.vectorCount = data.length;
                     }
                     else if (data.vectors) {
-                        agentdbStats.vectorCount = Object.keys(data.vectors).length;
+                        memoryStats.vectorCount = Object.keys(data.vectors).length;
                     }
                 }
             }
@@ -1169,8 +1169,8 @@ export const statuslineCommand = {
         const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
         // Dynamic perf indicator based on patterns/HNSW
         let perfIndicator = `${c.dim}⚡ HNSW: idle${c.reset}`;
-        if (agentdbStats.hasHnsw && agentdbStats.vectorCount > 0) {
-            perfIndicator = `${c.brightGreen}⚡ HNSW ${agentdbStats.vectorCount.toLocaleString()} vec${c.reset}`;
+        if (memoryStats.hasHnsw && memoryStats.vectorCount > 0) {
+            perfIndicator = `${c.brightGreen}⚡ HNSW ${memoryStats.vectorCount.toLocaleString()} vec${c.reset}`;
         }
         else if (progress.patternsLearned > 0) {
             const patternsK = progress.patternsLearned >= 1000 ? `${(progress.patternsLearned / 1000).toFixed(1)}k` : String(progress.patternsLearned);
@@ -1195,13 +1195,13 @@ export const statuslineCommand = {
             `${c.cyan}ADRs${c.reset} ${c.dim}●0/0${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}DDD${c.reset} ${dddColor}●${String(progress.dddProgress).padStart(3)}%${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}Security${c.reset} ${securityColor}●${security.status}${c.reset}`;
-        const vectorColor = agentdbStats.vectorCount > 0 ? c.brightGreen : c.dim;
+        const vectorColor = memoryStats.vectorCount > 0 ? c.brightGreen : c.dim;
         const testColor = testStats.testFiles > 0 ? c.brightGreen : c.dim;
         const mcpColor = mcpStats.enabled > 0 ? c.brightGreen : c.dim;
-        const sizeDisplay = agentdbStats.dbSizeKB >= 1024 ? `${(agentdbStats.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdbStats.dbSizeKB}KB`;
-        const hnswIndicator = agentdbStats.hasHnsw ? `${c.brightGreen}⚡${c.reset}` : '';
-        const line4 = `${c.brightCyan}📊 AgentDB${c.reset}    ` +
-            `${c.cyan}Vectors${c.reset} ${vectorColor}●${agentdbStats.vectorCount}${hnswIndicator}${c.reset}  ${c.dim}│${c.reset}  ` +
+        const sizeDisplay = memoryStats.dbSizeKB >= 1024 ? `${(memoryStats.dbSizeKB / 1024).toFixed(1)}MB` : `${memoryStats.dbSizeKB}KB`;
+        const hnswIndicator = memoryStats.hasHnsw ? `${c.brightGreen}⚡${c.reset}` : '';
+        const line4 = `${c.brightCyan}📊 LanceDB${c.reset}    ` +
+            `${c.cyan}Vectors${c.reset} ${vectorColor}●${memoryStats.vectorCount}${hnswIndicator}${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisplay}${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}Tests${c.reset} ${testColor}●${testStats.testFiles}${c.reset} ${c.dim}(${testStats.testCases} cases)${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}MCP${c.reset} ${mcpColor}●${mcpStats.enabled}/${mcpStats.total}${c.reset}`;

package/packages/@monomind/cli/dist/src/commands/hooks-routing-commands.js

@@ -623,7 +623,7 @@ export const transferFromProjectCommand = {
 // Parent transfer command combining all transfer methods
 export const transferCommand = {
     name: 'transfer',
-    description: 'Transfer patterns and plugins via IPFS-based decentralized registry',
+    description: 'Transfer patterns via IPFS-based decentralized registry',
     subcommands: [storeCommand, transferFromProjectCommand],
     examples: [
         { command: 'monomind hooks transfer store list', description: 'List patterns from registry' },

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

@@ -498,7 +498,7 @@ export const hooksCommand = {
         output.printList([
             '🧠 Trajectory + outcome logging',
             '🎯 Keyword routing + route-outcome measurement',
-            '🔍 AgentDB integration (pure-JS HNSW search)',
+            '🔍 LanceDB integration (ANN vector search)',
             '🎯 32.3% token reduction',
             '👥 Agent Teams integration (auto task assignment)'
         ]);

package/packages/@monomind/cli/dist/src/commands/index.d.ts

@@ -43,7 +43,6 @@ export declare function getNeuralCommand(): Promise<Command | undefined>;
 export declare function getSecurityCommand(): Promise<Command | undefined>;
 export declare function getPerformanceCommand(): Promise<Command | undefined>;
 export declare function getProvidersCommand(): Promise<Command | undefined>;
-export declare function getPluginsCommand(): Promise<Command | undefined>;
 export declare function getDeploymentCommand(): Promise<Command | undefined>;
 export declare function getClaimsCommand(): Promise<Command | undefined>;
 export declare function getCompletionsCommand(): Promise<Command | undefined>;

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

@@ -36,7 +36,6 @@ const commandLoaders = {
     security: () => import('./security.js'),
     performance: () => import('./performance.js'),
     providers: () => import('./providers.js'),
-    plugins: () => import('./plugins.js'),
     deployment: () => import('./deployment.js'),
     claims: () => import('./claims.js'),
     // P0 Commands
@@ -133,7 +132,6 @@ import { analyzeCommand } from './analyze.js';
 import { routeCommand } from './route.js';
 import { progressCommand } from './progress.js';
 import { providersCommand } from './providers.js';
-import { pluginsCommand } from './plugins.js';
 import { deploymentCommand } from './deployment.js';
 import { claimsCommand } from './claims.js';
 import { issuesCommand } from './issues.js';
@@ -217,7 +215,6 @@ export async function getNeuralCommand() { return loadCommand('neural'); }
 export async function getSecurityCommand() { return loadCommand('security'); }
 export async function getPerformanceCommand() { return loadCommand('performance'); }
 export async function getProvidersCommand() { return loadCommand('providers'); }
-export async function getPluginsCommand() { return loadCommand('plugins'); }
 export async function getDeploymentCommand() { return loadCommand('deployment'); }
 export async function getClaimsCommand() { return loadCommand('claims'); }
 export async function getCompletionsCommand() { return loadCommand('completions'); }
@@ -304,7 +301,6 @@ export const commandsByCategory = {
     ],
     management: [
         providersCommand,
-        pluginsCommand,
         deploymentCommand,
         claimsCommand,
         issuesCommand,

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

@@ -346,12 +346,12 @@ const wizardCommand = {
                         message: 'Select skill sets:',
                         options: [
                             { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC skills', selected: true },
-                            { value: 'agentdb', label: 'AgentDB', hint: 'Vector database skills', selected: true },
+                            { value: 'memory', label: 'Memory (LanceDB)', hint: 'Vector database skills', selected: true },
                             { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
                         ],
                     });
                     options.skills.core = skillSets.includes('core');
-                    options.skills.agentdb = skillSets.includes('agentdb');
+                    options.skills.memory = skillSets.includes('memory');
                     options.skills.github = skillSets.includes('github');
                 }
                 // Hooks selection
@@ -401,15 +401,15 @@ const wizardCommand = {
             const memoryBackend = await select({
                 message: 'Select memory backend:',
                 options: [
-                    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
-                    { value: 'agentdb', label: 'AgentDB', hint: '150x faster vector search' },
+                    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + LanceDB (recommended)' },
+                    { value: 'lancedb', label: 'LanceDB', hint: '150x faster vector search' },
                     { value: 'sqlite', label: 'SQLite', hint: 'Standard SQL storage' },
                     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' },
                 ],
             });
             options.runtime.memoryBackend = memoryBackend;
             // HNSW indexing
-            if (memoryBackend === 'agentdb' || memoryBackend === 'hybrid') {
+            if (memoryBackend === 'lancedb' || memoryBackend === 'hybrid') {
                 const enableHNSW = await confirm({
                     message: 'Enable HNSW indexing for faster vector search?',
                     default: true,
@@ -423,7 +423,7 @@ const wizardCommand = {
             });
             options.runtime.enableNeural = enableNeural;
             // ADR-049: Self-Learning Memory capabilities
-            if (memoryBackend === 'agentdb' || memoryBackend === 'hybrid') {
+            if (memoryBackend === 'lancedb' || memoryBackend === 'hybrid') {
                 const enableSelfLearning = await confirm({
                     message: 'Enable self-learning memory? (LearningBridge + Knowledge Graph + Agent Scopes)',
                     default: true,
@@ -582,7 +582,7 @@ const skillsCommand = {
     options: [
         { name: 'all', description: 'Install all skills', type: 'boolean', default: false },
         { name: 'core', description: 'Install core skills', type: 'boolean', default: true },
-        { name: 'agentdb', description: 'Install AgentDB skills', type: 'boolean', default: false },
+        { name: 'memory', description: 'Install memory skills', type: 'boolean', default: false },
         { name: 'github', description: 'Install GitHub skills', type: 'boolean', default: false },
     ],
     action: async (ctx) => {
@@ -605,7 +605,7 @@ const skillsCommand = {
             skills: {
                 all: ctx.flags.all,
                 core: ctx.flags.core,
-                agentdb: ctx.flags.agentdb,
+                memory: ctx.flags.memory,
                 github: ctx.flags.github,
                 browser: false,
                 advanced: false,

package/packages/@monomind/cli/dist/src/commands/memory.d.ts

@@ -1,6 +1,6 @@
 /**
  * CLI Memory Command
- * Memory operations for AgentDB integration
+ * Memory operations for LanceDB integration
  */
 import type { Command } from '../types.js';
 export declare const memoryCommand: Command;