fix: CPU real por proceso en el monitor, y UTXO Map usando la caché

La columna %CPU de ps aux es la media desde que arrancó el proceso, no el
consumo actual: un proceso que trabajó mucho hace días seguía apareciendo
alto para siempre. Se detectó porque los porcentajes no cambiaban nunca entre
lecturas mientras la CPU global sí variaba.

Ahora se mide con dos lecturas de /proc/PID/stat separadas 500 ms, el mismo
método que ya usaba getCpuUsage para el total. La UI muestra el % sobre el
total de la máquina, con el % por núcleo y la media de ps en el tooltip.

Verificado con carga artificial: 100% de un núcleo (25% de 4) frente al 152%
que reportaba ps, imposible para un proceso de un solo hilo.

Además, el UTXO Map era el único punto que se saltaba la caché usando
fetchWithTimeout directo. Ahora pasa por get().

system-metrics.js

@@ -168,10 +168,33 @@ async function getDisk() {
 }
 
 // ── Procesos destacados (nombre limpio del binario) ────────────────────────
+// Tiempo de CPU consumido por un proceso, en ticks, desde /proc/PID/stat.
+// Campos 14 (utime) y 15 (stime). El nombre del proceso va entre paréntesis y
+// puede contener espacios, así que se corta por el ÚLTIMO ')' antes de partir.
+function readProcCpuTicks(pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+    const resto = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+    // resto[0] es el campo 3 (estado), así que utime=campo14 → resto[11]
+    const utime = parseInt(resto[11], 10);
+    const stime = parseInt(resto[12], 10);
+    if (Number.isNaN(utime) || Number.isNaN(stime)) return null;
+    return utime + stime;
+  } catch { return null; }
+}
+
+// OJO con la columna %CPU de `ps`: NO es el consumo actual, sino la media del
+// proceso desde que arrancó (tiempo de CPU / tiempo de vida). Un proceso que
+// trabajó mucho al principio y ahora está ocioso sigue mostrando un número
+// alto días después, y se lee como si estuviera saturando la máquina.
+// Aquí se mide de verdad: dos lecturas de /proc separadas 500 ms, el mismo
+// método que ya usa getCpuUsage para el total del sistema. Las dos esperas
+// corren en paralelo (van dentro del mismo Promise.all), así que no cuesta
+// tiempo extra.
 async function getProcesses() {
   const result = await sh("ps aux --no-headers --sort=-%mem | head -8");
   if (!result) return [];
-  return result.split("\n").map(line => {
+  const filas = result.split("\n").map(line => {
     const parts = line.trim().split(/\s+/);
     // Nombre limpio: basename del ejecutable; si es un intérprete (node,
     // python...), añade el basename del script que ejecuta.
@@ -190,12 +213,33 @@ async function getProcesses() {
     }
     command = command.slice(0, 24);
     return {
+      pid: parts[1],
       user: parts[0],
-      cpu: parseFloat(parts[2]),
+      cpuMedia: parseFloat(parts[2]), // media desde el arranque (lo que da ps)
       mem: parseFloat(parts[3]),
       command,
     };
   }).filter(p => p.mem > 0.5);
+
+  const ticks1 = filas.map(p => readProcCpuTicks(p.pid));
+  await sleep(500);
+  const ticks2 = filas.map(p => readProcCpuTicks(p.pid));
+
+  const USER_HZ = 100;      // estándar en Linux
+  const VENTANA_S = 0.5;
+  const nucleos = os.cpus().length || 1;
+
+  return filas.map((p, i) => {
+    let cpu = null, cpuSistema = null;
+    if (ticks1[i] !== null && ticks2[i] !== null) {
+      const seg = (ticks2[i] - ticks1[i]) / USER_HZ;
+      // % de UN núcleo (criterio de top/ps: puede pasar de 100 si va en varios)
+      cpu = Math.max(0, Math.round((seg / VENTANA_S) * 1000) / 10);
+      // % del total de la máquina, que es lo que suele querer saberse
+      cpuSistema = Math.round((cpu / nucleos) * 10) / 10;
+    }
+    return { user: p.user, command: p.command, mem: p.mem, cpu, cpuSistema, cpuMedia: p.cpuMedia };
+  });
 }
 
 // ── Load / Uptime ───────────────────────────────────────────────────────────