monomind 1.18.15 → 2.0.0

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

@@ -1,10 +1,9 @@
 /**
  * Memory Admin Commands
- * deleteCommand, statsCommand, configureCommand, cleanupCommand
+ * deleteCommand, statsCommand, configureCommand
  */
 import { output } from '../output.js';
 import { select, confirm } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { configManager } from '../services/config-file-manager.js';
 // Memory backends (needed for configureCommand)
 const BACKENDS = [
@@ -330,120 +329,4 @@ export const configureCommand = {
         return { success: true, data: config };
     }
 };
-// Cleanup command
-export const cleanupCommand = {
-    name: 'cleanup',
-    description: 'Clean up stale and expired memory entries',
-    options: [
-        {
-            name: 'dry-run',
-            short: 'd',
-            description: 'Show what would be deleted',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'older-than',
-            short: 'o',
-            description: 'Delete entries older than (e.g., "7d", "30d")',
-            type: 'string'
-        },
-        {
-            name: 'expired-only',
-            short: 'e',
-            description: 'Only delete expired TTL entries',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'low-quality',
-            short: 'l',
-            description: 'Delete low quality patterns (threshold)',
-            type: 'number'
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Clean specific namespace only',
-            type: 'string'
-        },
-        {
-            name: 'force',
-            short: 'f',
-            description: 'Skip confirmation',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind memory cleanup --dry-run', description: 'Preview cleanup' },
-        { command: 'monomind memory cleanup --older-than 30d', description: 'Delete entries older than 30 days' },
-        { command: 'monomind memory cleanup --expired-only', description: 'Clean expired entries' }
-    ],
-    action: async (ctx) => {
-        const dryRun = ctx.flags['dry-run'];
-        const force = ctx.flags.force;
-        if (dryRun) {
-            output.writeln(output.warning('DRY RUN - No changes will be made'));
-        }
-        output.printInfo('Analyzing memory for cleanup...');
-        try {
-            const result = await callMCPTool('memory_cleanup', {
-                dryRun,
-                olderThan: ctx.flags['older-than'],
-                expiredOnly: ctx.flags['expired-only'],
-                lowQualityThreshold: ctx.flags['low-quality'],
-                namespace: ctx.flags.namespace,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Cleanup Analysis'));
-            output.printTable({
-                columns: [
-                    { key: 'category', header: 'Category', width: 20 },
-                    { key: 'count', header: 'Count', width: 15, align: 'right' }
-                ],
-                data: [
-                    { category: 'Expired (TTL)', count: result.candidates.expired },
-                    { category: 'Stale (unused)', count: result.candidates.stale },
-                    { category: 'Low Quality', count: result.candidates.lowQuality },
-                    { category: output.bold('Total'), count: output.bold(String(result.candidates.total)) }
-                ]
-            });
-            if (!dryRun && result.candidates.total > 0 && !force) {
-                const confirmed = await confirm({
-                    message: `Delete ${result.candidates.total} entries (${result.freed.formatted})?`,
-                    default: false
-                });
-                if (!confirmed) {
-                    output.printInfo('Cleanup cancelled');
-                    return { success: true, data: result };
-                }
-            }
-            if (!dryRun) {
-                output.writeln();
-                output.printSuccess(`Cleaned ${result.deleted.entries} entries`);
-                output.printList([
-                    `Vectors removed: ${result.deleted.vectors}`,
-                    `Patterns removed: ${result.deleted.patterns}`,
-                    `Space freed: ${result.freed.formatted}`,
-                    `Duration: ${result.duration}ms`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Cleanup error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 //# sourceMappingURL=memory-admin.js.map

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

@@ -1,9 +1,8 @@
 /**
  * Memory Transfer Commands
- * compressCommand, exportCommand, importCommand
+ * exportCommand, importCommand
  */
 import type { Command } from '../types.js';
-export declare const compressCommand: Command;
 export declare const exportCommand: Command;
 export declare const importCommand: Command;
 //# sourceMappingURL=memory-transfer.d.ts.map

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

@@ -1,128 +1,8 @@
 /**
  * Memory Transfer Commands
- * compressCommand, exportCommand, importCommand
+ * exportCommand, importCommand
  */
 import { output } from '../output.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-// Compress command
-export const compressCommand = {
-    name: 'compress',
-    description: 'Compress and optimize memory storage',
-    options: [
-        {
-            name: 'level',
-            short: 'l',
-            description: 'Compression level (fast, balanced, max)',
-            type: 'string',
-            choices: ['fast', 'balanced', 'max'],
-            default: 'balanced'
-        },
-        {
-            name: 'target',
-            short: 't',
-            description: 'Target (vectors, text, patterns, all)',
-            type: 'string',
-            choices: ['vectors', 'text', 'patterns', 'all'],
-            default: 'all'
-        },
-        {
-            name: 'quantize',
-            short: 'z',
-            description: 'Enable vector quantization (reduces memory 4-32x)',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'bits',
-            description: 'Quantization bits (4, 8, 16)',
-            type: 'number',
-            default: 8
-        },
-        {
-            name: 'rebuild-index',
-            short: 'r',
-            description: 'Rebuild HNSW index after compression',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    examples: [
-        { command: 'monomind memory compress', description: 'Balanced compression' },
-        { command: 'monomind memory compress --quantize --bits 4', description: '4-bit quantization (32x reduction)' },
-        { command: 'monomind memory compress -l max -t vectors', description: 'Max compression on vectors' }
-    ],
-    action: async (ctx) => {
-        const level = ctx.flags.level || 'balanced';
-        const target = ctx.flags.target || 'all';
-        const quantize = ctx.flags.quantize;
-        const bits = ctx.flags.bits || 8;
-        const rebuildIndex = ctx.flags.rebuildIndex ?? true;
-        output.writeln();
-        output.writeln(output.bold('Memory Compression'));
-        output.writeln(output.dim(`Level: ${level}, Target: ${target}, Quantize: ${quantize ? `${bits}-bit` : 'no'}`));
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Analyzing current storage...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('memory_compress', {
-                level,
-                target,
-                quantize,
-                bits,
-                rebuildIndex,
-            });
-            spinner.succeed('Compression complete');
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Storage Comparison'));
-            output.printTable({
-                columns: [
-                    { key: 'category', header: 'Category', width: 15 },
-                    { key: 'before', header: 'Before', width: 12, align: 'right' },
-                    { key: 'after', header: 'After', width: 12, align: 'right' },
-                    { key: 'saved', header: 'Saved', width: 12, align: 'right' }
-                ],
-                data: [
-                    { category: 'Vectors', before: result.before.vectorsSize, after: result.after.vectorsSize, saved: '-' },
-                    { category: 'Text', before: result.before.textSize, after: result.after.textSize, saved: '-' },
-                    { category: 'Patterns', before: result.before.patternsSize, after: result.after.patternsSize, saved: '-' },
-                    { category: 'Index', before: result.before.indexSize, after: result.after.indexSize, saved: '-' },
-                    { category: output.bold('Total'), before: result.before.totalSize, after: result.after.totalSize, saved: output.success(result.compression.formattedSaved) }
-                ]
-            });
-            output.writeln();
-            output.printBox([
-                `Compression Ratio: ${result.compression.ratio.toFixed(2)}x`,
-                `Space Saved: ${result.compression.formattedSaved}`,
-                `Quantization: ${result.compression.quantizationApplied ? `Yes (${bits}-bit)` : 'No'}`,
-                `Index Rebuilt: ${result.compression.indexRebuilt ? 'Yes' : 'No'}`,
-                `Duration: ${(result.duration / 1000).toFixed(1)}s`
-            ].join('\n'), 'Results');
-            if (result.performance) {
-                output.writeln();
-                output.writeln(output.bold('Performance Impact'));
-                output.printList([
-                    `Search latency: ${result.performance.searchLatencyBefore.toFixed(2)}ms → ${result.performance.searchLatencyAfter.toFixed(2)}ms`,
-                    `Speedup: ${output.success(result.performance.searchSpeedup)}`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Compression failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Compression error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 // Export command
 export const exportCommand = {
     name: 'export',
@@ -207,31 +87,8 @@ export const exportCommand = {
                 return { success: false, exitCode: 1 };
             }
         }
-        try {
-            const result = await callMCPTool('memory_export', {
-                outputPath,
-                format,
-                namespace: ctx.flags.namespace,
-                includeVectors: ctx.flags.includeVectors ?? true,
-            });
-            output.printSuccess(`Exported to ${result.outputPath}`);
-            output.printList([
-                `Entries: ${result.exported.entries}`,
-                `Vectors: ${result.exported.vectors}`,
-                `Patterns: ${result.exported.patterns}`,
-                `File size: ${result.fileSize}`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Export error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
+        output.printError(`Unsupported export format: ${format}. Use --format okf for file-based export.`);
+        return { success: false, exitCode: 1 };
     }
 };
 // Import command
@@ -342,31 +199,8 @@ export const importCommand = {
                 return { success: false, exitCode: 1 };
             }
         }
-        try {
-            const result = await callMCPTool('memory_import', {
-                inputPath,
-                merge: ctx.flags.merge ?? true,
-                namespace: ctx.flags.namespace,
-            });
-            output.printSuccess(`Imported from ${result.inputPath}`);
-            output.printList([
-                `Entries: ${result.imported.entries}`,
-                `Vectors: ${result.imported.vectors}`,
-                `Patterns: ${result.imported.patterns}`,
-                `Skipped (duplicates): ${result.skipped}`,
-                `Duration: ${result.duration}ms`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Import error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
+        output.printError(`Unsupported import format. Provide a directory of .md files (OKF bundle) for file-based import.`);
+        return { success: false, exitCode: 1 };
     }
 };
 //# sourceMappingURL=memory-transfer.js.map

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

@@ -11,8 +11,8 @@
 import { output } from '../output.js';
 import { storeCommand, retrieveCommand, searchCommand } from './memory-crud.js';
 import { listCommand, editCommand, templatesCommand } from './memory-list.js';
-import { deleteCommand, statsCommand, configureCommand, cleanupCommand } from './memory-admin.js';
-import { compressCommand, exportCommand, importCommand } from './memory-transfer.js';
+import { deleteCommand, statsCommand, configureCommand } from './memory-admin.js';
+import { exportCommand, importCommand } from './memory-transfer.js';
 // Init subcommand - initialize memory database using sql.js
 const initMemoryCommand = {
     name: 'init',
@@ -209,7 +209,6 @@ const initMemoryCommand = {
             output.printList([
                 `Store data: ${output.highlight('monomind memory store -k "key" --value "data"')}`,
                 `Search: ${output.highlight('monomind memory search -q "query"')}`,
-                `Train patterns: ${output.highlight('monomind neural train -p coordination')}`,
                 `View stats: ${output.highlight('monomind memory stats')}`
             ]);
             // Also sync to .claude directory
@@ -248,7 +247,7 @@ const initMemoryCommand = {
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, editCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, templatesCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand],
+    subcommands: [initMemoryCommand, storeCommand, editCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, templatesCommand, statsCommand, configureCommand, exportCommand, importCommand],
     options: [],
     examples: [
         { command: 'monomind memory store -k "key" -v "value"', description: 'Store data' },
@@ -273,8 +272,6 @@ export const memoryCommand = {
             `${output.highlight('templates')}   - Show best-practice entry templates`,
             `${output.highlight('stats')}       - Show statistics`,
             `${output.highlight('configure')}   - Configure backend`,
-            `${output.highlight('cleanup')}     - Clean expired entries`,
-            `${output.highlight('compress')}    - Compress database`,
             `${output.highlight('export')}      - Export memory to file`,
             `${output.highlight('import')}      - Import from file`
         ]);

package/packages/@monomind/cli/dist/src/commands/neural-core.d.ts

@@ -1,8 +1,10 @@
 /**
- * Neural core commands — status, patterns, predict
+ * Neural core commands — train, status, patterns, predict
+ * Pattern storage and similarity search (no ML/neural-network training)
  */
 import type { Command } from '../types.js';
 export declare const statusCommand: Command;
 export declare const patternsCommand: Command;
+export declare const trainCommand: Command;
 export declare const predictCommand: Command;
 //# sourceMappingURL=neural-core.d.ts.map

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

@@ -1,17 +1,18 @@
 /**
- * Neural core commands — status, patterns, predict
+ * Neural core commands — train, status, patterns, predict
+ * Pattern storage and similarity search (no ML/neural-network training)
  */
 import { output } from '../output.js';
 // ─── status subcommand ───────────────────────────────────────────────────────
 export const statusCommand = {
     name: 'status',
-    description: 'Check pattern-learning status (JS intelligence layer)',
+    description: 'Check pattern storage and similarity search status',
     options: [
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
     ],
     examples: [
-        { command: 'monomind neural status', description: 'Show pattern-learning status' },
-        { command: 'monomind neural status -v', description: 'Show detailed metrics' },
+        { command: 'monomind hooks intelligence status', description: 'Show pattern-learning status' },
+        { command: 'monomind hooks intelligence status -v', description: 'Show detailed metrics' },
     ],
     action: async (ctx) => {
         const verbose = ctx.flags.verbose === true;
@@ -96,15 +97,15 @@ export const statusCommand = {
 // ─── patterns subcommand ─────────────────────────────────────────────────────
 export const patternsCommand = {
     name: 'patterns',
-    description: 'Analyze and manage cognitive patterns',
+    description: 'List and search stored patterns',
     options: [
         { name: 'action', short: 'a', type: 'string', description: 'Action: analyze, learn, predict, list', default: 'list' },
         { name: 'query', short: 'q', type: 'string', description: 'Pattern query for search' },
         { name: 'limit', short: 'l', type: 'number', description: 'Max patterns to return', default: '10' },
     ],
     examples: [
-        { command: 'monomind neural patterns --action list', description: 'List all patterns' },
-        { command: 'monomind neural patterns -a analyze -q "error handling"', description: 'Analyze patterns' },
+        { command: 'monomind hooks intelligence patterns --action list', description: 'List all patterns' },
+        { command: 'monomind hooks intelligence patterns -a analyze -q "error handling"', description: 'Analyze patterns' },
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
@@ -122,7 +123,7 @@ export const patternsCommand = {
                 const allPatterns = await getAllPatterns();
                 const patterns = query ? await findSimilarPatterns(query, { k: limit }) : allPatterns.slice(0, limit);
                 if (patterns.length === 0) {
-                    output.writeln(output.dim('No patterns found. Train some patterns first with: neural train'));
+                    output.writeln(output.dim('No patterns found. Train some patterns first with: hooks intelligence train'));
                     output.writeln();
                     output.printBox([
                         `Total Patterns: ${stats.patternsLearned}`,
@@ -183,23 +184,161 @@ export const patternsCommand = {
         }
         catch {
             output.writeln(output.dim('Intelligence system not initialized.'));
-            output.writeln(output.dim('Run: monomind neural train --pattern-type general'));
+            output.writeln(output.dim('Run: monomind hooks intelligence train --pattern-type general'));
             return { success: false };
         }
     },
 };
+// ─── train subcommand ───────────────────────────────────────────────────────
+export const trainCommand = {
+    name: 'train',
+    description: 'Ingest outcome and edit history into the pattern store for routing optimization',
+    options: [
+        { name: 'pattern-type', short: 't', type: 'string', description: 'Pattern type label (e.g. general, security, refactor)', default: 'general' },
+        { name: 'verbose', short: 'v', type: 'boolean', description: 'Show each ingested pattern' },
+    ],
+    examples: [
+        { command: 'monomind hooks intelligence train', description: 'Ingest outcomes and edits into pattern store' },
+        { command: 'monomind hooks intelligence train -t security -v', description: 'Ingest with type label, verbose' },
+    ],
+    action: async (ctx) => {
+        const patternType = ctx.flags['pattern-type'] || 'general';
+        const verbose = ctx.flags.verbose === true;
+        output.writeln();
+        output.writeln(output.bold('Pattern Store — Train'));
+        output.writeln(output.dim('Reads outcome/edit history and stores patterns for routing'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Initializing intelligence layer...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const crypto = await import('crypto');
+            const { initializeIntelligence, getReasoningBank, flushPatterns, getIntelligenceStats } = await import('../memory/intelligence.js');
+            await initializeIntelligence();
+            const bank = getReasoningBank();
+            if (!bank) {
+                spinner.fail('ReasoningBank not available');
+                return { success: false, exitCode: 1 };
+            }
+            const dataDir = path.join(process.cwd(), '.monomind', 'data');
+            const outcomesFile = path.join(dataDir, 'intelligence-outcomes.jsonl');
+            const editsFile = path.join(dataDir, 'recent-edits.jsonl');
+            let stored = 0;
+            const MAX_FILE_BYTES = 50 * 1024 * 1024;
+            // Helper: read a JSONL file safely, return parsed lines
+            const readJsonl = (filePath) => {
+                if (!fs.existsSync(filePath))
+                    return [];
+                const stat = fs.statSync(filePath);
+                if (stat.size > MAX_FILE_BYTES) {
+                    output.writeln(output.warning(`Skipping ${path.basename(filePath)}: too large (${stat.size} bytes)`));
+                    return [];
+                }
+                const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(l => l.trim());
+                const results = [];
+                for (const line of lines) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj && typeof obj === 'object' && !('__proto__' in obj)) {
+                            results.push(obj);
+                        }
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                }
+                return results;
+            };
+            // --- 1. Ingest intelligence-outcomes.jsonl (successful outcomes) ---
+            spinner.setText('Reading intelligence outcomes...');
+            const outcomes = readJsonl(outcomesFile);
+            const successOutcomes = outcomes.filter(o => o.success === true || o.verdict === 'success');
+            for (const outcome of successOutcomes) {
+                const content = (outcome.description || outcome.task || outcome.content || outcome.command || '');
+                if (!content || typeof content !== 'string' || content.length > 4096)
+                    continue;
+                const id = `outcome_${crypto.createHash('sha256').update(content).digest('hex').substring(0, 16)}`;
+                bank.store({
+                    id,
+                    type: patternType,
+                    content,
+                    confidence: typeof outcome.confidence === 'number' ? outcome.confidence : 0.8,
+                    embedding: [],
+                    metadata: { source: 'intelligence-outcomes', originalType: outcome.type },
+                });
+                stored++;
+                if (verbose)
+                    output.writeln(output.dim(`  + ${id}: ${content.substring(0, 60)}`));
+            }
+            // --- 2. Ingest recent-edits.jsonl (edit history) ---
+            spinner.setText('Reading edit history...');
+            const edits = readJsonl(editsFile);
+            for (const edit of edits) {
+                const file = (edit.file || edit.path || '');
+                const operation = (edit.operation || edit.action || 'edit');
+                if (!file || typeof file !== 'string')
+                    continue;
+                const content = `${operation}: ${file}`;
+                const id = `edit_${crypto.createHash('sha256').update(content + String(edit.timestamp || '')).digest('hex').substring(0, 16)}`;
+                bank.store({
+                    id,
+                    type: patternType,
+                    content,
+                    confidence: 0.7,
+                    embedding: [],
+                    metadata: { source: 'recent-edits', file, operation },
+                });
+                stored++;
+                if (verbose)
+                    output.writeln(output.dim(`  + ${id}: ${content.substring(0, 60)}`));
+            }
+            // --- 3. Flush to disk ---
+            spinner.setText('Persisting patterns...');
+            flushPatterns();
+            const stats = getIntelligenceStats();
+            spinner.succeed(`Stored ${stored} patterns from outcome/edit history`);
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 28 },
+                    { key: 'value', header: 'Value', width: 20 },
+                ],
+                data: [
+                    { metric: 'Outcomes Ingested', value: String(successOutcomes.length) },
+                    { metric: 'Edits Ingested', value: String(edits.length) },
+                    { metric: 'Patterns Stored', value: String(stored) },
+                    { metric: 'Total Patterns (bank)', value: String(stats.patternsLearned) },
+                    { metric: 'Pattern Type', value: patternType },
+                ],
+            });
+            if (stored === 0) {
+                output.writeln();
+                output.writeln(output.dim('No data found to ingest. Patterns are stored as you work:'));
+                output.writeln(output.dim('  - Outcomes: .monomind/data/intelligence-outcomes.jsonl'));
+                output.writeln(output.dim('  - Edits:    .monomind/data/recent-edits.jsonl'));
+            }
+            return { success: true, data: { stored, outcomes: successOutcomes.length, edits: edits.length } };
+        }
+        catch (error) {
+            spinner.fail('Training failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
 // ─── predict subcommand ──────────────────────────────────────────────────────
 export const predictCommand = {
     name: 'predict',
-    description: 'Make AI predictions using trained models',
+    description: 'Find similar patterns by similarity search',
     options: [
         { name: 'input', short: 'i', type: 'string', description: 'Input text to predict routing for', required: true },
         { name: 'k', short: 'k', type: 'number', description: 'Number of top predictions', default: '5' },
         { name: 'format', short: 'f', type: 'string', description: 'Output format: json, table', default: 'table' },
     ],
     examples: [
-        { command: 'monomind neural predict -i "implement authentication"', description: 'Predict routing for task' },
-        { command: 'monomind neural predict -i "fix bug in login" -k 3', description: 'Get top 3 predictions' },
+        { command: 'monomind hooks intelligence predict -i "implement authentication"', description: 'Predict routing for task' },
+        { command: 'monomind hooks intelligence predict -i "fix bug in login" -k 3', description: 'Get top 3 predictions' },
     ],
     action: async (ctx) => {
         const inputText = ctx.flags.input;
@@ -210,9 +349,9 @@ export const predictCommand = {
             return { success: false, exitCode: 1 };
         }
         output.writeln();
-        output.writeln(output.bold('Neural Prediction (Real)'));
+        output.writeln(output.bold('Pattern Similarity Search'));
         output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Running inference...', spinner: 'dots' });
+        const spinner = output.createSpinner({ text: 'Searching patterns...', spinner: 'dots' });
         spinner.start();
         try {
             const { initializeIntelligence, findSimilarPatterns } = await import('../memory/intelligence.js');
@@ -223,7 +362,7 @@ export const predictCommand = {
             spinner.succeed(`Prediction complete (search: ${searchTime.toFixed(1)}ms)`);
             output.writeln();
             if (matches.length === 0) {
-                output.writeln(output.warning('No similar patterns found. Try training first: monomind neural train'));
+                output.writeln(output.warning('No similar patterns found. Try training first: monomind hooks intelligence train'));
                 return { success: true, data: { matches: [] } };
             }
             if (format === 'json') {