fullcourtdefense-cli 1.26.13 → 1.26.15

package/dist/commands/daemon.js

@@ -109,16 +109,50 @@ const DEBOUNCE_MS = envMs('FCD_DAEMON_DEBOUNCE_MS', 2_000);
 const RESCAN_INTERVAL_MS = envMs('FCD_DAEMON_RESCAN_MS', 5 * 60_000);
 /** Heartbeat / spool flush cadence. */
 const HEARTBEAT_INTERVAL_MS = envMs('FCD_DAEMON_HEARTBEAT_MS', 5 * 60_000);
+/**
+ * Floor between integrity-triggered repairs. The drift watcher reacts to config
+ * CHANGES; this path reacts to a failing verdict, which persists until fixed. If
+ * a repair cannot fix it (no write permission, a config owned by another
+ * install) an uncooled retry would re-run protect-all every heartbeat forever.
+ */
+const INTEGRITY_HEAL_COOLDOWN_MS = envMs('FCD_INTEGRITY_HEAL_COOLDOWN_MS', 60 * 60_000);
 /** Bundle (mode / suspension / policy version) poll cadence. */
 const BUNDLE_POLL_MS = envMs('FCD_DAEMON_BUNDLE_POLL_MS', 60_000);
+/**
+ * Fetch budget for the daemon's background bundle poll. Deliberately NOT the
+ * hot-path default (getRuntimeBundle's 1.5s), which exists so a hook never
+ * stalls a developer's command. Nothing waits on this poll — it runs on its own
+ * 60s timer inside a 45s deadline — so a slow-but-healthy control plane must be
+ * waited out, not reported as an outage. At 1.5s roughly 10% of polls aborted
+ * on ordinary p95 latency spikes and each one raised a `network_down` distress
+ * signal, while `doctor --health` (already passing 10s) stayed green against
+ * the same backend: alert noise with no failure behind it.
+ */
+const BUNDLE_FETCH_TIMEOUT_MS = envMs('FCD_DAEMON_BUNDLE_TIMEOUT_MS', 10_000);
 /**
  * Hard ceilings for one poll attempt (see startPollLoop). Generous multiples of
- * the work each poll actually does — a bundle poll is a 1.5s fetch plus an 8s
+ * the work each poll actually does — a bundle poll is a 10s fetch plus an 8s
  * snapshot refresh, a heartbeat is a spool flush plus a log upload — so these
  * only ever fire on a genuinely hung socket, never on a merely slow network.
  */
 const BUNDLE_POLL_DEADLINE_MS = envMs('FCD_DAEMON_BUNDLE_DEADLINE_MS', 45_000);
 const HEARTBEAT_DEADLINE_MS = envMs('FCD_DAEMON_HEARTBEAT_DEADLINE_MS', 120_000);
+/**
+ * Wake-from-sleep detection. Timers are the only awake clock we have: a beat
+ * that observes far more wall time than its own interval proves the machine
+ * was suspended in between. The jump bound is a generous multiple of the beat
+ * so ordinary event-loop lag or a busy CPU can never look like a resume.
+ */
+const RESUME_BEAT_MS = envMs('FCD_DAEMON_RESUME_BEAT_MS', 30_000);
+const RESUME_JUMP_MS = envMs('FCD_DAEMON_RESUME_JUMP_MS', 120_000);
+/**
+ * Report-in attempts after a resume, and the base delay between them (linear
+ * backoff: 10s, 20s, 30s, 40s). Sized to outlast a normal Wi-Fi reassociation
+ * plus DHCP/DNS, so waking on a slow network costs seconds of staleness rather
+ * than a whole reporting window.
+ */
+const RESUME_REPORT_ATTEMPTS = envMs('FCD_DAEMON_RESUME_ATTEMPTS', 5);
+const RESUME_RETRY_BASE_MS = envMs('FCD_DAEMON_RESUME_RETRY_MS', 10_000);
 /** Delay before the one-time initial discovery sweep on a fresh machine. */
 const INITIAL_DISCOVER_DELAY_MS = envMs('FCD_DAEMON_INITIAL_DISCOVER_MS', 2 * 60_000);
 /** A discovery upload older than this is stale — the daemon catches up itself. */
@@ -505,6 +539,7 @@ async function runDaemon(args, config) {
     let quietUntil = 0; // ignore events until this time (self-writes)
     let debounceTimer = null;
     let reprotecting = false;
+    let lastIntegrityHealAt = 0; // cooldown anchor for integrity-triggered repairs
     let suspended = false;
     let stopped = false;
     const executingActionIds = new Set();
@@ -582,16 +617,23 @@ async function runDaemon(args, config) {
         }
         catch { /* next tick */ }
     };
