fullstack-critic 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstack-critic",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A free, universal principal-engineer critic. Attach it to any project or run it as a background watcher over any in-progress workflow. Reviews 100% of resources — code, packages, and dependencies — across 12 dimensions and emits an evidence-based report with a fix / optimize / delete / add action plan.",
   "keywords": [
     "code-review",

package/src/sysinfo.js

@@ -0,0 +1,395 @@
+'use strict';
+/**
+ * Zero-dependency (Node core only) OS-level telemetry for the built-in critic
+ * dashboard. It answers one question the report never could: "what is actually
+ * running on this machine right now, app-by-app, and when will the critic finish?"
+ *
+ * Design rules (same discipline as the rest of the tool):
+ *   - Never crash the workflow. Every external probe is wrapped; a platform or
+ *     tool we cannot read degrades to an empty/partial snapshot, not an error.
+ *   - Cross-platform: Windows (Get-Process), macOS/Linux (ps). CPU% per process
+ *     uses deltas between samples so the numbers are real, not lifetime averages.
+ *   - "Project / app wise" grouping: processes are folded into apps and tagged
+ *     with a coarse category (project, runtime, browser, terminal, database,
+ *     system, other) so the live-task table is structured, not a raw dump.
+ *   - The critic's OWN process is highlighted — that is the concrete "live task"
+ *     this app is running — with its CPU/RSS and a scan-rate-based ETA.
+ */
+const os = require('os');
+const { spawnSync, exec } = require('child_process');
+
+const IS_WIN = process.platform === 'win32';
+
+// The machine-wide per-process probe is expensive on Windows (PowerShell cold
+// start ~3s) — it must therefore run ASYNC + throttled in the live dashboard and
+// is skipped entirely for one-shot `review`. System/self CPU, by contrast, is
+// read from Node core and is always instant.
+
+/* ------------------------------- primitives ------------------------------- */
+
+// Block the thread for `ms` without busy-spinning (used only for the one-shot
+// static snapshot, where there is no sample history to diff CPU against).
+function sleepMs(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch { /* SharedArrayBuffer disabled → just skip the wait */ }
+}
+
+function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
+function round(n, d) { const m = Math.pow(10, d || 0); return Math.round((Number(n) || 0) * m) / m; }
+
+// Aggregate instantaneous system CPU% from two os.cpus() readings.
+function cpuPctFrom(prev, cur) {
+  if (!prev || !cur || prev.length !== cur.length) return null;
+  let prevIdle = 0, prevTotal = 0, curIdle = 0, curTotal = 0;
+  for (let i = 0; i < cur.length; i++) {
+    const p = prev[i].times, c = cur[i].times;
+    prevIdle += p.idle; curIdle += c.idle;
+    prevTotal += p.user + p.nice + p.sys + p.idle + p.irq;
+    curTotal += c.user + c.nice + c.sys + c.idle + c.irq;
+  }
+  const dt = curTotal - prevTotal;
+  if (dt <= 0) return null;
+  return clamp((1 - (curIdle - prevIdle) / dt) * 100, 0, 100);
+}
+
+function memInfo() {
+  const total = os.totalmem();
+  const free = os.freemem();
+  const used = Math.max(0, total - free);
+  return { memTotal: total, memFree: free, memUsed: used, memPct: total ? round((used / total) * 100, 1) : 0 };
+}
+
+function systemStatic() {
+  const cpus = os.cpus();
+  const load = os.loadavg ? os.loadavg() : [0, 0, 0];
+  return {
+    cores: cpus.length,
+    cpuModel: (cpus[0] && cpus[0].model ? cpus[0].model : '').trim(),
+    load1: round(load[0] || 0, 2),
+    uptimeSec: Math.round(os.uptime() || 0),
+    hostname: os.hostname(),
+    platform: process.platform,
+    arch: os.arch(),
+    nodeVersion: process.version,
+    pid: process.pid,
+  };
+}
+
+/* ------------------------------ process list ------------------------------ */
+
+// Coarse, honest categorisation so the live-task view is structured.
+const CAT_RULES = [
+  ['project', /fullstack-critic|critic[\\/]|bin\/fullstack/i],
+  ['runtime', /^(node|deno|bun|python|python3|java|ruby|php|dotnet|go|rustc|cargo|perl|jl)\b/i],
+  ['package', /^(npm|pnpm|yarn|npx|pip|pipenv|poetry|composer|bundle|gem|nuget)\b/i],
+  ['browser', /(chrome|chromium|msedge|edge|firefox|safari|brave|opera|vivaldi)/i],
+  ['terminal', /(powershell|pwsh|\bcmd\b|conhost|wt\b|terminal|iterm|\bbash\b|\bzsh\b|\bfish\b|codium)/i],
+  ['editor', /(code|cursor|idea|webstorm|pycharm|goland|clion|rubymine|phpstorm|sublime|atom|nvim|\bvim\b|emacs|eclipse|devenv)/i],
+  ['database', /(postgres|psql|mysqld|\bmariadb\b|mongod|redis|sqlite|clickhouse|influx|etcd)/i],
+  ['container', /(docker|com\.docker|kubelet|kubectl|containerd|podman|orbstack)/i],
+  ['vcs', /\bgit\b|git-lfs/i],
+  ['system', /(svchost|csrss|services|lsass|wininit|winlogon|dwm|explorer|ntoskrnl|system\b|\bsmss\b|\bwin32\b|taskhostw|\bsearch\b|fontdrvhost|memory\.diagnostic|registry|wmiprvse)/i],
+];
+function classify(name) {
+  const n = String(name || '');
+  for (const [cat, re] of CAT_RULES) if (re.test(n)) return cat;
+  return 'other';
+}
+
+function execCapture(cmd, args, timeoutMs) {
+  try {
+    const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: timeoutMs || 1500, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
+    if (r.error || r.status == null) return null;
+    return r.stdout || '';
+  } catch { return null; }
+}
+
+// Return raw process rows: { pid, name, memBytes, cpuSec, path }. cpuSec is total
+// CPU-seconds consumed (POSIX returns an instantaneous % which we pass through as
+// cpuPctRaw instead). Callers diff successive samples to get a real CPU%.
+function processes() {
+  return IS_WIN ? winProcesses() : posixProcesses();
+}
+
+// Non-blocking process probe. cb(err, rows) — rows is [] on any failure so the
+// live dashboard simply keeps showing the last successful app table.
+function processesAsync(cb) {
+  if (IS_WIN) return runAsync('powershell.exe', WIN_ARGS, parseWinJson, cb);
+  return runAsync('ps', ['-axo', 'pid=,pcpu=,rss=,comm='], parsePosixText, cb);
+}
+
+const WIN_SCRIPT =
+  '$ErrorActionPreference="SilentlyContinue";' +
+  'Get-Process | ForEach-Object {' +
+  '$cpu=0; try{$cpu=$_.CPU}catch{$cpu=0}' +
+  '$ws=0; try{$ws=$_.WS}catch{$ws=0}' +
+  '[pscustomobject]@{Id=$_.Id;Name=$_.ProcessName;WS=$ws;CPU=$cpu}' +
+  '} | ConvertTo-Json -Compress';
+const WIN_ARGS = ['-NoProfile', '-NonInteractive', '-Command', WIN_SCRIPT];
+
+function runAsync(cmd, args, parser, cb) {
+  const { spawn } = require('child_process');
+  let child;
+  try { child = spawn(cmd, args, { windowsHide: true }); } catch (e) { return cb(e, []); }
+  let out = '';
+  let done = false;
+  const finish = (err) => { if (done) return; done = true; clearTimeout(timer); cb(err, err ? [] : parseSafe(parser, out)); };
+  const timer = setTimeout(() => { try { child.kill('SIGKILL'); } catch { /* gone */ } finish(new Error('probe-timeout')); }, 15000);
+  child.stdout.on('data', (d) => { out += d; });
+  child.on('error', (e) => finish(e));
+  child.on('close', () => finish(null));
+}
+function parseSafe(parser, out) { try { return parser(out) || []; } catch { return []; } }
+
+function parseWinJson(stdout) {
+  if (!stdout) return [];
+  let rows; try { rows = JSON.parse(stdout); } catch { return []; }
+  if (!Array.isArray(rows)) rows = [rows];
+  return rows.filter((r) => r && r.Id != null).map((r) => ({
+    pid: Number(r.Id), name: String(r.Name || '?'),
+    memBytes: Number(r.WS) || 0, cpuSec: Number(r.CPU) || 0, path: '',
+  }));
+}
+function parsePosixText(stdout) { return parsePsText(stdout); }
+
+// Shared ps -text parser (POSIX). pcpu is an instantaneous-ish %; rss is KB.
+function parsePsText(stdout) {
+  if (!stdout) return [];
+  const out = [];
+  for (const line of stdout.split('\n')) {
+    const m = line.match(/^\s*(\d+)\s+([\d.]+)\s+(\d+)\s+(.*)$/);
+    if (!m) continue;
+    out.push({
+      pid: Number(m[1]),
+      name: String(m[4]).trim().split(/[\\/]/).pop(),
+      memBytes: (Number(m[3]) || 0) * 1024,
+      cpuSec: 0,
+      cpuPctRaw: Number(m[2]) || 0,
+      path: '',
+    });
+  }
+  return out;
+}
+
+// Synchronous variants — used only by tests and anywhere a blocking read is fine.
+function winProcesses() {
+  const stdout = execCapture('powershell.exe', WIN_ARGS, 6000);
+  return parseWinJson(stdout);
+}
+function posixProcesses() {
+  const stdout = execCapture('ps', ['-axo', 'pid=,pcpu=,rss=,comm='], 1500);
+  return parsePsText(stdout);
+}
+
+// Fold processes into apps and compute a real CPU% from the previous sample.
+// prevByPid: Map<pid,{cpuSec,ts}> | null.  nowMs: current epoch ms.
+function toAppRows(procs, prevByPid, nowMs, cores) {
+  const apps = new Map();
+  const updated = new Map();
+  for (const p of procs) {
+    let cpuPct = 0;
+    if (typeof p.cpuPctRaw === 'number') {
+      cpuPct = clamp(p.cpuPctRaw, 0, (cores || 1) * 100);
+    } else if (prevByPid) {
+      const prev = prevByPid.get(p.pid);
+      if (prev && nowMs > prev.ts) {
+        const dtSec = (nowMs - prev.ts) / 1000;
+        cpuPct = clamp(((p.cpuSec - prev.cpuSec) / dtSec) * 100, 0, (cores || 1) * 100);
+      }
+    }
+    updated.set(p.pid, { cpuSec: p.cpuSec, ts: nowMs });
+
+    const key = (p.name || '?').toLowerCase();
+    let a = apps.get(key);
+    if (!a) { a = { app: p.name || '?', category: classify(p.name), count: 0, cpuPct: 0, memBytes: 0, pids: [] }; apps.set(key, a); }
+    a.count++;
+    a.cpuPct += cpuPct;
+    a.memBytes += p.memBytes;
+    if (a.pids.length < 8) a.pids.push(p.pid);
+    if (!a.category || a.category === 'other') a.category = classify(p.name);
+  }
+  const rows = [...apps.values()].map((a) => ({ ...a, cpuPct: round(a.cpuPct, 1), memBytes: a.memBytes }));
+  return { rows, prevByPid: updated };
+}
+
+function byCategory(rows) {
+  const out = {};
+  for (const r of rows) {
+    const c = (out[r.category] || (out[r.category] = { count: 0, apps: 0, cpuPct: 0, memBytes: 0 }));
+    c.apps += 1; c.count += r.count; c.cpuPct += r.cpuPct; c.memBytes += r.memBytes;
+  }
+  for (const k of Object.keys(out)) { out[k].cpuPct = round(out[k].cpuPct, 1); }
+  return out;
+}
+
+/* ------------------------------ self (critic) ----------------------------- */
+
+// CPU% of THIS critic process between samples, plus its resident memory.
+function selfUsage(prev) {
+  const cpu = process.cpuUsage(prev && prev.cpuUsage); // microseconds since last
+  const wallMs = prev ? Date.now() - prev.ts : 0;
+  const cpuUs = (cpu.user || 0) + (cpu.system || 0);
+  const cpuPct = wallMs > 0 ? clamp((cpuUs / 1000 / (wallMs / 1000)) * 100, 0, (os.cpus().length || 1) * 100) : 0;
+  const mem = process.memoryUsage();
+  return {
+    cpuPct: round(cpuPct, 1),
+    rss: Math.round(mem.rss || 0),
+    heapUsed: Math.round(mem.heapUsed || 0),
+    rssMb: round((mem.rss || 0) / 1048576, 1),
+    next: { cpuUsage: process.cpuUsage(), ts: Date.now() },
+  };
+}
+
+/* -------------------------------- estimate -------------------------------- */
+
+/**
+ * Expected-completion math for the critic's own scan. Fully pure & testable:
+ * it turns the analyzer's measured throughput and pass history into an honest
+ * ETA — and refuses to overclaim when there is not enough signal yet.
+ */
+function computeEstimate(input) {
+  const o = input || {};
+  const now = o.now || Date.now();
+  const cores = o.cores || os.cpus().length || 1;
+  const passNo = Number(o.passNo) || 0;
+  const durationsMs = Array.isArray(o.durationsMs) ? o.durationsMs.filter((x) => x > 0) : [];
+  const lastPassMs = Number(o.lastPassMs) || (durationsMs.length ? durationsMs[durationsMs.length - 1] : 0);
+  const avgPassMs = durationsMs.length ? Math.round(durationsMs.reduce((s, x) => s + x, 0) / durationsMs.length) : lastPassMs;
+  const filesTotal = Number(o.filesTotal) || 0;
+  const totalLines = Number(o.totalLines) || 0;
+
+  const scanRateFps = lastPassMs > 0 ? round(filesTotal / (lastPassMs / 1000), 1) : 0;
+  const linesPerSec = lastPassMs > 0 ? round(totalLines / (lastPassMs / 1000), 0) : 0;
+  const timeOnTaskSec = o.startedAt ? round((now - o.startedAt) / 1000, 1) : 0;
+
+  // Under heavy system load the next pass will stretch; scale the estimate.
+  const loadFactor = o.cpuPct != null ? round(1 + Math.max(0, (o.cpuPct - 60) / 100), 2) : 1;
+  const estPassMs = avgPassMs ? Math.round(avgPassMs * loadFactor) : 0;
+
+  let etaLabel;
+  let complete = true;
+  if (o.mode === 'watch') {
+    const nextSec = round((estPassMs / 1000) + (Number(o.debounceMs) || 400) / 1000, 1);
+    etaLabel = `each re-scan completes in ~${nextSec}s after a change`;
+    complete = false; // watch never "finishes"; it waits for the next edit
+  } else if (estPassMs > 0) {
+    etaLabel = `full review completed in ~${round(estPassMs / 1000, 1)}s`;
+  } else {
+    etaLabel = 'measuring throughput…';
+  }
+
+  return {
+    mode: o.mode || 'review',
+    passNo, cores, filesTotal, totalLines,
+    lastPassMs, avgPassMs, estPassMs,
+    scanRateFps, linesPerSec, loadFactor,
+    timeOnTaskSec, serverNow: now, startedAt: o.startedAt || null,
+    etaLabel, complete,
+  };
+}
+
+/* -------------------------------- monitor --------------------------------- */
+
+// Stateful sampler used by the live dashboard: keeps system-CPU, per-process-CPU
+// and critic-process deltas between calls, plus a rolling history for the charts.
+function createMonitor(root) {
+  const state = {
+    root: root || process.cwd(),
+    prevCpus: os.cpus(),
+    prevTs: Date.now(),
+    prevByPid: null,
+    prevSelf: { cpuUsage: process.cpuUsage(), ts: Date.now() },
+    history: [],
+    maxHistory: 60,
+    lastRows: [],
+    lastProcs: 0,
+    lastErr: null,
+  };
+
+  // Cheap, always-current reading: system CPU% (Node-core delta), memory, and
+  // this critic process. Safe to call on every poll / history tick — never blocks.
+  function sample() {
+    const now = Date.now();
+    const sysStatic = systemStatic();
+    let cpuPct = cpuPctFrom(state.prevCpus, os.cpus());
+    if (cpuPct == null) cpuPct = state.history.length ? state.history[state.history.length - 1].cpu : 0;
+    state.prevCpus = os.cpus();
+    state.prevTs = now;
+    const mem = memInfo();
+    const self = selfUsage(state.prevSelf);
+    state.prevSelf = self.next;
+    delete self.next;
+    state.history.push({ t: now, cpu: round(cpuPct, 1), mem: mem.memPct, procCount: state.lastProcs, selfCpu: self.cpuPct });
+    if (state.history.length > state.maxHistory) state.history.shift();
+    return buildSnapshot(sysStatic, cpuPct, mem, self, now);
+  }
+
+  function buildSnapshot(sysStatic, cpuPct, mem, self, now) {
+    const byCpu = state.lastRows.slice().sort((a, b) => b.cpuPct - a.cpuPct || b.memBytes - a.memBytes);
+    const topMem = state.lastRows.slice().sort((a, b) => b.memBytes - a.memBytes).slice(0, 8);
+    return {
+      ts: now,
+      system: { ...sysStatic, cpuPct: round(cpuPct, 1), ...mem },
+      self,
+      apps: byCpu.slice(0, 24),
+      totals: {
+        procCount: state.lastProcs, appCount: state.lastRows.length, topMem,
+        byCategory: byCategory(state.lastRows), refreshing: !!state.refreshing,
+      },
+      history: state.history.slice(),
+      error: state.lastErr || null,
+    };
+  }
+
+  // Expensive: the machine-wide per-process table. Runs async so it never blocks
+  // the HTTP server or the watch loop; cb() fires once the rows are cached.
+  function refresh(cb) {
+    if (state.refreshing) { if (cb) cb(null); return; }
+    state.refreshing = true;
+    processesAsync((err, procs) => {
+      state.refreshing = false;
+      const list = Array.isArray(procs) ? procs : [];
+      if (err) { state.lastErr = err.message; if (cb) cb(err); return; }
+      const now = Date.now();
+      const folded = toAppRows(list, state.prevByPid, now, systemStatic().cores);
+      state.prevByPid = folded.prevByPid;
+      state.lastRows = folded.rows;
+      state.lastProcs = list.length;
+      state.lastErr = null;
+      if (cb) cb(null);
+    });
+  }
+
+  return { sample, refresh, get historyLen() { return state.history.length; } };
+}
+
+// One-shot snapshot for a single (non-looping) `critic review`. Only the cheap,
+// always-available readings (system CPU over a 60ms window, memory, this
+// process). The machine-wide per-app table is deliberately omitted here because
+// it needs the slow async probe — that lives in the live `watch` dashboard.
+function snapshotOnce(root) {
+  const p1 = os.cpus();
+  const self1 = { cpuUsage: process.cpuUsage(), ts: Date.now() };
+  sleepMs(60);
+  const cpuPct = cpuPctFrom(p1, os.cpus()) || 0;
+  const selfRaw = selfUsage(self1);
+  const self = { cpuPct: selfRaw.cpuPct, rss: selfRaw.rss, heapUsed: selfRaw.heapUsed, rssMb: selfRaw.rssMb };
+  const mem = memInfo();
+  const now = Date.now();
+  return {
+    ts: now,
+    system: { ...systemStatic(), cpuPct: round(cpuPct, 1), ...mem },
+    self,
+    apps: [],
+    totals: { procCount: 0, appCount: 0, topMem: [], byCategory: {}, refreshing: false },
+    history: [{ t: now, cpu: round(cpuPct, 1), mem: mem.memPct, procCount: 0, selfCpu: self.cpuPct }],
+    live: false,
+    error: null,
+  };
+}
+
+module.exports = {
+  createMonitor, snapshotOnce, processes, processesAsync, toAppRows, byCategory, classify,
+  selfUsage, computeEstimate, cpuPctFrom, systemStatic, memInfo, sleepMs, IS_WIN,
+};

package/src/ui.js

@@ -26,6 +26,7 @@ const net = require('net');
 const { DIMENSIONS } = require('./analyzer');
 const { execSummary } = require('./report');
 const { openBrowser } = require('./observatory');
+const sysinfo = require('./sysinfo');
 
 const SEV_ORDER = ['BLOCKER', 'CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'INFO'];
 const UI_BASE_PORT = 4781;   // distinct from the observatory's 4780
@@ -81,6 +82,9 @@ function buildSnapshot(result, extra = {}) {
       file: f.file, line: f.line, severity: f.severity, category: f.category,
       dimension: f.dimension, title: f.title, problem: f.problem, fix: f.fix, evidence: f.evidence,
     })),
