@nocville/npc 0.2.2 → 0.3.0

package/dist/npcs/office-characters/index.d.ts

@@ -0,0 +1,50 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import type { PollingNpcConfig } from '../../core/polling-npc.js';
+import type { Archetype, BehaviorHints, CollectedMetrics } from '../../core/types.js';
+/** Quiet heartbeats; the authoritative server drives routines and conversation. */
+declare abstract class OfficeCharacterNPC extends PollingNPC {
+    constructor(config: PollingNpcConfig);
+    abstract get name(): NonNullable<BehaviorHints['role']>;
+    get archetype(): Archetype;
+    get behavior(): BehaviorHints;
+    protected collect(): Promise<CollectedMetrics>;
+}
+export declare class JanitorNPC extends OfficeCharacterNPC {
+    get name(): 'janitor';
+    protected get defaultDisplayName(): string;
+}
+export declare class BaristaNPC extends OfficeCharacterNPC {
+    get name(): 'barista';
+    protected get defaultDisplayName(): string;
+}
+export declare class OfficeCatNPC extends OfficeCharacterNPC {
+    get name(): 'office-cat';
+    protected get defaultDisplayName(): string;
+}
+export declare class OfficeDogNPC extends OfficeCharacterNPC {
+    get name(): 'office-dog';
+    protected get defaultDisplayName(): string;
+}
+export declare class PlantCaretakerNPC extends OfficeCharacterNPC {
+    get name(): 'plant-caretaker';
+    protected get defaultDisplayName(): string;
+}
+export declare class ITTechnicianNPC extends OfficeCharacterNPC {
+    get name(): 'it-technician';
+    protected get defaultDisplayName(): string;
+}
+export declare class OutOfTouchExecutiveNPC extends OfficeCharacterNPC {
+    get name(): 'out-of-touch-executive';
+    protected get defaultDisplayName(): string;
+}
+export declare const OFFICE_CHARACTER_NPCS: {
+    readonly janitor: typeof JanitorNPC;
+    readonly barista: typeof BaristaNPC;
+    readonly 'office-cat': typeof OfficeCatNPC;
+    readonly 'office-dog': typeof OfficeDogNPC;
+    readonly 'plant-caretaker': typeof PlantCaretakerNPC;
+    readonly 'it-technician': typeof ITTechnicianNPC;
+    readonly 'out-of-touch-executive': typeof OutOfTouchExecutiveNPC;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/npcs/office-characters/index.js

@@ -0,0 +1,82 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+/** Quiet heartbeats; the authoritative server drives routines and conversation. */
+class OfficeCharacterNPC extends PollingNPC {
+    constructor(config) {
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
+    }
+    get archetype() {
+        return 'custom';
+    }
+    get behavior() {
+        return { role: this.name, activity: 'idle', idlePose: 'stand' };
+    }
+    async collect() {
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
+    }
+}
+export class JanitorNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'janitor';
+    }
+    get defaultDisplayName() {
+        return 'Janitor';
+    }
+}
+export class BaristaNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'barista';
+    }
+    get defaultDisplayName() {
+        return 'Barista';
+    }
+}
+export class OfficeCatNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'office-cat';
+    }
+    get defaultDisplayName() {
+        return 'Office Cat';
+    }
+}
+export class OfficeDogNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'office-dog';
+    }
+    get defaultDisplayName() {
+        return 'Office Dog';
+    }
+}
+export class PlantCaretakerNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'plant-caretaker';
+    }
+    get defaultDisplayName() {
+        return 'Plant Caretaker';
+    }
+}
+export class ITTechnicianNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'it-technician';
+    }
+    get defaultDisplayName() {
+        return 'IT Technician';
+    }
+}
+export class OutOfTouchExecutiveNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'out-of-touch-executive';
+    }
+    get defaultDisplayName() {
+        return 'Out-of-Touch Executive';
+    }
+}
+export const OFFICE_CHARACTER_NPCS = {
+    janitor: JanitorNPC,
+    barista: BaristaNPC,
+    'office-cat': OfficeCatNPC,
+    'office-dog': OfficeDogNPC,
+    'plant-caretaker': PlantCaretakerNPC,
+    'it-technician': ITTechnicianNPC,
+    'out-of-touch-executive': OutOfTouchExecutiveNPC,
+};
+//# sourceMappingURL=index.js.map