-    const reprotect = async (reasonPaths) => {
+    /**
+     * One repair path, two triggers: a watched config CHANGED (drift), or the
+     * integrity check reported a reason protect-all can fix (integrity). Keeping
+     * them on the same function preserves the reprotecting/quiet-window guards —
+     * a second copy would race this one and re-enter protect-all concurrently.
+     */
+    const reprotect = async (reasonPaths, cause = 'drift') => {
+        const headline = cause === 'integrity' ? 'Integrity self-heal' : 'Config drift detected';
         if (reprotecting || stopped)
             return;
         if (suspended) {
-            log(`Config drift detected (${reasonPaths.join(', ')}) but machine is suspended — not re-protecting.`);
+            log(`${headline} (${reasonPaths.join(', ')}) but machine is suspended — not re-protecting.`);
             return;
         }
         reprotecting = true;
         quietUntil = Date.now() + SELF_WRITE_QUIET_MS;
-        log(`Config drift detected: ${reasonPaths.join(', ')} — re-running protect-all.`);
+        log(`${headline}: ${reasonPaths.join(', ')} — re-running protect-all.`);
         try {
             const repaired = await (0, protectionRepair_1.repairProtection)({ ...args, dryRun: undefined }, config);
             quietUntil = Date.now() + SELF_WRITE_QUIET_MS;
@@ -601,7 +643,9 @@ async function runDaemon(args, config) {
             if (!quiet) {
                 (0, notify_1.notifyOs)({
                     title: 'FullCourtDefense re-protected this machine',
-                    message: 'An MCP or hook config changed; the FullCourtDefense gateway was re-applied.',
+                    message: cause === 'integrity'
+                        ? 'Protection was reported incomplete; the FullCourtDefense gateway was re-applied.'
+                        : 'An MCP or hook config changed; the FullCourtDefense gateway was re-applied.',
                     url: (0, notify_1.consoleUrl)('/agent-security/users?view=desktop'),
                 });
             }
@@ -990,6 +1034,7 @@ async function runDaemon(args, config) {
                     machineId: identity.machineId,
                     force: true,
                     ttlMs: 0,
+                    timeoutMs: BUNDLE_FETCH_TIMEOUT_MS,
                 });
                 log(bundle.policyHash
                     ? `Policy refresh: bundle applied (hash ${bundle.policyHash.slice(0, 12)}…, ${bundle.policyCount ?? 0} policies).`
@@ -1155,6 +1200,7 @@ async function runDaemon(args, config) {
                 machineName: identity.hostname,
                 machineId: identity.machineId,
                 force: true,
+                timeoutMs: BUNDLE_FETCH_TIMEOUT_MS,
             });
             if (typeof bundle.pollIntervalMs === 'number' && Number.isFinite(bundle.pollIntervalMs)) {
                 bundlePollBaseMs = Math.min(Math.max(bundle.pollIntervalMs, 15_000), 60 * 60_000);
@@ -1260,8 +1306,33 @@ async function runDaemon(args, config) {
         recoverCredentialsIfMissing();
         if (!creds.shieldId)
             return;
+        // Did THIS beat actually record daemon liveness upstream? `flushSpool`
+        // reports every failure by returning null and never throws, so without
+        // this flag a heartbeat that never left the machine was indistinguishable
+        // from a delivered one — and the loop happily waited a full cadence before
+        // trying again. `null` also covers the case where a hook flusher held the
+        // flush lock, which drops the daemon marker specifically (hook flushes do
+        // not set `daemon: true`), so retrying soon is right in that case too.
+        let reported = false;
         try {
-            const integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+            let integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+            // A failing verdict used to be REPORTED and nothing more, so a machine
+            // could sit "Damaged" in the console indefinitely on a reason the daemon
+            // already knows how to fix — the drift watcher only fires when a config
+            // file changes, and a stale gateway path changes nothing. Heal first, then
+            // report what is true AFTER the repair rather than the verdict that
+            // triggered it.
+            if (!integrity.ok
+                && !suspended
+                && Date.now() - lastIntegrityHealAt >= INTEGRITY_HEAL_COOLDOWN_MS
+                && (0, integrity_1.hasHealableIntegrityReason)(integrity.reasons)) {
+                lastIntegrityHealAt = Date.now();
+                await reprotect(integrity.reasons, 'integrity');
+                integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+                log(integrity.ok
+                    ? 'Integrity self-heal: protection restored.'
+                    : `Integrity self-heal: still failing (${integrity.reasons.join(', ')}) — reported for support.`);
+            }
             // Report a previous daemon's unclean death exactly once.
             const crash = (0, daemonForensics_1.readPostmortem)();
             const unreportedCrash = crash && !crash.reportedAt ? crash : undefined;
@@ -1293,6 +1364,7 @@ async function runDaemon(args, config) {
                     }
                     : undefined,
             });
+            reported = result !== null;
             if (result && unreportedCrash)
                 (0, daemonForensics_1.markPostmortemReported)();
             if (result && result.accepted > 0)
@@ -1303,8 +1375,13 @@ async function runDaemon(args, config) {
         }
         catch { /* spool stays on disk for the next tick */ }
         // Settle any in-flight upgrade_cli action (success once the new build is
-        // live, failure when the target never arrived).
+        // live, failure when the target never arrived). Runs BEFORE the failure
+        // signal below so a lost heartbeat can never strand a pending upgrade.
         await verifyPendingUpgrade();
+        // Surface the miss to the caller (poll loop / resume path) so it retries in
+        // seconds. Nothing else can tell them: liveness has exactly one writer.
+        if (!reported)
+            throw new Error('heartbeat did not reach the backend — daemon liveness was not recorded');
     };
     // --- boot ---------------------------------------------------------------
     // Self-heal autostart + watchdog tasks: machines installed by older versions
@@ -1330,7 +1407,19 @@ async function runDaemon(args, config) {
     // would report a false "damaged" state (and fire admin integrity alerts)
     // for a condition the very next line repairs.
     await reprotect(['startup pass']);
-    await heartbeat();
+    // The FIRST beat must not be able to abort the rest of this function.
+    // `heartbeat` throws when the report did not reach the backend (that is how
+    // the poll loop knows to retry in seconds), and an exception here propagates
+    // out of `runDaemon` and skips every loop registered below it — the heartbeat
+    // loop, the resume timer and the bundle poll. The process itself survives on
+    // the `unhandledRejection` handler, which is worse than dying: it holds the
+    // pid lock, so the scheduled task declines to start a replacement, and it
+    // never polls the bundle, so no remote action can reach it. Booting before
+    // the network is up (captive portal, VPN, resumed in a lift) is routine, and
+    // the heartbeat loop below retries within seconds.
+    await heartbeat().catch(error => {
+        log(`First heartbeat did not reach the backend (${error?.message || String(error)}) — the heartbeat loop will retry shortly.`);
+    });
     // Claude Desktop chat guard (Windows, advisory): Claude Desktop's regular
     // chat has no hook and never hits an MCP server, so it is the one machine
     // surface neither hooks nor the gateway can see. Supervise the advisory guard
@@ -1471,6 +1560,60 @@ async function runDaemon(args, config) {
         },
         onError: error => log(`Heartbeat error: ${error instanceof Error ? error.message : String(error)}`),
     });
+    // ── Wake-from-sleep recovery ──────────────────────────────────────────────
+    // Nothing in the agent reacts to a resume, so after a laptop wakes the
+    // machine kept reporting "daemon down" until the next SCHEDULED heartbeat —
+    // a full cadence later. Worse, the liveness marker stayed stale for that
+    // whole window, which is what the watchdog reads before deciding the daemon
+    // is wedged. Refreshing the marker the moment we notice the wall-clock jump
+    // closes the reporting gap and removes the evidence of a hang that never
+    // happened. Both calls go through runWithDeadline, so a resume that lands on
+    // sockets which died during sleep cannot leak an unhandled rejection.
+    // The resume beat is RETRIED, because it fires the instant the wall-clock
+    // jump is noticed — which on a laptop is reliably before Wi-Fi has
+    // reassociated. As a single shot, the one beat whose whole job is to prove
+    // the daemon survived the sleep was also the likeliest to be lost, and modern
+    // standby routinely re-suspends the machine before the next cadence tick, so
+    // liveness could stay stale indefinitely while IDE-hook flushes kept the
+    // machine "online" — a live daemon displayed as down.
+    let resumeReportInFlight = false;
+    const reportInAfterResume = async () => {
+        if (resumeReportInFlight)
+            return; // a previous resume is still catching up
+        resumeReportInFlight = true;
+        try {
+            for (let attempt = 1; attempt <= RESUME_REPORT_ATTEMPTS; attempt++) {
+                let failed = false;
+                const outcome = await (0, pollLoop_1.runWithDeadline)({
+                    run: heartbeat,
+                    deadlineMs: HEARTBEAT_DEADLINE_MS,
+                    onError: () => { failed = true; },
+                });
+                if (outcome === 'settled' && !failed)
+                    return; // liveness recorded
+                if (attempt === RESUME_REPORT_ATTEMPTS) {
+                    log(`Resume report-in did not land after ${attempt} attempt(s) — the scheduled heartbeat keeps retrying.`);
+                    return;
+                }
+                await new Promise(resolve => setTimeout(resolve, RESUME_RETRY_BASE_MS * attempt));
+            }
+        }
+        finally {
+            resumeReportInFlight = false;
+        }
+    };
+    let lastResumeBeatMs = Date.now();
+    const resumeTimer = setInterval(() => {
+        const now = Date.now();
+        const drift = now - lastResumeBeatMs;
+        lastResumeBeatMs = now;
+        if (drift < RESUME_JUMP_MS)
+            return;
+        log(`Resume detected: ${Math.round(drift / 1000)}s of wall time elapsed while suspended — refreshing liveness and reporting in now.`);
+        (0, daemonForensics_1.touchDaemonAlive)();
+        void reportInAfterResume();
+        void (0, pollLoop_1.runWithDeadline)({ run: pollBundle, deadlineMs: BUNDLE_POLL_DEADLINE_MS });
+    }, RESUME_BEAT_MS);
     // PowerShell transcript retention (Windows): the Transcription policy FCD
     // enables writes a file per session forever — prune anything older than the
     // retention window once a day (plus once shortly after boot, so laptops
@@ -1496,6 +1639,7 @@ async function runDaemon(args, config) {
         clearInterval(rescanTimer);
         bundleLoop.stop();
         heartbeatLoop.stop();
+        clearInterval(resumeTimer);
         clearTimeout(transcriptPruneBootTimer);
         clearInterval(transcriptPruneTimer);
         clearTimeout(discoverCatchUpBootTimer);

package/dist/commands/watchdog.js

@@ -66,6 +66,16 @@ async function watchdogCommand(args, config) {
     const state = (0, daemon_1.daemonRuntimeState)();
     let relaunched = false;
     let postmortem = (0, daemonForensics_1.readPostmortem)();
+    // Our own tick cadence is the only awake clock available (see
+    // detectMachineSuspension): a gap far larger than the interval proves the
+    // MACHINE was suspended, which fully explains a stale daemon marker. Read
+    // the previous tick BEFORE recording this one, and record unconditionally so
+    // an early return below still leaves the next tick a baseline.
+    const machineSuspended = (0, daemonForensics_1.detectMachineSuspension)({
+        previousTickAt: (0, daemonForensics_1.readWatchdogTick)()?.lastTickAt,
+        nowMs: Date.now(),
+    });
+    (0, daemonForensics_1.recordWatchdogTick)();
     // Beyond "the pid exists": a wedged daemon or a recycled pid both pass a
     // plain pid check while the machine has no working control plane. Classify
     // with the alive-marker freshness + a verdict-pipe probe.
@@ -77,6 +87,7 @@ async function watchdogCommand(args, config) {
             marker: (0, daemonForensics_1.readAliveMarker)(),
             staleAfterMs: (0, daemonForensics_1.daemonHungAfterMs)(),
             pipeProbe: await (0, verdictIpcClient_1.probeVerdictServer)(1_500),
+            machineSuspended,
         });
     }
     if (health === 'hung' && state.pid && process.env.FCD_WATCHDOG_NO_RELAUNCH !== '1') {
@@ -85,6 +96,9 @@ async function watchdogCommand(args, config) {
         // clean. The distress ledger survives; the fresh daemon's first heartbeat
         // ships the story to the fleet.
         (0, distress_1.reportDistress)('watchdog', distress_1.DISTRESS.DAEMON_HUNG, `daemon pid ${state.pid} unresponsive (alive-marker stale + verdict pipe silent) — recycled by watchdog`);
+        // Claim the kill first: otherwise the next daemon boots, finds a marker
+        // with no clean-exit stamp, and reports EDR/AV killed it.
+        (0, daemonForensics_1.recordWatchdogRecycle)(state.pid);
         (0, daemon_1.forceStopPid)(state.pid);
     }
     // NOTE for 'pid_reused': the pid belongs to an UNRELATED process — never

package/dist/daemonForensics.d.ts

@@ -98,7 +98,81 @@ export declare function classifyDaemonHealth(input: {
     marker: DaemonAliveMarker | undefined;
     staleAfterMs: number;
     pipeProbe: 'responsive' | 'unresponsive' | 'no-endpoint' | 'not-probed';
+    /**
+     * True when the machine itself stopped running since the previous check
+     * (sleep/hibernate). Marker staleness is then not evidence of anything —
+     * see detectMachineSuspension.
+     */
+    machineSuspended?: boolean;
     nowMs?: number;
 }): DaemonHealthClass;
+/**
+ * WHY THIS EXISTS (a real developer-machine incident, 2026-08)
+ * Staleness above is a WALL-CLOCK measurement, but the daemon can only refresh
+ * its marker while the CPU is actually running. A laptop that sleeps longer
+ * than `staleAfterMs` therefore produces a stale marker through no fault of
+ * the daemon — and the watchdog read that as "wedged" and killed a perfectly
+ * healthy process on every lid-open. One developer machine was recycled 8
+ * times in 7 days, each kill also writing a post-mortem blaming EDR/AV for
+ * what was in fact our own watchdog.
+ *
+ * There is no portable awake clock to compare against. On Windows
+ * `os.uptime()` still INCLUDES sleep (measured on the incident machine: 26.66h
+ * of "uptime" spanning a 13h sleep), and reading the kernel power log would
+ * mean spawning PowerShell every 5 minutes — precisely the pattern that gets
+ * this agent killed by EDR, which the watchdog is documented to avoid.
+ *
+ * What we do have is our OWN cadence. A fixed-interval scheduled task that
+ * observes far more wall time between two of its own ticks than its interval
+ * allows has proven the machine was not running in between. That gap explains
+ * the daemon's stale marker, so staleness stops counting as evidence.
+ */
+/** The watchdog scheduled task's interval — its ticks are the awake clock. */
+export declare const WATCHDOG_CADENCE_MS: number;
+/** Gaps beyond cadence x this factor cannot be explained by jitter or a slow tick. */
+export declare const SUSPEND_GAP_FACTOR = 3;
+/** The watchdog's own proof that IT was running, persisted between ticks. */
+export interface WatchdogTick {
+    lastTickAt: string;
+}
+export declare function watchdogTickFile(): string;
+export declare function readWatchdogTick(): WatchdogTick | undefined;
+export declare function recordWatchdogTick(now?: Date): void;
+/**
+ * Pure: did the machine stop running between the previous watchdog tick and
+ * this one?
+ *
+ * A MISSING baseline answers FALSE (i.e. "not suspended", the pre-existing
+ * behavior) rather than granting grace. That looks backwards next to "never
+ * kill on a guess", but it is the safer failure mode overall: the grace
+ * depends on a tick file, and if that file can never be persisted (locked
+ * directory, full disk, AV quarantine) then every tick would see no baseline,
+ * grant grace forever, and silently disable the watchdog's ability to recycle
+ * a genuinely wedged daemon. Answering false means a persistence failure
+ * degrades to the known old behavior instead of to no protection at all, and
+ * costs at most one stale verdict on the very first tick after upgrade.
+ *
+ * A baseline that EXISTS but cannot be trusted (unparseable, or the clock
+ * moved backwards under us) still answers TRUE: there we have positive
+ * evidence that time is not measurable, which is exactly when a staleness
+ * comparison must not be believed.
+ */
+export declare function detectMachineSuspension(input: {
+    previousTickAt?: string;
+    nowMs: number;
+    cadenceMs?: number;
+    factor?: number;
+}): boolean;
+/**
+ * Stamp the marker before the watchdog force-stops a wedged daemon, so the
+ * NEXT boot's `detectUncleanDeath` does not report our own recycle as an
+ * external kill. The reason is distinct from a real shutdown's signal name,
+ * and the recycle stays visible via the `daemon_hung` distress entry and the
+ * beacon's `daemonHealth` field — this only suppresses the false EDR/AV story.
+ *
+ * Keyed on the DAEMON's pid (not `process.pid`): the watchdog is a different
+ * process, which is exactly why `recordCleanExit` cannot be reused here.
+ */
+export declare function recordWatchdogRecycle(daemonPid: number): void;
 /** Stamp the post-mortem as delivered so heartbeats stop re-sending it. */
 export declare function markPostmortemReported(): void;

package/dist/daemonForensics.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUSPEND_GAP_FACTOR = exports.WATCHDOG_CADENCE_MS = void 0;
 exports.aliveMarkerFile = aliveMarkerFile;
 exports.postmortemFile = postmortemFile;
 exports.readAliveMarker = readAliveMarker;
@@ -45,6 +46,11 @@ exports.touchDaemonAlive = touchDaemonAlive;
 exports.recordCleanExit = recordCleanExit;
 exports.daemonHungAfterMs = daemonHungAfterMs;
 exports.classifyDaemonHealth = classifyDaemonHealth;
+exports.watchdogTickFile = watchdogTickFile;
+exports.readWatchdogTick = readWatchdogTick;
+exports.recordWatchdogTick = recordWatchdogTick;
+exports.detectMachineSuspension = detectMachineSuspension;
+exports.recordWatchdogRecycle = recordWatchdogRecycle;
 exports.markPostmortemReported = markPostmortemReported;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -199,12 +205,109 @@ function classifyDaemonHealth(input) {
         return 'healthy';
     if (input.pipeProbe === 'responsive')
         return 'healthy';
+    // The marker is stale, but the daemon had no CPU with which to refresh it.
+    // Judging it now would convict a healthy daemon of the machine's sleep, so
+    // defer: the next tick runs after a full awake interval and decides fairly.
+    if (input.machineSuspended)
+        return 'indeterminate';
     if (input.pipeProbe === 'unresponsive')
         return 'hung';
     if (input.pipeProbe === 'no-endpoint')
         return 'pid_reused';
     return 'indeterminate';
 }
+// ---------------------------------------------------------------------------
+// Suspend awareness
+// ---------------------------------------------------------------------------
+/**
+ * WHY THIS EXISTS (a real developer-machine incident, 2026-08)
+ * Staleness above is a WALL-CLOCK measurement, but the daemon can only refresh
+ * its marker while the CPU is actually running. A laptop that sleeps longer
+ * than `staleAfterMs` therefore produces a stale marker through no fault of
+ * the daemon — and the watchdog read that as "wedged" and killed a perfectly
+ * healthy process on every lid-open. One developer machine was recycled 8
+ * times in 7 days, each kill also writing a post-mortem blaming EDR/AV for
+ * what was in fact our own watchdog.
+ *
+ * There is no portable awake clock to compare against. On Windows
+ * `os.uptime()` still INCLUDES sleep (measured on the incident machine: 26.66h
+ * of "uptime" spanning a 13h sleep), and reading the kernel power log would
+ * mean spawning PowerShell every 5 minutes — precisely the pattern that gets
+ * this agent killed by EDR, which the watchdog is documented to avoid.
+ *
+ * What we do have is our OWN cadence. A fixed-interval scheduled task that
+ * observes far more wall time between two of its own ticks than its interval
+ * allows has proven the machine was not running in between. That gap explains
+ * the daemon's stale marker, so staleness stops counting as evidence.
+ */
+/** The watchdog scheduled task's interval — its ticks are the awake clock. */
+exports.WATCHDOG_CADENCE_MS = 5 * 60_000;
+/** Gaps beyond cadence x this factor cannot be explained by jitter or a slow tick. */
+exports.SUSPEND_GAP_FACTOR = 3;
+function watchdogTickFile() {
+    return path.join(stateDir(), 'watchdog.tick.json');
+}
+function readWatchdogTick() {
+    try {
+        const tick = JSON.parse(fs.readFileSync(watchdogTickFile(), 'utf8'));
+        return tick && typeof tick.lastTickAt === 'string' ? tick : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function recordWatchdogTick(now = new Date()) {
+    writeJson(watchdogTickFile(), { lastTickAt: now.toISOString() });
+}
+/**
+ * Pure: did the machine stop running between the previous watchdog tick and
+ * this one?
+ *
+ * A MISSING baseline answers FALSE (i.e. "not suspended", the pre-existing
+ * behavior) rather than granting grace. That looks backwards next to "never
+ * kill on a guess", but it is the safer failure mode overall: the grace
+ * depends on a tick file, and if that file can never be persisted (locked
+ * directory, full disk, AV quarantine) then every tick would see no baseline,
+ * grant grace forever, and silently disable the watchdog's ability to recycle
+ * a genuinely wedged daemon. Answering false means a persistence failure
+ * degrades to the known old behavior instead of to no protection at all, and
+ * costs at most one stale verdict on the very first tick after upgrade.
+ *
+ * A baseline that EXISTS but cannot be trusted (unparseable, or the clock
+ * moved backwards under us) still answers TRUE: there we have positive
+ * evidence that time is not measurable, which is exactly when a staleness
+ * comparison must not be believed.
+ */
+function detectMachineSuspension(input) {
+    const cadence = input.cadenceMs && input.cadenceMs > 0 ? input.cadenceMs : exports.WATCHDOG_CADENCE_MS;
+    const factor = input.factor && input.factor > 0 ? input.factor : exports.SUSPEND_GAP_FACTOR;
+    if (!input.previousTickAt)
+        return false;
+    const previous = Date.parse(input.previousTickAt);
+    if (!Number.isFinite(previous))
+        return true;
+    const gap = input.nowMs - previous;
+    if (gap < 0)
+        return true;
+    return gap > cadence * factor;
+}
+/**
+ * Stamp the marker before the watchdog force-stops a wedged daemon, so the
+ * NEXT boot's `detectUncleanDeath` does not report our own recycle as an
+ * external kill. The reason is distinct from a real shutdown's signal name,
+ * and the recycle stays visible via the `daemon_hung` distress entry and the
+ * beacon's `daemonHealth` field — this only suppresses the false EDR/AV story.
+ *
+ * Keyed on the DAEMON's pid (not `process.pid`): the watchdog is a different
+ * process, which is exactly why `recordCleanExit` cannot be reused here.
+ */
+function recordWatchdogRecycle(daemonPid) {
+    const marker = readAliveMarker();
+    if (!marker || marker.pid !== daemonPid)
+        return;
+    marker.cleanExit = { at: new Date().toISOString(), reason: 'watchdog-recycle' };
+    writeJson(aliveMarkerFile(), marker);
+}
 /** Stamp the post-mortem as delivered so heartbeats stop re-sending it. */
 function markPostmortemReported() {
     const pm = readPostmortem();

package/dist/integrity.d.ts

@@ -1,4 +1,6 @@
 export type IntegrityReason = 'mcp_gateway_missing' | 'mcp_gateway_stale_path' | 'cursor_hook_missing' | 'cursor_hook_stale_path' | 'cursor_hook_changed' | 'claude_hook_missing' | 'claude_hook_stale_path' | 'claude_hook_changed' | 'daemon_not_running' | 'runtime_bundle_stale';
+/** Pure: does this verdict contain anything a protect-all pass could fix? */
+export declare function hasHealableIntegrityReason(reasons: readonly string[]): boolean;
 export interface LocalIntegrityReport {
     ok: boolean;
     reasons: IntegrityReason[];

package/dist/integrity.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasHealableIntegrityReason = hasHealableIntegrityReason;
 exports.isDaemonRunning = isDaemonRunning;
 exports.getLocalIntegrityReport = getLocalIntegrityReport;
 const fs = __importStar(require("fs"));
@@ -42,6 +43,27 @@ const installClaudeHook_1 = require("./commands/installClaudeHook");
 const installCursorHook_1 = require("./commands/installCursorHook");
 const mcpGateway_1 = require("./commands/mcpGateway");
 const appDetection_1 = require("./appDetection");
+/**
+ * The reasons `protect-all` can actually repair. Detecting a failure is only
+ * half the job: the daemon heals these instead of reporting them forever, which
+ * is why the taxonomy lives beside the reason type rather than in the caller.
+ *
+ * Excluded on purpose:
+ *  - `daemon_not_running` — the daemon is the thing evaluating this; re-wrapping
+ *    configs cannot start a process that is already running or already dead.
+ *  - `runtime_bundle_stale` — a control-plane reachability symptom. Re-wrapping
+ *    would churn every config on this machine and still not fetch the bundle,
+ *    hiding a network problem behind protection noise.
+ */
+const HEALABLE_REASONS = new Set([
+    'mcp_gateway_missing', 'mcp_gateway_stale_path',
+    'cursor_hook_missing', 'cursor_hook_stale_path', 'cursor_hook_changed',
+    'claude_hook_missing', 'claude_hook_stale_path', 'claude_hook_changed',
+]);
+/** Pure: does this verdict contain anything a protect-all pass could fix? */
+function hasHealableIntegrityReason(reasons) {
+    return reasons.some(reason => HEALABLE_REASONS.has(reason));
+}
 function readText(file) {
     try {
         return fs.readFileSync(file, 'utf8');

package/dist/pollLoop.d.ts

@@ -51,6 +51,12 @@ export interface PollLoopInput {
     onError?: (error: unknown) => void;
     /** Cadence jitter fraction (0..1, default 0.2) — a proxied fleet must not poll in lockstep. */
     jitter?: number;
+    /**
+     * First delay after an attempt that FAILED or was abandoned, doubled on each
+     * consecutive failure and capped at the normal cadence (so a retry is never
+     * lazier than the ordinary tick). Reset the moment an attempt succeeds.
+     */
+    retryDelayMs?: number;
     /** Injectable timers for tests. */
     timers?: {
         setTimeout: (fn: () => void, ms: number) => unknown;

package/dist/pollLoop.js

@@ -32,6 +32,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWithDeadline = runWithDeadline;
 exports.startPollLoop = startPollLoop;
 const MIN_DELAY_MS = 5_000;
+/**
+ * Default first retry after a failed/abandoned attempt.
+ *
+ * WHY A RETRY EXISTS AT ALL (the "Online · daemon down" bug)
+ * The loop used to reschedule at the full cadence no matter how the attempt
+ * ended, so ONE failed heartbeat left the daemon unreported for 5-6 minutes.
+ * That is not rare on a laptop: the wake-from-sleep path fires a heartbeat the
+ * instant a resume is noticed, which is usually BEFORE Wi-Fi has reassociated,
+ * so the very beat meant to prove the daemon survived the sleep is the one most
+ * likely to fail. Modern standby then re-suspends the machine in ~10-minute
+ * blocks, often before the next cadence tick — so `daemonReportedAt` could stay
+ * stale indefinitely while IDE-hook flushes kept the machine "online", showing
+ * a live daemon as down and making remote actions undeliverable.
+ *
+ * Retrying in seconds (not minutes) means a network that is merely late to come
+ * back costs one short delay instead of a whole reporting window.
+ */
+const RETRY_BASE_MS = 15_000;
 /**
  * Await `run()` but never longer than `deadlineMs`. Resolves 'settled' when the
  * attempt finished (fulfilled or rejected) and 'abandoned' when the deadline
@@ -75,22 +93,42 @@ function startPollLoop(input) {
     let stopped = false;
     let stalled = 0;
     let tickHandle;
-    const nextDelay = () => {
+    /** Consecutive failed/abandoned attempts, driving the retry backoff. */
+    let consecutiveFailures = 0;
+    const cadenceMs = () => {
         const base = input.intervalMs();
-        const safeBase = Number.isFinite(base) && base > 0 ? base : MIN_DELAY_MS;
+        return Number.isFinite(base) && base > 0 ? base : MIN_DELAY_MS;
+    };
+    const nextDelay = () => {
+        const base = cadenceMs();
         const factor = 1 - jitter + random() * jitter * 2;
-        return Math.max(MIN_DELAY_MS, Math.round(safeBase * factor));
+        return Math.max(MIN_DELAY_MS, Math.round(base * factor));
+    };
+    /**
+     * Back off exponentially from RETRY_BASE_MS but never past the ordinary
+     * cadence: a retry may be more eager than a normal tick, never lazier.
+     */
+    const retryDelay = () => {
+        const base = Math.max(1, input.retryDelayMs ?? RETRY_BASE_MS);
+        const backoff = base * Math.pow(2, Math.max(0, consecutiveFailures - 1));
+        return Math.max(MIN_DELAY_MS, Math.round(Math.min(backoff, cadenceMs())));
     };
-    const schedule = () => {
+    const schedule = (delayMs) => {
         if (stopped)
             return;
         tickHandle = timers.setTimeout(async () => {
             if (stopped)
                 return;
+            // `runWithDeadline` reports settled-vs-abandoned; a settled attempt may
+            // still have REJECTED, and for retry purposes that is just as bad.
+            let rejected = false;
             const outcome = await runWithDeadline({
                 run: input.run,
                 deadlineMs: input.deadlineMs,
-                onError: input.onError,
+                onError: error => {
+                    rejected = true;
+                    input.onError?.(error);
+                },
                 timers,
             });
             if (outcome === 'abandoned') {
@@ -100,10 +138,16 @@ function startPollLoop(input) {
                 }
                 catch { /* never break the loop */ }
             }
-            schedule();
-        }, nextDelay());
+            if (outcome === 'abandoned' || rejected) {
+                consecutiveFailures += 1;
+                schedule(retryDelay());
+                return;
+            }
+            consecutiveFailures = 0;
+            schedule(nextDelay());
+        }, delayMs);
     };
-    schedule();
+    schedule(nextDelay());
     return {
         stop() {
             stopped = true;

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.26.13"
+  "version": "1.26.15"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.26.13",
+  "version": "1.26.15",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -30,6 +30,7 @@
     "test:audit-restore": "node scripts/test-audit-restore.js",
     "test:shell-guard": "npm run build && node scripts/test-shell-guard.js",
     "test:cmd-guard": "npm run build && node scripts/test-cmd-guard.js",
+    "test:cmd-guard-perf": "npm run build && node scripts/test-cmd-guard-perf.js",
     "test:posix-guard": "npm run build && node scripts/test-posix-guard.js",
     "test:secret-posture": "npm run build && node scripts/test-secret-posture-fixtures.js",
     "test:agent-file-posture": "npm run build && node scripts/test-agent-file-posture.js",