monomind 1.18.15 → 2.0.0

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

@@ -5,14 +5,14 @@ import { output } from '../output.js';
 // ─── optimize subcommand ─────────────────────────────────────────────────────
 export const optimizeCommand = {
     name: 'optimize',
-    description: 'Optimize neural patterns (Int8 quantization, memory compression)',
+    description: 'Optimize pattern storage (Int8 quantization, memory compression)',
     options: [
         { name: 'method', type: 'string', description: 'Method: quantize, analyze, compact', default: 'quantize' },
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
     ],
     examples: [
-        { command: 'monomind neural optimize --method quantize', description: 'Quantize patterns to Int8' },
-        { command: 'monomind neural optimize --method analyze -v', description: 'Analyze memory usage' },
+        { command: 'monomind hooks intelligence optimize --method quantize', description: 'Quantize patterns to Int8' },
+        { command: 'monomind hooks intelligence optimize --method analyze -v', description: 'Analyze memory usage' },
     ],
     action: async (ctx) => {
         const method = ctx.flags.method || 'quantize';
@@ -54,9 +54,8 @@ export const optimizeCommand = {
                     return { ...p, embedding: int8Embedding, _quantized: true, _scale: scale };
                 });
                 const patternFile = path.join(patternDir, 'patterns.json');
-                const tmpFile = `${patternFile}.${process.pid}.tmp`;
-                fs.writeFileSync(tmpFile, JSON.stringify(quantizedPatterns, null, 2), 'utf-8');
-                fs.renameSync(tmpFile, patternFile);
+                const { writeJsonFileAtomic } = await import('../utils/json-file.js');
+                writeJsonFileAtomic(patternFile, quantizedPatterns);
                 spinner.succeed(`Quantized ${quantized} patterns`);
                 output.writeln();
                 output.printTable({
@@ -138,7 +137,7 @@ export const optimizeCommand = {
 // ─── export subcommand ───────────────────────────────────────────────────────
 export const exportCommand = {
     name: 'export',
-    description: 'Export trained models to IPFS for sharing (Ed25519 signed)',
+    description: 'Export stored patterns to IPFS for sharing (Ed25519 signed)',
     options: [
         { name: 'model', short: 'm', type: 'string', description: 'Model ID or category to export' },
         { name: 'output', short: 'o', type: 'string', description: 'Output file path (optional)' },
@@ -148,8 +147,8 @@ export const exportCommand = {
         { name: 'name', short: 'n', type: 'string', description: 'Custom name for exported model' },
     ],
     examples: [
-        { command: 'monomind neural export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
-        { command: 'monomind neural export -m code-review -o ./export.json', description: 'Export to file' },
+        { command: 'monomind hooks intelligence export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
+        { command: 'monomind hooks intelligence export -m code-review -o ./export.json', description: 'Export to file' },
     ],
     action: async (ctx) => {
         const modelId = ctx.flags.model || 'all';
@@ -159,7 +158,7 @@ export const exportCommand = {
         const stripPii = ctx.flags['strip-pii'] !== false;
         const customName = ctx.flags.name;
         output.writeln();
-        output.writeln(output.bold('Secure Model Export'));
+        output.writeln(output.bold('Secure Pattern Export'));
         output.writeln(output.dim('─'.repeat(50)));
         const spinner = output.createSpinner({ text: 'Preparing export...', spinner: 'dots' });
         spinner.start();
@@ -167,7 +166,7 @@ export const exportCommand = {
             const fs = await import('fs');
             const path = await import('path');
             const crypto = await import('crypto');
-            spinner.setText('Collecting trained patterns...');
+            spinner.setText('Collecting stored patterns...');
             const { getIntelligenceStats, flushPatterns } = await import('../memory/intelligence.js');
             await flushPatterns();
             const stats = await getIntelligenceStats();
@@ -267,9 +266,8 @@ export const exportCommand = {
                     spinner.fail(`--output path escapes project directory: ${outputFile}`);
                     return { success: false, exitCode: 1 };
                 }
-                const tmpOutput = outputFile + '.tmp';
-                fs.writeFileSync(tmpOutput, JSON.stringify(exportPackage, null, 2));
-                fs.renameSync(tmpOutput, outputFile);
+                const { writeJsonFileAtomic } = await import('../utils/json-file.js');
+                writeJsonFileAtomic(resolvedOut, exportPackage);
                 spinner.succeed(`Exported to: ${outputFile}`);
             }
             if (pinToIpfs) {
@@ -314,7 +312,7 @@ export const exportCommand = {
                 });
                 output.writeln();
                 output.writeln(output.success('Share this CID for others to import your trained patterns'));
-                output.writeln(output.dim(`Import command: monomind neural import --cid ${result.IpfsHash}`));
+                output.writeln(output.dim(`Import command: monomind hooks intelligence import --cid ${result.IpfsHash}`));
             }
             if (!outputFile && !pinToIpfs) {
                 spinner.succeed('Export prepared');

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

@@ -1,5 +1,5 @@
 /**
- * Neural registry commands — list and import models from IPFS
+ * Neural registry commands — list and import pattern sets from IPFS
  */
 import type { Command } from '../types.js';
 export declare const listCommand: Command;

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

@@ -1,20 +1,20 @@
 /**
- * Neural registry commands — list and import models from IPFS
+ * Neural registry commands — list and import pattern sets from IPFS
  */
 import { output } from '../output.js';
 // ─── list subcommand ─────────────────────────────────────────────────────────
 export const listCommand = {
     name: 'list',
-    description: 'List available pre-trained models from the official registry',
+    description: 'List available pattern sets from the official registry',
     options: [
         { name: 'category', type: 'string', description: 'Filter by category (security, quality, performance, etc.)' },
         { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json, simple', default: 'table' },
         { name: 'cid', type: 'string', description: 'Custom registry CID (default: official registry)' },
     ],
     examples: [
-        { command: 'monomind neural list', description: 'List all available models' },
-        { command: 'monomind neural list --category security', description: 'List only security models' },
-        { command: 'monomind neural list -f json', description: 'Output as JSON' },
+        { command: 'monomind hooks intelligence list', description: 'List all available models' },
+        { command: 'monomind hooks intelligence list --category security', description: 'List only security models' },
+        { command: 'monomind hooks intelligence list -f json', description: 'Output as JSON' },
     ],
     action: async (ctx) => {
         const category = ctx.flags.category;
@@ -96,12 +96,12 @@ export const listCommand = {
                 output.writeln(output.dim('Registry CID: ' + registryCid));
                 output.writeln();
                 output.writeln(output.bold('Import Commands:'));
-                output.writeln(output.dim('  All models:      ') + `monomind neural import --cid ${registryCid}`);
+                output.writeln(output.dim('  All models:      ') + `monomind hooks intelligence import --cid ${registryCid}`);
                 if (category) {
-                    output.writeln(output.dim(`  ${category} only: `) + `monomind neural import --cid ${registryCid} --category ${category}`);
+                    output.writeln(output.dim(`  ${category} only: `) + `monomind hooks intelligence import --cid ${registryCid} --category ${category}`);
                 }
                 else {
-                    output.writeln(output.dim('  By category:     ') + `monomind neural import --cid ${registryCid} --category <category>`);
+                    output.writeln(output.dim('  By category:     ') + `monomind hooks intelligence import --cid ${registryCid} --category <category>`);
                 }
             }
             return { success: true };
@@ -115,7 +115,7 @@ export const listCommand = {
 // ─── import subcommand ───────────────────────────────────────────────────────
 export const importCommand = {
     name: 'import',
-    description: 'Import trained models from IPFS with signature verification',
+    description: 'Import pattern sets from IPFS with signature verification',
     options: [
         { name: 'cid', short: 'c', type: 'string', description: 'IPFS CID to import from' },
         { name: 'file', short: 'f', type: 'string', description: 'Local file to import' },
@@ -124,9 +124,9 @@ export const importCommand = {
         { name: 'category', type: 'string', description: 'Only import patterns from specific category' },
     ],
     examples: [
-        { command: 'monomind neural import --cid QmXxx...', description: 'Import from IPFS' },
-        { command: 'monomind neural import -f ./patterns.json --verify', description: 'Import from file' },
-        { command: 'monomind neural import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
+        { command: 'monomind hooks intelligence import --cid QmXxx...', description: 'Import from IPFS' },
+        { command: 'monomind hooks intelligence import -f ./patterns.json --verify', description: 'Import from file' },
+        { command: 'monomind hooks intelligence import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
     ],
     action: async (ctx) => {
         const cid = ctx.flags.cid;
@@ -139,7 +139,7 @@ export const importCommand = {
             return { success: false, exitCode: 1 };
         }
         output.writeln();
-        output.writeln(output.bold('Secure Model Import'));
+        output.writeln(output.bold('Secure Pattern Import'));
         output.writeln(output.dim('─'.repeat(50)));
         const spinner = output.createSpinner({ text: 'Fetching model...', spinner: 'dots' });
         spinner.start();
@@ -278,7 +278,7 @@ export const importCommand = {
             });
             output.writeln();
             output.writeln(output.success('Patterns imported and ready to use'));
-            output.writeln(output.dim('Run "monomind neural patterns --action list" to see imported patterns'));
+            output.writeln(output.dim('Run "monomind hooks intelligence patterns --action list" to see imported patterns'));
             return { success: true };
         }
         catch (error) {

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

@@ -1,6 +1,6 @@
 /**
  * CLI Neural Command
- * Pattern learning, search, and prediction backed by the pure-JS intelligence layer
+ * Pattern storage and similarity search for routing optimization
  *
  * github.com/monoes/monomind
  */

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

@@ -1,17 +1,17 @@
 /**
  * CLI Neural Command
- * Pattern learning, search, and prediction backed by the pure-JS intelligence layer
+ * Pattern storage and similarity search for routing optimization
  *
  * github.com/monoes/monomind
  */
 import { output } from '../output.js';
-import { statusCommand, patternsCommand, predictCommand } from './neural-core.js';
+import { statusCommand, patternsCommand, trainCommand, predictCommand } from './neural-core.js';
 import { optimizeCommand, exportCommand } from './neural-optimize.js';
 import { listCommand, importCommand } from './neural-registry.js';
 export const neuralCommand = {
     name: 'neural',
-    description: 'Pattern learning, search, and prediction (pure-JS intelligence layer)',
-    subcommands: [statusCommand, patternsCommand, predictCommand, optimizeCommand, listCommand, exportCommand, importCommand],
+    description: 'Store and query edit patterns for routing optimization',
+    subcommands: [trainCommand, statusCommand, patternsCommand, predictCommand, optimizeCommand, listCommand, exportCommand, importCommand],
     examples: [
         { command: 'monomind neural status', description: 'Check pattern-learning system status' },
         { command: 'monomind neural patterns --action list', description: 'List learned patterns' },
@@ -19,8 +19,8 @@ export const neuralCommand = {
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('MonoMind Pattern Learning'));
-        output.writeln(output.dim('Pattern learning, search, and prediction (pure-JS)'));
+        output.writeln(output.bold('MonoMind Pattern Storage'));
+        output.writeln(output.dim('Store and query edit patterns for routing optimization'));
         output.writeln();
         output.writeln('Use --help with subcommands for more info');
         output.writeln();

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

@@ -296,7 +296,23 @@ const profileCommand = {
         output.writeln(output.dim(`Profile duration: ${elapsedMs.toFixed(0)}ms`));
         const outputFile = ctx.flags.output;
         if (outputFile) {
-            output.printWarning(`--output flag is not yet implemented. Profile data was not saved to ${outputFile}.`);
+            const profileData = {
+                timestamp: new Date().toISOString(),
+                duration_ms: Math.round(elapsedMs),
+                cpu: { user_us: endCpu.user, system_us: endCpu.system, percent: parseFloat(cpuPercent) },
+                memory: {
+                    heap_used_mb: parseFloat(heapUsedMB),
+                    heap_total_mb: parseFloat(heapTotalMB),
+                    rss_mb: parseFloat(rssMB),
+                    external_mb: parseFloat(externalMB),
+                },
+                event_loop_lag_ms: parseFloat(eventLoopLag),
+            };
+            const fs = await import('fs');
+            const path = await import('path');
+            const resolved = path.resolve(outputFile);
+            fs.writeFileSync(resolved, JSON.stringify(profileData, null, 2) + '\n');
+            output.writeln(output.success(`Profile data saved to ${resolved}`));
         }
         return { success: true };
     },
@@ -488,53 +504,6 @@ const metricsCommand = {
         return { success: true };
     },
 };
-// Optimize subcommand
-const optimizeCommand = {
-    name: 'optimize',
-    description: 'Run performance optimization recommendations',
-    options: [
-        { name: 'target', short: 't', type: 'string', description: 'Target: memory, cpu, latency, all', default: 'all' },
-        { name: 'apply', short: 'a', type: 'boolean', description: 'Apply recommended optimizations' },
-        { name: 'dry-run', short: 'd', type: 'boolean', description: 'Show changes without applying' },
-    ],
-    examples: [
-        { command: 'monomind performance optimize -t memory', description: 'Optimize memory usage' },
-        { command: 'monomind performance optimize --apply', description: 'Apply all optimizations' },
-    ],
-    action: async (ctx) => {
-        const targetRaw = ctx.flags.target || 'all';
-        const VALID_TARGETS = new Set(['memory', 'cpu', 'latency', 'all']);
-        const target = VALID_TARGETS.has(targetRaw) ? targetRaw : 'all';
-        if (ctx.flags.apply) {
-            output.printWarning('Optimization application is not yet implemented. Showing recommendations only.');
-        }
-        output.writeln();
-        output.writeln(output.bold('Performance Optimization'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Analyzing performance...', spinner: 'dots' });
-        spinner.start();
-        await new Promise(r => setTimeout(r, 800));
-        spinner.succeed('Analysis complete');
-        output.writeln();
-        output.writeln(output.bold('Recommendations:'));
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'priority', header: 'Priority', width: 10 },
-                { key: 'area', header: 'Area', width: 15 },
-                { key: 'recommendation', header: 'Recommendation', width: 40 },
-                { key: 'impact', header: 'Impact', width: 15 },
-            ],
-            data: [
-                { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: '+50% reduction' },
-                { priority: output.warning('P1'), area: 'CPU', recommendation: 'Enable WASM SIMD acceleration', impact: '+4x speedup' },
-                { priority: output.info('P2'), area: 'Cache', recommendation: 'Increase pattern cache size', impact: '+15% hit rate' },
-                { priority: output.info('P2'), area: 'Network', recommendation: 'Enable request batching', impact: '-30% latency' },
-            ],
-        });
-        return { success: true };
-    },
-};
 // Bottleneck subcommand
 const bottleneckCommand = {
     name: 'bottleneck',
@@ -548,26 +517,68 @@ const bottleneckCommand = {
         { command: 'monomind performance bottleneck -d full', description: 'Full analysis' },
     ],
     action: async (ctx) => {
-        output.printWarning('Bottleneck analysis is using static sample data. Dynamic analysis coming soon.');
         output.writeln();
         output.writeln(output.bold('Bottleneck Analysis'));
         output.writeln(output.dim('─'.repeat(50)));
         const spinner = output.createSpinner({ text: 'Analyzing system...', spinner: 'dots' });
         spinner.start();
-        await new Promise(r => setTimeout(r, 600));
-        spinner.succeed('Analysis complete');
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const findings = [];
+        const mem = process.memoryUsage();
+        const heapUsedMB = mem.heapUsed / 1024 / 1024;
+        if (heapUsedMB > 200) {
+            findings.push({ component: 'Runtime', bottleneck: `Heap ${heapUsedMB.toFixed(0)}MB`, severity: output.error('High'), solution: 'Investigate memory leaks or increase --max-old-space-size' });
+        }
+        const configPath = 'monomind.config.json';
+        let config = {};
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }
+        catch { /* no config */ }
+        const perf = (config.performance ?? {});
+        const hnsw = (perf.hnsw ?? {});
+        if (!hnsw.quantization) {
+            findings.push({ component: 'Vector Search', bottleneck: 'No HNSW quantization', severity: output.error('High'), solution: 'Run: monomind performance optimize --apply -t memory' });
+        }
+        const tracesDir = '.monomind/traces';
+        if (fs.existsSync(tracesDir)) {
+            try {
+                const traceFiles = fs.readdirSync(tracesDir);
+                if (traceFiles.length > 500) {
+                    findings.push({ component: 'Traces', bottleneck: `${traceFiles.length} trace files`, severity: output.warning('Medium'), solution: 'Prune old traces: rm .monomind/traces/*.jsonl' });
+                }
+            }
+            catch { /* ok */ }
+        }
+        const memoryDir = '.monomind/memory';
+        if (fs.existsSync(memoryDir)) {
+            try {
+                const stat = fs.statSync(path.join(memoryDir, 'lance.db')).size ?? 0;
+                const sizeMB = stat / 1024 / 1024;
+                if (sizeMB > 100) {
+                    findings.push({ component: 'Memory DB', bottleneck: `LanceDB ${sizeMB.toFixed(0)}MB`, severity: output.warning('Medium'), solution: 'Run: monomind memory compact' });
+                }
+            }
+            catch { /* no lance.db */ }
+        }
+        const network = (perf.network ?? {});
+        if (!network.batching) {
+            findings.push({ component: 'Network', bottleneck: 'No request batching', severity: output.info('Low'), solution: 'Run: monomind performance optimize --apply -t latency' });
+        }
+        if (findings.length === 0) {
+            findings.push({ component: 'System', bottleneck: 'No bottlenecks detected', severity: output.success('None'), solution: 'System is performing well' });
+        }
+        spinner.succeed(`Analysis complete — ${findings.length} finding(s)`);
         output.writeln();
         output.printTable({
             columns: [
                 { key: 'component', header: 'Component', width: 20 },
                 { key: 'bottleneck', header: 'Bottleneck', width: 25 },
                 { key: 'severity', header: 'Severity', width: 12 },
-                { key: 'solution', header: 'Solution', width: 30 },
-            ],
-            data: [
-                { component: 'Vector Search', bottleneck: 'Linear scan O(n)', severity: output.error('High'), solution: 'Enable HNSW indexing' },
-                { component: 'Memory Store', bottleneck: 'Lock contention', severity: output.info('Low'), solution: 'Use sharded storage' },
+                { key: 'solution', header: 'Solution', width: 50 },
             ],
+            data: findings,
         });
         return { success: true };
     },
@@ -577,7 +588,7 @@ export const performanceCommand = {
     name: 'performance',
     description: 'Performance profiling, benchmarking, optimization, metrics',
     aliases: ['perf'],
-    subcommands: [benchmarkCommand, profileCommand, metricsCommand, optimizeCommand, bottleneckCommand],
+    subcommands: [benchmarkCommand, profileCommand, metricsCommand, bottleneckCommand],
     examples: [
         { command: 'monomind performance benchmark', description: 'Run benchmarks' },
         { command: 'monomind performance profile', description: 'Profile application' },
@@ -593,7 +604,6 @@ export const performanceCommand = {
             'benchmark  - Run performance benchmarks (WASM, neural, search)',
             'profile    - Profile CPU, memory, I/O usage',
             'metrics    - View and export performance metrics',
-            'optimize   - Get optimization recommendations',
             'bottleneck - Identify performance bottlenecks',
         ]);
         output.writeln();

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

@@ -6,43 +6,6 @@
  */
 import { output } from '../output.js';
 import { configManager } from '../services/config-file-manager.js';
-// List subcommand
-const listCommand = {
-    name: 'list',
-    description: 'List available AI providers and models',
-    options: [
-        { name: 'type', short: 't', type: 'string', description: 'Filter by type: llm, embedding, image', default: 'all' },
-        { name: 'active', short: 'a', type: 'boolean', description: 'Show only active providers' },
-    ],
-    examples: [
-        { command: 'monomind providers list', description: 'List all providers' },
-        { command: 'monomind providers list -t embedding', description: 'List embedding providers' },
-    ],
-    action: async (ctx) => {
-        const type = ctx.flags.type || 'all';
-        // Note: Static provider catalog — does not reflect user's configured providers
-        output.writeln();
-        output.writeln(output.bold('Available Providers'));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.printTable({
-            columns: [
-                { key: 'provider', header: 'Provider', width: 18 },
-                { key: 'type', header: 'Type', width: 12 },
-                { key: 'models', header: 'Models', width: 25 },
-                { key: 'status', header: 'Status', width: 12 },
-            ],
-            data: [
-                { provider: 'Anthropic', type: 'LLM', models: 'claude-3.5-sonnet, opus', status: output.success('Active') },
-                { provider: 'OpenAI', type: 'LLM', models: 'gpt-4o, gpt-4-turbo', status: output.success('Active') },
-                { provider: 'OpenAI', type: 'Embedding', models: 'text-embedding-3-small/large', status: output.success('Active') },
-                { provider: 'Transformers.js', type: 'Embedding', models: 'Xenova/all-MiniLM-L6-v2', status: output.success('Active') },
-                { provider: 'Agentic Flow', type: 'Embedding', models: 'ONNX optimized', status: output.success('Active') },
-                { provider: 'Mock', type: 'All', models: 'mock-*', status: output.dim('Dev only') },
-            ],
-        });
-        return { success: true };
-    },
-};
 // Configure subcommand
 const configureCommand = {
     name: 'configure',
@@ -271,94 +234,100 @@ const testCommand = {
         }
     },
 };
-// Models subcommand
-const modelsCommand = {
-    name: 'models',
-    description: 'List and manage available models',
+// List subcommand
+const listCommand = {
+    name: 'list',
+    description: 'List configured providers',
     options: [
-        { name: 'provider', short: 'p', type: 'string', description: 'Filter by provider' },
-        { name: 'capability', short: 'c', type: 'string', description: 'Filter by capability: chat, completion, embedding' },
+        { name: 'json', short: 'j', type: 'boolean', description: 'Output as JSON' },
     ],
     examples: [
-        { command: 'monomind providers models', description: 'List all models' },
-        { command: 'monomind providers models -p anthropic', description: 'List Anthropic models' },
+        { command: 'monomind providers list', description: 'List all configured providers' },
     ],
     action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Available Models'));
-        output.writeln(output.dim('─'.repeat(70)));
-        output.printTable({
-            columns: [
-                { key: 'model', header: 'Model', width: 28 },
-                { key: 'provider', header: 'Provider', width: 14 },
-                { key: 'capability', header: 'Capability', width: 12 },
-                { key: 'context', header: 'Context', width: 10 },
-                { key: 'cost', header: 'Cost/1K', width: 12 },
-            ],
-            data: [
-                { model: 'claude-3.5-sonnet-20241022', provider: 'Anthropic', capability: 'Chat', context: '200K', cost: '$0.003/$0.015' },
-                { model: 'claude-3-opus-20240229', provider: 'Anthropic', capability: 'Chat', context: '200K', cost: '$0.015/$0.075' },
-                { model: 'gpt-4o', provider: 'OpenAI', capability: 'Chat', context: '128K', cost: '$0.005/$0.015' },
-                { model: 'gpt-4-turbo', provider: 'OpenAI', capability: 'Chat', context: '128K', cost: '$0.01/$0.03' },
-                { model: 'text-embedding-3-small', provider: 'OpenAI', capability: 'Embedding', context: '8K', cost: '$0.00002' },
-                { model: 'text-embedding-3-large', provider: 'OpenAI', capability: 'Embedding', context: '8K', cost: '$0.00013' },
-                { model: 'Xenova/all-MiniLM-L6-v2', provider: 'Transformers', capability: 'Embedding', context: '512', cost: output.success('Free') },
-            ],
-        });
-        return { success: true };
+        try {
+            const cwd = process.cwd();
+            const config = configManager.getConfig(cwd);
+            const agents = (config.agents ?? {});
+            const providers = (agents.providers ?? []);
+            if (ctx.flags.json) {
+                const redacted = providers.map((p) => ({
+                    ...p,
+                    apiKey: p.apiKey ? '***configured***' : undefined,
+                }));
+                output.printJson(redacted);
+                return { success: true, data: redacted };
+            }
+            output.writeln();
+            output.writeln(output.bold('Configured Providers'));
+            output.writeln(output.dim('─'.repeat(40)));
+            if (providers.length === 0) {
+                output.writeln(output.dim('  No providers configured. Use "providers configure -p <name>" to add one.'));
+            }
+            else {
+                for (const p of providers) {
+                    const name = String(p.name ?? 'unknown');
+                    const hasKey = p.apiKey ? 'key set' : 'no key';
+                    const model = p.model ? `, model: ${p.model}` : '';
+                    output.writeln(`  ${output.highlight(name)} — ${hasKey}${model}`);
+                }
+            }
+            output.writeln();
+            return { success: true, data: providers };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.printError(`Failed to list providers: ${msg}`);
+            return { success: false, exitCode: 1 };
+        }
     },
 };
-// Usage subcommand
-const usageCommand = {
-    name: 'usage',
-    description: 'View provider usage and costs',
+// Remove subcommand
+const removeCommand = {
+    name: 'remove',
+    description: 'Remove a configured provider',
     options: [
-        { name: 'provider', short: 'p', type: 'string', description: 'Filter by provider' },
-        { name: 'timeframe', short: 't', type: 'string', description: 'Timeframe: 24h, 7d, 30d', default: '7d' },
+        { name: 'provider', short: 'p', type: 'string', description: 'Provider name', required: true },
     ],
     examples: [
-        { command: 'monomind providers usage', description: 'View all usage' },
-        { command: 'monomind providers usage -t 30d', description: 'View 30-day usage' },
+        { command: 'monomind providers remove -p openai', description: 'Remove OpenAI provider config' },
     ],
     action: async (ctx) => {
-        const timeframe = ctx.flags.timeframe || '7d';
-        output.writeln();
-        output.writeln(output.bold(`Provider Usage (${timeframe})`));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.printTable({
-            columns: [
-                { key: 'provider', header: 'Provider', width: 15 },
-                { key: 'requests', header: 'Requests', width: 12 },
-                { key: 'tokens', header: 'Tokens', width: 15 },
-                { key: 'cost', header: 'Est. Cost', width: 12 },
-                { key: 'trend', header: 'Trend', width: 12 },
-            ],
-            data: [
-                { provider: 'Anthropic', requests: '12,847', tokens: '4.2M', cost: '$12.60', trend: output.warning('↑ 15%') },
-                { provider: 'OpenAI (LLM)', requests: '3,421', tokens: '1.1M', cost: '$5.50', trend: output.success('↓ 8%') },
-                { provider: 'OpenAI (Embed)', requests: '89,234', tokens: '12.4M', cost: '$0.25', trend: output.success('↓ 12%') },
-                { provider: 'Transformers.js', requests: '234,567', tokens: '45.2M', cost: output.success('$0.00'), trend: '→' },
-            ],
-        });
-        output.writeln();
-        output.printBox([
-            `Total Requests: 340,069`,
-            `Total Tokens: 62.9M`,
-            `Total Cost: $18.35`,
-            ``,
-            `Savings from local embeddings: $890.12`,
-        ].join('\n'), 'Summary');
-        return { success: true };
+        try {
+            const provider = (ctx.flags.provider || (ctx.args && ctx.args[0]) || '').slice(0, 64);
+            if (!provider) {
+                output.printError('Provider name is required. Use -p <name> or pass as first argument.');
+                return { success: false, exitCode: 1 };
+            }
+            const cwd = process.cwd();
+            const config = configManager.getConfig(cwd);
+            const agents = (config.agents ?? {});
+            const providers = (agents.providers ?? []);
+            const filtered = providers.filter((p) => !(typeof p.name === 'string' && p.name.toLowerCase() === provider.toLowerCase()));
+            if (filtered.length === providers.length) {
+                output.printWarning(`Provider "${provider}" was not configured.`);
+                return { success: true };
+            }
+            configManager.set(cwd, 'agents.providers', filtered);
+            output.writeln(output.success(`Provider "${provider}" removed.`));
+            return { success: true };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.printError(`Failed to remove provider: ${msg}`);
+            return { success: false, exitCode: 1 };
+        }
     },
 };
 // Main providers command
 export const providersCommand = {
     name: 'providers',
     description: 'Manage AI providers, models, and configurations',
-    subcommands: [listCommand, configureCommand, testCommand, modelsCommand, usageCommand],
+    subcommands: [listCommand, configureCommand, removeCommand, testCommand],
     examples: [
-        { command: 'monomind providers list', description: 'List all providers' },
-        { command: 'monomind providers configure -p openai', description: 'Configure OpenAI' },
+        { command: 'monomind providers list', description: 'List configured providers' },
+        { command: 'monomind providers configure -p openai -k sk-...', description: 'Configure OpenAI' },
+        { command: 'monomind providers remove -p openai', description: 'Remove OpenAI config' },
         { command: 'monomind providers test --all', description: 'Test all providers' },
     ],
     action: async () => {
@@ -368,19 +337,10 @@ export const providersCommand = {
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
-            'list      - List available providers and their status',
+            'list      - List configured providers',
             'configure - Configure provider settings and API keys',
+            'remove    - Remove a configured provider',
             'test      - Test provider connectivity',
-            'models    - List and manage available models',
-            'usage     - View usage statistics and costs',
-        ]);
-        output.writeln();
-        output.writeln('Supported Providers:');
-        output.printList([
-            'Anthropic (Claude models)',
-            'OpenAI (GPT + embeddings)',
-            'Transformers.js (local ONNX)',
-            'Agentic Flow (optimized ONNX with SIMD)',
         ]);
         output.writeln();
         output.writeln(output.dim('github.com/monoes/monomind'));