fullcourtdefense-cli 1.36.4 → 1.37.0

package/dist/commands/daemon.js

@@ -46,6 +46,7 @@ exports.buildTaskXml = buildTaskXml;
 exports.buildTaskXmlVariants = buildTaskXmlVariants;
 exports.registerHiddenTask = registerHiddenTask;
 exports.windowsTaskReferencesScriptHost = windowsTaskReferencesScriptHost;
+exports.ensureWindowsAutostartHealthy = ensureWindowsAutostartHealthy;
 exports.daemonRuntimeState = daemonRuntimeState;
 exports.spawnDetachedDaemon = spawnDetachedDaemon;
 exports.pidIsAlive = pidIsAlive;
@@ -58,6 +59,7 @@ exports.daemonCommand = daemonCommand;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const perf_hooks_1 = require("perf_hooks");
 const child_process_1 = require("child_process");
 const config_1 = require("../config");
 const distress_1 = require("../distress");
@@ -65,12 +67,8 @@ const pollLoop_1 = require("../pollLoop");
 const selfTest_1 = require("../selfTest");
 const daemonForensics_1 = require("../daemonForensics");
 const verdictIpcClient_1 = require("../verdictIpcClient");
-const securityAgents_1 = require("../securityAgents");
-const mcpGateway_1 = require("./mcpGateway");
-const protectionRepair_1 = require("./protectionRepair");
 const runtimeConfig_1 = require("../runtimeConfig");
 const discoverPaths_1 = require("./discoverPaths");
-const localSafetySnapshot_1 = require("../localSafetySnapshot");
 const policyRefresh_1 = require("../policyRefresh");
 const telemetry_1 = require("../telemetry");
 const identityRecovery_1 = require("../identityRecovery");
@@ -81,18 +79,23 @@ const machineIdentity_1 = require("../machineIdentity");
 const localDetectionUpdates_1 = require("../localDetectionUpdates");
 const discoveryMarker_1 = require("../discoveryMarker");
 const selfUpdate_1 = require("../selfUpdate");
-const cmdGuard_1 = require("./cmdGuard");
 const machineActionVerify_1 = require("../machineActionVerify");
 const perfSnapshot_1 = require("../perfSnapshot");
 const desktopChatGuard_1 = require("./desktopChatGuard");
 const honeypot_1 = require("../honeypot");
-const msiProductCode_1 = require("../msiProductCode");
 const windowsAudit_1 = require("./windowsAudit");
 const hook_1 = require("./hook");
+// hook.ts loads the ask envelope lazily (one-shot hooks rarely ask). The
+// resident daemon loads it at boot, as it always did: an in-place npm upgrade
+// must not hand a long-running daemon a newer copy at its first ask.
+require("../askDialog");
 const verdictIpc_1 = require("../verdictIpc");
 const windowsTaskState_1 = require("../windowsTaskState");
 Object.defineProperty(exports, "windowsTaskRunsInteractive", { enumerable: true, get: function () { return windowsTaskState_1.windowsTaskRunsInteractive; } });
 Object.defineProperty(exports, "windowsTaskRunsVisibly", { enumerable: true, get: function () { return windowsTaskState_1.windowsTaskRunsVisibly; } });
+const housekeeping_1 = require("../housekeeping");
+const hookIo_1 = require("../hookIo");
+const detectorInThread_1 = require("../detectorInThread");
 const COLOR = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
     red: '\x1b[31m', yellow: '\x1b[33m', green: '\x1b[32m', cyan: '\x1b[36m', gray: '\x1b[90m',
@@ -457,13 +460,32 @@ function releasePidLock() {
     }
     catch { /* best-effort */ }
 }