package/dist/npcs/process-watcher/index.d.ts

@@ -19,8 +19,8 @@ export declare class ProcessWatcherNPC extends PollingNPC {
     get name(): string;
     protected get defaultDisplayName(): string;
     get archetype(): Archetype;
-    get heartbeatSeconds(): number;
     get companion(): CompanionDecl;
     protected collect(): Promise<CollectedMetrics>;
+    private scanFailed;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,7 @@
 import { PollingNPC } from '../../core/polling-npc.js';
-import { worstStatus } from '../../core/thresholds.js';
-import { pushHistory } from '../../core/screen.js';
+import { evaluateThreshold, worstStatus, moodForStatus } from '../../core/thresholds.js';
+import { statusColor, pushHistory } from '../../core/screen.js';
+import { NpcConfigError } from '../../core/errors.js';
 import { scanProcesses, detectTransitions } from './process-scanner.js';
 import { DEFAULTS } from './defaults.js';
 /** Max per-process panels on the companion dashboard. */
@@ -12,14 +13,16 @@ export class ProcessWatcherNPC extends 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.');
-        }
         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 NpcConfigError('process-watcher needs at least one process name (--processes)');
+        }
         this.cpuWarn = config.cpuWarn ?? DEFAULTS.cpuWarn;
         this.memWarn = config.memWarn ?? DEFAULTS.memWarn;
+        if (!(this.cpuWarn > 0) || !(this.memWarn > 0)) {
+            throw new NpcConfigError('--cpu-warn and --mem-warn must be positive numbers');
+        }
     }
     get name() {
         return 'process-watcher';
@@ -30,9 +33,6 @@ export class ProcessWatcherNPC extends PollingNPC {
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get companion() {
         return {
             screenType: 'dashboard-wall',
@@ -42,22 +42,28 @@ export class ProcessWatcherNPC extends PollingNPC {
         };
     }
     async collect() {
-        const infos = await scanProcesses(this.processes);
+        let infos;
+        try {
+            infos = await 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' });
                 }
@@ -65,72 +71,75 @@ export class ProcessWatcherNPC extends 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) ?? [];
             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 = evaluateThreshold(cpu, { warning: this.cpuWarn, critical: Infinity });
+            const memStatus = evaluateThreshold(memMb, { warning: this.memWarn, critical: Infinity });
+            const status = 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: 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 = detectTransitions(this.previousRunning, currentRunning);
-        }
+        const transitions = this.previousRunning === null ? [] : detectTransitions(this.previousRunning, currentRunning);
         this.previousRunning = currentRunning;
         const status = 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: moodForStatus(status),
             message,
             subStatus: totalMissing > 0 ? 'process-down' : undefined,
-            screenData,
+            screenData: { layout: 'multi-metric', values: panels },
             metrics,
         };
     }
-}
-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: 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 },
+        };
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/npcs/process-watcher/process-scanner.d.ts

@@ -2,6 +2,8 @@ export interface ProcessInfo {
     name: string;
     running: boolean;
     pid?: number;
+    /** Instances matched (all are summed into cpu/mem). */
+    count?: number;
     cpuPercent?: number;
     memMb?: number;
 }
