fullcourtdefense-cli 1.15.10 → 1.15.12

package/dist/commands/daemon.js

@@ -41,7 +41,9 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const config_1 = require("../config");
 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 telemetry_1 = require("../telemetry");
 const notify_1 = require("../notify");
@@ -53,6 +55,7 @@ const COLOR = {
     red: '\x1b[31m', yellow: '\x1b[33m', green: '\x1b[32m', cyan: '\x1b[36m', gray: '\x1b[90m',
 };
 const TASK_NAME = 'FullCourtDefense Daemon';
+const WATCHDOG_TASK_NAME = 'FullCourtDefense Daemon Watchdog';
 const CRON_MARKER = '# FCD_DAEMON';
 const LAUNCHD_LABEL = 'ai.fullcourtdefense.daemon';
 const SYSTEMD_UNIT = 'fullcourtdefense-daemon.service';
@@ -262,6 +265,16 @@ async function runDaemon(args, config) {
         console.log(`${COLOR.yellow}Another FullCourtDefense daemon is already running (pid file: ${pidFile()}).${COLOR.reset}`);
         return;
     }
+    // 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
+    // that would restart a crashed process instantly.
+    process.on('uncaughtException', error => {
+        log(`Uncaught exception (daemon continues): ${error?.stack || String(error)}`);
+    });
+    process.on('unhandledRejection', reason => {
+        log(`Unhandled rejection (daemon continues): ${reason?.stack || String(reason)}`);
+    });
     const creds = (0, config_1.resolveCliCredentials)(config, {
         shieldId: args.shieldId,
         shieldKey: args.shieldKey,
@@ -272,6 +285,7 @@ async function runDaemon(args, config) {
     log(`Shield: ${creds.shieldId || '(none — protect-only mode, telemetry disabled)'}  API: ${creds.apiUrl}`);
     // --- state ---------------------------------------------------------------
     const watchers = new Map(); // directory -> watcher
+    const rootWatchers = new Map(); // admin protection roots -> recursive watcher
     const watchedFiles = new Set(); // lowercased absolute file paths we react to
     let quietUntil = 0; // ignore events until this time (self-writes)
     let debounceTimer = null;
@@ -290,9 +304,10 @@ async function runDaemon(args, config) {
         quietUntil = Date.now() + SELF_WRITE_QUIET_MS;
         log(`Config drift detected: ${reasonPaths.join(', ')} — re-running protect-all.`);
         try {
-            await (0, mcpGateway_1.protectAllCommand)({ ...args, dryRun: undefined }, config);
+            const repaired = await (0, protectionRepair_1.repairProtection)({ ...args, dryRun: undefined }, config);
             quietUntil = Date.now() + SELF_WRITE_QUIET_MS;
-            log('Re-protection pass complete.');
+            log(`Re-protection pass complete (Cursor hooks ${repaired.cursorHooksHealthy ? 'healthy' : 'unhealthy'}, Claude hooks ${repaired.claudeHooksHealthy ? 'healthy' : 'unhealthy'}).`);
+            refreshWatchTargets();
             await uploadLogTail();
             if (!quiet) {
                 (0, notify_1.notifyOs)({
@@ -323,6 +338,25 @@ async function runDaemon(args, config) {
             clearTimeout(debounceTimer);
         debounceTimer = setTimeout(() => { void reprotect([full]); }, DEBOUNCE_MS);
     };
+    const onAdminRootEvent = (root, filename) => {
+        if (stopped || Date.now() < quietUntil || !filename)
+            return;
+        const full = path.resolve(root, filename.toString());
+        const normalized = full.replace(/\\/g, '/').toLowerCase();
+        if (normalized.includes('.fcd-backup-'))
+            return;
+        if (!/(?:\/\.cursor\/mcp\.json|\/\.mcp\.json|\/mcp\.json|\/\.claude\/settings\.json|\/\.vscode\/mcp\.json|\/\.codex\/config\.toml|\/\.gemini\/settings\.json)$/.test(normalized))
+            return;
+        const { disabledScanRoots } = (0, runtimeConfig_1.getCachedScanRootOverrides)();
+        if ((0, discoverPaths_1.isExcludedPath)(full, disabledScanRoots))
+            return;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            refreshWatchTargets();
+            void reprotect([full]);
+        }, DEBOUNCE_MS);
+    };
     /**
      * (Re)build the watch set from the current MCP client configs + hook files.
      * Watches parent directories (not files) so atomic replaces on Windows and
@@ -355,6 +389,27 @@ async function runDaemon(args, config) {
             }
             catch { /* directory may vanish; the rescan tick re-tries */ }
         }
+        const { extraScanRoots, disabledScanRoots } = (0, runtimeConfig_1.getCachedScanRootOverrides)();
+        const wantedRoots = new Set(extraScanRoots
+            .filter(root => !(0, discoverPaths_1.isExcludedPath)(root, disabledScanRoots) && fs.existsSync(root))
+            .map(discoverPaths_1.normalizedPath));
+        for (const [root, watcher] of rootWatchers) {
+            if (!wantedRoots.has((0, discoverPaths_1.normalizedPath)(root))) {
+                watcher.close();
+                rootWatchers.delete(root);
+            }
+        }
+        for (const root of extraScanRoots) {
+            const key = (0, discoverPaths_1.normalizedPath)(root);
+            if (!wantedRoots.has(key) || [...rootWatchers.keys()].some(existing => (0, discoverPaths_1.normalizedPath)(existing) === key))
+                continue;
+            try {
+                const watcher = fs.watch(path.resolve(root), { recursive: true }, (_event, filename) => onAdminRootEvent(root, filename ? String(filename) : null));
+                watcher.on('error', () => { watcher.close(); rootWatchers.delete(root); });
+                rootWatchers.set(path.resolve(root), watcher);
+            }
+            catch { /* unsupported/unreadable roots are retried on the rescan tick */ }
+        }
         return targets.length;
     };
     // Ship the REAL daemon log tail to the control plane so the dashboard's
@@ -461,7 +516,7 @@ async function runDaemon(args, config) {
                     throw new Error('Machine is suspended; resume it before repairing protection.');
                 log('Repair protection: running protect-all (IDE hooks + MCP gateways)…');
                 await uploadLogTail();
-                await (0, mcpGateway_1.protectAllCommand)({ ...args, dryRun: undefined }, config);
+                await (0, protectionRepair_1.repairProtection)({ ...args, dryRun: undefined }, config);
                 log('Repair protection: verifying hooks, gateways and daemon integrity…');
                 const verification = (0, integrity_1.getLocalIntegrityReport)({ requireDaemon: true });
                 if (!verification.ok) {
@@ -613,6 +668,8 @@ async function runDaemon(args, config) {
             clearTimeout(debounceTimer);
         for (const watcher of watchers.values())
             watcher.close();
+        for (const watcher of rootWatchers.values())
+            watcher.close();
         releasePidLock();
         process.exit(0);
     };
@@ -696,12 +753,23 @@ function installWindows() {
         ], { stdio: 'ignore', windowsHide: true });
         ok = reg.status === 0;
     }
+    // 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.
+    (0, child_process_1.spawnSync)('schtasks', [
+        '/Create', '/TN', WATCHDOG_TASK_NAME, '/TR', `wscript.exe "${vbs}"`,
+        '/SC', 'MINUTE', '/MO', '5', '/F',
+    ], { stdio: 'ignore', windowsHide: true });
     if (ok)
         startDaemonNowWindows(vbs, taskOk);
     return ok;
 }
 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 {
@@ -790,11 +858,16 @@ WantedBy=default.target
             return true;
     }
     catch { /* fall back to cron */ }
-    // Fallback: cron @reboot for boxes without a systemd user session.
+    // Fallback: cron for boxes without a systemd user session. @reboot starts
+    // the daemon at boot; the 5-min line is the watchdog (pid lock makes each
+    // tick a no-op while the daemon is alive, and revives it after a kill/crash).
     const command = `"${process.execPath}" "${cliEntry()}" daemon >/dev/null 2>&1`;
     const list = (0, child_process_1.spawnSync)('crontab', ['-l'], { encoding: 'utf8' });
     const existing = (list.status === 0 ? (list.stdout || '') : '').split('\n').filter(l => l && !l.includes(CRON_MARKER));
-    const write = (0, child_process_1.spawnSync)('crontab', ['-'], { input: [...existing, `@reboot ${command} ${CRON_MARKER}`].join('\n') + '\n', encoding: 'utf8' });
+    const write = (0, child_process_1.spawnSync)('crontab', ['-'], {
+        input: [...existing, `@reboot ${command} ${CRON_MARKER}`, `*/5 * * * * ${command} ${CRON_MARKER}`].join('\n') + '\n',
+        encoding: 'utf8',
+    });
     return write.status === 0;
 }
 function uninstallLinux() {
@@ -854,6 +927,10 @@ function statusCommand() {
         else {
             console.log('  not installed — run: fullcourtdefense daemon --install true');
         }
+        const watchdog = (0, child_process_1.spawnSync)('schtasks', ['/Query', '/TN', WATCHDOG_TASK_NAME], { stdio: 'ignore', windowsHide: true, timeout: 5_000 });
+        console.log(watchdog.status === 0
+            ? `  Watchdog task "${WATCHDOG_TASK_NAME}" installed — revives a killed daemon within 5 min`
+            : `  ${COLOR.yellow}watchdog not installed${COLOR.reset} — a killed daemon stays down until next logon; re-run: fullcourtdefense daemon --install true`);
     }
     else if (process.platform === 'darwin') {
         console.log(fs.existsSync(launchdPlistPath()) ? `  launchd agent installed (${launchdPlistPath()})` : '  not installed');
@@ -897,7 +974,7 @@ async function daemonCommand(args, config) {
                 : installLinux();
         if (ok) {
             console.log(`${COLOR.green}${COLOR.bold}Daemon autostart installed.${COLOR.reset}`);
-            console.log(`${COLOR.gray}Trigger:${COLOR.reset} ${process.platform === 'win32' ? `at logon (Scheduled Task "${TASK_NAME}")` : process.platform === 'darwin' ? 'launchd (RunAtLoad + KeepAlive)' : 'systemd user unit (or @reboot cron)'}`);
+            console.log(`${COLOR.gray}Trigger:${COLOR.reset} ${process.platform === 'win32' ? `at logon (Scheduled Task "${TASK_NAME}") + 5-min watchdog ("${WATCHDOG_TASK_NAME}") that revives a killed daemon` : process.platform === 'darwin' ? 'launchd (RunAtLoad + KeepAlive)' : 'systemd user unit (or @reboot + 5-min watchdog cron)'}`);
             console.log(`${COLOR.gray}Start now:${COLOR.reset} fullcourtdefense daemon`);
             console.log(`${COLOR.gray}Status:${COLOR.reset} fullcourtdefense daemon --status true`);
             console.log(`${COLOR.gray}Remove:${COLOR.reset} fullcourtdefense daemon --uninstall true`);

package/dist/commands/discover.js

@@ -774,6 +774,7 @@ function printPostureReport(posture, silent) {
     }
 }
 async function discoverCommand(args, config) {
+    const scanStartedAt = new Date().toISOString();
     const surfaces = parseSurfaces(args);
     const silent = args.silent === 'true';
     const uploadRequested = args.upload === 'true';
@@ -827,14 +828,18 @@ async function discoverCommand(args, config) {
     // covers them without extra flags. Default folders the admin explicitly
     // removed in the console are dropped from the sweep.
     const { extraScanRoots: adminScanRoots, disabledScanRoots } = (0, runtimeConfig_1.getCachedScanRootOverrides)();
-    const disabledRootSet = new Set(disabledScanRoots.map(root => path.resolve(root).toLowerCase()));
-    const isDisabledRoot = (root) => disabledRootSet.has(path.resolve(root).toLowerCase());
-    const scanRoots = [...new Set([...(0, discoverPaths_1.resolveScanRoots)(args.scanRoot), ...adminScanRoots])]
+    const normalizedDisabledRoots = (0, discoverPaths_1.uniqueNormalizedPaths)(disabledScanRoots);
+    const isDisabledRoot = (root) => (0, discoverPaths_1.isExcludedPath)(root, normalizedDisabledRoots);
+    const scanRoots = (0, discoverPaths_1.uniqueNormalizedPaths)([...(0, discoverPaths_1.resolveScanRoots)(args.scanRoot), ...adminScanRoots])
         .filter(root => !isDisabledRoot(root));
-    const sweep = scanRoots.length > 0 ? (0, discoverPaths_1.scanRootsForProjectConfigs)(scanRoots) : { candidates: [], scannedDirs: 0 };
+    const sweep = scanRoots.length > 0
+        ? (0, discoverPaths_1.scanRootsForProjectConfigs)(scanRoots, { excludedRoots: normalizedDisabledRoots })
+        : { candidates: [], scannedDirs: 0, excludedDirs: 0, truncated: false, maxDepth: 4, maxDirs: 25000 };
     // Admin roots are scanned for env/secrets even when no MCP config lives there.
-    const sweepProjectRoots = [...new Set([...deriveProjectRoots(sweep.candidates), ...adminScanRoots])];
-    const knownConfigCandidates = candidateConfigPaths(cwd, args.extraPath);
+    const sweepProjectRoots = (0, discoverPaths_1.uniqueNormalizedPaths)([...deriveProjectRoots(sweep.candidates), ...adminScanRoots])
+        .filter(root => !isDisabledRoot(root));
+    const knownConfigCandidates = candidateConfigPaths(cwd, args.extraPath)
+        .filter(candidate => !isDisabledRoot(candidate.path));
     const secretConfigFiles = [...knownConfigCandidates, ...sweep.candidates]
         .map(candidate => path.resolve(candidate.path))
         .filter(file => fs.existsSync(file));
@@ -881,11 +886,12 @@ async function discoverCommand(args, config) {
         }
     }
     const secrets = surfaces.has('secrets') || surfaces.has('posture')
-        ? (0, discoverSecrets_1.scanSecrets)({ cwd, extraRoots: sweepProjectRoots, disabledRoots: disabledScanRoots, configFiles: secretConfigFiles })
+        ? (0, discoverSecrets_1.scanSecrets)({ cwd, extraRoots: sweepProjectRoots, disabledRoots: normalizedDisabledRoots, configFiles: secretConfigFiles })
         : undefined;
-    const agentFiles = surfaces.has('agent-files') || surfaces.has('posture')
-        ? (0, discoverAgentFiles_1.scanAgentFiles)({ cwd, extraRoots: sweepProjectRoots })
+    const agentFileScan = surfaces.has('agent-files') || surfaces.has('posture')
+        ? (0, discoverAgentFiles_1.scanAgentFilesWithMetadata)({ cwd, extraRoots: sweepProjectRoots, disabledRoots: normalizedDisabledRoots })
         : undefined;
+    const agentFiles = agentFileScan?.findings;
     const posture = surfaces.has('posture')
         ? (0, discoverBlastRadius_1.computeBlastRadius)({
             mcpServers: found,
@@ -932,14 +938,43 @@ async function discoverCommand(args, config) {
                 `User-level AI rules, skills, hooks, and instruction files under ${home}`,
                 `Credential stores and shell history under ${home}`,
                 `Environment files under ${cwd}, ${path.join(home, 'dev')}, ${path.join(home, 'repos')}, ${path.join(home, 'projects')}, ${path.join(home, 'Documents')}, and ${path.join(home, 'code')}`,
-                ...adminScanRoots.map(root => `Admin-selected folder: ${root} (and subfolders)`),
+                ...adminScanRoots.map(root => `Admin-selected folder: ${root} (bounded descendant scan; exclusions and limits below)`),
             ],
             excluded: [
                 'Unrelated project folders outside the listed roots',
                 'Large/generated dependency and build folders such as node_modules, .git, dist, build, vendor, caches, and temp folders',
+                ...normalizedDisabledRoots.map(root => `Admin-excluded subtree: ${root}`),
                 'Full disk contents, browser profiles, email/chat archives, binary files, and operating-system folders',
             ],
-            note: 'Desktop posture is a targeted AI-development exposure scan, not a full-device forensic scan. Add folders from the machine page to expand coverage.',
+            note: `Desktop posture is a bounded AI-development exposure scan (project walk depth ${sweep.maxDepth}, up to ${sweep.maxDirs} folders), not a full-device forensic scan.`,
+            scannedAt: scanStartedAt,
+            limits: {
+                projectMaxDepth: sweep.maxDepth,
+                projectMaxDirectories: sweep.maxDirs,
+                secretMaxFileBytes: secrets?.limits?.maxFileBytes,
+                secretMaxCandidateFiles: secrets?.limits?.maxEnvFiles,
+                secretMaxFindings: secrets?.limits?.maxFindings,
+                agentFileMaxFiles: agentFileScan?.limits.maxFiles,
+                agentFileMaxBytes: agentFileScan?.limits.maxFileBytes,
+                agentFileMaxDepth: agentFileScan?.limits.maxDepth,
+            },
+            stats: {
+                projectDirectoriesScanned: sweep.scannedDirs,
+                projectConfigsFound: sweep.candidates.length,
+                projectRootsFound: sweepProjectRoots.length,
+                rootsScanned: scannedRoots.length,
+                secretCandidateFilesScanned: secrets?.scannedFiles ?? 0,
+                secretFindingsFound: secrets?.findings.length ?? 0,
+                secretFindingsUploaded: secrets?.findings.length ?? 0,
+                agentFilesScanned: agentFileScan?.stats.scannedFiles ?? 0,
+                excludedPathsSkipped: sweep.excludedDirs + (secrets?.stats?.excludedFiles ?? 0) + (agentFileScan?.stats.excludedPaths ?? 0),
+            },
+            truncated: {
+                projectDirectories: sweep.truncated,
+                secretCandidates: secrets?.truncated?.candidateFiles ?? false,
+                secretFindings: secrets?.truncated?.findings ?? false,
+                agentFiles: agentFileScan?.truncated ?? false,
+            },
         },
     };
     async function maybeUpload() {
@@ -967,6 +1002,7 @@ async function discoverCommand(args, config) {
             secrets,
             agentFiles,
             posture,
+            scanScope: uploadExtras.scanScope,
         }, null, 2));
         return;
     }

package/dist/commands/discoverAgentFiles.d.ts

@@ -10,7 +10,27 @@ export interface AgentFileFinding {
     riskTags: string[];
     excerpt?: string;
 }
+export interface AgentFilesScanResult {
+    findings: AgentFileFinding[];
+    limits: {
+        maxFiles: number;
+        maxFileBytes: number;
+        maxDepth: number;
+    };
+    stats: {
+        scannedFiles: number;
+        excludedPaths: number;
+    };
+    truncated: boolean;
+}
+export declare function scanAgentFilesWithMetadata(options?: {
+    cwd?: string;
+    extraRoots?: string[];
+    disabledRoots?: string[];
+}): AgentFilesScanResult;
+/** Backward-compatible findings-only API used by existing callers/tests. */
 export declare function scanAgentFiles(options?: {
     cwd?: string;
     extraRoots?: string[];
+    disabledRoots?: string[];
 }): AgentFileFinding[];

package/dist/commands/discoverAgentFiles.js

@@ -33,11 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanAgentFilesWithMetadata = scanAgentFilesWithMetadata;
 exports.scanAgentFiles = scanAgentFiles;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const discoverPaths_1 = require("./discoverPaths");
 const MAX_FILES = 150;
 const MAX_FILE_BYTES = 512 * 1024;
 const EXCERPT_LEN = 180;
@@ -131,9 +133,19 @@ function pushFinding(out, seen, input) {
         excerpt: excerpt || undefined,
     });
 }
-function walkDir(dir, out, seen, matcher, mapper, maxDepth = 4, depth = 0) {
-    if (depth > maxDepth || out.length >= MAX_FILES)
+function walkDir(dir, out, seen, matcher, mapper, maxDepth = 4, depth = 0, excludedRoots = [], stats) {
+    if (depth > maxDepth) {
+        if (stats)
+            stats.depthLimited = true;
         return;
+    }
+    if (out.length >= MAX_FILES)
+        return;
+    if ((0, discoverPaths_1.isExcludedPath)(dir, excludedRoots)) {
+        if (stats)
+            stats.excludedPaths += 1;
+        return;
+    }
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -145,10 +157,15 @@ function walkDir(dir, out, seen, matcher, mapper, maxDepth = 4, depth = 0) {
         if (out.length >= MAX_FILES)
             return;
         const full = path.join(dir, entry.name);
+        if ((0, discoverPaths_1.isExcludedPath)(full, excludedRoots)) {
+            if (stats)
+                stats.excludedPaths += 1;
+            continue;
+        }
         if (entry.isDirectory()) {
             if (['node_modules', '.git', 'dist', 'build'].includes(entry.name))
                 continue;
-            walkDir(full, out, seen, matcher, mapper, maxDepth, depth + 1);
+            walkDir(full, out, seen, matcher, mapper, maxDepth, depth + 1, excludedRoots, stats);
             continue;
         }
         if (!entry.isFile() || !matcher(full, entry.name))
@@ -159,12 +176,22 @@ function walkDir(dir, out, seen, matcher, mapper, maxDepth = 4, depth = 0) {
         pushFinding(out, seen, { ...mapper(full), ...parsed, content: parsed.content });
     }
 }
-function scanNamedFiles(roots, names, kind, titleFor, out, seen) {
+function scanNamedFiles(roots, names, kind, titleFor, out, seen, excludedRoots = [], stats) {
     for (const { root, client } of roots) {
+        if ((0, discoverPaths_1.isExcludedPath)(root, excludedRoots)) {
+            if (stats)
+                stats.excludedPaths += 1;
+            continue;
+        }
         if (!fs.existsSync(root))
             continue;
         for (const name of names) {
             const filePath = path.join(root, name);
+            if ((0, discoverPaths_1.isExcludedPath)(filePath, excludedRoots)) {
+                if (stats)
+                    stats.excludedPaths += 1;
+                continue;
+            }
             if (!fs.existsSync(filePath))
                 continue;
             const parsed = readAgentFile(filePath);
@@ -183,17 +210,22 @@ function scanNamedFiles(roots, names, kind, titleFor, out, seen) {
     }
 }
 /** Scan a single project root for agent instruction/rule/skill/hook files. */
-function scanProjectRootAgentFiles(root, clientLabel, out, seen) {
+function scanProjectRootAgentFiles(root, clientLabel, out, seen, excludedRoots = [], stats) {
+    if ((0, discoverPaths_1.isExcludedPath)(root, excludedRoots)) {
+        if (stats)
+            stats.excludedPaths += 1;
+        return;
+    }
     scanNamedFiles([{ root, client: clientLabel }], [
         'AGENTS.md',
         'CLAUDE.md',
         'GEMINI.md',
         '.cursorrules',
         '.windsurfrules',
-    ], 'instructions', name => `Agent instructions (${name})`, out, seen);
+    ], 'instructions', name => `Agent instructions (${name})`, out, seen, excludedRoots, stats);
     scanNamedFiles([{ root: path.join(root, '.github'), client: 'github' }], [
         'copilot-instructions.md',
-    ], 'instructions', () => 'GitHub Copilot instructions', out, seen);
+    ], 'instructions', () => 'GitHub Copilot instructions', out, seen, excludedRoots, stats);
     for (const base of [
         { dir: path.join(root, '.cursor', 'rules'), client: `Cursor (${clientLabel})`, kind: 'rules' },
         { dir: path.join(root, '.agents', 'skills'), client: `Agents (${clientLabel})`, kind: 'skills' },
@@ -207,7 +239,7 @@ function scanProjectRootAgentFiles(root, clientLabel, out, seen) {
             title: path.basename(filePath),
             sizeBytes: 0,
             lineCount: 0,
-        }));
+        }), 4, 0, excludedRoots, stats);
     }
     const hooksPath = path.join(root, '.cursor', 'hooks.json');
     if (fs.existsSync(hooksPath)) {
@@ -226,20 +258,24 @@ function scanProjectRootAgentFiles(root, clientLabel, out, seen) {
         }
     }
 }
