fullcourtdefense-cli 1.21.28 → 1.21.29

package/dist/commands/daemon.d.ts

@@ -32,6 +32,18 @@ export declare function discoverSweepCredentialEnv(credentials?: {
     shieldKey?: string;
     apiUrl?: string;
 }): Record<string, string>;
+/** Snapshot of the resident daemon for out-of-process callers (watchdog/status). */
+export interface DaemonRuntimeState {
+    alive: boolean;
+    pid?: number;
+    version?: string;
+    startedAt?: string;
+}
+export declare function daemonRuntimeState(): DaemonRuntimeState;
+/** Relaunch the daemon outside our process tree (plain node — no shells). */
+export declare function spawnDetachedDaemon(): boolean;
+/** Pid-alive check shared with the watchdog (EPERM still means alive). */
+export declare function pidIsAlive(pid: number): boolean;
 export declare function macosLaunchdPath(currentPath?: string, execPath?: string): string;
 /** Whether the daemon has been registered to start automatically. */
 export declare function isDaemonAutostartInstalled(): boolean;

package/dist/commands/daemon.js

@@ -36,6 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.daemonDiscoverSweepArgs = daemonDiscoverSweepArgs;
 exports.summarizeDiscoverStderr = summarizeDiscoverStderr;
 exports.discoverSweepCredentialEnv = discoverSweepCredentialEnv;
+exports.daemonRuntimeState = daemonRuntimeState;
+exports.spawnDetachedDaemon = spawnDetachedDaemon;
+exports.pidIsAlive = pidIsAlive;
 exports.macosLaunchdPath = macosLaunchdPath;
 exports.isDaemonAutostartInstalled = isDaemonAutostartInstalled;
 exports.daemonCommand = daemonCommand;
@@ -44,6 +47,8 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const config_1 = require("../config");
+const daemonForensics_1 = require("../daemonForensics");
+const securityAgents_1 = require("../securityAgents");
 const mcpGateway_1 = require("./mcpGateway");
 const protectionRepair_1 = require("./protectionRepair");
 const runtimeConfig_1 = require("../runtimeConfig");
