@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/mcp-tools/performance-tools.js

@@ -11,15 +11,15 @@
  *
  * Note: Some optimization suggestions are illustrative
  */
-import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, statSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import * as os from 'node:os';
+import { join } from 'node:path';
+import { getProjectCwd } from './types.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const PERF_DIR = 'performance';
 const METRICS_FILE = 'metrics.json';
-const BENCHMARKS_FILE = 'benchmarks.json';
+const _BENCHMARKS_FILE = 'benchmarks.json';
 function getPerfDir() {
     return join(getProjectCwd(), STORAGE_DIR, PERF_DIR);
 }
@@ -33,18 +33,33 @@ function ensurePerfDir() {
     }
 }
 const MAX_PERF_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
+// Bumped from 3.0.0: pre-3.1.0 stores may contain `metrics` entries whose
+// latency/throughput fields were fabricated on first run (50/40/100/200ms,
+// +1/+10 ops) and then compounded into "history" averages on every
+// subsequent call. Those fields are dropped on load so old fake data can't
+// keep poisoning stats — cpu/memory history (which was always real) is kept.
+const PERF_STORE_VERSION = '3.1.0';
 function loadPerfStore() {
     try {
         const path = getPerfPath();
         if (existsSync(path) && statSync(path).size <= MAX_PERF_STORE_BYTES) {
-            return JSON.parse(readFileSync(path, 'utf-8'));
+            const store = JSON.parse(readFileSync(path, 'utf-8'));
+            if (store.version !== PERF_STORE_VERSION) {
+                store.metrics = (store.metrics || []).map((m) => ({
+                    ...m,
+                    latency: null,
+                    throughput: null,
+                }));
+                store.version = PERF_STORE_VERSION;
+            }
+            return store;
         }
     }
     catch (e) {
         if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
             console.error('[performance-tools] failed to load perf store, using empty store:', e);
     }
-    return { metrics: [], benchmarks: {}, version: '3.0.0' };
+    return { metrics: [], benchmarks: {}, version: PERF_STORE_VERSION };
 }
 function savePerfStore(store) {
     ensurePerfDir();
@@ -62,8 +77,16 @@ export const performanceTools = [
             type: 'object',
             properties: {
                 timeRange: { type: 'string', description: 'Time range (1h, 24h, 7d)' },
-                format: { type: 'string', enum: ['json', 'summary', 'detailed'], description: 'Report format' },
-                components: { type: 'array', items: { type: 'string' }, description: 'Components to include' },
+                format: {
+                    type: 'string',
+                    enum: ['json', 'summary', 'detailed'],
+                    description: 'Report format',
+                },
+                components: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Components to include',
+                },
             },
         },
         handler: async (input) => {
@@ -71,7 +94,7 @@ export const performanceTools = [
             const format = input.format || 'summary';
             // Get REAL system metrics via Node.js APIs
             const memUsage = process.memoryUsage();
-            const cpuUsage = process.cpuUsage();
+            const _cpuUsage = process.cpuUsage();
             const loadAvg = os.loadavg();
             const cpus = os.cpus();
             const totalMem = os.totalmem();
@@ -87,16 +110,10 @@ export const performanceTools = [
                     total: Math.round(totalMem / 1024 / 1024),
                     heap: Math.round(memUsage.heapUsed / 1024 / 1024),
                 },
-                latency: {
-                    avg: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.avg, 0) / Math.min(store.metrics.length, 10) : 50,
-                    p50: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p50, 0) / Math.min(store.metrics.length, 10) : 40,
-                    p95: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p95, 0) / Math.min(store.metrics.length, 10) : 100,
-                    p99: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p99, 0) / Math.min(store.metrics.length, 10) : 200,
-                },
-                throughput: {
-                    requests: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.requests + 1 : 1,
-                    operations: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.operations + 10 : 10,
-                },
+                // No real latency/throughput instrumentation exists anywhere in this
+                // tool — do not seed fake numbers. Report null with a note instead.
+                latency: null,
+                throughput: null,
                 errors: { count: 0, rate: 0 },
             };
             store.metrics.push(currentMetrics);