-/** Cursor/Claude hook config files worth watching for tamper (deletion/rewrite). */
-function hookConfigFiles() {
-    const home = os.homedir();
-    return [
-        path.join(home, '.cursor', 'hooks.json'),
-        path.join(home, '.claude', 'settings.json'),
-    ].filter(file => fs.existsSync(file));
+/**
+ * Task Scheduler starts the daemon at its default priority 7: BelowNormal CPU
+ * and Low I/O. Under load the one process every hook waits on was preempted
+ * first, by the very hooks and fallbacks waiting for it. Windows only, and
+ * only upward to Normal; the task definitions themselves are not touched.
+ */
+function raiseDaemonPriority() {
+    let launched;
+    try {
+        launched = os.getPriority();
+    }
+    catch {
+        return undefined;
+    }
+    if (process.platform !== 'win32' || process.env.FCD_DAEMON_PRIORITY === 'inherit')
+        return launched;
+    if (launched <= os.constants.priority.PRIORITY_NORMAL)
+        return launched;
+    try {
+        os.setPriority(os.constants.priority.PRIORITY_NORMAL);
+        log(`Daemon CPU priority raised to normal (was ${launched >= os.constants.priority.PRIORITY_LOW ? 'idle' : 'below normal'}) so hook verdicts are not starved under load.`);
+    }
+    catch (error) {
+        log(`Could not raise the daemon CPU priority (${error.message}) — continuing at the inherited priority.`);
+    }
+    return launched;
 }
 // ---------------------------------------------------------------------------
 // The resident loop
@@ -492,6 +514,19 @@ async function runDaemon(args, config) {
         console.log(`${COLOR.yellow}Another FullCourtDefense daemon is already running (pid file: ${pidFile()}).${COLOR.reset}`);
         return;
     }
+    // This event loop serves verdicts (verdict IPC, desktop chat guard): a
+    // policy refresh one of them requests (a hook pinned to another shield, an
+    // entry overdue after sleep) runs as an async task here, never as a spawned
+    // process — CreateProcess would stall every verdict in flight with it.
+    (0, runtimeConfig_1.refreshPolicyCachesInThisProcess)();
+    const launchPriority = raiseDaemonPriority();
+    // Housekeeping (protect-all, integrity walks, heartbeat diagnostics, DPAPI
+    // recovery, task self-heal) runs in a worker process so it never holds the
+    // event loop that answers hooks, at the priority this daemon was launched
+    // with: what all of it ran at before. Created before the crash handlers that stop it.
+    const housekeeping = new housekeeping_1.HousekeepingClient({ cliEntry: cliEntry(), log, priority: launchPriority });
+    // hook.log appends from in-daemon evaluations leave the verdict loop too.
+    (0, hookIo_1.useAsyncHookLog)();
     // The resident loop must never die silently from one bad tick (fs watcher
     // callback, fetch, timer). Log and keep running — the loop is timer-driven,
     // so surviving a failed tick is safe, and on Windows there is no supervisor
@@ -515,6 +550,8 @@ async function runDaemon(args, config) {
             // misreport this as an external kill (EDR/AV) — the distress code above
             // already carries the true story.
             (0, daemonForensics_1.recordCleanExit)('uncaught-exception burst — self-recycled');
+            housekeeping.stop();
+            (0, hookIo_1.flushHookLogSync)();
             releasePidLock();
             process.exit(1);
         }
@@ -531,17 +568,64 @@ 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}`);
+    // Settle the machine id before anything reports: the only place a pinned
+    // but unconfirmed fallback id may be re-checked against the OS (#1853).
+    // Verdict evaluations report too, so this precedes the verdict server.
+    try {
+        const id = (0, machineIdentity_1.reconcileMachineIdentity)('heal');
+        log(`Machine id ${(0, machineIdentity_1.shortMachineId)(id.machineId)} (${id.source}${id.confirmed ? ', backend-confirmed' : ''}${id.probed ? `, native read ${id.probeError ? `failed: ${id.probeError}` : 'ok'}` : ''}).`
+            + (id.healed ? ` Healed from stale fallback id ${(0, machineIdentity_1.shortMachineId)(id.healed.from)}.` : '')
+            + (id.conflict ? ` Native id ${(0, machineIdentity_1.shortMachineId)(id.conflict.native)} disagrees with the confirmed id — kept the confirmed one (machine_id_conflict).` : ''));
+    }
+    catch (error) {
+        log(`Machine id reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Verdict IPC server (resident-agent pattern): per-event hook processes
+    // become thin clients that ask THIS process for the verdict over a named
+    // pipe / Unix socket — everything (config, bundle, snapshot, policy engine)
+    // is warm here, so verdicts resolve in milliseconds instead of repeating
+    // cold-start work per IDE event. Config is re-read per request (small YAML,
+    // cheap) so on-disk edits apply without a daemon restart. Hooks fall back
+    // to full local evaluation whenever this server is down — never a blocker.
+    //
+    // Started FIRST, serving from the on-disk policy cache: boot self-heal, the
+    // bundle poll, the startup protection pass and the first heartbeat used to
+    // run before it, leaving every hook on the cold local path for 10-190s after
+    // each daemon start. None of them is needed to answer a hook, and all of the
+    // synchronous ones now run in the housekeeping worker.
+    let verdictServer;
+    // Evaluations served here only append to the spool. A debounced timer
+    // (never a verdict) hands the upload — spool read and trim, queued native
+    // allow reports, the POST, the guard-rule refresh — to the housekeeping
+    // worker, so neither the work nor a process spawn lands on this loop. In
+    // the degraded in-process housekeeping mode a detached flusher does it.
+    (0, telemetry_1.serveSpoolFlushOffLoop)(() => Boolean(creds.shieldId), {
+        upload: ({ refreshGuardRules }) => (housekeeping.offLoop
+            ? housekeeping.run({
+                op: 'spoolFlush',
+                input: { apiUrl: creds.apiUrl, shieldId: creds.shieldId || '', shieldKey: creds.shieldKey, heartbeat: false, refreshGuardRules },
+            })
+            : undefined),
+    });
+    try {
+        verdictServer = (0, verdictIpc_1.startVerdictServer)((hookArgs, stdin) => (0, hook_1.evaluateHookRequest)(hookArgs, stdin, (0, config_1.loadConfig)(), { viaDaemon: true }), log);
+    }
+    catch (error) {
+        log(`Verdict IPC: failed to start (${error.message}) — hooks will evaluate locally.`);
+    }
+    // How long the verdict loop was held, reported with each heartbeat.
+    // Sampled ten times a second: cheap enough to leave on for the daemon's life.
+    const loopDelay = (0, perf_hooks_1.monitorEventLoopDelay)({ resolution: envMs('FCD_DAEMON_LOOP_SAMPLE_MS', 100) });
+    loopDelay.enable();
     if (process.platform === 'win32') {
         // `reg query /s` over the uninstall hive can take seconds; keep it off the startup path.
         setTimeout(() => {
-            try {
-                const productCode = (0, msiProductCode_1.findMsiProductCode)();
-                if ((0, msiProductCode_1.recordMsiProductCode)(productCode))
+            housekeeping.run({ op: 'msiProductCode' }).then(({ productCode, recorded }) => {
+                if (recorded)
                     log(`Recorded installed MSI ProductCode ${productCode} for the Local Safety uninstall rule.`);
-            }
-            catch (error) {
+            }, error => {
                 log(`Could not record the installed MSI ProductCode: ${error?.message || String(error)}`);
-            }
+            });
         }, 20_000).unref();
     }
     // A machine enrolled with a DPAPI key whose decrypt fails (blocked