@@ -351,6 +356,18 @@ async function runDaemon(args, config) {
     const quiet = args.quiet === 'true';
     log(`Daemon started (pid ${process.pid}, platform ${process.platform}).`);
     log(`Shield: ${creds.shieldId || '(none — protect-only mode, telemetry disabled)'}  API: ${creds.apiUrl}`);
+    // A machine enrolled with a DPAPI key whose decrypt fails (blocked
+    // PowerShell) lands here: shieldId readable, key not. Say so LOUDLY — this
+    // state looks identical to "machine off" on the dashboard otherwise.
+    if (creds.shieldId && !creds.shieldKey) {
+        const ph = (0, config_1.getPowershellHealth)();
+        log(`Shield key UNAVAILABLE${ph && !ph.spawnOk ? ' — powershell.exe could not start (EDR/policy block?), so the DPAPI-protected key cannot be decrypted' : ''}. Telemetry/control-plane sync disabled; retrying periodically.`);
+    }
+    // Crash forensics: was the previous daemon killed without a clean shutdown?
+    const postmortem = (0, daemonForensics_1.recordDaemonStart)({ version: cliVersion(), isPidAlive });
+    if (postmortem) {
+        log(`Previous daemon (v${postmortem.version || '?'}) died UNCLEANLY — last alive ${postmortem.lastAliveAt || 'unknown'}, no shutdown recorded. Likely killed externally (EDR/AV, OOM, or forced termination). Post-mortem recorded; reporting upstream.`);
+    }
     // --- state ---------------------------------------------------------------
     const watchers = new Map(); // directory -> watcher
     const rootWatchers = new Map(); // admin protection roots -> recursive watcher
@@ -363,6 +380,34 @@ async function runDaemon(args, config) {
     const executingActionIds = new Set();
     /** Latest org auto-update policy seen on a bundle poll. */
     let autoUpdatePolicy;
+    /** Heartbeat ticks spent without full credentials (drives recovery cadence). */
+    let credRecoveryTicks = 0;
+    /**
+     * A daemon that starts without a usable shield key (DPAPI decrypt blocked,
+     * config written after start by `login`) must NOT stay credential-less
+     * forever — that silences telemetry AND auto-update, stranding the machine.
+     * Retry quickly right after start, then hourly (each retry may spawn
+     * PowerShell for DPAPI, which we keep rare on machines that block it).
+     */
+    const recoverCredentialsIfMissing = () => {
+        if (creds.shieldId && creds.shieldKey)
+            return;
+        credRecoveryTicks += 1;
+        if (credRecoveryTicks > 3 && credRecoveryTicks % 12 !== 0)
+            return;
+        try {
+            const fresh = (0, config_1.resolveCliCredentials)((0, config_1.loadConfig)(args.config), {
+                shieldId: args.shieldId,
+                shieldKey: args.shieldKey,
+                apiUrl: args.apiUrl,
+            });
+            if (fresh.shieldId && fresh.shieldKey) {
+                Object.assign(creds, fresh);
+                log('Credentials recovered — telemetry and control-plane sync restored.');
+            }
+        }
+        catch { /* next tick */ }
+    };
     const reprotect = async (reasonPaths) => {
         if (reprotecting || stopped)
             return;
@@ -812,10 +857,16 @@ async function runDaemon(args, config) {
         catch { /* offline — cached stance applies */ }
     };
     const heartbeat = async () => {
+        (0, daemonForensics_1.touchDaemonAlive)();
+        recoverCredentialsIfMissing();
         if (!creds.shieldId)
             return;
         try {
             const integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+            // Report a previous daemon's unclean death exactly once.
+            const crash = (0, daemonForensics_1.readPostmortem)();
+            const unreportedCrash = crash && !crash.reportedAt ? crash : undefined;
+            const powershell = (0, config_1.getPowershellHealth)();
             const result = await (0, telemetry_1.flushSpool)({
                 apiUrl: creds.apiUrl,
                 shieldId: creds.shieldId,
@@ -827,7 +878,21 @@ async function runDaemon(args, config) {
                 integrityReasons: integrity.reasons,
                 integrityCheckedAt: integrity.checkedAt,
                 desktopChatGuard: (0, desktopChatGuard_1.desktopChatGuardSupported)() && (0, desktopChatGuard_1.desktopChatGuardHealthy)(),
+                securityAgents: (0, securityAgents_1.getSecurityAgentsReport)()?.products,
+                powershellSpawnOk: powershell?.spawnOk,
+                powershellDecryptOk: powershell?.decryptOk,
+                lastCrash: unreportedCrash
+                    ? {
+                        version: unreportedCrash.version,
+                        startedAt: unreportedCrash.startedAt,
+                        lastAliveAt: unreportedCrash.lastAliveAt,
+                        detectedAt: unreportedCrash.detectedAt,
+                        detectedBy: unreportedCrash.detectedBy,
+                    }
+                    : undefined,
             });
+            if (result && unreportedCrash)
+                (0, daemonForensics_1.markPostmortemReported)();
             if (result && result.accepted > 0)
                 log(`Heartbeat: flushed ${result.accepted} spooled event(s).`);
             if (!integrity.ok)
@@ -840,6 +905,9 @@ async function runDaemon(args, config) {
         await verifyPendingUpgrade();
     };
     // --- boot ---------------------------------------------------------------
+    // Self-heal autostart + watchdog tasks: machines installed by older versions
+    // (or where task creation failed once) must converge without a reinstall.
+    ensureWindowsAutostartHealthy(log);
     const watched = refreshWatchTargets();
     log(`Watching ${watched} config file(s) across ${watchers.size} director${watchers.size === 1 ? 'y' : 'ies'}.`);
     // First: if this boot IS the post-upgrade relaunch, confirm the pending
@@ -962,6 +1030,9 @@ async function runDaemon(args, config) {
             watcher.close();
         for (const watcher of rootWatchers.values())
             watcher.close();
+        // Forensics: this is an INTENTIONAL exit — without this stamp the next
+        // boot would report it as an external kill.
+        (0, daemonForensics_1.recordCleanExit)(signal);
         releasePidLock();
         process.exit(0);
     };
@@ -975,18 +1046,29 @@ async function runDaemon(args, config) {
 // Autostart install / uninstall / status
 // ---------------------------------------------------------------------------
 /** Hidden VBS launcher so the logon task doesn't flash a console window. */
-function ensureWindowsLauncher() {
+function writeHiddenLauncher(fileName, cliCommand) {
     const base = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
     const dir = path.join(base, 'FullCourtDefense');
     fs.mkdirSync(dir, { recursive: true });
-    const vbs = path.join(dir, 'daemon.vbs');
+    const vbs = path.join(dir, fileName);
     // Run node directly — routing through `cmd /c` breaks cmd's quote parsing
     // when node/CLI live under a path with spaces (e.g. Program Files).
-    const inner = `"${process.execPath}" "${cliEntry()}" daemon`;
+    const inner = `"${process.execPath}" "${cliEntry()}" ${cliCommand}`;
     const content = `CreateObject("WScript.Shell").Run "${inner.replace(/"/g, '""')}", 0, False\n`;
     fs.writeFileSync(vbs, content, 'utf8');
     return vbs;
 }
+function ensureWindowsLauncher() {
+    return writeHiddenLauncher('daemon.vbs', 'daemon');
+}
+/**
+ * Watchdog launcher: runs the `watchdog` command (liveness beacon + daemon
+ * revival + crash post-mortem) instead of blindly starting the daemon — the
+ * beacon is what lets the console tell "daemon dead" apart from "machine off".
+ */
+function ensureWindowsWatchdogLauncher() {
+    return writeHiddenLauncher('watchdog.vbs', 'watchdog');
+}
 const WINDOWS_RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
 const WINDOWS_RUN_VALUE = 'FullCourtDefenseDaemon';
 function isWindowsRunKeyInstalled() {
@@ -1047,28 +1129,102 @@ function installWindows() {
     }
     // Watchdog: logon triggers only START the daemon — nothing restarts it if it
     // is killed or crashes mid-session. A time-based per-user task (no elevation
-    // needed, unlike ONLOGON) re-launches the daemon every 5 minutes;
-    // acquirePidLock() makes each tick a cheap no-op while the daemon is alive,
-    // and revives it within one tick when it is not. Best-effort: a missing
-    // watchdog never fails the install.
+    // needed, unlike ONLOGON) runs the `watchdog` command every 5 minutes: it
+    // beacons daemon liveness to the console (so "daemon dead" is visible even
+    // when the daemon can't say so itself) and revives a dead daemon within one
+    // tick. Best-effort: a missing watchdog never fails the install.
     (0, child_process_1.spawnSync)('schtasks', [
-        '/Create', '/TN', WATCHDOG_TASK_NAME, '/TR', `wscript.exe "${vbs}"`,
+        '/Create', '/TN', WATCHDOG_TASK_NAME, '/TR', `wscript.exe "${ensureWindowsWatchdogLauncher()}"`,
         '/SC', 'MINUTE', '/MO', '5', '/F',
     ], { stdio: 'ignore', windowsHide: true });
     if (ok)
         startDaemonNowWindows(vbs, taskOk);
     return ok;
 }
+/**
+ * Boot-time self-heal for the Windows autostart chain. Recreates a missing
+ * daemon logon entry, refreshes the launcher scripts (paths move on upgrade),
+ * and re-points the watchdog task at the `watchdog` launcher (older versions
+ * pointed it at daemon.vbs, which restarts but never beacons). Creating
+ * per-user MINUTE tasks needs no elevation; ONLOGON does — fall back to the
+ * per-user Run key exactly like installWindows().
+ */
+function ensureWindowsAutostartHealthy(logFn) {
+    if (process.platform !== 'win32')
+        return;
+    // Kill-switch for sandboxed test daemons — a test-spawned daemon must never
+    // (re)write the developer machine's real scheduled tasks.
+    if (process.env.FCD_DAEMON_NO_TASK_SELF_HEAL === '1')
+        return;
+    try {
+        const vbs = ensureWindowsLauncher();
+        const watchdogVbs = ensureWindowsWatchdogLauncher();
+        const daemonTask = (0, child_process_1.spawnSync)('schtasks', ['/Query', '/TN', TASK_NAME], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
+        if (daemonTask.status !== 0 && !isWindowsRunKeyInstalled()) {
+            const created = (0, child_process_1.spawnSync)('schtasks', [
+                '/Create', '/TN', TASK_NAME, '/TR', `wscript.exe "${vbs}"`,
+                '/SC', 'ONLOGON', '/F', '/RL', 'LIMITED',
+            ], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
+            if (created.status !== 0) {
+                (0, child_process_1.spawnSync)('reg', [
+                    'add', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE, '/t', 'REG_SZ',
+                    '/d', `wscript.exe "${vbs}"`, '/f',
+                ], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
+            }
+            logFn('Self-heal: daemon autostart entry was missing — recreated.');
+        }
+        const watchdog = (0, child_process_1.spawnSync)('schtasks', [
+            '/Create', '/TN', WATCHDOG_TASK_NAME, '/TR', `wscript.exe "${watchdogVbs}"`,
+            '/SC', 'MINUTE', '/MO', '5', '/F',
+        ], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
+        if (watchdog.status !== 0) {
+            logFn('Self-heal: could not (re)create the watchdog task — daemon revival relies on logon autostart only.');
+        }
+    }
+    catch { /* self-heal is best-effort — never blocks daemon boot */ }
+}
+function daemonRuntimeState() {
+    try {
+        const pid = Number(fs.readFileSync(pidFile(), 'utf8').trim());
+        if (Number.isFinite(pid) && pid > 0 && isPidAlive(pid)) {
+            const meta = readDaemonMeta();
+            const owned = meta?.pid === pid;
+            return { alive: true, pid, version: owned ? meta?.version : undefined, startedAt: owned ? meta?.startedAt : undefined };
+        }
+    }
+    catch { /* no pid file — not running */ }
+    return { alive: false };
+}
+/** Relaunch the daemon outside our process tree (plain node — no shells). */
+function spawnDetachedDaemon() {
+    try {
+        const child = (0, child_process_1.spawn)(process.execPath, [cliEntry(), 'daemon'], {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Pid-alive check shared with the watchdog (EPERM still means alive). */
+function pidIsAlive(pid) {
+    return isPidAlive(pid);
+}
 function uninstallWindows() {
     const task = (0, child_process_1.spawnSync)('schtasks', ['/Delete', '/TN', TASK_NAME, '/F'], { stdio: 'ignore', windowsHide: true });
     (0, child_process_1.spawnSync)('schtasks', ['/Delete', '/TN', WATCHDOG_TASK_NAME, '/F'], { stdio: 'ignore', windowsHide: true });
     const reg = (0, child_process_1.spawnSync)('reg', ['delete', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE, '/f'], { stdio: 'ignore', windowsHide: true });
-    const vbs = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'FullCourtDefense', 'daemon.vbs');
-    try {
-        if (fs.existsSync(vbs))
-            fs.unlinkSync(vbs);
+    const launcherDir = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'FullCourtDefense');
+    for (const launcher of ['daemon.vbs', 'watchdog.vbs']) {
+        try {
+            fs.unlinkSync(path.join(launcherDir, launcher));
+        }
+        catch { /* ignore */ }
     }
-    catch { /* ignore */ }
     return task.status === 0 || reg.status === 0;
 }
 function launchdPlistPath() {

package/dist/commands/discover.d.ts

@@ -64,6 +64,8 @@ export interface DesktopDiscoveryHost {
     probeMode: 'config' | 'deep';
     /** Windows-only: PowerShell audit coverage (ScriptBlock Logging + Transcription). */
     shellAudit?: ShellAuditReport;
+    /** Windows-only: EDR/AV products detected on this machine (read-only service probe). */
+    securityAgents?: string[];
     /** True when the scan ran on an ephemeral CI runner (GitHub Actions, GitLab, etc.) — not a user machine. */
     isCi?: boolean;
 }

package/dist/commands/discover.js

@@ -51,6 +51,7 @@ const discoverAgentFiles_1 = require("./discoverAgentFiles");
 const discoverBlastRadius_1 = require("./discoverBlastRadius");
 const discoverSecrets_1 = require("./discoverSecrets");
 const windowsAudit_1 = require("./windowsAudit");
+const securityAgents_1 = require("../securityAgents");
 const discoveryMarker_1 = require("../discoveryMarker");
 const machineIdentity_1 = require("../machineIdentity");
 const DEFAULT_API_URL = 'https://api.fullcourtdefense.ai';
@@ -126,6 +127,7 @@ function buildHostMetadata(userEmail, probeMode = 'config') {
         scannedAt: new Date().toISOString(),
         probeMode,
         shellAudit: (0, windowsAudit_1.getShellAuditReport)(),
+        securityAgents: (0, securityAgents_1.getSecurityAgentsReport)()?.products,
         isCi: isCiEnvironment() || undefined,
     };
 }

package/dist/commands/watchdog.d.ts

@@ -0,0 +1,25 @@
+import { BotGuardConfig } from '../config';
+/**
+ * Watchdog tick — runs OUTSIDE the daemon (Windows scheduled task, every
+ * 5 minutes) so machine health stays observable even when the daemon itself
+ * is dead. Three jobs, all best-effort, never throws, exits 0:
+ *
+ *   1. Liveness: is the daemon running? If not, detect + persist the unclean
+ *      death post-mortem (the daemon can no longer say how it died).
+ *   2. Revival: relaunch a dead daemon (plain detached node — no shells).
+ *   3. Beacon: report daemon state to the console so the dashboard can tell
+ *      "daemon dead since 11:02" apart from "machine off".
+ *
+ * Shell-quiet by design: credential resolution NEVER attempts the DPAPI/
+ * PowerShell decrypt here (this runs every 5 minutes — exactly the hourly-
+ * PowerShell pattern that made EDRs kill us). On DPAPI-enrolled machines the
+ * beacon goes out WITHOUT a shield key; the backend accepts it on a
+ * constrained, rate-limited path that can only update watchdog liveness
+ * fields of an already-enrolled machine.
+ */
+export interface WatchdogArgs {
+    apiUrl?: string;
+    shieldId?: string;
+    shieldKey?: string;
+}
+export declare function watchdogCommand(args: WatchdogArgs, config: BotGuardConfig): Promise<void>;

package/dist/commands/watchdog.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchdogCommand = watchdogCommand;
+const config_1 = require("../config");
+const daemon_1 = require("./daemon");
+const daemonForensics_1 = require("../daemonForensics");
+const machineIdentity_1 = require("../machineIdentity");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function cliVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', '..', 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function crashSummary(pm) {
+    if (!pm || pm.reportedAt)
+        return undefined;
+    return {
+        version: pm.version,
+        startedAt: pm.startedAt,
+        lastAliveAt: pm.lastAliveAt,
+        detectedAt: pm.detectedAt,
+        detectedBy: pm.detectedBy,
+    };
+}
+async function watchdogCommand(args, config) {
+    const state = (0, daemon_1.daemonRuntimeState)();
+    let relaunched = false;
+    let postmortem = (0, daemonForensics_1.readPostmortem)();
+    if (!state.alive) {
+        // The daemon is down — capture how it died BEFORE reviving it (the fresh
+        // daemon rewrites the alive marker on boot).
+        postmortem = (0, daemonForensics_1.recordUncleanDeathFromWatchdog)(daemon_1.pidIsAlive) || postmortem;
+        // Revival can be disabled for tests/diagnostics; default is on.
+        if (process.env.FCD_WATCHDOG_NO_RELAUNCH !== '1') {
+            relaunched = (0, daemon_1.spawnDetachedDaemon)();
+        }
+    }
+    // Beacon — fail-soft on every axis: missing credentials, endpoint not yet
+    // deployed (404), network down. The next tick retries in 5 minutes.
+    const creds = (0, config_1.resolveCliCredentialsShellFree)(config, {
+        shieldId: args.shieldId,
+        shieldKey: args.shieldKey,
+        apiUrl: args.apiUrl,
+    });
+    if (!creds.shieldId)
+        return;
+    const identity = (0, machineIdentity_1.getMachineIdentity)();
+    const beacon = {
+        shieldId: creds.shieldId,
+        machineId: identity.machineId,
+        agentVersion: cliVersion(),
+        daemonAlive: state.alive,
+        daemonPid: state.pid,
+        daemonVersion: state.version,
+        daemonStartedAt: state.startedAt,
+        relaunched: relaunched || undefined,
+        lastCrash: crashSummary(postmortem),
+    };
+    const headers = { 'Content-Type': 'application/json' };
+    if (creds.shieldKey)
+        headers['x-shield-key'] = creds.shieldKey;
+    try {
+        const resp = await fetch(`${creds.apiUrl}/api/cli/machines/watchdog`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(beacon),
+            signal: AbortSignal.timeout(8_000),
+        });
+        // Only a trusted (shield-key) delivery consumes the crash report — the
+        // constrained path stores a hint but the daemon should still report the
+        // full post-mortem on its next authenticated heartbeat.
+        if (resp.ok && beacon.lastCrash && creds.shieldKey)
+            (0, daemonForensics_1.markPostmortemReported)();
+    }
+    catch { /* offline / endpoint not deployed yet — next tick retries */ }
+}

package/dist/config.d.ts

@@ -18,6 +18,20 @@ export interface BotGuardConfig {
         webhookFormat?: string;
     };
 }
+/**
+ * Outcome of the most recent DPAPI PowerShell attempt in THIS process —
+ * the fleet's "is PowerShell blocked on this machine?" health bit, derived
+ * from work we had to do anyway (never a dedicated PowerShell spawn).
+ * spawnOk=false means powershell.exe/pwsh.exe could not even start (EDR/
+ * AppLocker block, missing shells); spawnOk=true + decryptOk=false means the
+ * shell ran but the blob would not decrypt (wrong user profile / corrupt).
+ */
+export interface PowershellHealth {
+    spawnOk: boolean;
+    decryptOk: boolean;
+    checkedAt: string;
+}
+export declare function getPowershellHealth(): PowershellHealth | undefined;
 export declare function getHomeConfigPath(): string;
 export declare function loadConfig(configPath?: string): BotGuardConfig;
 export declare function getDefaultConfigPath(): string;
@@ -53,7 +67,17 @@ export interface ResolvedCliCredentials {
  */
 export declare function daemonHandoffShieldKey(env?: NodeJS.ProcessEnv): string | undefined;
 /** Merge saved ~/.fullcourtdefense.yml + env + optional CLI flag overrides. */
-export declare function resolveCliCredentials(config: BotGuardConfig, overrides?: Partial<ResolvedCliCredentials>): ResolvedCliCredentials;
+export declare function resolveCliCredentials(config: BotGuardConfig, overrides?: Partial<ResolvedCliCredentials>, options?: {
+    skipDpapi?: boolean;
+}): ResolvedCliCredentials;
+/**
+ * Credential resolution that is guaranteed to spawn NO child process — for
+ * frequent low-privilege callers (watchdog beacon every 5 min). Skips the
+ * DPAPI/PowerShell decrypt entirely; on a DPAPI-enrolled machine this may
+ * yield no shieldKey, in which case the caller sends a constrained
+ * (unauthenticated) beacon instead.
+ */
+export declare function resolveCliCredentialsShellFree(config: BotGuardConfig, overrides?: Partial<ResolvedCliCredentials>): ResolvedCliCredentials;
 export declare function isCliSetupComplete(config: BotGuardConfig): boolean;
 /** Fail fast with a clear message when setup was not run. */
 export declare function requireCliSetup(config: BotGuardConfig, overrides?: Partial<ResolvedCliCredentials>, options?: {

package/dist/config.js

@@ -33,12 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPowershellHealth = getPowershellHealth;
 exports.getHomeConfigPath = getHomeConfigPath;
 exports.loadConfig = loadConfig;
 exports.getDefaultConfigPath = getDefaultConfigPath;
 exports.saveShieldConfig = saveShieldConfig;
 exports.daemonHandoffShieldKey = daemonHandoffShieldKey;
 exports.resolveCliCredentials = resolveCliCredentials;
+exports.resolveCliCredentialsShellFree = resolveCliCredentialsShellFree;
 exports.isCliSetupComplete = isCliSetupComplete;
 exports.requireCliSetup = requireCliSetup;
 exports.saveSetupConfig = saveSetupConfig;
@@ -155,15 +157,21 @@ function readConfigFile(filePath) {
             : undefined,
     };
 }
+let powershellHealth;
+function getPowershellHealth() {
+    return powershellHealth;
+}
 function powershellDpapi(script, value) {
     if (process.platform !== 'win32' || !value)
         return undefined;
     // Windows PowerShell 5.1 first, then PowerShell 7 — both use DPAPI for
     // SecureString on Windows. Some locked-down/service contexts (e.g. CI
     // runners) break one shell but not the other.
+    let anyShellSpawned = false;
+    let output;
     for (const shell of ['powershell.exe', 'pwsh.exe']) {
         try {
-            const output = (0, child_process_1.execFileSync)(shell, [
+            const raw = (0, child_process_1.execFileSync)(shell, [
                 '-NoProfile',
                 '-NonInteractive',
                 '-ExecutionPolicy', 'Bypass',
@@ -175,12 +183,23 @@ function powershellDpapi(script, value) {
                 timeout: 15_000,
                 windowsHide: true,
             }).trim();
-            if (output)
-                return output;
+            anyShellSpawned = true;
+            if (raw) {
+                output = raw;
+                break;
+            }
+        }
+        catch (error) {
+            // A non-zero exit still proves the shell STARTED (status set); a spawn
+            // failure (ENOENT/EACCES/EPERM, or timeout kill) proves it did not.
+            const err = error;
+            if (typeof err.status === 'number')
+                anyShellSpawned = true;
+            /* try the next shell */
         }
-        catch { /* try the next shell */ }
     }
-    return undefined;
+    powershellHealth = { spawnOk: anyShellSpawned, decryptOk: !!output, checkedAt: new Date().toISOString() };
+    return output;
 }
 function protectShieldKeyForCurrentWindowsUser(value) {
     return powershellDpapi('$secure=ConvertTo-SecureString -String $env:FCD_DPAPI_VALUE -AsPlainText -Force; ConvertFrom-SecureString -SecureString $secure', value);
@@ -245,7 +264,7 @@ function daemonHandoffShieldKey(env = process.env) {
     return env.FCD_SHIELD_ID && env.FCD_SHIELD_KEY ? env.FCD_SHIELD_KEY : undefined;
 }
 /** Merge saved ~/.fullcourtdefense.yml + env + optional CLI flag overrides. */
-function resolveCliCredentials(config, overrides = {}) {
+function resolveCliCredentials(config, overrides = {}, options = {}) {
     return {
         apiKey: overrides.apiKey
             || config.apiKey
@@ -266,13 +285,23 @@ function resolveCliCredentials(config, overrides = {}) {
             // Daemon handoff BEFORE the DPAPI decrypt: no powershell.exe spawn at
             // all during daemon-driven sweeps (see daemonHandoffShieldKey docs).
             || daemonHandoffShieldKey()
-            || unprotectShieldKeyForCurrentWindowsUser(config.shieldKeyDpapi || '')
+            || (options.skipDpapi ? undefined : unprotectShieldKeyForCurrentWindowsUser(config.shieldKeyDpapi || ''))
             || config.shieldKey
             || process.env.FCD_SHIELD_KEY
             || process.env.FULLCOURTDEFENSE_SHIELD_KEY
             || process.env.AGENTGUARD_SHIELD_KEY,
     };
 }
+/**
+ * Credential resolution that is guaranteed to spawn NO child process — for
+ * frequent low-privilege callers (watchdog beacon every 5 min). Skips the
+ * DPAPI/PowerShell decrypt entirely; on a DPAPI-enrolled machine this may
+ * yield no shieldKey, in which case the caller sends a constrained
+ * (unauthenticated) beacon instead.
+ */
+function resolveCliCredentialsShellFree(config, overrides = {}) {
+    return resolveCliCredentials(config, overrides, { skipDpapi: true });
+}
 function isCliSetupComplete(config) {
     const creds = resolveCliCredentials(config);
     return Boolean(creds.shieldId && creds.apiKey && creds.organizationId);

package/dist/daemonForensics.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Daemon crash forensics — answers "HOW did the daemon die?" after the fact.
+ *
+ * The daemon keeps an alive-marker on disk (pid + lastAliveAt, refreshed on
+ * every heartbeat tick) and records a clean-exit stamp when it shuts down
+ * normally. Whoever runs next — a restarted daemon or the watchdog task —
+ * compares the marker against reality: a marker without a clean exit whose
+ * pid is gone means the previous daemon was killed externally (EDR/AV kill,
+ * OOM, forced reboot). That produces a post-mortem record (with the last
+ * daemon.log lines) which is reported upstream via the heartbeat/beacon, so
+ * a remote fleet machine's death is diagnosable without hands-on access.
+ *
+ * Everything here is best-effort file I/O: forensics must never break the
+ * daemon or the watchdog. Pure logic (`detectUncleanDeath`) is injectable
+ * for offline tests.
+ */
+export interface DaemonAliveMarker {
+    pid: number;
+    version?: string;
+    startedAt: string;
+    lastAliveAt: string;
+    /** Present only when the daemon shut down on purpose (SIGINT/SIGTERM/supersede). */
+    cleanExit?: {
+        at: string;
+        reason: string;
+    };
+}
+export interface DaemonPostmortem {
+    /** Version of the daemon that died. */
+    version?: string;
+    startedAt?: string;
+    /** Last proof of life — death happened within one heartbeat tick after this. */
+    lastAliveAt?: string;
+    detectedAt: string;
+    detectedBy: 'daemon' | 'watchdog';
+    uncleanExit: true;
+    /** Tail of daemon.log at detection time — the daemon's last words. */
+    lastLogLines: string[];
+    /** Set once the post-mortem reached the backend (stop re-sending). */
+    reportedAt?: string;
+}
+export declare function aliveMarkerFile(): string;
+export declare function postmortemFile(): string;
+export declare function readAliveMarker(): DaemonAliveMarker | undefined;
+export declare function readPostmortem(): DaemonPostmortem | undefined;
+/** Last non-empty lines of daemon.log (the dead daemon's final output). */
+export declare function tailDaemonLog(maxLines?: number): string[];
+/**
+ * Pure detection: did the previously recorded daemon die WITHOUT a clean exit?
+ * Returns the post-mortem (not yet persisted) or undefined when the previous
+ * daemon exited cleanly, is still alive, or nothing was recorded.
+ */
+export declare function detectUncleanDeath(input: {
+    marker: DaemonAliveMarker | undefined;
+    isPidAlive: (pid: number) => boolean;
+    detectedBy: 'daemon' | 'watchdog';
+    lastLogLines?: string[];
+    ownPid?: number;
+    now?: string;
+}): DaemonPostmortem | undefined;
+/**
+ * Called once at daemon startup: detect an unclean previous death (persisting
+ * the post-mortem for reporting), then claim the alive marker for this pid.
+ * Returns the detected post-mortem so the daemon can log it.
+ */
+export declare function recordDaemonStart(input: {
+    version?: string;
+    isPidAlive: (pid: number) => boolean;
+}): DaemonPostmortem | undefined;
+/** Watchdog-side detection (daemon not running): persist + return the post-mortem. */
+export declare function recordUncleanDeathFromWatchdog(isPidAlive: (pid: number) => boolean): DaemonPostmortem | undefined;
+/** Refresh proof-of-life; called from the daemon's heartbeat tick. */
+export declare function touchDaemonAlive(): void;
+/** Record an intentional shutdown so the next boot knows this was NOT a kill. */
+export declare function recordCleanExit(reason: string): void;
+/** Stamp the post-mortem as delivered so heartbeats stop re-sending it. */
+export declare function markPostmortemReported(): void;

package/dist/daemonForensics.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliveMarkerFile = aliveMarkerFile;
+exports.postmortemFile = postmortemFile;
+exports.readAliveMarker = readAliveMarker;
+exports.readPostmortem = readPostmortem;
+exports.tailDaemonLog = tailDaemonLog;
+exports.detectUncleanDeath = detectUncleanDeath;
+exports.recordDaemonStart = recordDaemonStart;
+exports.recordUncleanDeathFromWatchdog = recordUncleanDeathFromWatchdog;
+exports.touchDaemonAlive = touchDaemonAlive;
+exports.recordCleanExit = recordCleanExit;
+exports.markPostmortemReported = markPostmortemReported;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function stateDir() {
+    return path.join(os.homedir(), '.fullcourtdefense');
+}
+function aliveMarkerFile() {
+    return path.join(stateDir(), 'daemon.alive.json');
+}
+function postmortemFile() {
+    return path.join(stateDir(), 'daemon.postmortem.json');
+}
+function readAliveMarker() {
+    try {
+        const marker = JSON.parse(fs.readFileSync(aliveMarkerFile(), 'utf8'));
+        return marker && typeof marker.pid === 'number' ? marker : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readPostmortem() {
+    try {
+        const pm = JSON.parse(fs.readFileSync(postmortemFile(), 'utf8'));
+        return pm && pm.uncleanExit === true ? pm : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeJson(file, value) {
+    try {
+        fs.mkdirSync(stateDir(), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(value, null, 2), 'utf8');
+    }
+    catch { /* best-effort */ }
+}
+/** Last non-empty lines of daemon.log (the dead daemon's final output). */
+function tailDaemonLog(maxLines = 40) {
+    try {
+        const file = path.join(stateDir(), 'daemon.log');
+        const raw = fs.readFileSync(file, 'utf8');
+        return raw
+            .split(/\r?\n/)
+            .map(line => line.trim())
+            .filter(Boolean)
+            .slice(-maxLines)
+            .map(line => line.slice(0, 400));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Pure detection: did the previously recorded daemon die WITHOUT a clean exit?
+ * Returns the post-mortem (not yet persisted) or undefined when the previous
+ * daemon exited cleanly, is still alive, or nothing was recorded.
+ */
+function detectUncleanDeath(input) {
+    const { marker } = input;
+    if (!marker || marker.cleanExit)
+        return undefined;
+    if (marker.pid === (input.ownPid ?? process.pid))
+        return undefined;
+    if (input.isPidAlive(marker.pid))
+        return undefined;
+    return {
+        version: marker.version,
+        startedAt: marker.startedAt,
+        lastAliveAt: marker.lastAliveAt,
+        detectedAt: input.now || new Date().toISOString(),
+        detectedBy: input.detectedBy,
+        uncleanExit: true,
+        lastLogLines: input.lastLogLines ?? [],
+    };
+}
+/**
+ * Called once at daemon startup: detect an unclean previous death (persisting
+ * the post-mortem for reporting), then claim the alive marker for this pid.
+ * Returns the detected post-mortem so the daemon can log it.
+ */
+function recordDaemonStart(input) {
+    const postmortem = detectUncleanDeath({
+        marker: readAliveMarker(),
+        isPidAlive: input.isPidAlive,
+        detectedBy: 'daemon',
+        lastLogLines: tailDaemonLog(),
+    });
+    if (postmortem)
+        writeJson(postmortemFile(), postmortem);
+    const now = new Date().toISOString();
+    const marker = {
+        pid: process.pid,
+        version: input.version,
+        startedAt: now,
+        lastAliveAt: now,
+    };
+    writeJson(aliveMarkerFile(), marker);
+    return postmortem;
+}
+/** Watchdog-side detection (daemon not running): persist + return the post-mortem. */
+function recordUncleanDeathFromWatchdog(isPidAlive) {
+    const existing = readPostmortem();
+    const postmortem = detectUncleanDeath({
+        marker: readAliveMarker(),
+        isPidAlive,
+        detectedBy: 'watchdog',
+        lastLogLines: tailDaemonLog(),
+    });
+    if (!postmortem)
+        return existing;
+    // Don't clobber an identical, possibly already-reported record.
+    if (existing && existing.lastAliveAt === postmortem.lastAliveAt && existing.startedAt === postmortem.startedAt) {
+        return existing;
+    }
+    writeJson(postmortemFile(), postmortem);
+    return postmortem;
+}
+/** Refresh proof-of-life; called from the daemon's heartbeat tick. */
+function touchDaemonAlive() {
+    const marker = readAliveMarker();
+    if (!marker || marker.pid !== process.pid)
+        return;
+    marker.lastAliveAt = new Date().toISOString();
+    writeJson(aliveMarkerFile(), marker);
+}
+/** Record an intentional shutdown so the next boot knows this was NOT a kill. */
+function recordCleanExit(reason) {
+    const marker = readAliveMarker();
+    if (!marker || marker.pid !== process.pid)
+        return;
+    marker.cleanExit = { at: new Date().toISOString(), reason: reason.slice(0, 120) };
+    writeJson(aliveMarkerFile(), marker);
+}
+/** Stamp the post-mortem as delivered so heartbeats stop re-sending it. */
+function markPostmortemReported() {
+    const pm = readPostmortem();
+    if (!pm || pm.reportedAt)
+        return;
+    pm.reportedAt = new Date().toISOString();
+    writeJson(postmortemFile(), pm);
+}

package/dist/index.js

@@ -53,6 +53,7 @@ const onboard_1 = require("./commands/onboard");
 const uninstallAll_1 = require("./commands/uninstallAll");
 const autoProtect_1 = require("./commands/autoProtect");
 const daemon_1 = require("./commands/daemon");
+const watchdog_1 = require("./commands/watchdog");
 const desktopChatGuard_1 = require("./commands/desktopChatGuard");
 const windowsAudit_1 = require("./commands/windowsAudit");
 const shellGuard_1 = require("./commands/shellGuard");
@@ -873,6 +874,17 @@ async function main() {
             await (0, daemon_1.daemonCommand)(args, config);
             break;
         }
+        case 'watchdog': {
+            // Internal: 5-minute scheduled-task tick — daemon liveness beacon,
+            // crash post-mortem capture, and dead-daemon revival. Shell-quiet.
+            const args = {
+                apiUrl: flags['api-url'],
+                shieldId: flags['shield-id'],
+                shieldKey: flags['shield-key'],
+            };
+            await (0, watchdog_1.watchdogCommand)(args, config);
+            break;
+        }
         case 'desktop-chat-guard': {
             const args = {
                 apiUrl: flags['api-url'],

package/dist/securityAgents.d.ts

@@ -0,0 +1,26 @@
+/**
+ * EDR / antivirus presence probe (Windows).
+ *
+ * Detects which endpoint-security products run on a fleet machine so the
+ * console can explain machine-side interference (blocked PowerShell, killed
+ * daemons, quarantined installs) instead of showing a bare "stale" badge.
+ *
+ * Deliberately shell-quiet: detection is read-only `reg.exe query` of known
+ * service keys — the same benign mechanism the posture probe already uses.
+ * NO PowerShell/WMI (spawning those is exactly the behavior EDRs flag).
+ * Results are cached in-process; the probe re-runs at most every 6 hours.
+ */
+export interface SecurityAgentsReport {
+    /** Human-readable product names detected on this machine. */
+    products: string[];
+    checkedAt: string;
+}
+/** Windows service name → product label. Service keys are stable across versions. */
+export declare const KNOWN_SECURITY_SERVICES: Record<string, string>;
+/**
+ * Pure core — service-existence check is injectable for offline tests.
+ * Returns undefined on non-Windows platforms (field omitted from payloads).
+ */
+export declare function detectSecurityAgents(serviceExists?: (service: string) => boolean, platform?: NodeJS.Platform): SecurityAgentsReport | undefined;
+/** Cached probe for periodic callers (daemon heartbeat every 5 min must not re-spawn reg.exe each tick). */
+export declare function getSecurityAgentsReport(): SecurityAgentsReport | undefined;

package/dist/securityAgents.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_SECURITY_SERVICES = void 0;
+exports.detectSecurityAgents = detectSecurityAgents;
+exports.getSecurityAgentsReport = getSecurityAgentsReport;
+const child_process_1 = require("child_process");
+/** Windows service name → product label. Service keys are stable across versions. */
+exports.KNOWN_SECURITY_SERVICES = {
+    WinDefend: 'Microsoft Defender',
+    Sense: 'Microsoft Defender for Endpoint',
+    CSFalconService: 'CrowdStrike Falcon',
+    SentinelAgent: 'SentinelOne',
+    CylanceSvc: 'BlackBerry Cylance',
+    xagt: 'Trellix (FireEye) Endpoint',
+    CbDefense: 'Carbon Black Cloud',
+    CarbonBlack: 'Carbon Black EDR',
+    mfemms: 'Trellix (McAfee) ePO',
+    ekrn: 'ESET Endpoint',
+    EPSecurityService: 'Bitdefender Endpoint',
+    'Sophos Endpoint Defense Service': 'Sophos Intercept X',
+    klnagent: 'Kaspersky Endpoint',
+    AVP: 'Kaspersky Endpoint',
+    Amsp: 'Trend Micro',
+    ElasticEndpoint: 'Elastic Defend',
+    HuntressAgent: 'Huntress',
+    cyserver: 'Palo Alto Cortex XDR',
+    CiscoAMP: 'Cisco Secure Endpoint',
+    WRSVC: 'Webroot',
+};
+function windowsServiceExists(service) {
+    const result = (0, child_process_1.spawnSync)('reg', [
+        'query', `HKLM\\SYSTEM\\CurrentControlSet\\Services\\${service}`,
+    ], { stdio: 'ignore', windowsHide: true, timeout: 5_000 });
+    return result.status === 0;
+}
+/**
+ * Pure core — service-existence check is injectable for offline tests.
+ * Returns undefined on non-Windows platforms (field omitted from payloads).
+ */
+function detectSecurityAgents(serviceExists = windowsServiceExists, platform = process.platform) {
+    if (platform !== 'win32')
+        return undefined;
+    const products = [];
+    for (const [service, product] of Object.entries(exports.KNOWN_SECURITY_SERVICES)) {
+        try {
+            if (serviceExists(service) && !products.includes(product))
+                products.push(product);
+        }
+        catch { /* one bad probe never kills the report */ }
+    }
+    return { products, checkedAt: new Date().toISOString() };
+}
+const CACHE_TTL_MS = 6 * 60 * 60_000;
+let cached;
+let cachedAt = 0;
+/** Cached probe for periodic callers (daemon heartbeat every 5 min must not re-spawn reg.exe each tick). */
+function getSecurityAgentsReport() {
+    if (process.platform !== 'win32')
+        return undefined;
+    if (!cached || Date.now() - cachedAt > CACHE_TTL_MS) {
+        cached = detectSecurityAgents();
+        cachedAt = Date.now();
+    }
+    return cached;
+}

package/dist/telemetry.d.ts

@@ -36,6 +36,20 @@ export interface FlushInput {
     daemon?: boolean;
     /** Windows Claude Desktop chat guard liveness (advisory prompt protection). */
     desktopChatGuard?: boolean;
+    /** EDR/AV products detected on this machine (Windows service probe). */
+    securityAgents?: string[];
+    /** Could powershell.exe/pwsh.exe be spawned at all? (from real DPAPI work, never a dedicated spawn) */
+    powershellSpawnOk?: boolean;
+    /** Did the DPAPI-protected shield key actually decrypt? */
+    powershellDecryptOk?: boolean;
+    /** Post-mortem of a previous daemon that died without a clean shutdown. */
+    lastCrash?: {
+        version?: string;
+        startedAt?: string;
+        lastAliveAt?: string;
+        detectedAt: string;
+        detectedBy: 'daemon' | 'watchdog';
+    };
     timeoutMs?: number;
 }
 /** Drain the spool to the backend in one batch (+ optional heartbeat). Returns accepted count. */

package/dist/telemetry.js

@@ -170,6 +170,13 @@ async function flushSpool(input) {
                         // Logging + Transcription). Keeps the fleet dashboard's coverage
                         // fresh on every ping — undefined (omitted) on other platforms.
                         shellAudit: (0, windowsAudit_1.getShellAuditReport)(),
+                        // Machine-environment diagnostics: which EDR/AV runs here, can
+                        // PowerShell spawn, and did a previous daemon die uncleanly —
+                        // the data that explains a "stale" machine remotely.
+                        securityAgents: input.securityAgents,
+                        powershellSpawnOk: input.powershellSpawnOk,
+                        powershellDecryptOk: input.powershellDecryptOk,
+                        lastCrash: input.lastCrash,
                     }
                     : undefined,
                 events: batch,

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.21.28"
+  "version": "1.21.29"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.21.28",
+  "version": "1.21.29",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -36,6 +36,7 @@
     "test:daemon-e2e": "npm run build && node scripts/test-daemon-e2e.js",
     "test:daemon-discovery-args": "npm run build && node scripts/test-daemon-discovery-args.js",
     "test:daemon-discover-stderr": "npm run build && node scripts/test-daemon-discover-stderr.js",
+    "test:watchdog-forensics": "npm run build && node scripts/test-watchdog-forensics.js",
     "test:macos-daemon-path": "npm run build && node scripts/test-macos-daemon-path.js",
     "test:machine-action-signing": "npm run build && node scripts/test-machine-action-signing.js",
     "test:integrity": "npm run build && node scripts/test-integrity.js",