@nocville/npc 0.2.2 → 0.2.3

package/dist/cjs/npcs/log-watcher/index.js

@@ -1,49 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogWatcherNPC = void 0;
+const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const base_npc_js_1 = require("../../core/base-npc.js");
+const polling_npc_js_1 = require("../../core/polling-npc.js");
 const thresholds_js_1 = require("../../core/thresholds.js");
-const text_js_1 = require("../../core/text.js");
+const errors_js_1 = require("../../core/errors.js");
 const tail_js_1 = require("./tail.js");
 const buffer_js_1 = require("./buffer.js");
 const defaults_js_1 = require("./defaults.js");
-class LogWatcherNPC extends base_npc_js_1.BaseNPC {
+/** Lines shown on the log terminal, and their width. */
+const SCREEN_LINES = 12;
+const SCREEN_LINE_CHARS = 80;
+function compilePattern(flag, source) {
+    try {
+        return new RegExp(source);
+    }
+    catch (err) {
+        throw new errors_js_1.NpcConfigError(`${flag}: invalid regular expression (${err instanceof Error ? err.message : String(err)})`);
+    }
+}
+/** "45s", "5min", "1.5h" */
+function formatWindow(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.round((seconds / 60) * 10) / 10}min`;
+    return `${Math.round((seconds / 3600) * 10) / 10}h`;
+}
+/**
+ * Tails log files and reports error bursts. A periodic report (every
+ * `reportInterval`) carries the error count over the sliding window and the
+ * last lines for the log terminal; a fresh error line also triggers an
+ * immediate report, debounced to one per 5s, so a burst shows up at once.
+ * Every report is one composed push, never a push per line.
+ */
+class LogWatcherNPC extends polling_npc_js_1.PollingNPC {
     tailers = [];
-    timer = null;
-    entries = [];
+    counter;
     recentLines = [];
-    lastBurstPush = 0;
+    lastError = null;
+    /** The error line that triggered an immediate report, consumed by the next collect(). */
+    burstLine = null;
+    lastBurstAt = 0;
     errorRegex;
     warningRegex;
     windowMs;
-    errorWarn;
-    errorCrit;
-    reportInterval;
+    errorThreshold;
     files;
     constructor(config) {
-        super(config);
-        this.files = config.files;
-        this.errorRegex = new RegExp(config.errorPattern ?? defaults_js_1.DEFAULTS.errorPattern);
-        this.warningRegex = new RegExp(config.warningPattern ?? defaults_js_1.DEFAULTS.warningPattern);
-        this.windowMs = (config.windowSeconds ?? defaults_js_1.DEFAULTS.windowSeconds) * 1000;
-        this.errorWarn = config.errorWarn ?? defaults_js_1.DEFAULTS.errorWarn;
-        this.errorCrit = config.errorCrit ?? defaults_js_1.DEFAULTS.errorCrit;
-        this.reportInterval = config.reportInterval ?? defaults_js_1.DEFAULTS.reportInterval;
+        super({
+            ...config,
+            pollInterval: config.reportInterval ?? config.pollInterval ?? defaults_js_1.DEFAULTS.reportInterval,
+        });
+        this.files = [...new Set(config.files.map((f) => f.trim()).filter(Boolean))].map((f) => (0, node_path_1.resolve)(f));
+        if (this.files.length === 0) {
+            throw new errors_js_1.NpcConfigError('log-watcher needs at least one file (--files)');
+        }
+        this.errorRegex = compilePattern('--error-pattern', config.errorPattern ?? defaults_js_1.DEFAULTS.errorPattern);
+        this.warningRegex = compilePattern('--warning-pattern', config.warningPattern ?? defaults_js_1.DEFAULTS.warningPattern);
+        const windowSeconds = config.windowSeconds ?? defaults_js_1.DEFAULTS.windowSeconds;
+        if (!(windowSeconds > 0))
+            throw new errors_js_1.NpcConfigError('--window must be a positive number of seconds');
+        this.windowMs = windowSeconds * 1000;
+        this.counter = new buffer_js_1.WindowCounter(this.windowMs);
+        this.errorThreshold = {
+            warning: config.errorWarn ?? defaults_js_1.DEFAULTS.errorWarn,
+            critical: config.errorCrit ?? defaults_js_1.DEFAULTS.errorCrit,
+            direction: 'above',
+        };
+        const problem = (0, thresholds_js_1.thresholdProblem)('--error-warn/--error-crit', this.errorThreshold);
+        if (problem)
+            throw new errors_js_1.NpcConfigError(problem);
     }
     get name() {
         return 'log-watcher';
     }
     get defaultDisplayName() {
-        const first = this.files[0];
-        return first ? `Logs: ${(0, node_path_1.basename)(first)}` : 'Logs';
+        return `Logs: ${(0, node_path_1.basename)(this.files[0])}`;
     }
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get behavior() {
         return { idle: 'wander' };
     }
@@ -52,109 +90,77 @@ class LogWatcherNPC extends base_npc_js_1.BaseNPC {
             screenType: 'log-terminal',
             size: { w: 2, h: 2 },
             placement: 'adjacent-wall',
-            label: this.files[0] ? (0, node_path_1.basename)(this.files[0]) : 'log',
+            label: (0, node_path_1.basename)(this.files[0]),
         };
     }
     async onStart() {
         for (const filePath of this.files) {
-            this.logger.info(`Tailing ${filePath}`);
-            const tailer = (0, tail_js_1.createTailer)(filePath, (line) => {
-                this.handleLine(line);
-            });
-            this.tailers.push(tailer);
+            if ((0, node_fs_1.existsSync)(filePath)) {
+                this.logger.info(`Tailing ${filePath}`);
+            }
+            else {
+                this.logger.warn(`${filePath} does not exist yet; will tail it once it appears`);
+            }
+            this.tailers.push((0, tail_js_1.createTailer)(filePath, (line) => this.handleLine(line), {
+                onError: (err) => this.logger.warn(`Cannot read ${filePath}`, { error: err.message }),
+            }));
         }
-        // Report immediately, then on interval
-        await this.report();
-        this.timer = setInterval(() => {
-            void this.report();
-        }, this.reportInterval);
+        await super.onStart();
     }
     async onStop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        for (const tailer of this.tailers) {
+        for (const tailer of this.tailers)
             tailer.close();
-        }
         this.tailers = [];
+        await super.onStop();
     }
-    handleLine(line) {
-        const now = Date.now();
+    /** Visible for tests: feed one raw line as if a tailer had read it. */
+    handleLine(line, now = Date.now()) {
         const level = (0, buffer_js_1.classifyLine)(line, this.errorRegex, this.warningRegex);
-        // Ring buffer holds ALL lines (matched ones flagged) for the log TV.
-        (0, buffer_js_1.pushRecent)(this.recentLines, line, level);
-        if (level === 'error') {
-            this.entries.push({ timestamp: now, type: 'error', message: line });
-            this.onErrorBurst(line);
-        }
-        else if (level === 'warning') {
-            this.entries.push({ timestamp: now, type: 'warning', message: line });
-        }
-    }
-    /** A fresh error triggers an immediate push, debounced to at most once / 5s. */
-    onErrorBurst(line) {
-        const now = Date.now();
-        if (!(0, buffer_js_1.shouldEmitBurst)(this.lastBurstPush, now))
+        // The ring buffer holds ALL lines (matched ones flagged) for the log TV.
+        (0, buffer_js_1.pushRecent)(this.recentLines, (0, buffer_js_1.cleanLogLine)(line, SCREEN_LINE_CHARS), level, SCREEN_LINES);
+        if (level === 'info')
             return;
-        this.lastBurstPush = now;
-        void this.pushReport((0, text_js_1.truncate)(line, 200), 'error');
-    }
-    pruneWindow() {
-        const cutoff = Date.now() - this.windowMs;
-        this.entries = this.entries.filter((e) => e.timestamp >= cutoff);
-    }
-    async report() {
-        if (this.state !== 'running')
+        this.counter.add(level, now);
+        if (level !== 'error')
             return;
-        await this.pushReport();
+        const text = (0, buffer_js_1.cleanLogLine)(line);
+        this.lastError = { text, at: now };
+        if ((0, buffer_js_1.shouldEmitBurst)(this.lastBurstAt, now)) {
+            this.lastBurstAt = now;
+            this.burstLine = text;
+            this.collectNow();
+        }
     }
-    /**
-     * Build and push the current status. If `overrideMessage` is set (burst push),
-     * it drives the bubble and the status floors at warning.
-     */
-    async pushReport(overrideMessage, subStatus) {
-        if (this.state !== 'running')
-            return;
-        this.pruneWindow();
-        const errorCount = this.entries.filter((e) => e.type === 'error').length;
-        const warningCount = this.entries.filter((e) => e.type === 'warning').length;
-        const windowSeconds = this.windowMs / 1000;
-        let status = (0, thresholds_js_1.evaluateThreshold)(errorCount, {
-            warning: this.errorWarn,
-            critical: this.errorCrit,
-            direction: 'above',
-        });
-        if (overrideMessage)
+    async collect() {
+        const now = Date.now();
+        const { errors, warnings } = this.counter.counts(now);
+        const window = formatWindow(this.windowMs / 1000);
+        const burst = this.burstLine;
+        this.burstLine = null;
+        let status = (0, thresholds_js_1.evaluateThreshold)(errors, this.errorThreshold);
+        // A burst report drives the bubble with the error itself and floors at warning.
+        if (burst)
             status = (0, thresholds_js_1.worstStatus)([status, 'warning']);
-        const mood = status === 'critical' ? 'stressed' : status === 'warning' ? 'concerned' : 'happy';
-        const lastError = this.entries.filter((e) => e.type === 'error').at(-1);
-        const message = overrideMessage ??
-            (errorCount > 0
-                ? `${errorCount} error${errorCount !== 1 ? 's' : ''} in last ${windowSeconds / 60}min across ${this.files.length} file${this.files.length !== 1 ? 's' : ''}`
-                : `No errors in last ${windowSeconds / 60}min`);
-        const metrics = {
+        const fileCount = `${this.files.length} file${this.files.length !== 1 ? 's' : ''}`;
+        const message = burst ??
+            (errors > 0
+                ? `${errors} error${errors !== 1 ? 's' : ''} in last ${window} across ${fileCount}`
+                : `No errors in last ${window}`);
+        const lastErrorInWindow = this.lastError && now - this.lastError.at <= this.windowMs ? this.lastError.text : '';
+        return {
             status,
-            mood,
+            mood: (0, thresholds_js_1.moodForStatus)(status),
             message,
-            subStatus,
+            subStatus: burst ? 'error' : undefined,
             screenData: (0, buffer_js_1.buildLogScreen)(this.recentLines),
             metrics: {
-                error_count: errorCount,
-                warning_count: warningCount,
-                window_seconds: windowSeconds,
+                error_count: errors,
+                warning_count: warnings,
+                window_seconds: this.windowMs / 1000,
                 files_watched: this.files.length,
-                last_error_message: lastError?.message ?? '',
+                last_error_message: lastErrorInWindow,
             },
         };
-        try {
-            await this.pushMetrics(metrics);
-        }
-        catch (err) {
-            this.logger.error('Failed to push metrics', {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
     }
 }
 exports.LogWatcherNPC = LogWatcherNPC;

package/dist/cjs/npcs/log-watcher/tail.js

@@ -2,79 +2,126 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTailer = createTailer;
 const node_fs_1 = require("node:fs");
-const node_readline_1 = require("node:readline");
+const node_string_decoder_1 = require("node:string_decoder");
+const DEFAULTS = {
+    pollMs: 1000,
+    maxLineChars: 16 * 1024,
+    maxReadBytes: 1024 * 1024,
+    maxBacklogBytes: 8 * 1024 * 1024,
+};
+function isNotFound(err) {
+    return err?.code === 'ENOENT';
+}
 /**
- * Tail a file by watching for changes and reading new lines from the last
- * known byte offset. Handles file rotation (size shrinks -> reset to 0).
+ * Follow a growing file like `tail -F`: emit each complete new line, starting
+ * from the end of the file as it is now (or from the start of a file created
+ * later).
+ *
+ * Polls with `stat` instead of `fs.watch`: watchers follow the inode, so they
+ * go deaf after logrotate's rename-and-recreate, and they throw for files that
+ * don't exist yet. Rotation (new inode) and truncation (size shrinks) restart
+ * from offset 0. Reads are bounded per poll, a partial last line is held until
+ * its newline arrives, over-long lines are cut, and a backlog beyond
+ * `maxBacklogBytes` (a runaway logger) is skipped so the watcher stays current.
  */
-function createTailer(filePath, onLine) {
+function createTailer(filePath, onLine, options = {}) {
+    const opts = { ...DEFAULTS, ...options };
     let offset = 0;
-    let reading = false;
-    let watcher = null;
+    let inode = null;
+    let partial = '';
+    let decoder = new node_string_decoder_1.StringDecoder('utf8');
+    let busy = false;
     let closed = false;
-    async function init() {
-        // Start at the end of the file so we only read new lines
+    /** False until the first successful stat (or ENOENT) fixes the starting offset. */
+    let started = false;
+    let lastError = '';
+    const reset = () => {
+        offset = 0;
+        partial = '';
+        decoder = new node_string_decoder_1.StringDecoder('utf8');
+    };
+    const reportError = (err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (error.message === lastError)
+            return;
+        lastError = error.message;
+        opts.onError?.(error);
+    };
+    const emitText = (text) => {
+        const pieces = (partial + text).split('\n');
+        partial = pieces.pop().slice(0, opts.maxLineChars);
+        for (const piece of pieces) {
+            if (closed)
+                return;
+            onLine(piece.replace(/\r$/, '').slice(0, opts.maxLineChars));
+        }
+    };
+    async function readNew(size) {
+        if (size - offset > opts.maxBacklogBytes) {
+            // Too far behind: jump to the newest data rather than lag forever.
+            offset = size - opts.maxReadBytes;
+            partial = '';
+            decoder = new node_string_decoder_1.StringDecoder('utf8');
+        }
+        const length = Math.min(size - offset, opts.maxReadBytes);
+        const handle = await node_fs_1.promises.open(filePath, 'r');
         try {
-            const stats = await node_fs_1.promises.stat(filePath);
-            offset = stats.size;
+            const buf = Buffer.alloc(length);
+            const { bytesRead } = await handle.read(buf, 0, length, offset);
+            offset += bytesRead;
+            emitText(decoder.write(buf.subarray(0, bytesRead)));
         }
-        catch {
-            // File may not exist yet; start at 0
-            offset = 0;
+        finally {
+            await handle.close();
         }
-        watcher = (0, node_fs_1.watch)(filePath, () => {
-            if (!closed) {
-                void readNewLines();
-            }
-        });
-        // Ignore watcher errors (e.g. file deleted then recreated)
-        watcher.on('error', () => { });
     }
-    async function readNewLines() {
-        if (reading || closed)
+    async function poll() {
+        if (busy || closed)
             return;
-        reading = true;
+        busy = true;
         try {
-            const stats = await node_fs_1.promises.stat(filePath);
-            // File rotation detected: size smaller than our offset
-            if (stats.size < offset) {
-                offset = 0;
-            }
-            // Nothing new to read
-            if (stats.size === offset) {
-                reading = false;
+            const st = await node_fs_1.promises.stat(filePath);
+            if (!started) {
+                // Start at the current end of the file so only new lines are reported.
+                started = true;
+                inode = st.ino;
+                offset = st.size;
+                lastError = '';
                 return;
             }
-            const stream = (0, node_fs_1.createReadStream)(filePath, {
-                start: offset,
-                encoding: 'utf-8',
-            });
-            const rl = (0, node_readline_1.createInterface)({ input: stream, crlfDelay: Infinity });
-            let bytesRead = 0;
-            for await (const line of rl) {
-                if (closed)
-                    break;
-                // Account for line content + newline character
-                bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
-                onLine(line);
-            }
-            offset += bytesRead;
+            if (inode !== null && st.ino !== inode)
+                reset(); // rotated: a new file took the name
+            inode = st.ino;
+            if (st.size < offset)
+                reset(); // truncated in place
+            if (st.size > offset)
+                await readNew(st.size);
+            lastError = '';
         }
-        catch {
-            // File may have been removed; ignore and wait for next change
+        catch (err) {
+            if (isNotFound(err)) {
+                started = true;
+                // Rotated away and not yet recreated (or never created): start the
+                // replacement from its first byte.
+                if (inode !== null)
+                    reportError(new Error(`${filePath} disappeared; waiting for it`));
+                inode = null;
+                reset();
+            }
+            else {
+                reportError(err);
+            }
         }
         finally {
-            reading = false;
+            busy = false;
         }
     }
-    void init();
+    const timer = setInterval(() => void poll(), opts.pollMs);
+    void poll();
     return {
         close() {
             closed = true;
-            if (watcher) {
-                watcher.close();
-                watcher = null;
-            }
+            clearInterval(timer);
         },
     };
 }

package/dist/cjs/npcs/process-watcher/index.js

@@ -4,6 +4,7 @@ exports.ProcessWatcherNPC = void 0;
 const polling_npc_js_1 = require("../../core/polling-npc.js");
 const thresholds_js_1 = require("../../core/thresholds.js");
 const screen_js_1 = require("../../core/screen.js");
+const errors_js_1 = require("../../core/errors.js");
 const process_scanner_js_1 = require("./process-scanner.js");
 const defaults_js_1 = require("./defaults.js");
 /** Max per-process panels on the companion dashboard. */
@@ -15,14 +16,17 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
     cpuHistories = new Map();
     previousRunning = null;
     constructor(config) {
-        if (process.platform === 'win32') {
-            throw new Error('process-watcher is not supported on Windows (relies on the POSIX `ps` command). ' +
-                'Run it under WSL/Linux, or use system-monitor instead.');
-        }
+        (0, errors_js_1.assertPosix)('process-watcher', 'It relies on the POSIX `ps` command; run it under WSL/Linux, or use system-monitor instead.');
         super(config);
-        this.processes = config.processes;
+        this.processes = [...new Set(config.processes.map((p) => p.trim()).filter(Boolean))];
+        if (this.processes.length === 0) {
+            throw new errors_js_1.NpcConfigError('process-watcher needs at least one process name (--processes)');
+        }
         this.cpuWarn = config.cpuWarn ?? defaults_js_1.DEFAULTS.cpuWarn;
         this.memWarn = config.memWarn ?? defaults_js_1.DEFAULTS.memWarn;
+        if (!(this.cpuWarn > 0) || !(this.memWarn > 0)) {
+            throw new errors_js_1.NpcConfigError('--cpu-warn and --mem-warn must be positive numbers');
+        }
     }
     get name() {
         return 'process-watcher';
@@ -33,9 +37,6 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get companion() {
         return {
             screenType: 'dashboard-wall',
@@ -45,22 +46,28 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
         };
     }
     async collect() {
-        const infos = await (0, process_scanner_js_1.scanProcesses)(this.processes);
+        let infos;
+        try {
+            infos = await (0, process_scanner_js_1.scanProcesses)(this.processes);
+        }
+        catch (err) {
+            // Not knowing is different from "everything died": report unknown and
+            // leave the transition baseline alone so recovery doesn't say "is back".
+            return this.scanFailed(err);
+        }
         const statuses = [];
-        const messageParts = [];
+        const problems = [];
         const metrics = {};
         const panels = [];
         let totalRunning = 0;
-        let totalMissing = 0;
         for (const info of infos) {
             const safeKey = info.name.replace(/[^a-zA-Z0-9_]/g, '_');
             if (!info.running) {
                 statuses.push('critical');
-                messageParts.push(`${info.name}: NOT FOUND`);
+                problems.push(`${info.name} DOWN`);
                 metrics[`${safeKey}_running`] = 0;
                 metrics[`${safeKey}_cpu`] = 0;
                 metrics[`${safeKey}_mem_mb`] = 0;
-                totalMissing++;
                 if (panels.length < MAX_PANELS) {
                     panels.push({ label: info.name, value: 'DOWN', color: 'red' });
                 }
@@ -68,73 +75,76 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
             }
             totalRunning++;
             const cpu = info.cpuPercent ?? 0;
+            const memMb = info.memMb ?? 0;
             metrics[`${safeKey}_running`] = 1;
             metrics[`${safeKey}_cpu`] = cpu;
-            metrics[`${safeKey}_mem_mb`] = info.memMb ?? 0;
+            metrics[`${safeKey}_mem_mb`] = memMb;
             const history = this.cpuHistories.get(info.name) ?? [];
             (0, screen_js_1.pushHistory)(history, cpu);
             this.cpuHistories.set(info.name, history);
-            const cpuHigh = cpu >= this.cpuWarn;
-            const memHigh = (info.memMb ?? 0) >= this.memWarn;
-            if (cpuHigh || memHigh) {
-                statuses.push('warning');
-                const warnings = [];
-                if (cpuHigh)
-                    warnings.push(`cpu=${cpu}%`);
-                if (memHigh)
-                    warnings.push(`mem=${info.memMb}MB`);
-                messageParts.push(`${info.name}: WARN (${warnings.join(', ')})`);
-            }
-            else {
-                statuses.push('healthy');
-                messageParts.push(`${info.name}: OK`);
+            // Single warning thresholds: no critical level for resource use.
+            const cpuStatus = (0, thresholds_js_1.evaluateThreshold)(cpu, { warning: this.cpuWarn, critical: Infinity });
+            const memStatus = (0, thresholds_js_1.evaluateThreshold)(memMb, { warning: this.memWarn, critical: Infinity });
+            const status = (0, thresholds_js_1.worstStatus)([cpuStatus, memStatus]);
+            statuses.push(status);
+            if (status !== 'healthy') {
+                const high = [];
+                if (cpuStatus !== 'healthy')
+                    high.push(`cpu ${cpu}%`);
+                if (memStatus !== 'healthy')
+                    high.push(`mem ${Math.round(memMb)}MB`);
+                problems.push(`${info.name} high ${high.join(', ')}`);
             }
             if (panels.length < MAX_PANELS) {
                 panels.push({
                     label: info.name,
                     value: `${cpu}%`,
-                    color: cpuHigh || memHigh ? 'amber' : 'green',
+                    color: (0, screen_js_1.statusColor)(status),
                     sparkline: [...history],
                 });
             }
         }
+        const totalMissing = infos.length - totalRunning;
         metrics['total_watched'] = this.processes.length;
         metrics['total_running'] = totalRunning;
         metrics['total_missing'] = totalMissing;
         // Transition speech: compare the running set to last poll's. On the first
         // poll we only seed the set (no bogus "is back" for already-running procs).
         const currentRunning = new Set(infos.filter((i) => i.running).map((i) => i.name));
-        let transitions = [];
-        if (this.previousRunning !== null) {
-            transitions = (0, process_scanner_js_1.detectTransitions)(this.previousRunning, currentRunning);
-        }
+        const transitions = this.previousRunning === null ? [] : (0, process_scanner_js_1.detectTransitions)(this.previousRunning, currentRunning);
         this.previousRunning = currentRunning;
         const status = (0, thresholds_js_1.worstStatus)(statuses);
-        const mood = deriveMood(status);
-        // A death message takes over the bubble this cycle so it reads as an alert.
-        const message = transitions.length > 0 ? transitions.join(' · ') : messageParts.join(' | ');
-        const screenData = { layout: 'multi-metric', values: panels };
+        const summary = problems.length === 0
+            ? `All ${infos.length} running`
+            : `${totalRunning}/${infos.length} running · ${problems.join(' · ')}`;
+        // A death/return takes over the bubble this cycle so it reads as an alert.
+        const message = transitions.length > 0 ? transitions.join(' · ') : summary;
         return {
             status,
-            mood,
+            mood: (0, thresholds_js_1.moodForStatus)(status),
             message,
             subStatus: totalMissing > 0 ? 'process-down' : undefined,
-            screenData,
+            screenData: { layout: 'multi-metric', values: panels },
             metrics,
         };
     }
-}
-exports.ProcessWatcherNPC = ProcessWatcherNPC;
-function deriveMood(status) {
-    switch (status) {
-        case 'healthy':
-            return 'happy';
-        case 'warning':
-            return 'concerned';
-        case 'critical':
-            return 'stressed';
-        default:
-            return 'idle';
+    scanFailed(err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        this.logger.warn('Cannot list processes', { error: reason });
+        return {
+            status: 'unknown',
+            mood: (0, thresholds_js_1.moodForStatus)('unknown'),
+            message: 'Cannot list processes (ps failed)',
+            subStatus: 'scan-failed',
+            screenData: {
+                layout: 'multi-metric',
+                values: this.processes
+                    .slice(0, MAX_PANELS)
+                    .map((name) => ({ label: name, value: '?', color: 'gray' })),
+            },
+            metrics: { total_watched: this.processes.length },
+        };
     }
 }
+exports.ProcessWatcherNPC = ProcessWatcherNPC;
 //# sourceMappingURL=index.js.map