thinknagent 0.1.23 → 0.1.25

package/lib/history.js

@@ -56,6 +56,7 @@ class HistoryManager {
         load: metrics.cpu?.loadAvg ?? 0,
         mem: metrics.memory?.usedPct ?? 0,
         memUsedMB: Math.round((metrics.memory?.used || 0) / (1024 * 1024)),
+        buffcache: metrics.memory?.buffcache ?? 0,
         rxSec: metrics.network?.[0]?.rxSec ?? 0,
         txSec: metrics.network?.[0]?.txSec ?? 0,
         procs: metrics.processes?.total ?? 0,

package/lib/metrics.js

@@ -47,6 +47,12 @@ class MetricsPoller {
         si.processes(),
       ]);
 
+      // True active process memory (excluding OS buffer / page cache)
+      const realUsedBytes = (typeof mem.available === 'number' && mem.available > 0)
+        ? (mem.total - mem.available)
+        : (mem.active || (mem.used - (mem.buffcache || 0)));
+      const realUsedPct = parseFloat(Math.min(100, Math.max(0, (realUsedBytes / mem.total) * 100)).toFixed(1));
+
       const payload = {
         ts: Date.now(),
         cpu: {
@@ -55,10 +61,15 @@ class MetricsPoller {
           loadAvg: cpu.avgLoad ?? 0,
         },
         memory: {
-          total:   mem.total,
-          used:    mem.used,
-          free:    mem.free,
-          usedPct: parseFloat(((mem.used / mem.total) * 100).toFixed(1)),
+          total:       mem.total,
+          active:      realUsedBytes,
+          activePct:   realUsedPct,
+          buffcache:   mem.buffcache || Math.max(0, mem.used - realUsedBytes),
+          rawUsed:     mem.used,
+          rawUsedPct:  parseFloat(((mem.used / mem.total) * 100).toFixed(1)),
+          free:        mem.available || mem.free,
+          used:        realUsedBytes,
+          usedPct:     realUsedPct,
         },
         disk: disk.map(d => ({
           fs:      d.fs,
@@ -130,10 +141,18 @@ class MetricsPoller {
 
       // ─── Automated Spike Diagnostic & Root Cause Engine ────────────────────────
       const curCpuUsage = parseFloat(cpu.currentLoad.toFixed(1));
-      const curMemPct   = parseFloat(((mem.used / mem.total) * 100).toFixed(1));
-      const sortedProcs = (procs.list || []).slice().sort((a, b) => (b.pmem || 0) - (a.pmem || 0));
-      const topMemProc  = sortedProcs[0] || null;
-      const topCpuProc  = (procs.list || []).slice().sort((a, b) => (b.pcpu || 0) - (a.pcpu || 0))[0] || null;
+      const curMemPct   = realUsedPct;
+
+      // Filter real user/application processes with actual resource footprint
+      const sortedMemProcs = (procs.list || [])
+        .filter(p => p && p.pid > 1 && (p.pmem > 0.5 || p.pcpu > 0.5))
+        .sort((a, b) => (b.pmem || 0) - (a.pmem || 0));
+      const topMemProc = sortedMemProcs[0] || (procs.list || []).sort((a, b) => (b.pmem || 0) - (a.pmem || 0))[0] || null;
+
+      const sortedCpuProcs = (procs.list || [])
+        .filter(p => p && p.pid > 1 && (p.pcpu > 0.5 || p.pmem > 0.5))
+        .sort((a, b) => (b.pcpu || 0) - (a.pcpu || 0));
+      const topCpuProc = sortedCpuProcs[0] || (procs.list || []).sort((a, b) => (b.pcpu || 0) - (a.pcpu || 0))[0] || null;
 
       let diagnostics = {
         hasSpike: false,
@@ -150,35 +169,44 @@ class MetricsPoller {
       this._lastMemPct = curMemPct;
       this._lastCpuUsage = curCpuUsage;
 
-      if (curMemPct >= 80 || memDelta >= 3.5) {
+      const topMemMB = topMemProc ? Math.round(((topMemProc.pmem || 0) / 100) * (mem.total / (1024 * 1024))) : 0;
+      const topMemPct = topMemProc ? parseFloat((topMemProc.pmem || 0).toFixed(1)) : 0;
+      const hasRealMemCulprit = topMemProc && (topMemPct >= 3.0 || topMemMB >= 35);
+
+      // Trigger spike only on sudden surge OR critically high memory with an identified culprit
+      if (memDelta >= 5.0 || (curMemPct >= 90 && hasRealMemCulprit)) {
         diagnostics.hasSpike = true;
         diagnostics.type = 'memory';
         diagnostics.deltaPct = memDelta;
-        if (topMemProc) {
-          const procMemMB = Math.round(((topMemProc.pmem || 0) / 100) * (mem.total / (1024 * 1024)));
+        if (hasRealMemCulprit) {
           diagnostics.culprit = {
             pid: topMemProc.pid,
             name: topMemProc.name,
             command: topMemProc.command ? topMemProc.command.slice(0, 80) : topMemProc.name,
-            memPct: parseFloat((topMemProc.pmem || 0).toFixed(1)),
-            memMB: procMemMB,
+            memPct: topMemPct,
+            memMB: topMemMB,
             cpu: parseFloat((topMemProc.pcpu || 0).toFixed(1))
           };
-          diagnostics.explanation = `Memory surge detected (${curMemPct}% RAM, delta: ${memDelta >= 0 ? '+' : ''}${memDelta}%). Primary consumer is "${topMemProc.name}" (PID ${topMemProc.pid}) utilizing ${diagnostics.culprit.memPct}% (${procMemMB} MB). Probable cause: Rapid memory allocation, large dataset buffer in memory, or memory leak.`;
+          diagnostics.explanation = `Memory surge detected (${curMemPct}% RAM, delta: ${memDelta >= 0 ? '+' : ''}${memDelta}%). Primary consumer is "${topMemProc.name}" (PID ${topMemProc.pid}) utilizing ${topMemPct}% (${topMemMB} MB). Probable cause: Rapid memory allocation, large dataset buffer in memory, or memory leak.`;
+        } else {
+          diagnostics.explanation = `Memory load is elevated (${curMemPct}% RAM, delta: ${memDelta >= 0 ? '+' : ''}${memDelta}%), distributed across system caches and background services. No single runaway process.`;
         }
-      } else if (curCpuUsage >= 80 || cpuDelta >= 25.0) {
+      } else if (cpuDelta >= 30.0 || (curCpuUsage >= 85 && topCpuProc && (topCpuProc.pcpu || 0) >= 10.0)) {
+        const topCpuVal = topCpuProc ? parseFloat((topCpuProc.pcpu || 0).toFixed(1)) : 0;
         diagnostics.hasSpike = true;
         diagnostics.type = 'cpu';
         diagnostics.deltaPct = cpuDelta;
-        if (topCpuProc) {
+        if (topCpuProc && topCpuVal >= 5.0) {
           diagnostics.culprit = {
             pid: topCpuProc.pid,
             name: topCpuProc.name,
             command: topCpuProc.command ? topCpuProc.command.slice(0, 80) : topCpuProc.name,
-            cpu: parseFloat((topCpuProc.pcpu || 0).toFixed(1)),
+            cpu: topCpuVal,
             memPct: parseFloat((topCpuProc.pmem || 0).toFixed(1))
           };
-          diagnostics.explanation = `High CPU workload spike detected (${curCpuUsage}% CPU, delta: ${cpuDelta >= 0 ? '+' : ''}${cpuDelta}%). Primary consumer is "${topCpuProc.name}" (PID ${topCpuProc.pid}) utilizing ${diagnostics.culprit.cpu}% CPU. Probable cause: Intensive computation, complex query/loop execution, or heavy background processing.`;
+          diagnostics.explanation = `High CPU workload spike detected (${curCpuUsage}% CPU, delta: ${cpuDelta >= 0 ? '+' : ''}${cpuDelta}%). Primary consumer is "${topCpuProc.name}" (PID ${topCpuProc.pid}) utilizing ${topCpuVal}% CPU. Probable cause: Intensive computation, complex query/loop execution, or heavy background processing.`;
+        } else {
+          diagnostics.explanation = `High CPU utilization (${curCpuUsage}% CPU, delta: ${cpuDelta >= 0 ? '+' : ''}${cpuDelta}%) spread across multiple threads.`;
         }
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinknagent",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "ThinkNCollab server agent & MCP server — metrics, logs, alerts, shell bridge, AI planning",
   "main": "lib/agent.js",
   "author": "ThinkNCollab Team <raman@thinkncollab.com>",