+    // OS-level live telemetry + expected-completion estimate (see sysinfo.js).
+    sys: extra.sys || null,
+    estimate: extra.estimate || null,
   };
 }
 
@@ -133,6 +137,36 @@ function renderHtml(data, opts = {}) {
   footer{color:var(--mut);font-size:11.5px;padding:20px 26px;border-top:1px solid var(--line);margin-top:24px}
   .pulse{display:inline-block;width:8px;height:8px;border-radius:50%;background:var(--ok);margin-right:6px;animation:p 1.4s infinite}
   @keyframes p{0%,100%{opacity:.3}50%{opacity:1}}
+  /* --- OS live-task + ETA panels --- */
+  .row2{display:grid;grid-template-columns:1fr 1fr;gap:14px;margin-bottom:18px}
+  @media(max-width:860px){.row2{grid-template-columns:1fr}}
+  .card{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:14px 16px}
+  .card h2{margin-top:0}
+  .gauges{display:flex;gap:18px;flex-wrap:wrap;margin-bottom:8px}
+  .gauge{min-width:120px;flex:1}
+  .gauge .top{display:flex;justify-content:space-between;align-items:baseline;color:var(--mut);font-size:11px;text-transform:uppercase;letter-spacing:.5px}
+  .gauge .top b{font-size:22px;color:var(--ink)}
+  .track{height:8px;background:#0c1226;border:1px solid var(--line);border-radius:999px;margin-top:6px;overflow:hidden}
+  .track>i{display:block;height:100%;border-radius:999px;transition:width .5s ease}
+  #charts{display:grid;grid-template-columns:1fr;gap:10px;margin-top:10px}
+  .chart{background:#0c1226;border:1px solid var(--line);border-radius:8px;padding:8px 10px}
+  .chart .ct{color:var(--mut);font-size:11px;text-transform:uppercase;letter-spacing:.5px;margin-bottom:4px}
+  .chart svg{display:block;width:100%;height:46px}
+  .eta-barbox{height:14px;background:#0c1226;border:1px solid var(--line);border-radius:999px;overflow:hidden;margin-bottom:8px}
+  .eta-bar{height:100%;width:0;background:linear-gradient(90deg,var(--ok),var(--info));transition:width .15s linear}
+  .eta-line{font-size:15px;font-weight:600}
+  .grid2{display:grid;grid-template-columns:1fr 1fr 1fr;gap:10px;margin-top:12px}
+  @media(max-width:860px){.grid2{grid-template-columns:1fr 1fr}}
+  .kv{background:#0c1226;border:1px solid var(--line);border-radius:8px;padding:8px 10px}
+  .kv .k{color:var(--mut);font-size:10.5px;text-transform:uppercase;letter-spacing:.5px}
+  .kv .v{font-size:14px;font-weight:600;margin-top:2px}
+  .bar{position:relative;height:20px;min-width:90px;background:#0c1226;border:1px solid var(--line);border-radius:6px;overflow:hidden}
+  .bar>i{display:block;height:100%;opacity:.5;transition:width .5s ease}
+  .bar>span{position:absolute;left:6px;top:0;line-height:20px;font-size:11.5px;color:#fff;text-shadow:0 0 3px rgba(0,0,0,.85)}
+  th.sortable{cursor:pointer} th.sortable:hover{color:var(--ink)} th.act{color:var(--ink)}
+  .c-project{color:var(--ok)} .c-runtime{color:var(--info)} .c-browser{color:var(--high)} .c-terminal{color:var(--med)}
+  .c-editor{color:#c792ea} .c-database{color:var(--critic)} .c-container{color:#7fdbca} .c-package{color:#ffd166}
+  .c-vcs{color:#93a0c2} .c-system{color:var(--mut)} .c-other{color:var(--mut)}
 </style></head>
 <body>
 <header>
@@ -142,6 +176,12 @@ function renderHtml(data, opts = {}) {
 <main>
   <div class="verdict" id="verdict"></div>
   <div class="grid" id="counts"></div>
+  <div class="row2">
+    <section class="card"><h2>Estimated Completion</h2><div id="eta"></div></section>
+    <section class="card"><h2>OS Activity <span class="sub" id="os-meta"></span></h2><div id="gauges"></div><div id="charts"></div></section>
+  </div>
+  <h2>Live Tasks — running processes, grouped app-wise</h2>
+  <div id="tasks" class="card"></div>
   <h2>12-Dimension Executive Summary</h2>
   <table id="dims"><thead><tr><th>Dimension</th><th>Status</th><th>Findings</th><th>Worst</th></tr></thead><tbody></tbody></table>
   <h2>Prioritised Action Plan</h2>
@@ -158,6 +198,51 @@ var LIVE = ${live};
 var SEV = ['BLOCKER','CRITICAL','HIGH','MEDIUM','LOW','INFO'];
 var CATS = [['fix','FIX — correctness & security'],['optimize','OPTIMIZE — performance & structure'],['delete','DELETE — dead code & debug'],['add','ADD — tests, config & docs']];
 function el(t,c,x){var e=document.createElement(t);if(c)e.className=c;if(x!=null)e.textContent=x;return e;}
+
+/* ---- OS live-task + expected-completion rendering (zero-dep SVG charts) ---- */
+var LASTSYS=null; var SORT='cpu'; var LASTEST=null; var PASS={no:-1,start:0};
+var SVGNS='http://www.w3.org/2000/svg';
+function fmtBytes(n){n=Number(n)||0;if(n>=1073741824)return (n/1073741824).toFixed(1)+' GB';if(n>=1048576)return (n/1048576).toFixed(0)+' MB';if(n>=1024)return (n/1024).toFixed(0)+' KB';return n+' B';}
+function fmtPct(n){return (Math.round((Number(n)||0)*10)/10)+'%';}
+function round1(n){return Math.round((Number(n)||0)*10)/10;}
+function dur(sec){sec=Math.max(0,Math.floor(Number(sec)||0));var h=Math.floor(sec/3600),m=Math.floor((sec%3600)/60),s=sec%60;if(h)return h+'h '+m+'m';if(m)return m+'m '+s+'s';return s+'s';}
+function maxOf(hist,key){var mx=0;for(var i=0;i<hist.length;i++){var v=Number(hist[i][key])||0;if(v>mx)mx=v;}return mx;}
+function bar(val,max,color,text){var b=el('div','bar');var f=el('i');f.style.width=(max>0?Math.min(100,(val/max)*100):0)+'%';if(color)f.style.background=color;b.appendChild(f);if(text!=null)b.appendChild(el('span',null,text));return b;}
+function kv(k,v){var d=el('div','kv');d.appendChild(el('div','k',k));d.appendChild(el('div','v',String(v)));return d;}
+function gaugeCard(label,pct,color){var g=el('div','gauge');var top=el('div','top');top.appendChild(el('span',null,label));top.appendChild(el('b',null,fmtPct(pct)));g.appendChild(top);var tr=el('div','track');var f=el('i');f.style.width=Math.min(100,Math.max(0,Number(pct)||0))+'%';f.style.background=color;tr.appendChild(f);g.appendChild(tr);return g;}
+function chart(hist,key,label,color,max){var box=el('div','chart');box.appendChild(el('div','ct',label));var W=300,H=46;var svg=document.createElementNS(SVGNS,'svg');svg.setAttribute('viewBox','0 0 '+W+' '+H);svg.setAttribute('preserveAspectRatio','none');box.appendChild(svg);var n=hist.length;if(!n||n<2){box.appendChild(el('div','sub','collecting samples…'));return box;}var mx=max||maxOf(hist,key)||1;var line='';var area='0,'+H+' ';for(var i=0;i<n;i++){var v=Number(hist[i][key])||0;var x=(i/(n-1))*W;var y=H-(Math.min(v,mx)/mx)*H;line+=(i?' ':'')+x.toFixed(1)+','+y.toFixed(1);area+=x.toFixed(1)+','+y.toFixed(1)+' ';}area+=W+','+H;var pg=document.createElementNS(SVGNS,'polygon');pg.setAttribute('points',area);pg.setAttribute('fill',color);pg.setAttribute('opacity','0.12');var pl=document.createElementNS(SVGNS,'polyline');pl.setAttribute('points',line);pl.setAttribute('fill','none');pl.setAttribute('stroke',color);pl.setAttribute('stroke-width','1.6');svg.appendChild(pg);svg.appendChild(pl);var cap=el('div','sub');cap.textContent='now '+fmtPct(hist[n-1][key])+' · peak '+fmtPct(maxOf(hist,key))+' · scale '+round1(mx)+'%';box.appendChild(cap);return box;}
+function renderOs(sys){var box=document.getElementById('gauges');var ch=document.getElementById('charts');if(!box)return;box.textContent='';if(ch)ch.textContent='';if(!sys||!sys.system){box.appendChild(el('span','sub','OS telemetry unavailable'));return;}
+  var meta=document.getElementById('os-meta');if(meta)meta.textContent=sys.system.platform+'/'+sys.system.arch+' · '+sys.system.cores+' cores · '+sys.system.hostname;
+  var g=el('div','gauges');g.appendChild(gaugeCard('System CPU',sys.system.cpuPct,'var(--high)'));g.appendChild(gaugeCard('Memory',sys.system.memPct,'var(--info)'));g.appendChild(gaugeCard('Critic CPU',sys.self?sys.self.cpuPct:0,'var(--critic)'));box.appendChild(g);
+  var st=el('div','sub');st.textContent='Processes: '+sys.totals.procCount+' · Apps: '+sys.totals.appCount+' · RAM '+fmtBytes(sys.system.memUsed)+' / '+fmtBytes(sys.system.memTotal)+' · Critic RSS '+(sys.self?fmtBytes(sys.self.rss):'?')+' · uptime '+dur(sys.system.uptimeSec);box.appendChild(st);
+  if(ch){if(sys.history)ch.appendChild(chart(sys.history,'cpu','CPU %','var(--high)',100));if(sys.history)ch.appendChild(chart(sys.history,'mem','Memory %','var(--info)',100));if(sys.history)ch.appendChild(chart(sys.history,'selfCpu','Critic CPU %','var(--critic)',Math.max(40,maxOf(sys.history,'selfCpu'))));}
+}
+function th(label,key){var t=el('th','sortable'+(SORT===key?' act':''),label);if(key)t.onclick=function(){SORT=key;renderTasks(LASTSYS);};return t;}
+function renderTasks(sys){var box=document.getElementById('tasks');if(!box)return;box.textContent='';LASTSYS=sys;if(!sys||!sys.apps||!sys.apps.length){box.appendChild(el('p','sub',(sys&&sys.totals&&sys.totals.refreshing)?'sampling running processes…':'Per-app live tasks stream in here a few seconds after the dashboard starts.'));return;}
+  var maxcpu=1,maxmem=1;sys.apps.forEach(function(a){if(a.cpuPct>maxcpu)maxcpu=a.cpuPct;if(a.memBytes>maxmem)maxmem=a.memBytes;});
+  var rows=sys.apps.slice();if(SORT==='mem')rows.sort(function(a,b){return b.memBytes-a.memBytes;});else if(SORT==='name')rows.sort(function(a,b){return String(a.app).localeCompare(String(b.app));});else rows.sort(function(a,b){return b.cpuPct-a.cpuPct;});
+  var t=el('table');var thead=el('thead');var hr=el('tr');hr.appendChild(th('App / Process','name'));hr.appendChild(th('Category',''));hr.appendChild(th('Instances',''));hr.appendChild(th('CPU %','cpu'));hr.appendChild(th('Memory','mem'));thead.appendChild(hr);t.appendChild(thead);
+  var body=el('tbody');rows.forEach(function(a){var tr=el('tr');var nm=el('td');nm.appendChild(el('code',null,a.app));tr.appendChild(nm);tr.appendChild(el('td')).appendChild(el('span','tag c-'+a.category,a.category));tr.appendChild(el('td',null,String(a.count)));var cc=el('td');cc.appendChild(bar(a.cpuPct,maxcpu,'var(--high)',fmtPct(a.cpuPct)));tr.appendChild(cc);var mc=el('td');mc.appendChild(bar(a.memBytes,maxmem,'var(--info)',fmtBytes(a.memBytes)));tr.appendChild(mc);body.appendChild(tr);});
+  t.appendChild(body);box.appendChild(t);
+  var cats=Object.keys(sys.totals.byCategory||{});if(cats.length){var leg=el('div','sub');leg.style.marginTop='10px';leg.textContent='By category: '+cats.sort().map(function(k){return k+' ('+(sys.totals.byCategory[k].count)+' proc, '+fmtBytes(sys.totals.byCategory[k].memBytes)+')';}).join('  ·  ');box.appendChild(leg);}
+}
+function renderEta(e,d){var box=document.getElementById('eta');if(!box)return;box.textContent='';if(!e){box.appendChild(el('p','sub','Estimating expected completion…'));return;}LASTEST=e;if(e.passNo!==PASS.no){PASS.no=e.passNo;PASS.start=Date.now();}
+  var bb=el('div','eta-barbox');var b=el('div','eta-bar');b.id='eta-bar';if(e.complete)b.style.width='100%';bb.appendChild(b);box.appendChild(bb);
+  box.appendChild(el('div','eta-line',e.etaLabel||''));
+  var cnt=el('div','sub');cnt.id='eta-count';box.appendChild(cnt);
+  var g=el('div','grid2');
+  g.appendChild(kv('Scan rate',(e.scanRateFps||0)+' files/s'));
+  g.appendChild(kv('Lines/s',(e.linesPerSec||0).toLocaleString?String((e.linesPerSec||0).toLocaleString()):String(e.linesPerSec||0)));
+  g.appendChild(kv('Files scanned',String(e.filesTotal||0)));
+  g.appendChild(kv('Last pass',(e.lastPassMs||0)+' ms'));
+  g.appendChild(kv('Avg pass',(e.avgPassMs||0)+' ms'));
+  g.appendChild(kv('Passes','×'+(e.passNo||0)));
+  g.appendChild(kv('Time on task',dur(e.timeOnTaskSec)));
+  g.appendChild(kv('System load','×'+(e.loadFactor||1)));
+  g.appendChild(kv('Cores',String(e.cores||0)));
+  box.appendChild(g);tickEta();
+}
+function tickEta(){if(!LASTEST)return;var e=LASTEST;var b=document.getElementById('eta-bar');var c=document.getElementById('eta-count');var total=(e.estPassMs||0)/1000;if(e.complete){if(b)b.style.width='100%';if(c)c.textContent=(e.mode==='watch')?'idle — watching for your next edit':('done in ~'+round1(total)+'s');return;}var secs=(Date.now()-PASS.start)/1000;var pct=total>0?Math.min(100,(secs/total)*100):0;if(b)b.style.width=pct+'%';if(c)c.textContent='this pass: '+round1(secs)+'s / ~'+round1(total)+'s expected';}
 function render(d){
   document.getElementById('h-proj').textContent = '— ' + (d.project||'');
   var sub = (d.root||'') + '  ·  ' + (d.generatedAt? new Date(d.generatedAt).toLocaleString():'');
@@ -165,6 +250,8 @@ function render(d){
   else if(LIVE){ sub += '  ·  live pass #' + d.passNo + ' (+'+d.addedCount+' new / -'+d.resolvedCount+' fixed)'; }
   document.getElementById('h-sub').textContent = sub;
 
+  renderEta(d.estimate,d); renderOs(d.sys); renderTasks(d.sys);
+
   var v=document.getElementById('verdict'); v.textContent='';
   if(d.empty){ v.appendChild(el('span',null,'Analysis starting…')); return; }
   v.appendChild(el('span','pulse'));
@@ -209,6 +296,7 @@ function render(d){
 render(INITIAL);
 function offline(){ var v=document.getElementById('verdict'); if(v){ v.textContent=''; v.appendChild(el('span',null,'Dashboard disconnected - the critic watch process is no longer serving. Restart it to resume live updates.')); } }
 if(LIVE){ setInterval(function(){ fetch('/data',{cache:'no-store'}).then(function(r){return r.json();}).then(render).catch(offline); }, 1500); }
+setInterval(tickEta, 150);
 function esc(s){return String(s==null?'':s);}
 </script>
 </body></html>`;
@@ -239,7 +327,19 @@ function pickFreePort(base, span) {
 
 function writeStaticAndOpen(result, opts = {}) {
   try {
-    const data = buildSnapshot(result, opts.extra || {});
+    const cov = result.coverage || {};
+    let sys = null;
+    let estimate = null;
+    try {
+      sys = sysinfo.snapshotOnce((result.meta && result.meta.root) || process.cwd());
+      estimate = sysinfo.computeEstimate({
+        mode: 'review', passNo: 1,
+        lastPassMs: (result.meta && result.meta.durationMs) || 0,
+        filesTotal: cov.filesScanned || 0, totalLines: cov.totalLines || 0,
+        cores: sys.system.cores, cpuPct: sys.system.cpuPct,
+      });
+    } catch { /* OS probe is best-effort; the report still renders without it */ }
+    const data = buildSnapshot(result, Object.assign({ sys, estimate }, opts.extra || {}));
     const dir = path.join(os.tmpdir(), 'fullstack-critic');
     fs.mkdirSync(dir, { recursive: true });
     const stamp = data.generatedAt.replace(/[:.]/g, '-');
@@ -257,23 +357,60 @@ function writeStaticAndOpen(result, opts = {}) {
 
 function startLive(root, opts = {}) {
   let data = emptySnapshot(root);
+
+  // Live OS telemetry. The cheap system/self reading advances on a timer so the
+  // charts keep moving between HTTP polls; the expensive machine-wide process
+  // table refreshes async on its own slower cadence and never blocks requests.
+  const monitor = sysinfo.createMonitor(root);
+  const startedAt = Date.now();
+  const timing = { passNo: 0, lastPassMs: 0, durations: [] };
+  try { monitor.sample(); monitor.refresh(() => {}); } catch { /* best-effort */ }
+  const timers = [
+    setInterval(() => { try { monitor.sample(); } catch { /* ignore */ } }, 1200),
+    setInterval(() => { try { monitor.refresh(() => {}); } catch { /* ignore */ } }, 3500),
+  ];
+
+  function currentEstimate(sys) {
+    const cov = data.coverage || {};
+    try {
+      return sysinfo.computeEstimate({
+        mode: 'watch', passNo: timing.passNo, lastPassMs: timing.lastPassMs, durationsMs: timing.durations,
+        filesTotal: cov.filesScanned || 0, totalLines: cov.totalLines || 0,
+        cores: sys && sys.system ? sys.system.cores : undefined, cpuPct: sys && sys.system ? sys.system.cpuPct : null,
+        startedAt, now: Date.now(), debounceMs: opts.debounceMs,
+      });
+    } catch { return null; }
+  }
+
+  function withSys(d) {
+    let sys = null;
+    try { sys = monitor.sample(); } catch { /* ignore */ }
+    return Object.assign({}, d, { sys, estimate: currentEstimate(sys), startedAt, passNo: timing.passNo });
+  }
+
   const server = http.createServer((req, res) => {
     if (req.url === '/data') {
       res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
-      return res.end(JSON.stringify(data));
+      return res.end(JSON.stringify(withSys(data)));
+    }
+    if (req.url === '/sys') {
+      let sys = null; try { sys = monitor.sample(); } catch { /* ignore */ }
+      res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+      return res.end(JSON.stringify({ sys, estimate: currentEstimate(sys) }));
     }
     if (req.url === '/health') {
       res.writeHead(200, { 'content-type': 'application/json' });
       return res.end(JSON.stringify({ product: 'critic-ui', port: server.address() ? server.address().port : 0 }));
     }
     res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
-    res.end(renderHtml(data, { live: true }));
+    res.end(renderHtml(withSys(data), { live: true }));
   });
 
   return pickFreePort(opts.port).then((port) => {
-    if (!port) return null; // no free port in range → skip UI, never break the workflow
+    if (!port) { for (const t of timers) clearInterval(t); return null; } // no free port → skip UI, never break the workflow
     return new Promise((resolve) => {
       server.once('error', (e) => {
+        for (const t of timers) clearInterval(t);
         process.stderr.write(`critic UI server unavailable (${e.code || e.message}); watch continues without the dashboard.\n`);
         resolve(null);
       });
@@ -282,8 +419,17 @@ function startLive(root, opts = {}) {
         resolve({
           port: bound,
           url: `http://127.0.0.1:${bound}/`,
-          set: (r, extra) => { data = buildSnapshot(r, extra); },
-          close: () => { try { server.close(); } catch { /* already closed */ } },
+          set: (r, extra) => {
+            data = buildSnapshot(r, extra);
+            timing.passNo = (extra && extra.passNo) || timing.passNo + 1;
+            const d = (r.meta && r.meta.durationMs) || 0;
+            timing.lastPassMs = d;
+            if (d > 0) { timing.durations.push(d); if (timing.durations.length > 12) timing.durations.shift(); }
+          },
+          close: () => {
+            for (const t of timers) clearInterval(t);
+            try { server.close(); } catch { /* already closed */ }
+          },
         });
       });
       server.listen(port, '127.0.0.1');

package/tests/sysinfo.test.js

@@ -0,0 +1,121 @@
+'use strict';
+/**
+ * sysinfo unit tests — deliberately exercise the PURE, deterministic parts of the
+ * OS telemetry (grouping, CPU-delta, categorisation, ETA math) so they pass on
+ * any machine, plus a bounded check that the live process probe never throws.
+ */
+const test = require('node:test');
+const assert = require('node:assert');
+
+const sys = require('../src/sysinfo');
+
+test('classify() folds process names into structured categories', () => {
+  assert.strictEqual(sys.classify('node'), 'runtime');
+  assert.strictEqual(sys.classify('chrome'), 'browser');
+  assert.strictEqual(sys.classify('MicrosoftEdge'), 'browser');
+  assert.strictEqual(sys.classify('powershell'), 'terminal');
+  assert.strictEqual(sys.classify('Code'), 'editor');
+  assert.strictEqual(sys.classify('postgres'), 'database');
+  assert.strictEqual(sys.classify('com.docker.backend'), 'container');
+  assert.strictEqual(sys.classify('git'), 'vcs');
+  assert.strictEqual(sys.classify('svchost'), 'system');
+  assert.strictEqual(sys.classify('mystery-thing'), 'other');
+});
+
+test('toAppRows() computes real per-app CPU% from a sample delta', () => {
+  const procs = [
+    { pid: 1, name: 'node', cpuSec: 2, memBytes: 1000 },
+    { pid: 2, name: 'node', cpuSec: 1, memBytes: 500 },
+    { pid: 3, name: 'chrome', cpuSec: 0.5, memBytes: 4000 },
+  ];
+  // One second earlier: node pid1 used 1s CPU, pid2 1s, chrome 0.5s (no change).
+  const prev = new Map([
+    [1, { cpuSec: 1, ts: 0 }],
+    [2, { cpuSec: 1, ts: 0 }],
+    [3, { cpuSec: 0.5, ts: 0 }],
+  ]);
+  const { rows } = sys.toAppRows(procs, prev, 1000, /* cores */ 8);
+  const node = rows.find((r) => r.app === 'node');
+  const chrome = rows.find((r) => r.app === 'chrome');
+  assert.strictEqual(node.count, 2, 'two node processes folded into one app');
+  assert.ok(Math.abs(node.cpuPct - 100) < 1, 'pid1 grew 1 CPU-sec in 1 wall-sec = ~100% (pid2 flat)');
+  assert.strictEqual(chrome.cpuPct, 0, 'no CPU-sec delta → 0%');
+  assert.strictEqual(node.category, 'runtime');
+});
+
+test('toAppRows() uses ps instantaneous % on POSIX-style rows and clamps to cores', () => {
+  const procs = [{ pid: 9, name: 'python', memBytes: 10, cpuPctRaw: 1600 }]; // absurd value
+  const { rows } = sys.toAppRows(procs, null, 1000, /* cores */ 8);
+  assert.strictEqual(rows[0].cpuPct, 800, 'clamped to cores*100');
+});
+
+test('byCategory() aggregates counts and memory per category', () => {
+  const rows = [
+    { app: 'node', category: 'runtime', count: 2, cpuPct: 10, memBytes: 1000 },
+    { app: 'deno', category: 'runtime', count: 1, cpuPct: 5, memBytes: 1000 },
+    { app: 'chrome', category: 'browser', count: 4, cpuPct: 20, memBytes: 9999 },
+  ];
+  const by = sys.byCategory(rows);
+  assert.strictEqual(by.runtime.count, 3);
+  assert.strictEqual(by.runtime.apps, 2);
+  assert.strictEqual(by.browser.memBytes, 9999);
+});
+
+test('cpuPctFrom() turns two os.cpus() readings into a 0-100 percentage', () => {
+  const prev = [{ times: { user: 0, nice: 0, sys: 0, idle: 100, irq: 0 } }];
+  const cur = [{ times: { user: 50, nice: 0, sys: 0, idle: 150, irq: 0 } }];
+  assert.strictEqual(sys.cpuPctFrom(prev, cur), 50);
+  assert.strictEqual(sys.cpuPctFrom(null, cur), null, 'no previous reading → null (caller degrades)');
+});
+
+test('computeEstimate(): a finished review pass reports throughput + a completed ETA', () => {
+  const e = sys.computeEstimate({ mode: 'review', passNo: 1, lastPassMs: 420, filesTotal: 30, totalLines: 1500, cores: 8 });
+  assert.strictEqual(e.complete, true);
+  assert.match(e.etaLabel, /completed in/);
+  assert.ok(e.scanRateFps > 70 && e.scanRateFps < 72, 'files/sec from measured duration (' + e.scanRateFps + ')');
+  assert.strictEqual(e.lastPassMs, 420);
+});
+
+test('computeEstimate(): watch mode never claims completion and stretches under load', () => {
+  const calm = sys.computeEstimate({ mode: 'watch', passNo: 3, durationsMs: [200, 300, 400], filesTotal: 50, cores: 4, cpuPct: 20 });
+  assert.strictEqual(calm.complete, false);
+  assert.match(calm.etaLabel, /re-scan/);
+  assert.strictEqual(calm.avgPassMs, 300, 'rolling average of prior passes');
+  assert.strictEqual(calm.loadFactor, 1, 'no load penalty below 60% CPU');
+
+  const hot = sys.computeEstimate({ mode: 'watch', passNo: 3, durationsMs: [300], filesTotal: 50, cores: 4, cpuPct: 100 });
+  assert.strictEqual(hot.loadFactor, 1.4, 'ETA scales up under heavy system load');
+});
+
+test('systemStatic() / memInfo() always return sane, bounded numbers', () => {
+  const s = sys.systemStatic();
+  assert.ok(s.cores >= 1);
+  assert.ok(typeof s.platform === 'string' && s.platform.length);
+  const m = sys.memInfo();
+  assert.ok(m.memPct >= 0 && m.memPct <= 100, 'memory % bounded');
+  assert.ok(m.memUsed >= 0 && m.memUsed <= m.memTotal);
+});
+
+test('createMonitor().sample() advances a bounded rolling history', () => {
+  const mon = sys.createMonitor('.');
+  const a = mon.sample();
+  const b = mon.sample();
+  assert.ok(a.system.cpuPct >= 0 && a.system.cpuPct <= 100);
+  assert.ok(b.history.length >= a.history.length, 'each sample appends a point');
+  assert.ok(mon.historyLen <= 60, 'history capped');
+  assert.ok(a.self && typeof a.self.rss === 'number' && a.self.rss > 0, 'critic self memory is real');
+});
+
+test('processesAsync() resolves with an array and never throws (bounded, offline-safe)', (_t, done) => {
+  const to = setTimeout(() => assert.fail('processesAsync did not call back in 12s'), 12000);
+  sys.processesAsync((err, rows) => {
+    clearTimeout(to);
+    assert.ok(Array.isArray(rows) || err, 'either an array (possibly empty on a locked-down box) or an err');
+    if (Array.isArray(rows) && rows.length) {
+      const p = rows[0];
+      assert.ok(Number.isInteger(p.pid) && p.pid > 0, 'a process row has an integer pid');
+      assert.ok(typeof p.name === 'string' && p.name.length, 'and a name');
+    }
+    done();
+  });
+});