-function scanAgentFiles(options = {}) {
+function scanAgentFilesWithMetadata(options = {}) {
     const home = os.homedir();
     const cwd = options.cwd || process.cwd();
     const out = [];
     const seen = new Set();
+    const excludedRoots = (0, discoverPaths_1.uniqueNormalizedPaths)(options.disabledRoots ?? []);
+    // Count configured subtree exclusions even when pruning prevents the walker
+    // from ever enumerating their contents.
+    const stats = { excludedPaths: excludedRoots.length, depthLimited: false };
     // Current project + user-global locations.
-    scanProjectRootAgentFiles(cwd, 'project', out, seen);
+    scanProjectRootAgentFiles(cwd, 'project', out, seen, excludedRoots, stats);
     scanNamedFiles([{ root: home, client: 'user' }], [
         'AGENTS.md',
         'CLAUDE.md',
         'GEMINI.md',
         '.cursorrules',
         '.windsurfrules',
-    ], 'instructions', name => `Agent instructions (${name})`, out, seen);
+    ], 'instructions', name => `Agent instructions (${name})`, out, seen, excludedRoots, stats);
     for (const base of [
         { dir: path.join(home, '.cursor', 'rules'), client: 'Cursor', kind: 'rules' },
         { dir: path.join(home, '.agents', 'skills'), client: 'Agents', kind: 'skills' },
@@ -253,10 +289,10 @@ function scanAgentFiles(options = {}) {
             title: path.basename(filePath),
             sizeBytes: 0,
             lineCount: 0,
-        }));
+        }), 4, 0, excludedRoots, stats);
     }
     const homeHooks = path.join(home, '.cursor', 'hooks.json');