@@ -107,28 +124,46 @@ export const performanceTools = [
             savePerfStore(store);
             if (format === 'summary') {
                 return {
-                    _real: true,
                     status: 'healthy',
-                    cpu: `${currentMetrics.cpu.usage.toFixed(1)}%`,
-                    memory: `${currentMetrics.memory.used}MB / ${currentMetrics.memory.total}MB`,
-                    heap: `${currentMetrics.memory.heap}MB`,
-                    latency: `${currentMetrics.latency.avg.toFixed(0)}ms avg`,
-                    throughput: `${currentMetrics.throughput.operations} ops/s`,
-                    errorRate: `${(currentMetrics.errors.rate * 100).toFixed(2)}%`,
+                    cpu: { value: `${currentMetrics.cpu.usage.toFixed(1)}%`, _real: true },
+                    memory: {
+                        value: `${currentMetrics.memory.used}MB / ${currentMetrics.memory.total}MB`,
+                        _real: true,
+                    },
+                    heap: { value: `${currentMetrics.memory.heap}MB`, _real: true },
+                    latency: {
+                        value: null,
+                        _real: false,
+                        _note: 'No latency telemetry recorded yet — no instrumentation wired up here.',
+                    },
+                    throughput: {
+                        value: null,
+                        _real: false,
+                        _note: 'No throughput telemetry recorded yet — no instrumentation wired up here.',
+                    },
+                    errorRate: {
+                        value: `${(currentMetrics.errors.rate * 100).toFixed(2)}%`,
+                        _real: false,
+                        _note: 'No error tracking wired up — always 0.',
+                    },
                     timestamp: currentMetrics.timestamp,
                 };
             }
             // Calculate trends from history
             const history = store.metrics.slice(-10);
             const cpuTrend = history.length >= 2
-                ? (history[history.length - 1].cpu.usage > history[0].cpu.usage ? 'increasing' : 'stable')
+                ? history[history.length - 1].cpu.usage > history[0].cpu.usage
+                    ? 'increasing'
+                    : 'stable'
                 : 'stable';
             const memTrend = history.length >= 2
-                ? (history[history.length - 1].memory.used > history[0].memory.used ? 'increasing' : 'stable')
+                ? history[history.length - 1].memory.used > history[0].memory.used
+                    ? 'increasing'
+                    : 'stable'
                 : 'stable';
             return {
-                _real: true,
                 current: currentMetrics,
+                _real: { cpu: true, memory: true, latency: false, throughput: false, errors: false },
                 history,
                 system: {
                     platform: process.platform,
@@ -140,12 +175,22 @@ export const performanceTools = [
                 trends: {
                     cpu: cpuTrend,
                     memory: memTrend,
-                    latency: 'stable',
+                    latency: {
+                        value: 'unknown',
+                        _note: 'No latency telemetry recorded — trend cannot be computed.',
+                    },
                 },
+                // Rule-based thresholds on real cpu/memory readings — not an ML model.
+                _recommendationEngine: 'rule-based (static thresholds on real cpu/memory readings)',
                 recommendations: currentMetrics.memory.used / currentMetrics.memory.total > 0.8
                     ? [{ priority: 'high', message: 'Memory usage above 80% - consider cleanup' }]
                     : currentMetrics.cpu.usage > 70
-                        ? [{ priority: 'medium', message: 'CPU load elevated - check for resource-intensive processes' }]
+                        ? [
+                            {
+                                priority: 'medium',
+                                message: 'CPU load elevated - check for resource-intensive processes',
+                            },
+                        ]
                         : [{ priority: 'low', message: 'System running normally' }],
             };
         },
@@ -184,32 +229,82 @@ export const performanceTools = [
                 try {
                     unlinkSync(probeFile);
                 }
-                catch { /* best-effort */ }
+                catch {
+                    /* best-effort */
+                }
+            }
+            catch {
+                /* disk probe failed, leave -1 */
             }
-            catch { /* disk probe failed, leave -1 */ }
             // Check stored benchmark history for slow operations
             const store = loadPerfStore();
             const slowBenchmarks = Object.values(store.benchmarks)
                 .filter((b) => b.results.opsPerSecond < 100)
-                .map((b) => ({ name: b.name, opsPerSec: b.results.opsPerSecond, date: b.createdAt }));
-            const classify = (value, thresholds) => value > thresholds[0] ? 'critical' : value > thresholds[1] ? 'high' : value > thresholds[2] ? 'medium' : 'low';
+                .map((b) => ({
+                name: b.name,
+                opsPerSec: b.results.opsPerSecond,
+                date: b.createdAt,
+            }));
+            const classify = (value, thresholds) => value > thresholds[0]
+                ? 'critical'
+                : value > thresholds[1]
+                    ? 'high'
+                    : value > thresholds[2]
+                        ? 'medium'
+                        : 'low';
             const bottlenecks = [];
             const cpuSev = classify(cpuPercent, [90, 75, 50]);
-            bottlenecks.push({ component: 'cpu', severity: cpuSev, value: Math.round(cpuPercent * 10) / 10, threshold: cpuSev === 'critical' ? 90 : cpuSev === 'high' ? 75 : 50, message: `CPU load at ${(Math.round(cpuPercent * 10) / 10)}%` });
+            bottlenecks.push({
+                component: 'cpu',
+                severity: cpuSev,
+                value: Math.round(cpuPercent * 10) / 10,
+                threshold: cpuSev === 'critical' ? 90 : cpuSev === 'high' ? 75 : 50,
+                message: `CPU load at ${Math.round(cpuPercent * 10) / 10}%`,
+            });
             const memSev = classify(memPercent, [90, 75, 50]);
-            bottlenecks.push({ component: 'memory', severity: memSev, value: Math.round(memPercent * 10) / 10, threshold: memSev === 'critical' ? 90 : memSev === 'high' ? 75 : 50, message: `Memory at ${(Math.round(memPercent * 10) / 10)}%` });
+            bottlenecks.push({
+                component: 'memory',
+                severity: memSev,
+                value: Math.round(memPercent * 10) / 10,
+                threshold: memSev === 'critical' ? 90 : memSev === 'high' ? 75 : 50,
+                message: `Memory at ${Math.round(memPercent * 10) / 10}%`,
+            });
             if (diskLatencyMs >= 0) {
-                const diskSev = diskLatencyMs > 50 ? 'critical' : diskLatencyMs > 20 ? 'high' : diskLatencyMs > 5 ? 'medium' : 'low';
-                bottlenecks.push({ component: 'disk-io', severity: diskSev, value: diskLatencyMs, threshold: diskSev === 'critical' ? 50 : diskSev === 'high' ? 20 : 5, message: `Disk I/O latency ${diskLatencyMs}ms`, latencyMs: diskLatencyMs });
+                const diskSev = diskLatencyMs > 50
+                    ? 'critical'
+                    : diskLatencyMs > 20
+                        ? 'high'
+                        : diskLatencyMs > 5
+                            ? 'medium'
+                            : 'low';
+                bottlenecks.push({
+                    component: 'disk-io',
+                    severity: diskSev,
+                    value: diskLatencyMs,
+                    threshold: diskSev === 'critical' ? 50 : diskSev === 'high' ? 20 : 5,
+                    message: `Disk I/O latency ${diskLatencyMs}ms`,
+                    latencyMs: diskLatencyMs,
+                });
             }
             if (slowBenchmarks.length > 0) {
-                bottlenecks.push({ component: 'slow-operations', severity: 'medium', value: slowBenchmarks.length, threshold: 0, message: `${slowBenchmarks.length} slow benchmark(s) recorded` });
+                bottlenecks.push({
+                    component: 'slow-operations',
+                    severity: 'medium',
+                    value: slowBenchmarks.length,
+                    threshold: 0,
+                    message: `${slowBenchmarks.length} slow benchmark(s) recorded`,
+                });
             }
             return {
                 success: true,
                 _real: true,
                 bottlenecks,
-                system: { cpuPercent: Math.round(cpuPercent * 10) / 10, memoryPercent: Math.round(memPercent * 10) / 10, heapMB, diskLatencyMs },
+                system: {
+                    cpuPercent: Math.round(cpuPercent * 10) / 10,
+                    memoryPercent: Math.round(memPercent * 10) / 10,
+                    heapMB,
+                    diskLatencyMs,
+                },
                 slowBenchmarks: slowBenchmarks.slice(0, 5),
             };
         },
@@ -221,7 +316,11 @@ export const performanceTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                suite: { type: 'string', enum: ['all', 'memory', 'neural', 'swarm', 'io'], description: 'Benchmark suite' },
+                suite: {
+                    type: 'string',
+                    enum: ['all', 'memory', 'neural', 'monoswarm', 'io'],
+                    description: 'Benchmark suite',
+                },
                 iterations: { type: 'number', description: 'Number of iterations' },
                 warmup: { type: 'boolean', description: 'Include warmup phase' },
             },
