@nocville/npc 0.2.2 → 0.3.0

package/dist/npcs/receptionist/index.js

@@ -1,22 +1,7 @@
 import { PollingNPC } from '../../core/polling-npc.js';
-import { DEFAULTS } from './defaults.js';
-import { fetchWeather, geocodeLocation, autoGeo, formatClock, toFahrenheit } from './weather.js';
 export class ReceptionistNPC extends PollingNPC {
-    explicitCoords;
-    location;
-    fahrenheit;
-    coords = null;
-    geoAttempted = false;
-    weather = null;
-    lastWeatherFetch = 0;
     constructor(config) {
-        super({ ...config, pollInterval: config.pollInterval ?? DEFAULTS.pollInterval });
-        this.explicitCoords =
-            config.lat !== undefined && config.lon !== undefined
-                ? { lat: config.lat, lon: config.lon }
-                : null;
-        this.location = config.location;
-        this.fahrenheit = config.fahrenheit ?? false;
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
     }
     get name() {
         return 'receptionist';
@@ -29,88 +14,16 @@ export class ReceptionistNPC extends PollingNPC {
     }
     get behavior() {
         return {
+            role: 'receptionist',
+            activity: 'idle',
             greetPlayers: true,
-            patrol: { everyMinutes: [15, 30], stops: 5 },
             idle: 'stay',
-            home: { near: 'entrance' },
-        };
-    }
-    get companion() {
-        return {
-            screenType: 'welcome-sign',
-            size: { w: 2, h: 1 },
-            placement: 'adjacent-wall',
-            label: 'Welcome',
+            idlePose: 'sit',
         };
     }
     async collect() {
-        await this.refreshWeather();
-        const now = new Date();
-        const { day, date, time } = formatClock(now);
-        const values = [
-            { label: 'time', value: time },
-            { label: 'day', value: day },
-            { label: 'date', value: date },
-        ];
-        let message = `${day} ${time}`;
-        const metrics = { weather_ok: this.weather ? 1 : 0 };
-        if (this.weather) {
-            const temp = this.fahrenheit
-                ? `${toFahrenheit(this.weather.tempC)}°F`
-                : `${this.weather.tempC}°C`;
-            message += ` • ${temp} ${this.weather.text}`;
-            values.push({ label: 'temp', value: temp }, { label: 'condition', value: this.weather.text }, { label: 'icon', value: this.weather.icon });
-            metrics['temp_c'] = this.weather.tempC;
-            metrics['weather_code'] = this.weather.code;
-            metrics['wind_kph'] = this.weather.windKph;
-        }
-        // The receptionist is a greeter/clock — it stays healthy even when weather
-        // is unavailable (degraded time-only mode).
-        return {
-            status: 'healthy',
-            mood: 'happy',
-            message,
-            screenData: { layout: 'welcome-sign', values },
-            metrics,
-        };
-    }
-    async refreshWeather() {
-        if (!this.coords) {
-            await this.resolveCoords();
-        }
-        if (!this.coords)
-            return;
-        const now = Date.now();
-        if (this.weather && now - this.lastWeatherFetch < DEFAULTS.weatherRefreshMs)
-            return;
-        const w = await fetchWeather(this.coords, DEFAULTS.fetchTimeoutMs);
-        if (w) {
-            this.weather = w;
-            this.lastWeatherFetch = now;
-        }
-    }
-    async resolveCoords() {
-        if (this.explicitCoords) {
-            this.coords = this.explicitCoords;
-            return;
-        }
-        // Only attempt geocoding/geo-IP once per (failed) resolution to avoid
-        // hammering the keyless endpoints every poll.
-        if (this.geoAttempted)
-            return;
-        this.geoAttempted = true;
-        if (this.location) {
-            this.coords = await geocodeLocation(this.location, DEFAULTS.fetchTimeoutMs);
-            if (this.coords)
-                return;
-            this.logger.warn(`Could not geocode "${this.location}", falling back to IP geo`);
-        }
-        this.coords = await autoGeo(DEFAULTS.fetchTimeoutMs);
-        if (!this.coords) {
-            this.logger.warn('Weather geo unavailable — running in time-only mode');
-            // Allow a later retry.
-            this.geoAttempted = false;
-        }
+        // The server handles conversation and movement. Heartbeats stay quiet.
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/npcs/receptionist/weather.d.ts

@@ -1,8 +1,3 @@
-/**
- * Keyless weather + geolocation via open-meteo, with ipapi.co IP fallback.
- * All network helpers return null on failure so the receptionist can degrade
- * to a time-only mode without erroring.
- */
 export interface Coords {
     lat: number;
     lon: number;
@@ -20,9 +15,16 @@ export declare function describeWmo(code: number): {
     text: string;
     icon: string;
 };
+/** A finite, in-range latitude/longitude pair. */
+export declare function validCoords(lat: unknown, lon: unknown): boolean;
 /** Resolve a place name to coordinates via the open-meteo geocoding API. */
 export declare function geocodeLocation(name: string, timeoutMs?: number): Promise<Coords | null>;
-/** Best-effort IP geolocation via ipapi.co (keyless). */
+/**
+ * Best-effort IP geolocation via ipapi.co (keyless). This sends the machine's
+ * public IP to a third party, so the receptionist only calls it when no place
+ * was configured and the user hasn't opted out. Only the coordinates are used;
+ * nothing from the response is pushed to Nocville.
+ */
 export declare function autoGeo(timeoutMs?: number): Promise<Coords | null>;
 /** Fetch current temperature, weather code, and wind for coordinates. */
 export declare function fetchWeather(coords: Coords, timeoutMs?: number): Promise<Weather | null>;

package/dist/npcs/receptionist/weather.js

@@ -1,8 +1,11 @@
 /**
- * Keyless weather + geolocation via open-meteo, with ipapi.co IP fallback.
- * All network helpers return null on failure so the receptionist can degrade
- * to a time-only mode without erroring.
+ * Keyless weather + geolocation via open-meteo, with an optional ipapi.co IP
+ * fallback. Every call is time- and size-bounded, validates the (untrusted)
+ * response, and returns null on failure so the receptionist can degrade to a
+ * time-only mode without erroring.
  */
+import { asRecord, fetchJson, finiteNumber } from '../../core/http.js';
+import { sanitizeText } from '../../core/text.js';
 // WMO weather-interpretation codes → human text + a glyph keyword the
 // welcome-sign renderer understands (matched by /sun|clear|partly|rain|snow|storm|fog/).
 const WMO = {
@@ -39,65 +42,56 @@ const WMO = {
 export function describeWmo(code) {
     return WMO[code] ?? { text: 'Unknown', icon: 'cloud' };
 }
-async function fetchJson(url, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const res = await fetch(url, {
-            signal: controller.signal,
-            headers: { 'User-Agent': 'nocville-npc' },
-        });
-        if (!res.ok)
-            return null;
-        return (await res.json());
-    }
-    catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timer);
-    }
+/** A finite, in-range latitude/longitude pair. */
+export function validCoords(lat, lon) {
+    const la = finiteNumber(lat);
+    const lo = finiteNumber(lon);
+    return la !== null && lo !== null && Math.abs(la) <= 90 && Math.abs(lo) <= 180;
 }
-/** Resolve a place name to coordinates via the open-meteo geocoding API. */
-export async function geocodeLocation(name, timeoutMs = 5000) {
-    const url = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(name)}&count=1`;
-    const res = await fetchJson(url, timeoutMs);
-    const first = res?.['results']?.[0];
-    if (!first || typeof first['latitude'] !== 'number')
+function coordsFrom(rec, labelKey) {
+    if (!validCoords(rec['latitude'], rec['longitude']))
         return null;
+    const label = rec[labelKey];
     return {
-        lat: first['latitude'],
-        lon: first['longitude'],
-        label: first['name'] ?? name,
+        lat: rec['latitude'],
+        lon: rec['longitude'],
+        label: typeof label === 'string' ? sanitizeText(label, 60) : undefined,
     };
 }
-/** Best-effort IP geolocation via ipapi.co (keyless). */
+/** Resolve a place name to coordinates via the open-meteo geocoding API. */
+export async function geocodeLocation(name, timeoutMs = 5000) {
+    const url = 'https://geocoding-api.open-meteo.com/v1/search' +
+        `?name=${encodeURIComponent(name.slice(0, 100))}&count=1`;
+    const results = asRecord(await fetchJson(url, { timeoutMs }))?.['results'];
+    const first = Array.isArray(results) ? asRecord(results[0]) : null;
+    return first ? coordsFrom(first, 'name') : null;
+}
+/**
+ * Best-effort IP geolocation via ipapi.co (keyless). This sends the machine's
+ * public IP to a third party, so the receptionist only calls it when no place
+ * was configured and the user hasn't opted out. Only the coordinates are used;
+ * nothing from the response is pushed to Nocville.
+ */
 export async function autoGeo(timeoutMs = 5000) {
-    const res = await fetchJson('https://ipapi.co/json/', timeoutMs);
-    if (!res || typeof res['latitude'] !== 'number')
-        return null;
-    return {
-        lat: res['latitude'],
-        lon: res['longitude'],
-        label: res['city'],
-    };
+    const res = asRecord(await fetchJson('https://ipapi.co/json/', { timeoutMs }));
+    return res ? coordsFrom(res, 'city') : null;
 }
 /** Fetch current temperature, weather code, and wind for coordinates. */
 export async function fetchWeather(coords, timeoutMs = 5000) {
     const url = `https://api.open-meteo.com/v1/forecast?latitude=${coords.lat}` +
         `&longitude=${coords.lon}&current=temperature_2m,weather_code,wind_speed_10m`;
-    const res = await fetchJson(url, timeoutMs);
-    const cur = res?.['current'];
-    if (!cur || typeof cur['temperature_2m'] !== 'number')
+    const cur = asRecord(asRecord(await fetchJson(url, { timeoutMs }))?.['current']);
+    const temp = finiteNumber(cur?.['temperature_2m']);
+    if (!cur || temp === null || Math.abs(temp) > 100)
         return null;
-    const code = Number(cur['weather_code'] ?? 0);
+    const code = finiteNumber(cur['weather_code']) ?? -1;
     const { text, icon } = describeWmo(code);
     return {
-        tempC: Math.round(cur['temperature_2m']),
+        tempC: Math.round(temp),
         code,
         text,
         icon,
-        windKph: Math.round(Number(cur['wind_speed_10m'] ?? 0)),
+        windKph: Math.round(Math.max(0, finiteNumber(cur['wind_speed_10m']) ?? 0)),
     };
 }
 /** Convert Celsius to Fahrenheit, rounded. */

package/dist/npcs/security/index.d.ts

@@ -0,0 +1,12 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import type { PollingNpcConfig } from '../../core/polling-npc.js';
+import type { CollectedMetrics, Archetype, BehaviorHints } from '../../core/types.js';
+export declare class SecurityNPC extends PollingNPC {
+    constructor(config: PollingNpcConfig);
+    get name(): string;
+    protected get defaultDisplayName(): string;
+    get archetype(): Archetype;
+    get behavior(): BehaviorHints;
+    protected collect(): Promise<CollectedMetrics>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/npcs/security/index.js

@@ -0,0 +1,22 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+export class SecurityNPC extends PollingNPC {
+    constructor(config) {
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
+    }
+    get name() {
+        return 'security';
+    }
+    get defaultDisplayName() {
+        return 'Security';
+    }
+    get archetype() {
+        return 'custom';
+    }
+    get behavior() {
+        return { role: 'security', activity: 'idle', idlePose: 'stand' };
+    }
+    async collect() {
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/npcs/system-monitor/collectors.d.ts

@@ -34,11 +34,23 @@ export declare function createCpuSampler(readCpus?: () => Array<{
     times: CpuTimes;
 }>, readLoad?: () => number): CpuSampler;
 /**
- * Collect memory usage from OS.
+ * Parse `vm_stat` output into reclaimable ("available") bytes: free +
+ * inactive + speculative pages, the same estimate psutil uses on macOS.
+ * Returns null when the output is unrecognised.
  */
-export declare function collectMemory(): MemMetrics;
+export declare function parseVmStat(stdout: string): number | null;
 /**
- * Collect disk usage via fs.statfs (Node 18.15+).
+ * Bytes of memory available to new work. On macOS `os.freemem()` counts only
+ * never-used pages (the file cache is "used"), which reads ~95% full on any
+ * healthy Mac, so the reclaimable estimate comes from `vm_stat` instead. Linux
+ * (`MemAvailable`) and Windows report a meaningful value through Node.
+ */
+export declare function readAvailableMemory(): Promise<number>;
+/** Memory usage from the total and the available byte count. */
+export declare function collectMemory(availableBytes?: number, totalBytes?: number): MemMetrics;
+/**
+ * Disk usage via fs.statfs, computed like `df`: used / (used + available to
+ * unprivileged users), so blocks reserved for root don't hide a full disk.
  */
 export declare function collectDisk(path: string): Promise<DiskMetrics>;
 export {};

package/dist/npcs/system-monitor/collectors.js

@@ -1,5 +1,8 @@
 import os from 'node:os';
 import { promises as fsp } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
 function aggregate(cpus) {
     let idle = 0;
     let total = 0;
@@ -10,6 +13,12 @@ function aggregate(cpus) {
     }
     return { idle, total };
 }
+function gb(bytes) {
+    return Math.round((bytes / 1024 ** 3) * 100) / 100;
+}
+function percentOf(part, whole) {
+    return whole > 0 ? Math.min(100, Math.max(0, Math.round((part / whole) * 100))) : 0;
+}
 /**
  * Stateful CPU sampler that computes usage from the delta between consecutive
  * `os.cpus()` snapshots — no blocking sleep. The first sample reports usage
@@ -27,34 +36,72 @@ export function createCpuSampler(readCpus = () => os.cpus(), readLoad = () => os
             const idleDiff = cur.idle - base.idle;
             const totalDiff = cur.total - base.total;
             prev = cur;
-            const percent = totalDiff > 0 ? Math.round((1 - idleDiff / totalDiff) * 100) : 0;
+            const percent = totalDiff > 0 ? percentOf(totalDiff - idleDiff, totalDiff) : 0;
             return { percent, loadAvg1m };
         },
     };
 }
 /**
- * Collect memory usage from OS.
+ * Parse `vm_stat` output into reclaimable ("available") bytes: free +
+ * inactive + speculative pages, the same estimate psutil uses on macOS.
+ * Returns null when the output is unrecognised.
+ */
+export function parseVmStat(stdout) {
+    const pageSize = Number(stdout.match(/page size of (\d+) bytes/)?.[1]);
+    if (!Number.isFinite(pageSize) || pageSize <= 0)
+        return null;
+    const pages = (label) => {
+        const m = stdout.match(new RegExp(`^Pages ${label}:\\s+(\\d+)`, 'm'));
+        return m ? Number(m[1]) : null;
+    };
+    const free = pages('free');
+    const inactive = pages('inactive');
+    if (free === null || inactive === null)
+        return null;
+    return (free + inactive + (pages('speculative') ?? 0)) * pageSize;
+}
+/**
+ * Bytes of memory available to new work. On macOS `os.freemem()` counts only
+ * never-used pages (the file cache is "used"), which reads ~95% full on any
+ * healthy Mac, so the reclaimable estimate comes from `vm_stat` instead. Linux
+ * (`MemAvailable`) and Windows report a meaningful value through Node.
  */
-export function collectMemory() {
-    const totalBytes = os.totalmem();
-    const freeBytes = os.freemem();
-    const usedBytes = totalBytes - freeBytes;
-    const totalGb = Math.round((totalBytes / 1024 ** 3) * 100) / 100;
-    const usedGb = Math.round((usedBytes / 1024 ** 3) * 100) / 100;
-    const percent = Math.round((usedBytes / totalBytes) * 100);
-    return { percent, usedGb, totalGb };
+export async function readAvailableMemory() {
+    if (process.platform === 'darwin') {
+        try {
+            const { stdout } = await execFileAsync('vm_stat', [], { timeout: 2000 });
+            const available = parseVmStat(stdout);
+            if (available !== null)
+                return Math.min(available, os.totalmem());
+        }
+        catch {
+            // Fall through to Node's figure.
+        }
+    }
+    return os.freemem();
+}
+/** Memory usage from the total and the available byte count. */
+export function collectMemory(availableBytes = os.freemem(), totalBytes = os.totalmem()) {
+    const usedBytes = Math.max(0, totalBytes - availableBytes);
+    return {
+        percent: percentOf(usedBytes, totalBytes),
+        usedGb: gb(usedBytes),
+        totalGb: gb(totalBytes),
+    };
 }
 /**
- * Collect disk usage via fs.statfs (Node 18.15+).
+ * Disk usage via fs.statfs, computed like `df`: used / (used + available to
+ * unprivileged users), so blocks reserved for root don't hide a full disk.
  */
 export async function collectDisk(path) {
     const stats = await fsp.statfs(path);
     const totalBytes = stats.blocks * stats.bsize;
-    const freeBytes = stats.bavail * stats.bsize;
-    const usedBytes = totalBytes - freeBytes;
-    const totalGb = Math.round((totalBytes / 1024 ** 3) * 100) / 100;
-    const usedGb = Math.round((usedBytes / 1024 ** 3) * 100) / 100;
-    const percent = totalBytes > 0 ? Math.round((usedBytes / totalBytes) * 100) : 0;
-    return { percent, usedGb, totalGb };
+    const usedBytes = (stats.blocks - stats.bfree) * stats.bsize;
+    const availBytes = stats.bavail * stats.bsize;
+    return {
+        percent: percentOf(usedBytes, usedBytes + availBytes),
+        usedGb: gb(usedBytes),
+        totalGb: gb(totalBytes),
+    };
 }
 //# sourceMappingURL=collectors.js.map

package/dist/npcs/system-monitor/defaults.d.ts

@@ -3,5 +3,5 @@ export declare const DEFAULTS: {
     pollInterval: number;
     diskPath: string;
 };
-export declare const DEFAULT_THRESHOLDS: Record<string, ThresholdConfig>;
+export declare const DEFAULT_THRESHOLDS: Record<'cpu' | 'mem' | 'disk', ThresholdConfig>;
 //# sourceMappingURL=defaults.d.ts.map

package/dist/npcs/system-monitor/index.d.ts

@@ -15,13 +15,14 @@ export declare class SystemMonitorNPC extends PollingNPC {
     private cpuSampler;
     private cpuHistory;
     private memHistory;
+    private diskErrorLogged;
     constructor(config: SystemMonitorConfig);
     get name(): string;
     protected get defaultDisplayName(): string;
     get archetype(): Archetype;
-    get heartbeatSeconds(): number;
     get behavior(): BehaviorHints;
     get companion(): CompanionDecl;
     protected collect(): Promise<CollectedMetrics>;
+    private readDisk;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/npcs/system-monitor/index.js

@@ -1,7 +1,8 @@
 import { PollingNPC } from '../../core/polling-npc.js';
-import { evaluateThreshold, worstStatus } from '../../core/thresholds.js';
+import { evaluateThreshold, worstStatus, moodForStatus, thresholdProblem, } from '../../core/thresholds.js';
 import { statusColor, pushHistory } from '../../core/screen.js';
-import { createCpuSampler, collectMemory, collectDisk } from './collectors.js';
+import { NpcConfigError } from '../../core/errors.js';
+import { createCpuSampler, collectMemory, collectDisk, readAvailableMemory } from './collectors.js';
 import { DEFAULTS, DEFAULT_THRESHOLDS } from './defaults.js';
 export class SystemMonitorNPC extends PollingNPC {
     diskPath;
@@ -11,15 +12,21 @@ export class SystemMonitorNPC extends PollingNPC {
     cpuSampler = createCpuSampler();
     cpuHistory = [];
     memHistory = [];
+    diskErrorLogged = false;
     constructor(config) {
         super({
             ...config,
             pollInterval: config.pollInterval ?? DEFAULTS.pollInterval,
         });
         this.diskPath = config.diskPath ?? DEFAULTS.diskPath;
-        this.cpuThreshold = config.cpuThreshold ?? DEFAULT_THRESHOLDS['cpu'];
-        this.memThreshold = config.memThreshold ?? DEFAULT_THRESHOLDS['mem'];
-        this.diskThreshold = config.diskThreshold ?? DEFAULT_THRESHOLDS['disk'];
+        this.cpuThreshold = config.cpuThreshold ?? DEFAULT_THRESHOLDS.cpu;
+        this.memThreshold = config.memThreshold ?? DEFAULT_THRESHOLDS.mem;
+        this.diskThreshold = config.diskThreshold ?? DEFAULT_THRESHOLDS.disk;
+        const problem = thresholdProblem('CPU', this.cpuThreshold) ??
+            thresholdProblem('Memory', this.memThreshold) ??
+            thresholdProblem('Disk', this.diskThreshold);
+        if (problem)
+            throw new NpcConfigError(problem);
     }
     get name() {
         return 'system-monitor';
@@ -30,9 +37,6 @@ export class SystemMonitorNPC extends PollingNPC {
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get behavior() {
         return { idle: 'wander' };
     }
@@ -46,19 +50,20 @@ export class SystemMonitorNPC extends PollingNPC {
     }
     async collect() {
         const cpu = this.cpuSampler.sample();
-        const mem = collectMemory();
-        const disk = await collectDisk(this.diskPath);
+        const mem = collectMemory(await readAvailableMemory());
+        const disk = await this.readDisk();
         const cpuStatus = evaluateThreshold(cpu.percent, this.cpuThreshold);
         const memStatus = evaluateThreshold(mem.percent, this.memThreshold);
-        const diskStatus = evaluateThreshold(disk.percent, this.diskThreshold);
+        // An unreadable disk (unmounted volume, bad --disk-path) is a warning, not a crash.
+        const diskStatus = disk
+            ? evaluateThreshold(disk.percent, this.diskThreshold)
+            : 'warning';
         const status = worstStatus([cpuStatus, memStatus, diskStatus]);
-        const mood = status === 'critical'
-            ? 'stressed'
-            : status === 'warning'
-                ? 'concerned'
-                : 'happy';
         pushHistory(this.cpuHistory, cpu.percent);
         pushHistory(this.memHistory, mem.percent);
+        const diskText = disk ? `${disk.percent}%` : 'n/a';
+        // Windows has no load average (os.loadavg() is always zeros there).
+        const loadText = process.platform === 'win32' ? 'n/a' : cpu.loadAvg1m.toFixed(2);
         const screenData = {
             layout: 'multi-metric',
             values: [
@@ -74,28 +79,47 @@ export class SystemMonitorNPC extends PollingNPC {
                     color: statusColor(memStatus),
                     sparkline: [...this.memHistory],
                 },
-                { label: 'DISK', value: `${disk.percent}%`, color: statusColor(diskStatus) },
-                { label: 'LOAD', value: cpu.loadAvg1m.toFixed(2), color: 'gray' },
+                { label: 'DISK', value: diskText, color: statusColor(diskStatus) },
+                { label: 'LOAD', value: loadText, color: 'gray' },
             ],
         };
+        const metrics = {
+            cpu_percent: cpu.percent,
+            mem_percent: mem.percent,
+            mem_used_gb: mem.usedGb,
+            mem_total_gb: mem.totalGb,
+            load_avg_1m: cpu.loadAvg1m,
+        };
+        if (disk) {
+            metrics['disk_percent'] = disk.percent;
+            metrics['disk_used_gb'] = disk.usedGb;
+            metrics['disk_total_gb'] = disk.totalGb;
+        }
         return {
             status,
-            mood,
-            message: `CPU: ${cpu.percent}% | Mem: ${mem.percent}% | Disk: ${disk.percent}%`,
+            mood: moodForStatus(status),
+            message: `CPU: ${cpu.percent}% | Mem: ${mem.percent}% | Disk: ${disk ? diskText : 'unavailable'}`,
             screenData,
             // When strained, go find a desk and get to work; otherwise wander.
             behavior: status !== 'healthy' ? { busy: 'seek-desk' } : undefined,
-            metrics: {
-                cpu_percent: cpu.percent,
-                mem_percent: mem.percent,
-                mem_used_gb: mem.usedGb,
-                mem_total_gb: mem.totalGb,
-                disk_percent: disk.percent,
-                disk_used_gb: disk.usedGb,
-                disk_total_gb: disk.totalGb,
-                load_avg_1m: cpu.loadAvg1m,
-            },
+            metrics,
         };
     }
+    async readDisk() {
+        try {
+            const disk = await collectDisk(this.diskPath);
+            this.diskErrorLogged = false;
+            return disk;
+        }
+        catch (err) {
+            if (!this.diskErrorLogged) {
+                this.diskErrorLogged = true;
+                this.logger.warn(`Cannot read disk usage for ${this.diskPath}`, {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return null;
+        }
+    }
 }
 //# sourceMappingURL=index.js.map

package/dist/npcs/web-page-watcher/basic-mode.d.ts

@@ -5,12 +5,12 @@ export interface BasicCheck {
     ok: boolean;
     timedOut: boolean;
 }
-/** Extract the <title> text from an HTML string (empty if none). */
+/** Extract the <title> text from (untrusted) HTML: entities decoded, sanitized, ≤80 chars. */
 export declare function extractTitle(html: string): string;
 /** Map an HTTP status to NPC status: 2xx/3xx ok, 4xx/timeout warn, 5xx/refused crit. */
 export declare function statusFromHttp(code: number, timedOut?: boolean): Status;
 /** Fetch a page and extract HTTP status + <title> (basic, no browser). */
 export declare function basicCheck(url: string, timeoutMs?: number): Promise<BasicCheck>;
-/** Best-effort hostname for a URL, falling back to the raw string. */
+/** Hostname of a URL for labels and service ids (never credentials or path). */
 export declare function hostnameOf(url: string): string;
 //# sourceMappingURL=basic-mode.d.ts.map