-    if (fs.existsSync(homeHooks)) {
+    if (!(0, discoverPaths_1.isExcludedPath)(homeHooks, excludedRoots) && fs.existsSync(homeHooks)) {
         const parsed = readAgentFile(homeHooks);
         if (parsed) {
             pushFinding(out, seen, {
@@ -274,13 +310,26 @@ function scanAgentFiles(options = {}) {
     // Additional project roots (e.g. from `discover --scan-root`) — reference agent
     // files in every mapped project, not just the current folder.
     const cwdKey = path.resolve(cwd).toLowerCase();
-    for (const extra of options.extraRoots ?? []) {
+    for (const extra of (0, discoverPaths_1.uniqueNormalizedPaths)(options.extraRoots ?? [])) {
         if (path.resolve(extra).toLowerCase() === cwdKey)
             continue;
+        if ((0, discoverPaths_1.isExcludedPath)(extra, excludedRoots)) {
+            stats.excludedPaths += 1;
+            continue;
+        }
         if (!fs.existsSync(extra))
             continue;
-        scanProjectRootAgentFiles(extra, 'scanned project', out, seen);
+        scanProjectRootAgentFiles(extra, 'scanned project', out, seen, excludedRoots, stats);
     }
     out.sort((a, b) => b.riskTags.length - a.riskTags.length || b.sizeBytes - a.sizeBytes);
-    return out;
+    return {
+        findings: out,
+        limits: { maxFiles: MAX_FILES, maxFileBytes: MAX_FILE_BYTES, maxDepth: 4 },
+        stats: { scannedFiles: out.length, excludedPaths: stats.excludedPaths },
+        truncated: stats.depthLimited || out.length >= MAX_FILES,
+    };
+}
+/** Backward-compatible findings-only API used by existing callers/tests. */
+function scanAgentFiles(options = {}) {
+    return scanAgentFilesWithMetadata(options).findings;
 }

package/dist/commands/discoverBlastRadius.d.ts

@@ -7,6 +7,11 @@ export interface BlastRadiusCombo {
     severity: BlastSeverity;
     title: string;
     detail: string;
+    /** Exact entities that caused this combo; IDs are stable across rescans. */
+    evidenceRefs: Array<{
+        kind: 'mcp_server' | 'secret_finding' | 'agent_file' | 'client';
+        id: string;
+    }>;
 }
 export interface BlastRadiusReport {
     score: number;
@@ -16,6 +21,7 @@ export interface BlastRadiusReport {
 }
 interface McpServerLike {
     serverName: string;
+    configPath?: string;
     riskLevel: 'critical' | 'high' | 'medium' | 'low';
     riskTags: string[];
     proxyStatus: string;