@@ -230,7 +329,7 @@ export const performanceTools = [
             const store = loadPerfStore();
             // Validate suite against enum to prevent uncapped string from being stored
             // as a benchmark key on disk.
-            const VALID_SUITES = new Set(['all', 'memory', 'neural', 'swarm', 'io']);
+            const VALID_SUITES = new Set(['all', 'memory', 'neural', 'monoswarm', 'io']);
             const rawSuite = input.suite || 'all';
             const suite = VALID_SUITES.has(rawSuite) ? rawSuite : 'all';
             // Cap iterations to prevent event-loop blocking DoS.  The `neural`
@@ -258,22 +357,30 @@ export const performanceTools = [
                     // Simple matrix multiplication
                     for (let i = 0; i < size; i++) {
                         for (let j = 0; j < size; j++) {
-                            let sum = 0;
+                            let _sum = 0;
                             for (let k = 0; k < size; k++)
-                                sum += a[i][k] * b[k][j];
+                                _sum += a[i][k] * b[k][j];
                         }
                     }
                 },
-                swarm: () => {
+                monoswarm: () => {
                     // Real object creation and manipulation
-                    const agents = Array.from({ length: 10 }, (_, i) => ({ id: i, status: 'active', tasks: [] }));
-                    agents.forEach(a => { for (let i = 0; i < 100; i++)
-                        a.tasks.push(i); });
+                    const agents = Array.from({ length: 10 }, (_, i) => ({
+                        id: i,
+                        status: 'active',
+                        tasks: [],
+                    }));
+                    agents.forEach((a) => {
+                        for (let i = 0; i < 100; i++)
+                            a.tasks.push(i);
+                    });
                     agents.sort((a, b) => a.tasks.length - b.tasks.length);
                 },
                 io: () => {
                     // Real JSON serialization benchmark
-                    const data = { agents: Array.from({ length: 50 }, (_, i) => ({ id: i, name: `agent-${i}` })) };
+                    const data = {
+                        agents: Array.from({ length: 50 }, (_, i) => ({ id: i, name: `agent-${i}` })),
+                    };
                     const json = JSON.stringify(data);
                     JSON.parse(json);
                 },
@@ -319,8 +426,7 @@ export const performanceTools = [
                     store.benchmarks[id] = result;
                     // Evict oldest entries if over limit
                     const MAX_BENCHMARKS = 200;
-                    const benchEntries = Object.entries(store.benchmarks)
-                        .sort(([, a], [, b]) => (a.createdAt < b.createdAt ? -1 : 1));
+                    const benchEntries = Object.entries(store.benchmarks).sort(([, a], [, b]) => a.createdAt < b.createdAt ? -1 : 1);
                     if (benchEntries.length > MAX_BENCHMARKS) {
                         store.benchmarks = Object.fromEntries(benchEntries.slice(-MAX_BENCHMARKS));
                     }
@@ -338,14 +444,17 @@ export const performanceTools = [
             const runStart = new Date().toISOString();
             const allBenchmarks = Object.values(store.benchmarks);
             const previousBenchmarks = allBenchmarks
-                .filter(b => suitesToRun.includes(b.name) && b.createdAt < runStart)
+                .filter((b) => suitesToRun.includes(b.name) && b.createdAt < runStart)
                 .slice(-suitesToRun.length);
             const comparison = previousBenchmarks.length > 0
                 ? {
-                    vsPrevious: `${results.reduce((sum, r) => sum + r.opsPerSec, 0) > previousBenchmarks.reduce((sum, b) => sum + b.results.opsPerSecond, 0) ? '+' : ''}${Math.round(((results.reduce((sum, r) => sum + r.opsPerSec, 0) / previousBenchmarks.reduce((sum, b) => sum + b.results.opsPerSecond, 0)) - 1) * 100)}% vs previous`,
+                    vsPrevious: `${results.reduce((sum, r) => sum + r.opsPerSec, 0) > previousBenchmarks.reduce((sum, b) => sum + b.results.opsPerSecond, 0) ? '+' : ''}${Math.round((results.reduce((sum, r) => sum + r.opsPerSec, 0) / previousBenchmarks.reduce((sum, b) => sum + b.results.opsPerSecond, 0) - 1) * 100)}% vs previous`,
                     totalBenchmarks: allBenchmarks.length,
                 }
-                : { note: 'First benchmark run - no comparison available', totalBenchmarks: allBenchmarks.length };
+                : {
+                    note: 'First benchmark run - no comparison available',
+                    totalBenchmarks: allBenchmarks.length,
+                };
             return {
                 _real: true,
                 suite,
@@ -401,29 +510,51 @@ export const performanceTools = [
                     if (performance.now() >= deadline)
                         break;
                     if (t === 'memory') {
-                        runOp('json-serialize', () => { const d = Array.from({ length: 200 }, (_, i) => ({ id: i, v: Math.random() })); JSON.stringify(d); });
-                        runOp('json-parse', () => { JSON.parse(JSON.stringify({ a: 1, b: [2, 3], c: { d: 4 } })); });
-                        runOp('array-sort', () => { const a = Array.from({ length: 500 }, () => Math.random()); a.sort(); });
+                        runOp('json-serialize', () => {
+                            const d = Array.from({ length: 200 }, (_, i) => ({ id: i, v: Math.random() }));
+                            JSON.stringify(d);
+                        });
+                        runOp('json-parse', () => {
+                            JSON.parse(JSON.stringify({ a: 1, b: [2, 3], c: { d: 4 } }));
+                        });
+                        runOp('array-sort', () => {
+                            const a = Array.from({ length: 500 }, () => Math.random());
+                            a.sort();
+                        });
                     }
                     else if (t === 'io') {
                         if (ioOps >= MAX_IO_OPS)
                             continue;
-                        runOp('file-write', () => { ensurePerfDir(); writeFileSync(join(getPerfDir(), '.profile-probe'), 'x'.repeat(1024)); });
-                        runOp('file-read', () => { try {
-                            readFileSync(join(getPerfDir(), '.profile-probe'));
-                        }
-                        catch { /* ok */ } });
+                        runOp('file-write', () => {
+                            ensurePerfDir();
+                            writeFileSync(join(getPerfDir(), '.profile-probe'), 'x'.repeat(1024));
+                        });
+                        runOp('file-read', () => {
+                            try {
+                                readFileSync(join(getPerfDir(), '.profile-probe'));
+                            }
+                            catch {
+                                /* ok */
+                            }
+                        });
                         ioOps += 2;
                     }
                     else if (t === 'cpu') {
-                        runOp('matrix-mult', () => { const s = 32; const a = Array.from({ length: s }, () => Array.from({ length: s }, () => Math.random())); for (let i = 0; i < s; i++)
-                            for (let j = 0; j < s; j++) {
-                                let sum = 0;
-                                for (let k = 0; k < s; k++)
-                                    sum += a[i][k] * a[k][j];
-                            } });
-                        runOp('hash-compute', () => { let h = 0; for (let i = 0; i < 10000; i++)
-                            h = ((h << 5) - h + i) | 0; });
+                        runOp('matrix-mult', () => {
+                            const s = 32;
+                            const a = Array.from({ length: s }, () => Array.from({ length: s }, () => Math.random()));
+                            for (let i = 0; i < s; i++)
+                                for (let j = 0; j < s; j++) {
+                                    let _sum = 0;
+                                    for (let k = 0; k < s; k++)
+                                        _sum += a[i][k] * a[k][j];
+                                }
+                        });
+                        runOp('hash-compute', () => {
+                            let h = 0;
+                            for (let i = 0; i < 10000; i++)
+                                h = ((h << 5) - h + i) | 0;
+                        });
                     }
                 }
             }
@@ -444,7 +575,9 @@ export const performanceTools = [
             try {
                 unlinkSync(join(getPerfDir(), '.profile-probe'));
             }
-            catch { /* ok */ }
+            catch {
+                /* ok */
+            }
             return {
                 success: true,
                 _real: true,
@@ -456,8 +589,8 @@ export const performanceTools = [
                     percentUtilization: Math.round(((cpuAfter.user + cpuAfter.system) / 1000 / actualDuration) * 10000) / 100,
                 },
                 memory: {
-                    heapDeltaMB: Math.round((memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024 * 100) / 100,
-                    externalDeltaMB: Math.round((memAfter.external - memBefore.external) / 1024 / 1024 * 100) / 100,
+                    heapDeltaMB: Math.round(((memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024) * 100) / 100,
+                    externalDeltaMB: Math.round(((memAfter.external - memBefore.external) / 1024 / 1024) * 100) / 100,
                 },
                 hotspots,
             };
@@ -465,12 +598,16 @@ export const performanceTools = [
     },
     {
         name: 'performance_optimize',
-        description: 'Apply performance optimizations',
+        description: 'Rule-based recommendation engine over real system metrics; only GC collection and probe-file cleanup are actually applied automatically — everything else is a suggestion',
         category: 'performance',
         inputSchema: {
             type: 'object',
             properties: {
-                target: { type: 'string', enum: ['memory', 'latency', 'throughput', 'all'], description: 'Optimization target' },
+                target: {
+                    type: 'string',
+                    enum: ['memory', 'latency', 'throughput', 'all'],
+                    description: 'Optimization target',
+                },
                 aggressive: { type: 'boolean', description: 'Apply aggressive optimizations' },
             },
         },
@@ -486,7 +623,7 @@ export const performanceTools = [
             const cpusBefore = os.cpus();
             const cpuPercentBefore = Math.min((loadBefore[0] / cpusBefore.length) * 100, 100);
             const memBefore = process.memoryUsage();
-            const memMBBefore = Math.round(memBefore.heapUsed / 1024 / 1024 * 100) / 100;
+            const memMBBefore = Math.round((memBefore.heapUsed / 1024 / 1024) * 100) / 100;
             let diskLatencyBefore = -1;
             try {
                 ensurePerfDir();
@@ -498,9 +635,13 @@ export const performanceTools = [
                 try {
                     unlinkSync(probe);
                 }
-                catch { /* ok */ }
+                catch {
+                    /* ok */
+                }
+            }
+            catch {
+                /* ok */
             }
-            catch { /* ok */ }
             const optimizations = [];
             const targets = target === 'all' ? ['memory', 'latency', 'throughput'] : [target];
             for (const t of targets) {
@@ -509,30 +650,62 @@ export const performanceTools = [
                         const heapBefore = process.memoryUsage().heapUsed;
                         global.gc();
                         const heapAfter = process.memoryUsage().heapUsed;
-                        const freedMB = Math.round((heapBefore - heapAfter) / 1024 / 1024 * 100) / 100;
-                        optimizations.push({ action: 'gc-collect', applied: true, effect: `Freed ${freedMB}MB heap` });
+                        const freedMB = Math.round(((heapBefore - heapAfter) / 1024 / 1024) * 100) / 100;
+                        optimizations.push({
+                            action: 'gc-collect',
+                            applied: true,
+                            effect: `Freed ${freedMB}MB heap`,
+                        });
                     }
                     else if (aggressive) {
-                        optimizations.push({ action: 'gc-collect', applied: false, recommendation: 'Run with --expose-gc to enable forced garbage collection' });
+                        optimizations.push({
+                            action: 'gc-collect',
+                            applied: false,
+                            recommendation: 'Run with --expose-gc to enable forced garbage collection',
+                        });
                     }
                     const memPercent = ((os.totalmem() - os.freemem()) / os.totalmem()) * 100;
                     if (memPercent > 75) {
-                        optimizations.push({ action: 'recommend-memory-cleanup', applied: false, recommendation: `Memory at ${Math.round(memPercent)}% - consider reducing in-memory caches or agent count` });
+                        optimizations.push({
+                            action: 'recommend-memory-cleanup',
+                            applied: false,
+                            recommendation: `Memory at ${Math.round(memPercent)}% - consider reducing in-memory caches or agent count`,
+                        });
                     }
-                    optimizations.push({ action: 'recommend-hnsw-rebuild', applied: false, recommendation: 'Rebuild HNSW index to reclaim fragmented memory' });
+                    optimizations.push({
+                        action: 'recommend-hnsw-rebuild',
+                        applied: false,
+                        recommendation: 'Rebuild HNSW index to reclaim fragmented memory',
+                    });
                 }
                 if (t === 'latency') {
                     if (diskLatencyBefore > 20) {
-                        optimizations.push({ action: 'recommend-ssd', applied: false, recommendation: `Disk I/O latency ${diskLatencyBefore}ms is high - ensure storage is SSD-backed` });
+                        optimizations.push({
+                            action: 'recommend-ssd',
+                            applied: false,
+                            recommendation: `Disk I/O latency ${diskLatencyBefore}ms is high - ensure storage is SSD-backed`,
+                        });
                     }
-                    optimizations.push({ action: 'recommend-batch-io', applied: false, recommendation: 'Batch file operations to reduce syscall overhead' });
+                    optimizations.push({
+                        action: 'recommend-batch-io',
+                        applied: false,
+                        recommendation: 'Batch file operations to reduce syscall overhead',
+                    });
                 }
                 if (t === 'throughput') {
                     const coreCount = cpusBefore.length;
                     const batchSize = Math.max(2, Math.floor(coreCount / 2));
-                    optimizations.push({ action: 'recommend-batch-size', applied: false, recommendation: `Use batch size ${batchSize} for ${coreCount} CPU cores` });
+                    optimizations.push({
+                        action: 'recommend-batch-size',
+                        applied: false,
+                        recommendation: `Use batch size ${batchSize} for ${coreCount} CPU cores`,
+                    });
                     if (cpuPercentBefore > 70) {
-                        optimizations.push({ action: 'recommend-throttle', applied: false, recommendation: `CPU at ${Math.round(cpuPercentBefore)}% - throttle concurrent agents to avoid contention` });
+                        optimizations.push({
+                            action: 'recommend-throttle',
+                            applied: false,
+                            recommendation: `CPU at ${Math.round(cpuPercentBefore)}% - throttle concurrent agents to avoid contention`,
+                        });
                     }
                 }
             }
@@ -541,14 +714,24 @@ export const performanceTools = [
                 try {
                     const dir = getPerfDir();
                     const probes = readdirSync(dir).filter((f) => f.startsWith('.'));
-                    probes.forEach((f) => { try {
-                        unlinkSync(join(dir, f));
-                    }
-                    catch { /* ok */ } });
+                    probes.forEach((f) => {
+                        try {
+                            unlinkSync(join(dir, f));
+                        }
+                        catch {
+                            /* ok */
+                        }
+                    });
                     if (probes.length > 0)
-                        optimizations.push({ action: 'clear-probe-files', applied: true, effect: `Removed ${probes.length} probe file(s)` });
+                        optimizations.push({
+                            action: 'clear-probe-files',
+                            applied: true,
+                            effect: `Removed ${probes.length} probe file(s)`,
+                        });
+                }
+                catch {
+                    /* ok */
                 }
-                catch { /* ok */ }
             }
             // Snapshot AFTER
             const memAfter = process.memoryUsage();
@@ -556,13 +739,18 @@ export const performanceTools = [
             return {
                 success: true,
                 _real: true,
+                _recommendationEngine: 'rule-based (static thresholds on real cpu/memory/disk readings) — not ML-based',
                 target,
                 aggressive,
-                before: { cpuPercent: Math.round(cpuPercentBefore * 10) / 10, memoryMB: memMBBefore, diskLatencyMs: diskLatencyBefore },
+                before: {
+                    cpuPercent: Math.round(cpuPercentBefore * 10) / 10,
+                    memoryMB: memMBBefore,
+                    diskLatencyMs: diskLatencyBefore,
+                },
                 optimizations,
                 after: {
                     cpuPercent: Math.round(Math.min((loadAfter[0] / cpusBefore.length) * 100, 100) * 10) / 10,
-                    memoryMB: Math.round(memAfter.heapUsed / 1024 / 1024 * 100) / 100,
+                    memoryMB: Math.round((memAfter.heapUsed / 1024 / 1024) * 100) / 100,
                     diskLatencyMs: diskLatencyBefore, // same measurement window
                 },
             };
@@ -575,8 +763,16 @@ export const performanceTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                metric: { type: 'string', enum: ['cpu', 'memory', 'latency', 'throughput', 'all'], description: 'Metric type' },
-                aggregation: { type: 'string', enum: ['avg', 'min', 'max', 'p50', 'p95', 'p99'], description: 'Aggregation method' },
+                metric: {
+                    type: 'string',
+                    enum: ['cpu', 'memory', 'latency', 'throughput', 'all'],
+                    description: 'Metric type',
+                },
+                aggregation: {
+                    type: 'string',
+                    enum: ['avg', 'min', 'max', 'p50', 'p95', 'p99'],
+                    description: 'Aggregation method',
+                },
                 timeRange: { type: 'string', description: 'Time range' },
             },
         },
@@ -604,11 +800,19 @@ export const performanceTools = [
             const heapMB = Math.round(memUsage.heapUsed / 1024 / 1024);
             // Calculate statistics from stored history
             const history = store.metrics.slice(-100);
-            const cpuHistory = history.map(m => m.cpu.usage);
-            const memHistory = history.map(m => m.memory.used);
+            const cpuHistory = history.map((m) => m.cpu.usage);
+            const memHistory = history.map((m) => m.memory.used);
             const calcStats = (arr, current) => {
                 if (arr.length === 0)
-                    return { current, avg: current, min: current, max: current, p50: current, p95: current, p99: current };
+                    return {
+                        current,
+                        avg: current,
+                        min: current,
+                        max: current,
+                        p50: current,
+                        p95: current,
+                        p99: current,
+                    };
                 const sorted = [...arr].sort((a, b) => a - b);
                 return {
                     current,