@@ -652,7 +736,12 @@ async function runDaemon(args, config) {
      * Now a changed enrollment file reloads credentials whether or not the
      * daemon had some — one heartbeat later it is on the new key.
      */
-    const recoverCredentialsIfMissing = () => {
+    // The DPAPI decrypt behind a recovery spawns PowerShell: it runs in the
+    // housekeeping worker, whose view of PowerShell and of the key source then
+    // describes this daemon's credentials in the heartbeat.
+    let recoveredPowershell;
+    let recoveredTrace;
+    const recoverCredentialsIfMissing = async () => {
         let enrollmentChanged = false;
         try {
             const mtime = fs.statSync((0, config_1.getHomeConfigPath)()).mtimeMs;
@@ -670,11 +759,16 @@ async function runDaemon(args, config) {
                 return;
         }
         try {
-            const fresh = (0, config_1.resolveCliCredentials)((0, config_1.loadConfig)(args.config), {
-                shieldId: args.shieldId,
-                shieldKey: args.shieldKey,
-                apiUrl: args.apiUrl,
+            const recovered = await housekeeping.run({
+                op: 'recoverCredentials',
+                configPath: args.config,
+                overrides: { shieldId: args.shieldId, shieldKey: args.shieldKey, apiUrl: args.apiUrl },
             });
+            if (recovered.powershell)
+                recoveredPowershell = recovered.powershell;
+            if (recovered.trace)
+                recoveredTrace = recovered.trace;
+            const fresh = recovered.creds;
             if (!fresh.shieldId || !fresh.shieldKey)
                 return;
             const rotated = fresh.shieldId !== creds.shieldId || fresh.shieldKey !== creds.shieldKey || fresh.apiUrl !== creds.apiUrl;
@@ -733,23 +827,28 @@ async function runDaemon(args, config) {
                 attentionTimer = undefined;
                 if (stopped || suspended)
                     return;
-                let verified = false;
-                try {
-                    verified = !repairFailed && (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true }).ok;
-                }
-                catch { /* cannot verify */ }
-                deliverProtectionHealth(verified);
+                void (async () => {
+                    let verified = false;
+                    try {
+                        verified = !repairFailed && (await housekeeping.run({ op: 'integrity', requireDaemon: true })).ok;
+                    }
+                    catch { /* cannot verify */ }
+                    if (stopped || suspended)
+                        return;
+                    deliverProtectionHealth(verified);
+                })();
             }, PROTECTION_NOTICE_DELAY_MS);
         }
     };
-    const inspectProtection = () => {
+    const inspectProtection = async (pass) => {
         // Snapshot BEFORE verification. An external write during/after inspection
         // remains different from this baseline and its queued event gets checked.
-        const snapshot = (0, protectionMaintenance_1.captureProtectionConfiguration)(watchedFiles);
-        const integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
-        observedConfigurations = snapshot;
+        const { snapshot, integrity } = await housekeeping.run({ op: 'inspect', files: [...watchedFiles], pass });
+        observedConfigurations = new Map(snapshot);
         return integrity;
     };
+    // One scan-root walk serves every step of a protection pass (see setProjectConfigScanPass).
+    let passSeq = 0;
     /** One serialized repair path, including remote requests and new discovery. */
     const reprotect = async (reasonPaths, cause = 'drift') => {
         if (repairInFlight) {
@@ -767,8 +866,18 @@ async function runDaemon(args, config) {
             return;
         }
         repairInFlight = (async () => {
+            const pass = `repair-${++passSeq}`;
             try {
-                const before = inspectProtection();
+                const before = await inspectProtection(pass);
+                // The inspection ran in the housekeeping worker; an admin suspension
+                // (or shutdown) may have arrived meanwhile. A suspended machine is not
+                // re-protected, whenever the pass was asked for.
+                if (stopped)
+                    return before;
+                if (suspended) {
+                    log(`${headline} (${reasonPaths.join(', ')}) but machine is suspended — not re-protecting.`);
+                    return before;
+                }
                 // Integrity/discovery triggers use the shared healable taxonomy. A real
                 // content change still runs the full idempotent repair pipeline: the
                 // integrity summary does not cover every hook migration/companion.
@@ -784,9 +893,9 @@ async function runDaemon(args, config) {
                 // after our write, including when its watch event is lost. Persistent
                 // failures still enter the existing backoff, never a repair spin loop.
                 for (let attempt = 1; attempt <= 2; attempt++) {
-                    const repaired = await (0, protectionRepair_1.repairProtection)({ ...args, dryRun: undefined }, config);
-                    refreshWatchTargets();
-                    integrity = inspectProtection();
+                    const repaired = await housekeeping.run({ op: 'repair', args: { ...args, dryRun: undefined }, config, pass });
+                    await refreshWatchTargets(pass);
+                    integrity = await inspectProtection(pass);
                     log(`Re-protection pass complete (Cursor hooks ${repaired.cursorHooksHealthy ? 'healthy' : 'unhealthy'}, Claude hooks ${repaired.claudeHooksHealthy ? 'healthy' : 'unhealthy'}).`);
                     if (!(0, integrity_1.hasHealableIntegrityReason)(integrity.reasons) || suspended || stopped)
                         break;
@@ -821,26 +930,78 @@ async function runDaemon(args, config) {
             repairInFlight = undefined;
         }
     };
-    const scheduleProtectionCheck = () => {
+    /**
+     * The drift check's fingerprints, taken in the housekeeping worker. If the
+     * worker cannot answer (wedged past its ceiling, lost twice), they are taken
+     * here, as before the worker existed: a few file hashes, never a walk.
+     */
+    const captureWatchedFiles = async () => {
+        const files = [...watchedFiles];
+        try {
+            return new Map((await housekeeping.run({ op: 'capture', files })).snapshot);
+        }
+        catch (error) {
+            if (stopped)
+                throw error;
+            log(`Protection change check: the housekeeping worker could not capture (${error?.message || String(error)}) — capturing in the daemon.`);
+            return (0, protectionMaintenance_1.captureProtectionConfiguration)(files);
+        }
+    };
+    /** Consecutive failed checks; a failed check is retried with back-off, never dropped. */
+    let checkFailures = 0;
+    const scheduleProtectionCheck = (delayMs = DEBOUNCE_MS) => {
         if (debounceTimer)
             clearTimeout(debounceTimer);
         debounceTimer = setTimeout(() => {
             debounceTimer = null;
             void (async () => {
-                if (repairInFlight)
-                    await repairInFlight;
-                if (stopped)
+                // The capture runs in the housekeeping worker, so a repair pass can
+                // start and observe the files while it is in flight. Comparing such a
+                // stale capture with the newer observation reads the pass's own writes
+                // as drift: capture again after that pass. A check is never dropped —
+                // after a few overtaken captures the last one is compared anyway (at
+                // worst one extra, idempotent pass).
+                for (let attempt = 1;; attempt++) {
+                    // How that pass ended is its caller's to report; this check still runs.
+                    if (repairInFlight)
+                        await repairInFlight.catch(() => undefined);
+                    if (stopped)
+                        return;
+                    if (refreshPending) {
+                        refreshPending = false;
+                        // A failed scan keeps the refresh pending for the retry below. A
+                        // check's scan is protection convergence: it runs ahead of
+                        // heartbeat walks and rescans in the worker.
+                        try {
+                            await refreshWatchTargets(`check-${++passSeq}`);
+                        }
+                        catch (error) {
+                            refreshPending = true;
+                            throw error;
+                        }
+                    }
+                    const observed = observedConfigurations;
+                    const current = await captureWatchedFiles();
+                    if (stopped)
+                        return;
+                    if ((observed !== observedConfigurations || repairInFlight) && attempt < 3)
+                        continue;
+                    const changed = (0, protectionMaintenance_1.changedProtectionConfiguration)(observedConfigurations, current);
+                    if (changed.length > 0)
+                        await reprotect(changed);
                     return;
-                if (refreshPending) {
-                    refreshPending = false;
-                    refreshWatchTargets();
                 }
-                const current = (0, protectionMaintenance_1.captureProtectionConfiguration)(watchedFiles);
-                const changed = (0, protectionMaintenance_1.changedProtectionConfiguration)(observedConfigurations, current);
-                if (changed.length > 0)
-                    await reprotect(changed);
-            })().catch(error => log(`Protection change check failed: ${error.message}`));
-        }, DEBOUNCE_MS);
+            })().then(() => { checkFailures = 0; }, error => {
+                if (stopped)
+                    return;
+                // The change that triggered this check emits no second event: retry it.
+                const retryMs = Math.min(60_000, DEBOUNCE_MS * 2 ** Math.min(checkFailures, 5));
+                checkFailures += 1;
+                log(`Protection change check failed: ${error?.message || String(error)} — checking again in ${(retryMs / 1000).toFixed(1)}s.`);
+                if (!debounceTimer)
+                    scheduleProtectionCheck(retryMs);
+            });
+        }, delayMs);
     };
     const onFsEvent = (dir, filename) => {
         if (stopped)
@@ -872,13 +1033,13 @@ async function runDaemon(args, config) {
     /**
      * (Re)build the watch set from the current MCP client configs + hook files.
      * Watches parent directories (not files) so atomic replaces on Windows and
-     * editor save-via-rename still emit events.
+     * editor save-via-rename still emit events. The scan-root walk that finds
+     * the files runs in the housekeeping worker; only the watchers live here.
      */
-    const refreshWatchTargets = () => {
-        const targets = [
-            ...(0, mcpGateway_1.protectAllTargetFiles)(args.config).map(f => f.path),
-            ...hookConfigFiles(),
-        ];
+    const refreshWatchTargets = async (pass) => {
+        const { targets } = await housekeeping.run({ op: 'scanTargets', configPath: args.config, pass });
+        if (stopped)
+            return targets.length;
         watchedFiles.clear();
         watchedFileKeys.clear();
         const wantedDirs = new Set();
@@ -933,7 +1094,7 @@ async function runDaemon(args, config) {
         if (!creds.shieldId)
             return;
         try {
-            const raw = fs.readFileSync(logFile(), 'utf8');
+            const raw = await fs.promises.readFile(logFile(), 'utf8');
             // 200 lines (~half a day of routine ticks): enough context to diagnose a
             // failure loop remotely without asking the customer to paste anything.
             const lines = raw.split(/\r?\n/).filter(line => line.trim()).slice(-200);
@@ -986,18 +1147,18 @@ async function runDaemon(args, config) {
     // The complete remote support bundle: everything we asked Alex and Alin to
     // paste by hand during the lptx1110 incident, collected in one action.
     // Metadata + our own logs only — never customer files, prompts, or secrets.
-    const buildSupportBundle = () => {
-        const powershell = (0, config_1.getPowershellHealth)();
+    const buildSupportBundle = async () => {
+        const powershell = recoveredPowershell ?? (0, config_1.getPowershellHealth)();
         let integrity;
         try {
-            integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+            integrity = await housekeeping.run({ op: 'integrity', requireDaemon: true });
         }
         catch (error) {
             integrity = { error: error.message };
         }
         let daemonLogTail = [];
         try {
-            daemonLogTail = fs.readFileSync(logFile(), 'utf8')
+            daemonLogTail = (await fs.promises.readFile(logFile(), 'utf8'))
                 .split(/\r?\n/).map(line => line.trim()).filter(Boolean).slice(-200).map(line => line.slice(0, 400));
         }
         catch { /* log unreadable — the bundle reports everything else */ }
@@ -1006,10 +1167,15 @@ async function runDaemon(args, config) {
         // content previews exist only when support opted into FCD_HOOK_DEBUG.
         let hookLogTail = [];
         try {
-            hookLogTail = fs.readFileSync(path.join(os.homedir(), '.fullcourtdefense-hook.log'), 'utf8')
+            hookLogTail = (await fs.promises.readFile(path.join(os.homedir(), '.fullcourtdefense-hook.log'), 'utf8'))
                 .split(/\r?\n/).map(line => line.trim()).filter(Boolean).slice(-80).map(line => line.slice(0, 400));
         }
         catch { /* no hook activity on this machine yet */ }
+        let securityAgents;
+        try {
+            securityAgents = (await housekeeping.run({ op: 'securityAgents' })).products;
+        }
+        catch { /* reported without it */ }
         return {
             cliVersion: cliVersion(),
             platform: process.platform,
@@ -1018,9 +1184,9 @@ async function runDaemon(args, config) {
             hookLogTail,
             updaterLogTail: (0, selfUpdate_1.readUpdaterLogTail)(60),
             distress: (0, distress_1.readDistressLedger)(),
-            credentialTrace: (0, config_1.getCredentialResolutionTrace)(),
+            credentialTrace: recoveredTrace ?? (0, config_1.getCredentialResolutionTrace)(),
             powershell,
-            securityAgents: (0, securityAgents_1.getSecurityAgentsReport)()?.products,
+            securityAgents,
             integrity,
             lastCrash: (0, daemonForensics_1.readPostmortem)(),
             watchdogTaskInstalled: isWatchdogTaskInstalled(),
@@ -1178,13 +1344,15 @@ async function runDaemon(args, config) {
                 log('Health check: running deep self-test across all subsystems…');
                 await uploadLogTail();
                 const identity = (0, machineIdentity_1.getMachineIdentity)();
-                const report = await (0, selfTest_1.runDeepSelfTest)({
+                // PowerShell and DPAPI probes, schtasks queries and an integrity walk:
+                // seconds of synchronous work, run in the housekeeping worker.
+                const report = await housekeeping.run({
+                    op: 'selfTest',
                     creds,
                     developerName: identity.developerName,
                     machineName: identity.hostname,
                     machineId: identity.machineId,
-                    isWatchdogTaskInstalled,
-                    log,
+                    credentialTrace: recoveredTrace ?? (0, config_1.getCredentialResolutionTrace)(),
                 });
                 await uploadDiagnostics({ selfTest: report });
                 resultSummary = (0, selfTest_1.summarizeSelfTest)(report);
@@ -1195,7 +1363,7 @@ async function runDaemon(args, config) {
             else if (action.type === 'collect_diagnostics') {
                 log('Collect diagnostics: assembling support bundle (logs + distress ledger + environment — metadata only)…');
                 await uploadLogTail();
-                const bundle = buildSupportBundle();
+                const bundle = await buildSupportBundle();
                 const uploaded = await uploadDiagnostics({ bundle });
                 if (!uploaded)
                     throw new Error('Support bundle could not be uploaded (network or backend rejection).');
@@ -1234,7 +1402,7 @@ async function runDaemon(args, config) {
                 await uploadLogTail();
                 await reprotect(['remote repair request'], 'manual');
                 log('Repair protection: verifying hooks, gateways and daemon integrity…');
-                const verification = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+                const verification = await housekeeping.run({ op: 'integrity', requireDaemon: true });
                 if (!verification.ok) {
                     throw new Error(`Repair completed but verification still reports: ${verification.reasons.join(', ')}`);
                 }
@@ -1378,16 +1546,20 @@ async function runDaemon(args, config) {
         }
         const identity = (0, machineIdentity_1.getMachineIdentity)();
         try {
-            const bundle = await (0, runtimeConfig_1.getRuntimeBundle)({
+            // The hooks' Local Safety snapshot rides the same refresh: fetched
+            // unless the one on disk already is the bundle's policy hash, written
+            // before the new bundle (hooks never fetch either cache — this poll is
+            // what keeps them fresh). `scheduled` records the attempt, so hot paths
+            // start no refresher of their own for this shield while it runs.
+            const bundle = await (0, policyRefresh_1.refreshPolicyCaches)({
                 apiUrl: creds.apiUrl,
                 shieldId: creds.shieldId,
                 shieldKey: creds.shieldKey,
                 developerName: identity.developerName,
                 machineName: identity.hostname,
                 machineId: identity.machineId,
-                force: true,
                 timeoutMs: BUNDLE_FETCH_TIMEOUT_MS,
-                requireServerValidation: true,
+                scheduled: true,
             });
             if (typeof bundle.pollIntervalMs === 'number' && Number.isFinite(bundle.pollIntervalMs)) {
                 bundlePollBaseMs = Math.min(Math.max(bundle.pollIntervalMs, 15_000), 60 * 60_000);
@@ -1469,22 +1641,6 @@ async function runDaemon(args, config) {
                     log(`Honeypot: removal failed: ${error.message}`);
                 }
             }
-            // Keep the IDE hooks' Local Safety snapshot warm. Hooks on monitor
-            // machines read this cache with preferCached and never fetch — the
-            // daemon is the only process paying the network cost, off the hot path.
-            try {
-                const hookIdentity = (0, localSafetySnapshot_1.hookSnapshotIdentity)();
-                await (0, localSafetySnapshot_1.loadLocalSafetySnapshot)({
-                    apiUrl: creds.apiUrl,
-                    shieldId: creds.shieldId,
-                    shieldKey: creds.shieldKey,
-                    developerName: hookIdentity.developerName,
-                    machineName: hookIdentity.machineName,
-                    expectedPolicyHash: bundle.policyHash || bundle.version,
-                    timeoutMs: 8_000,
-                });
-            }
-            catch { /* hooks fall back to their own bounded fetch */ }
         }
         catch (error) {
             // Local enforcement can keep using its cache, but this delivery check
@@ -1493,9 +1649,22 @@ async function runDaemon(args, config) {
             throw error;
         }
     };
+    /** Verdict-loop health for this heartbeat window: the server's own counters plus how long the loop was held. */
+    const verdictIpcHealth = () => {
+        const delay = loopDelay.count > 0
+            ? { eventLoopDelayP99Ms: Math.round(loopDelay.percentile(99) / 1e6), eventLoopDelayMaxMs: Math.round(loopDelay.max / 1e6) }
+            : {};
+        return { ...(verdictServer ? verdictServer.stats() : { listening: false, state: 'closed' }), ...delay, detectorInThread: (0, detectorInThread_1.inThreadDetectorActive)() };
+    };
+    /** A delivered heartbeat starts the next percentile window. */
+    const resetHealthWindows = () => {
+        verdictServer?.stats(true);
+        housekeeping.stats(true);
+        loopDelay.reset();
+    };
     const heartbeat = async () => {
         (0, daemonForensics_1.touchDaemonAlive)();
-        recoverCredentialsIfMissing();
+        await recoverCredentialsIfMissing();
         if (!creds.shieldId)
             return;
         // Did THIS beat actually record daemon liveness upstream? `flushSpool`
@@ -1508,7 +1677,7 @@ async function runDaemon(args, config) {
         let reported = false;
         let refusal;
         try {
-            let integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+            let integrity = await housekeeping.run({ op: 'integrity', requireDaemon: true });
             // Recovery outside our repair pass (for example a manual fix) also clears
             // the old failure's backoff. It must not suppress an unrelated later gap.
             // An execution error can concern a component outside this summary (e.g.
@@ -1527,7 +1696,7 @@ async function runDaemon(args, config) {
                     || Date.now() - lastIntegrityHealFailureAt >= INTEGRITY_HEAL_COOLDOWN_MS)
                 && (repairFailed || (0, integrity_1.hasHealableIntegrityReason)(integrity.reasons))) {
                 const repaired = await reprotect(integrity.reasons, 'integrity');
-                integrity = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
+                integrity = await housekeeping.run({ op: 'integrity', requireDaemon: true });
                 if (repaired) {
                     log(integrity.ok
                         ? 'Integrity self-heal: protection restored.'
@@ -1539,39 +1708,52 @@ async function runDaemon(args, config) {
             // 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,
-                shieldKey: creds.shieldKey,
-                heartbeat: true,
-                daemon: true,
-                agentVersion: cliVersion(),
-                integrityOk: integrity.ok,
-                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,
-                powershellLanguageMode: powershell?.languageMode,
-                shieldKeySource: (0, config_1.getCredentialResolutionTrace)()?.shieldKeySource,
-                distress: (0, distress_1.readDistressSnapshot)(),
-                lastCrash: unreportedCrash
-                    ? {
-                        version: unreportedCrash.version,
-                        startedAt: unreportedCrash.startedAt,
-                        lastAliveAt: unreportedCrash.lastAliveAt,
-                        detectedAt: unreportedCrash.detectedAt,
-                        detectedBy: unreportedCrash.detectedBy,
-                        cause: unreportedCrash.cause,
-                        machineBootedAt: unreportedCrash.machineBootedAt,
-                    }
-                    : undefined,
+            const powershell = recoveredPowershell ?? (0, config_1.getPowershellHealth)();
+            // The flush (spool read/rewrite, shell-audit registry probes, guard-rule
+            // refresh, EDR probe) runs in the housekeeping worker; what only this
+            // process knows travels with it.
+            const { result, failure } = await housekeeping.run({
+                op: 'heartbeatFlush',
+                securityAgents: true,
+                input: {
+                    apiUrl: creds.apiUrl,
+                    shieldId: creds.shieldId,
+                    shieldKey: creds.shieldKey,
+                    heartbeat: true,
+                    daemon: true,
+                    agentVersion: cliVersion(),
+                    integrityOk: integrity.ok,
+                    integrityReasons: integrity.reasons,
+                    integrityCheckedAt: integrity.checkedAt,
+                    desktopChatGuard: (0, desktopChatGuard_1.desktopChatGuardSupported)() && (0, desktopChatGuard_1.desktopChatGuardHealthy)(),
+                    powershellSpawnOk: powershell?.spawnOk,
+                    powershellDecryptOk: powershell?.decryptOk,
+                    powershellLanguageMode: powershell?.languageMode,
+                    shieldKeySource: (recoveredTrace ?? (0, config_1.getCredentialResolutionTrace)())?.shieldKeySource,
+                    distress: (0, distress_1.readDistressSnapshot)(),
+                    lastCrash: unreportedCrash
+                        ? {
+                            version: unreportedCrash.version,
+                            startedAt: unreportedCrash.startedAt,
+                            lastAliveAt: unreportedCrash.lastAliveAt,
+                            detectedAt: unreportedCrash.detectedAt,
+                            detectedBy: unreportedCrash.detectedBy,
+                            cause: unreportedCrash.cause,
+                            machineBootedAt: unreportedCrash.machineBootedAt,
+                        }
+                        : undefined,
+                    verdictIpc: verdictIpcHealth(),
+                    housekeeping: { ...housekeeping.stats() },
+                    // The detector that decides verdicts is this process's, not the worker's.
+                    detectionUpdatesStatus: localDetectionUpdates_1.localDetectionUpdates.getStatus(),
+                    detectorUpdatesStatus: localDetectionUpdates_1.localDetectorUpdates.getDetectorStatus(),
+                },
             });
             reported = result !== null;
             if (!reported)
-                refusal = (0, telemetry_1.getLastFlushFailure)();
+                refusal = failure;
+            else
+                resetHealthWindows();
             if (result && unreportedCrash)
                 (0, daemonForensics_1.markPostmortemReported)();
             if (result && result.accepted > 0)
@@ -1596,29 +1778,26 @@ async function runDaemon(args, config) {
         }
     };
     // --- boot ---------------------------------------------------------------
-    // Settle the machine id before anything reports: the only place a pinned
-    // but unconfirmed fallback id may be re-checked against the OS (#1853).
+    // The machine id is settled and the verdict server is already serving (see
+    // above). Autostart/watchdog task self-heal, updater task convergence and a
+    // stale cmd AutoRun repair spawn schtasks/reg: housekeeping worker.
     try {
-        const id = (0, machineIdentity_1.reconcileMachineIdentity)('heal');
-        log(`Machine id ${(0, machineIdentity_1.shortMachineId)(id.machineId)} (${id.source}${id.confirmed ? ', backend-confirmed' : ''}${id.probed ? `, native read ${id.probeError ? `failed: ${id.probeError}` : 'ok'}` : ''}).`
-            + (id.healed ? ` Healed from stale fallback id ${(0, machineIdentity_1.shortMachineId)(id.healed.from)}.` : '')
-            + (id.conflict ? ` Native id ${(0, machineIdentity_1.shortMachineId)(id.conflict.native)} disagrees with the confirmed id — kept the confirmed one (machine_id_conflict).` : ''));
+        const healed = await housekeeping.run({ op: 'bootSelfHeal', apiUrl: creds.apiUrl });
+        if (healed.cmdAutorunRepaired)
+            log('Repaired a stale cmd.exe AutoRun / doskey guard left by an earlier install.');
+        if (healed.cacheTempsSwept)
+            log(`Removed ${healed.cacheTempsSwept} stale policy-cache temp file(s).`);
     }
     catch (error) {
-        log(`Machine id reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
+        log(`Boot self-heal failed: ${error?.message || String(error)} — retried on the next daemon start.`);
+    }
+    let watched = 0;
+    try {
+        watched = await refreshWatchTargets();
+    }
+    catch (error) {
+        log(`Config scan failed: ${error?.message || String(error)} — the rescan tick retries.`);
     }
-    // Self-heal autostart + watchdog tasks: machines installed by older versions
-    // (or where task creation failed once) must converge without a reinstall.
-    ensureWindowsAutostartHealthy(log);
-    // Converge pre-Node-updater machines onto the PowerShell-free updater task
-    // (best-effort; needs an elevated daemon to rewrite a SYSTEM task).
-    (0, selfUpdate_1.modernizeUpdaterTask)(log, creds.apiUrl);
-    // Heal a stale/broken cmd-guard AutoRun (bat deleted, or macros pointing at
-    // a dead node.exe) so wrapped commands (docker, git, …) never stay broken.
-    if ((0, cmdGuard_1.repairStaleCmdAutorun)()) {
-        log('Repaired a stale cmd.exe AutoRun / doskey guard left by an earlier install.');
-    }
-    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
     // upgrade_cli action before anything else touches the control plane.
@@ -1663,20 +1842,6 @@ async function runDaemon(args, config) {
         if (desktopChatGuard)
             log('Claude Desktop chat guard: supervising (advisory — warns on secrets typed into Claude Desktop).');
     }
-    // Verdict IPC server (resident-agent pattern): per-event hook processes
-    // become thin clients that ask THIS process for the verdict over a named
-    // pipe / Unix socket — everything (config, bundle, snapshot, policy engine)
-    // is warm here, so verdicts resolve in milliseconds instead of repeating
-    // cold-start work per IDE event. Config is re-read per request (small YAML,
-    // cheap) so on-disk edits apply without a daemon restart. Hooks fall back
-    // to full local evaluation whenever this server is down — never a blocker.
-    let verdictServer;
-    try {
-        verdictServer = (0, verdictIpc_1.startVerdictServer)((hookArgs, stdin) => (0, hook_1.evaluateHookRequest)(hookArgs, stdin, (0, config_1.loadConfig)(), { viaDaemon: true }), log);
-    }
-    catch (error) {
-        log(`Verdict IPC: failed to start (${error.message}) — hooks will evaluate locally.`);
-    }
     // Fresh machines have never uploaded an inventory (MSI/onboard defers the
     // initial discovery to keep setup fast), so the dashboard shows "Never" for
     // discovery + posture until the daily scheduled job fires — up to 24h later.
@@ -1748,18 +1913,30 @@ async function runDaemon(args, config) {
     // re-check still guarantees same-day freshness.
     const discoverCatchUpBootTimer = setTimeout(() => { void maybeCatchUpDiscovery('after start'); }, DISCOVER_BOOT_CATCHUP_DELAY_MS + Math.floor(Math.random() * DISCOVER_BOOT_CATCHUP_JITTER_MS));
     const discoverCatchUpTimer = setInterval(() => { void maybeCatchUpDiscovery('hourly check'); }, DISCOVER_CHECK_INTERVAL_MS);
+    let rescanInFlight = false;
     const rescanTimer = setInterval(() => {
-        const previousTargets = new Set(watchedFiles);
-        const count = refreshWatchTargets();
-        log(`Rescan: watching ${count} config file(s).`);
-        // A config created before its parent was watched emits no event for us.
-        // Discovery is therefore a repair trigger, even during another gap's
-        // failure backoff. Repeated scans of the same targets do not retry it.
-        const added = [...watchedFiles].filter(file => !previousTargets.has(file));
-        if (added.length > 0 && !suspended && !stopped
-            && (0, integrity_1.hasHealableIntegrityReason)((0, integrity_1.getLocalIntegrityReport)().reasons)) {
-            void reprotect(added, 'discovery');
-        }
+        // The walk runs in the housekeeping worker; a slow one never stacks. A
+        // repair pass in flight rescans the targets itself when it finishes.
+        if (rescanInFlight || repairInFlight)
+            return;
+        rescanInFlight = true;
+        void (async () => {
+            const pass = `rescan-${++passSeq}`;
+            const previousTargets = new Set(watchedFiles);
+            const count = await refreshWatchTargets(pass);
+            if (stopped)
+                return;
+            log(`Rescan: watching ${count} config file(s).`);
+            // A config created before its parent was watched emits no event for us.
+            // Discovery is therefore a repair trigger, even during another gap's
+            // failure backoff. Repeated scans of the same targets do not retry it.
+            const added = [...watchedFiles].filter(file => !previousTargets.has(file));
+            if (added.length > 0 && !suspended && !stopped
+                && (0, integrity_1.hasHealableIntegrityReason)((await housekeeping.run({ op: 'integrity', pass })).reasons)) {
+                void reprotect(added, 'discovery');
+            }
+        })().catch(error => log(`Rescan failed: ${error?.message || String(error)}`))
+            .finally(() => { rescanInFlight = false; });
     }, RESCAN_INTERVAL_MS);
     // Jittered self-rescheduling polls (±20%) instead of fixed setInterval:
     // a fleet enrolled behind one corporate proxy must not hit the gate in
@@ -1856,14 +2033,12 @@ async function runDaemon(args, config) {
     // that never stay up 24h still get cleaned). Only touches FCD-managed
     // transcript folders; see pruneTranscripts.
     const runTranscriptPrune = () => {
-        try {
-            const result = (0, windowsAudit_1.pruneTranscripts)();
+        housekeeping.run({ op: 'pruneTranscripts' }).then(result => {
             if (result.pruned > 0)
                 log(`Transcript retention: pruned ${result.pruned} transcript file(s) older than ${(0, windowsAudit_1.transcriptRetentionDays)()} day(s).`);
             if ((result.prunedBySize || 0) > 0)
                 log(`Transcript retention: pruned ${result.prunedBySize} more transcript file(s) (oldest first) to stay under the ${(0, windowsAudit_1.transcriptMaxMb)()}MB size budget.`);
-        }
-        catch { /* never let housekeeping hurt the daemon */ }
+        }, () => { });
     };
     const transcriptPruneBootTimer = setTimeout(runTranscriptPrune, 5 * 60_000);
     const transcriptPruneTimer = setInterval(runTranscriptPrune, 24 * 60 * 60_000);
@@ -1890,6 +2065,9 @@ async function runDaemon(args, config) {
             desktopChatGuard.stop();
         if (verdictServer)
             verdictServer.close();
+        housekeeping.stop();
+        loopDelay.disable();
+        (0, hookIo_1.flushHookLogSync)();
         for (const watcher of watchers.values())
             watcher.close();
         for (const watcher of rootWatchers.values())