@@ -11,9 +13,37 @@ export interface ProcessInfo {
  * "<name> is back" when one returns.
  */
 export declare function detectTransitions(prev: Set<string>, curr: Set<string>): string[];
+export interface PsEntry {
+    pid: number;
+    cpu: number;
+    memKb: number;
+    /** Executable name (Linux) or path (macOS); may contain spaces. */
+    comm: string;
+}
+/**
+ * Parse header-less `ps -eo pid=,pcpu=,rss=,comm=` output. COMMAND is the rest
+ * of the line, so macOS paths with spaces ("Google Chrome") survive intact.
+ */
+export declare function parsePsOutput(stdout: string): PsEntry[];
+/**
+ * Does a ps COMMAND entry match a watched name? Case-insensitive on the
+ * executable's basename:
+ * - exact: `nginx` matches `/usr/sbin/nginx`;
+ * - version suffix: `python` matches `python3` and `python3.11`;
+ * - Linux truncation: a name longer than 15 chars matches its 15-char prefix;
+ * - a name containing `/` must equal the full path (macOS reports paths).
+ * Unlike a substring match, `sh` does not match `bash` or `ssh-agent`.
+ */
+export declare function matchesName(comm: string, searchName: string): boolean;
+/** List every process. Throws if `ps` fails — callers must not read that as "all dead". */
+export declare function listProcesses(): Promise<PsEntry[]>;
+/** Windows instance suffixes (#1, #2) distinguish copies of the same executable. */
+export declare function parseWindowsProcesses(stdout: string, cores?: number): PsEntry[];
+/** Summarise each watched name against a process list (CPU and memory summed per name). */
+export declare function matchProcesses(names: string[], entries: PsEntry[]): ProcessInfo[];
 /**
  * Scan for processes by name and return their status and resource usage.
- * Works on macOS and Linux by using `ps` to list all processes.
+ * Uses `ps` on macOS/Linux and CIM on Windows. Throws when the process list is unavailable.
  */
 export declare function scanProcesses(names: string[]): Promise<ProcessInfo[]>;
 //# sourceMappingURL=process-scanner.d.ts.map

package/dist/npcs/process-watcher/process-scanner.js

@@ -1,6 +1,13 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { cpus } from 'node:os';
+import { join } from 'node:path';
 const execFileAsync = promisify(execFile);
+/** Bounds on the `ps` call: a wedged or enormous process table can't stall or flood us. */
+const PS_TIMEOUT_MS = 5000;
+const PS_MAX_BUFFER = 16 * 1024 * 1024;
+/** Linux truncates `comm` to 15 characters (TASK_COMM_LEN - 1). */
+const LINUX_COMM_LEN = 15;
 /**
  * Compare the previous and current running-process sets and return speech
  * strings for any transitions: "<name> died!" when a process disappears and
@@ -19,92 +26,112 @@ export function detectTransitions(prev, curr) {
     return messages;
 }
 /**
- * Parse the output of `ps` into structured entries.
- * Expects columns: PID, %CPU, RSS (KB), COMMAND
+ * Parse header-less `ps -eo pid=,pcpu=,rss=,comm=` output. COMMAND is the rest
+ * of the line, so macOS paths with spaces ("Google Chrome") survive intact.
  */
-function parsePsOutput(stdout) {
-    const lines = stdout.trim().split('\n');
-    // Skip the header line
+export function parsePsOutput(stdout) {
     const entries = [];
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (!line)
+    for (const line of stdout.split('\n')) {
+        const m = line.match(/^\s*(\d+)\s+([\d.]+)\s+(\d+)\s+(.+?)\s*$/);
+        if (!m)
             continue;
-        // Fields are whitespace-separated: PID, %CPU, RSS, COMMAND (may contain spaces)
-        const parts = line.split(/\s+/);
-        if (parts.length < 4)
-            continue;
-        const pid = parseInt(parts[0], 10);
-        const cpu = parseFloat(parts[1]);
-        const memKb = parseInt(parts[2], 10);
-        // COMMAND is everything from the 4th column onward
-        const comm = parts.slice(3).join(' ');
-        if (Number.isNaN(pid) || Number.isNaN(cpu) || Number.isNaN(memKb))
-            continue;
-        entries.push({ pid, cpu, memKb, comm });
+        entries.push({
+            pid: Number(m[1]),
+            cpu: Number(m[2]),
+            memKb: Number(m[3]),
+            comm: m[4],
+        });
     }
     return entries;
 }
 /**
- * Match a process name against a ps COMMAND column.
- * Matches if the basename of the command path equals the search name,
- * or if the command contains the search name.
+ * Does a ps COMMAND entry match a watched name? Case-insensitive on the
+ * executable's basename:
+ * - exact: `nginx` matches `/usr/sbin/nginx`;
+ * - version suffix: `python` matches `python3` and `python3.11`;
+ * - Linux truncation: a name longer than 15 chars matches its 15-char prefix;
+ * - a name containing `/` must equal the full path (macOS reports paths).
+ * Unlike a substring match, `sh` does not match `bash` or `ssh-agent`.
  */
-function matchesName(comm, searchName) {
-    // Get the basename of the command (strip path and arguments)
-    const basename = comm.split('/').pop()?.split(/\s/)[0] ?? '';
-    if (basename === searchName)
+export function matchesName(comm, searchName) {
+    if (/[\\/]/.test(searchName))
+        return comm === searchName;
+    const base = (comm.split(/[\\/]/).pop() ?? comm).toLowerCase().replace(/\.exe$/, '');
+    const name = searchName.toLowerCase().replace(/\.exe$/, '');
+    if (base === name)
         return true;
-    // Also check if the full command string contains the name
-    // (handles cases like "python my-script.py" when searching for "python")
-    return comm.toLowerCase().includes(searchName.toLowerCase());
+    if (name.length > LINUX_COMM_LEN && base === name.slice(0, LINUX_COMM_LEN))
+        return true;
+    return base.startsWith(name) && /^\d[\d.]*$/.test(base.slice(name.length));
 }
-/**
- * Scan for processes by name and return their status and resource usage.
- * Works on macOS and Linux by using `ps` to list all processes.
- */
-export async function scanProcesses(names) {
-    let psArgs;
-    if (process.platform === 'darwin') {
-        // macOS: -e selects all processes, -o specifies output columns
-        psArgs = ['-eo', 'pid,pcpu,rss,comm'];
-    }
-    else {
-        // Linux: -eo with similar columns
-        psArgs = ['-eo', 'pid,pcpu,rss,comm'];
-    }
-    let entries;
-    try {
-        const { stdout } = await execFileAsync('ps', psArgs);
-        entries = parsePsOutput(stdout);
-    }
-    catch {
-        // If ps fails, report all processes as unknown / not running
-        return names.map((name) => ({ name, running: false }));
+/** List every process. Throws if `ps` fails — callers must not read that as "all dead". */
+export async function listProcesses() {
+    if (process.platform === 'win32') {
+        // Fixed command, no user strings interpolated. Performance counters report a
+        // sampling interval (Get-Process.CPU is lifetime CPU seconds, not a percent).
+        const executable = join(process.env['SystemRoot'] || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+        const { stdout } = await execFileAsync(executable, [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            '$ErrorActionPreference="Stop"; Get-CimInstance Win32_PerfFormattedData_PerfProc_Process | Select-Object IDProcess,Name,PercentProcessorTime,WorkingSetPrivate | ConvertTo-Json -Compress',
+        ], { timeout: PS_TIMEOUT_MS, maxBuffer: PS_MAX_BUFFER, windowsHide: true });
+        return parseWindowsProcesses(stdout, cpus().length);
     }
-    const results = [];
-    for (const name of names) {
-        // Find all matching entries for this process name
+    const { stdout } = await execFileAsync('ps', ['-eo', 'pid=,pcpu=,rss=,comm='], {
+        timeout: PS_TIMEOUT_MS,
+        maxBuffer: PS_MAX_BUFFER,
+        // Some locales print %CPU with a decimal comma ("1,5"); force "1.5".
+        env: { ...process.env, LC_ALL: 'C' },
+    });
+    return parsePsOutput(stdout);
+}
+/** Windows instance suffixes (#1, #2) distinguish copies of the same executable. */
+export function parseWindowsProcesses(stdout, cores = 1) {
+    const value = JSON.parse(stdout.replace(/^\uFEFF/, ''));
+    const rows = Array.isArray(value) ? value : value ? [value] : [];
+    return rows.flatMap((row) => {
+        const pid = Number(row.IDProcess);
+        const cpu = Number(row.PercentProcessorTime);
+        const bytes = Number(row.WorkingSetPrivate);
+        if (!(pid > 0) ||
+            !Number.isFinite(cpu) ||
+            !Number.isFinite(bytes) ||
+            typeof row.Name !== 'string')
+            return [];
+        return [
+            {
+                pid,
+                cpu: cpu / Math.max(1, cores),
+                memKb: bytes / 1024,
+                comm: row.Name.replace(/#\d+$/, ''),
+            },
+        ];
+    });
+}
+/** Summarise each watched name against a process list (CPU and memory summed per name). */
+export function matchProcesses(names, entries) {
+    return names.map((name) => {
         const matching = entries.filter((e) => matchesName(e.comm, name));
-        if (matching.length === 0) {
-            results.push({ name, running: false });
-            continue;
-        }
-        // Aggregate: take the first matching PID, sum CPU and memory across all instances
-        let totalCpu = 0;
-        let totalMemKb = 0;
-        for (const entry of matching) {
-            totalCpu += entry.cpu;
-            totalMemKb += entry.memKb;
-        }
-        results.push({
+        if (matching.length === 0)
+            return { name, running: false };
+        const totalCpu = matching.reduce((sum, e) => sum + e.cpu, 0);
+        const totalMemKb = matching.reduce((sum, e) => sum + e.memKb, 0);
+        return {
             name,
             running: true,
             pid: matching[0].pid,
+            count: matching.length,
             cpuPercent: Math.round(totalCpu * 100) / 100,
             memMb: Math.round((totalMemKb / 1024) * 100) / 100,
-        });
-    }
-    return results;
+        };
+    });
+}
+/**
+ * Scan for processes by name and return their status and resource usage.
+ * Uses `ps` on macOS/Linux and CIM on Windows. Throws when the process list is unavailable.
+ */
+export async function scanProcesses(names) {
+    return matchProcesses(names, await listProcesses());
 }
 //# sourceMappingURL=process-scanner.js.map

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

@@ -1,6 +1,10 @@
 export declare const DEFAULTS: {
     pollInterval: number;
     weatherRefreshMs: number;
+    /** Drop a reading this old (repeated refresh failures) rather than show stale weather. */
+    weatherMaxAgeMs: number;
+    /** Wait this long before retrying a failed geocode / IP geo / weather call. */
+    retryBackoffMs: number;
     fetchTimeoutMs: number;
 };
 //# sourceMappingURL=defaults.d.ts.map

package/dist/npcs/receptionist/defaults.js

@@ -1,6 +1,10 @@
 export const DEFAULTS = {
     pollInterval: 60000, // 60s clock tick
     weatherRefreshMs: 15 * 60 * 1000, // refresh weather every 15 minutes
+    /** Drop a reading this old (repeated refresh failures) rather than show stale weather. */
+    weatherMaxAgeMs: 2 * 60 * 60 * 1000,
+    /** Wait this long before retrying a failed geocode / IP geo / weather call. */
+    retryBackoffMs: 5 * 60 * 1000,
     fetchTimeoutMs: 5000,
 };
 //# sourceMappingURL=defaults.js.map

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

@@ -1,29 +1,20 @@
 import { PollingNPC } from '../../core/polling-npc.js';
 import type { PollingNpcConfig } from '../../core/polling-npc.js';
-import type { CollectedMetrics, Archetype, BehaviorHints, CompanionDecl } from '../../core/types.js';
+import type { CollectedMetrics, Archetype, BehaviorHints } from '../../core/types.js';
 export interface ReceptionistConfig extends PollingNpcConfig {
+    /** @deprecated Reception no longer uses weather or geolocation. Accepted for compatibility. */
     lat?: number;
     lon?: number;
     location?: string;
-    /** Display temperature in Fahrenheit instead of Celsius. */
     fahrenheit?: boolean;
+    ipGeo?: boolean;
 }
 export declare class ReceptionistNPC extends PollingNPC {
-    private explicitCoords;
-    private location?;
-    private fahrenheit;
-    private coords;
-    private geoAttempted;
-    private weather;
-    private lastWeatherFetch;
     constructor(config: ReceptionistConfig);
     get name(): string;
     protected get defaultDisplayName(): string;
     get archetype(): Archetype;
     get behavior(): BehaviorHints;
-    get companion(): CompanionDecl;
     protected collect(): Promise<CollectedMetrics>;
-    private refreshWeather;
-    private resolveCoords;
 }
 //# sourceMappingURL=index.d.ts.map