react-doctor 0.6.3-dev.8325343 → 0.6.3-dev.bdf8074

package/dist/cli.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2921b8ff-14cf-5604-8ae5-b65b4f1347fc")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4d2b3e2c-ffb8-5da4-bf5d-833e608822bb")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as NodeChildProcess from "node:child_process";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
@@ -9,7 +9,7 @@ import * as NFS from "node:fs";
 import fs, { mkdtempSync, rmSync } from "node:fs";
 import process$1 from "node:process";
 import * as ts from "typescript";
-import reactDoctorPlugin, { ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_RULE_IDS, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, classifySecurityScanFile, shouldReadSecurityScanContent } from "oxlint-plugin-react-doctor";
+import reactDoctorPlugin, { ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_DEPENDENCY_COLLECTORS, CROSS_FILE_RULE_IDS, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, classifySecurityScanFile, collectCrossFileDependencyProbes, shouldReadSecurityScanContent } from "oxlint-plugin-react-doctor";
 import * as OS from "node:os";
 import os, { tmpdir } from "node:os";
 import { parseJSON5 } from "confbox";
@@ -18,6 +18,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
 import * as Crypto from "node:crypto";
 import crypto, { createHash, randomUUID } from "node:crypto";
+import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analyzed-inputs";
 import { gzipSync } from "node:zlib";
 import * as Sentry from "@sentry/node";
 import { performance as performance$1 } from "node:perf_hooks";
@@ -36128,6 +36129,10 @@ const SOCKET_PACKAGE_PAGE_BASE = "https://socket.dev/npm/package";
 const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
 const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
 const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
+const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
+const CORE_PACKAGE_VERSION = "0.6.3";
+const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
+const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
 const SUPPLY_CHAIN_RULE = "low-supply-chain-score";
 const SUPPLY_CHAIN_CATEGORY = "Security";
@@ -38812,6 +38817,48 @@ var PerFileLintCacheEnabled = class extends Reference("react-doctor/PerFileLintC
 	if (CACHE_DISABLED_VALUES$1.has(noFileCache)) return false;
 	return true;
 } }) {};
+/**
+* Whether the sidecar lint cache (`runners/oxlint/sidecar-lint-cache.ts`) is
+* active. Defaults ON — warm rescans replay the cross-file rules' cached
+* diagnostics for every file whose dependency fingerprint (the probe set the
+* plugin's collectors recorded) still matches the tree, and re-lint only the
+* rest. Only reachable when the per-file lint cache itself is on (the
+* sidecar covers its cache hits), so `REACT_DOCTOR_NO_CACHE` /
+* `REACT_DOCTOR_NO_FILE_CACHE` implicitly disable it too. Opt-OUT knobs:
+*
+*   - `REACT_DOCTOR_NO_CACHE` — the global off-switch.
+*   - `REACT_DOCTOR_NO_SIDECAR_CACHE` — granular rollback hatch: keep the
+*     per-file cache but run the always-fresh sidecar over every hit
+*     (the pre-cache behavior).
+*
+* Tests override via `Layer.succeed(SidecarLintCacheEnabled, false)`.
+*/
+var SidecarLintCacheEnabled = class extends Reference("react-doctor/SidecarLintCacheEnabled", { defaultValue: () => {
+	const noCache = process.env["REACT_DOCTOR_NO_CACHE"]?.toLowerCase() ?? "";
+	const noSidecarCache = process.env["REACT_DOCTOR_NO_SIDECAR_CACHE"]?.toLowerCase() ?? "";
+	if (CACHE_DISABLED_VALUES$1.has(noCache)) return false;
+	if (CACHE_DISABLED_VALUES$1.has(noSidecarCache)) return false;
+	return true;
+} }) {};
+/**
+* Whether the whole-project dead-code result cache
+* (`dead-code/dead-code-result-cache.ts`) is active. Defaults ON — a rescan
+* whose inputs (source tree, manifests, configs, analyzer version) are
+* unchanged replays the stored diagnostics instead of re-running the
+* analysis worker. Opt-OUT, two knobs (matching the per-file lint cache):
+*
+*   - `REACT_DOCTOR_NO_CACHE` — the global off-switch.
+*   - `REACT_DOCTOR_NO_DEAD_CODE_CACHE` — granular: bust only this cache.
+*
+* Tests override via `Layer.succeed(DeadCodeResultCacheEnabled, false)`.
+*/
+var DeadCodeResultCacheEnabled = class extends Reference("react-doctor/DeadCodeResultCacheEnabled", { defaultValue: () => {
+	const noCache = process.env["REACT_DOCTOR_NO_CACHE"]?.toLowerCase() ?? "";
+	const noDeadCodeCache = process.env["REACT_DOCTOR_NO_DEAD_CODE_CACHE"]?.toLowerCase() ?? "";
+	if (CACHE_DISABLED_VALUES$1.has(noCache)) return false;
+	if (CACHE_DISABLED_VALUES$1.has(noDeadCodeCache)) return false;
+	return true;
+} }) {};
 const DIAGNOSTIC_SURFACES = [
 	"cli",
 	"prComment",
@@ -40544,6 +40591,80 @@ const collectDeadCodeIgnorePatterns = (rootDirectory) => {
 	return [...seen].filter((pattern) => pattern.length > 0);
 };
 const collectDeadCodeEntryPatterns = (rootDirectory) => [...new Set(collectKnipPatterns(rootDirectory, "entry"))].filter((pattern) => pattern.length > 0);
+const atomicWriteJson = (filePath, value) => {
+	try {
+		NFS.mkdirSync(Path.dirname(filePath), { recursive: true });
+		const temporaryPath = `${filePath}.${process.pid}.tmp`;
+		NFS.writeFileSync(temporaryPath, JSON.stringify(value));
+		NFS.renameSync(temporaryPath, filePath);
+	} catch {
+		return;
+	}
+};
+const failOpenReadJson = (filePath, fallback) => {
+	try {
+		return JSON.parse(NFS.readFileSync(filePath, "utf8"));
+	} catch {
+		return fallback;
+	}
+};
+const ANALYZED_FILE_EXTENSIONS = new Set(DEFAULT_EXTENSIONS);
+const CORE_SIDE_MANIFEST_NAMES = ["knip.json", "deno.lock"];
+const ANALYZED_MANIFEST_NAMES = new Set([...ANALYZED_MANIFEST_FILENAMES, ...CORE_SIDE_MANIFEST_NAMES]);
+const isTsConfigLikeFile = (fileName) => (fileName.startsWith("tsconfig") || fileName.startsWith("jsconfig")) && fileName.endsWith(".json");
+const isFingerprintedFile = (fileName) => ANALYZED_FILE_EXTENSIONS.has(Path.extname(fileName).toLowerCase()) || ANALYZED_MANIFEST_NAMES.has(fileName) || isTsConfigLikeFile(fileName);
+const collectAnalyzedFileFingerprints = (rootDirectory) => {
+	const fingerprints = [];
+	for (const { absolutePath, name } of walkSourceTreeFiles(rootDirectory)) {
+		if (!isFingerprintedFile(name)) continue;
+		try {
+			const fileStat = NFS.statSync(absolutePath);
+			const relativePath = Path.relative(rootDirectory, absolutePath).replace(/\\/g, "/");
+			fingerprints.push(`${relativePath}:${fileStat.mtimeMs}:${fileStat.size}`);
+		} catch {}
+	}
+	return fingerprints.sort();
+};
+const bundledRequire$2 = createRequire(import.meta.url);
+const resolveDeslopVersion = () => {
+	try {
+		const packageJson = JSON.parse(NFS.readFileSync(bundledRequire$2.resolve("deslop-js/package.json"), "utf8"));
+		return isRecord$1(packageJson) && typeof packageJson.version === "string" ? packageJson.version : "unknown";
+	} catch {
+		return "unknown";
+	}
+};
+const computeDeadCodeCacheKey = (input) => crypto.createHash("sha1").update(JSON.stringify({
+	schemaVersion: 1,
+	coreVersion: input.coreVersion,
+	deslopVersion: resolveDeslopVersion(),
+	deslopJsModuleSpecifier: input.deslopJsModuleSpecifier,
+	entryPatterns: input.entryPatterns,
+	ignorePatterns: input.ignorePatterns,
+	tsConfigFile: input.tsConfigPath === void 0 ? null : Path.relative(input.rootDirectory, input.tsConfigPath).replace(/\\/g, "/"),
+	files: collectAnalyzedFileFingerprints(input.rootDirectory)
+})).digest("hex");
+const validateDiagnostic$2 = decodeUnknownSync(Diagnostic);
+const decodeCachedDiagnostics = (raw) => {
+	try {
+		for (const entry of raw) validateDiagnostic$2(entry);
+		return raw;
+	} catch {
+		return null;
+	}
+};
+const lookupDeadCodeResultCache = (cacheDirectory, cacheKey) => {
+	const persisted = failOpenReadJson(Path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME), null);
+	if (persisted === null || !isRecord$1(persisted) || persisted.version !== 1 || persisted.key !== cacheKey || !Array.isArray(persisted.diagnostics)) return null;
+	return decodeCachedDiagnostics(persisted.diagnostics);
+};
+const storeDeadCodeResultCache = (cacheDirectory, cacheKey, diagnostics) => {
+	atomicWriteJson(Path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME), {
+		version: 1,
+		key: cacheKey,
+		diagnostics
+	});
+};
 const readSystemFacts = () => ({
 	availableCores: os.availableParallelism(),
 	totalMemoryBytes: os.totalmem(),
@@ -40612,6 +40733,21 @@ const withDeadCodeWorkerSlot = async (task, abortSignal) => {
 		releaseSlot();
 	}
 };
+const projectCacheSubdir = (projectDirectory) => crypto.createHash("sha256").update(projectDirectory).digest("hex").slice(0, 16);
+const resolveReactDoctorCacheDir = (projectDirectory) => {
+	const cacheDirOverride = process.env["REACT_DOCTOR_CACHE_DIR"]?.trim();
+	if (cacheDirOverride) return Path.join(cacheDirOverride, projectCacheSubdir(projectDirectory));
+	const nodeModulesDirectory = Path.join(projectDirectory, "node_modules");
+	if (NFS.existsSync(nodeModulesDirectory)) return Path.join(nodeModulesDirectory, ".cache", "react-doctor");
+	return Path.join(os.tmpdir(), `react-doctor-cache-${resolveUserCacheScope()}`, projectCacheSubdir(projectDirectory));
+};
+const resolveUserCacheScope = () => {
+	try {
+		return String(process.getuid?.() ?? os.userInfo().username);
+	} catch {
+		return "shared";
+	}
+};
 /**
 * Resolves a path to its canonical, symlink-free form, falling back to
 * the input when it cannot be realpath'd (broken symlink, permission
@@ -40665,6 +40801,14 @@ process.stdin.on("end", () => {
     circularDependencies: result.circularDependencies.map((cycle) => ({
       files: cycle.files,
     })),
+    ...(result.incrementalCacheStats
+      ? {
+          summaryCacheStats: {
+            hits: result.incrementalCacheStats.summaryHits,
+            misses: result.incrementalCacheStats.summaryMisses,
+          },
+        }
+      : {}),
   });
 
   const serializeError = (error) =>
@@ -40688,6 +40832,9 @@ process.stdin.on("end", () => {
         ...(workerInput.ignorePatterns.length > 0
           ? { ignorePatterns: workerInput.ignorePatterns }
           : {}),
+        ...(workerInput.incrementalCachePath
+          ? { incrementalCachePath: workerInput.incrementalCachePath }
+          : {}),
         // We consume only deslop's GRAPH-based findings (unusedFiles, unusedExports,
         // unusedDependencies, circularDependencies). Everything else deslop can compute
         // is pure wasted work for us, and it's the bulk of the runtime:
@@ -40698,12 +40845,18 @@ process.stdin.on("end", () => {
         //     are the single most expensive pass — duplicate-block detection alone was
         //     ~83s of a ~130s Sentry scan — so skipping them is an ~8.5x dead-code
         //     speedup on a large repo.
-        // Both are provably safe: the consumed graph findings are computed by their own
+        //   - reportRedundancy: the DRY-pattern detectors (duplicate types/constants,
+        //     simplifiable functions, identity wrappers, …) — ~120 ms of discarded
+        //     output per scan, and skipping them lets the incremental cache drop the
+        //     DRY-pattern summary fields (the largest slice of the cache file).
+        // All are provably safe: the consumed graph findings are computed by their own
         // detectors, independent of these passes (confirmed byte-identical on
-        // excalidraw + mui-material + sentry). tsConfigPath stays — the module resolver
-        // needs it for path-alias resolution in the import graph.
+        // excalidraw + mui-material + sentry; re-verified on sentry after the
+        // reportRedundancy flip). tsConfigPath stays — the module resolver needs it
+        // for path-alias resolution in the import graph.
         semantic: { enabled: false },
         reportCodeQuality: false,
+        reportRedundancy: false,
       };
       const result = await analyze(defineConfig(config));
       emit({ ok: true, result: normalizeResult(result) });
@@ -40787,13 +40940,23 @@ const parseCircularDependencies = (value) => {
 	}
 	return circularDependencies;
 };
+const parseSummaryCacheStats = (value) => {
+	if (!isRecord$1(value)) return void 0;
+	if (typeof value.hits !== "number" || typeof value.misses !== "number") return void 0;
+	return {
+		hits: value.hits,
+		misses: value.misses
+	};
+};
 const parseDeadCodeWorkerResult = (value) => {
 	if (!isRecord$1(value)) throw new Error("Dead-code worker returned an invalid result.");
+	const summaryCacheStats = parseSummaryCacheStats(value.summaryCacheStats);
 	return {
 		unusedFiles: parseUnusedFiles(value.unusedFiles),
 		unusedExports: parseUnusedExports(value.unusedExports),
 		unusedDependencies: parseUnusedDependencies(value.unusedDependencies),
-		circularDependencies: parseCircularDependencies(value.circularDependencies)
+		circularDependencies: parseCircularDependencies(value.circularDependencies),
+		...summaryCacheStats ? { summaryCacheStats } : {}
 	};
 };
 const parseDeadCodeWorkerError = (value) => {
@@ -40907,17 +41070,35 @@ const checkDeadCode = async (options) => {
 	if (!NFS.existsSync(Path.join(rootDirectory, "package.json"))) return [];
 	const entryPatterns = collectDeadCodeEntryPatterns(rootDirectory);
 	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory);
+	const tsConfigPath = resolveTsConfigPath(rootDirectory);
+	const deslopJsModuleSpecifier = options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js");
+	const cacheKey = options.cacheEnabled ? computeDeadCodeCacheKey({
+		rootDirectory,
+		entryPatterns,
+		ignorePatterns,
+		tsConfigPath,
+		deslopJsModuleSpecifier,
+		coreVersion: CORE_PACKAGE_VERSION
+	}) : null;
+	if (cacheKey !== null) {
+		const cachedDiagnostics = lookupDeadCodeResultCache(resolveReactDoctorCacheDir(rootDirectory), cacheKey);
+		options.onCacheOutcome?.(cachedDiagnostics !== null);
+		if (cachedDiagnostics !== null) return [...cachedDiagnostics];
+	}
+	const incrementalCachePath = options.cacheEnabled === true ? Path.join(resolveReactDoctorCacheDir(rootDirectory), DEAD_CODE_SUMMARY_CACHE_FILENAME) : void 0;
 	const spawnAndRun = () => {
 		return runDeadCodeWorkerWithTimeout((options.createWorker ?? createDeadCodeWorker)({
 			rootDirectory,
 			entryPatterns,
-			tsConfigPath: resolveTsConfigPath(rootDirectory),
+			tsConfigPath,
 			ignorePatterns,
-			deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js"),
-			parseConcurrency: options.parseConcurrency
+			deslopJsModuleSpecifier,
+			parseConcurrency: options.parseConcurrency,
+			incrementalCachePath
 		}), options.workerTimeoutMs ?? 12e4, options.abortSignal);
 	};
 	const result = parseDeadCodeWorkerResult(options.createWorker === void 0 ? await withDeadCodeWorkerSlot(spawnAndRun, options.abortSignal) : await spawnAndRun());
+	if (result.summaryCacheStats !== void 0) options.onSummaryCacheStats?.(result.summaryCacheStats);
 	const toRelative = (filePath) => toRelativeFilePath(rootDirectory, filePath);
 	const diagnostics = [];
 	for (const unusedFile of result.unusedFiles) diagnostics.push({
@@ -40974,6 +41155,7 @@ const checkDeadCode = async (options) => {
 			category: DEAD_CODE_CATEGORY
 		});
 	}
+	if (cacheKey !== null) storeDeadCodeResultCache(resolveReactDoctorCacheDir(rootDirectory), cacheKey, diagnostics);
 	return diagnostics;
 };
 const DEAD_CODE_RULE_KEY_PREFIX = `${DEAD_CODE_PLUGIN}/`;
@@ -41076,12 +41258,16 @@ var Config = class Config extends Service()("react-doctor/Config") {
 */
 var DeadCode = class DeadCode extends Service()("react-doctor/DeadCode") {
 	static layerNode = succeed$3(DeadCode, DeadCode.of({ run: (input) => unwrap(fn("DeadCode.run")(function* () {
+		const cacheEnabled = yield* DeadCodeResultCacheEnabled;
 		return yield* tryPromise({
 			try: (signal) => checkDeadCode({
 				rootDirectory: input.rootDirectory,
 				parseConcurrency: input.parseConcurrency,
 				workerTimeoutMs: input.workerTimeoutMs,
-				abortSignal: signal
+				abortSignal: signal,
+				cacheEnabled,
+				onCacheOutcome: input.onCacheOutcome,
+				onSummaryCacheStats: input.onSummaryCacheStats
 			}),
 			catch: (cause) => new ReactDoctorError({ reason: new DeadCodeAnalysisFailed({ cause }) })
 		}).pipe(map$3((diagnostics) => fromIterable$1(diagnostics)));
@@ -41951,7 +42137,7 @@ const buildUserPluginRules = (userPlugin, severityControls) => {
 	}
 	return enabled;
 };
-const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set(), serverAuthFunctionNames, severityControls, userPlugins = [], disableReactHooksJsPlugin = false, ruleSelection }) => {
+const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set(), serverAuthFunctionNames, severityControls, userPlugins = [], disableReactHooksJsPlugin = false, ruleSelection, sidecarRuleIdFilter }) => {
 	const reactHooksJsPlugin = disableReactHooksJsPlugin || ruleSelection === "sidecar" ? null : resolveReactHooksJsPlugin(project.hasReactCompiler, customRulesOnly);
 	const reactCompilerRules = reactHooksJsPlugin ? applyRuleSeverityControls(filterRulesToAvailable(REACT_COMPILER_RULES, "react-hooks-js", reactHooksJsPlugin.availableRuleNames), severityControls) : {};
 	const jsPlugins = [];
@@ -41963,6 +42149,7 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		if (!rule) continue;
 		if (ruleSelection === "cacheable" && CROSS_FILE_RULE_IDS.has(registryEntry.id)) continue;
 		if (ruleSelection === "sidecar" && !CROSS_FILE_RULE_IDS.has(registryEntry.id)) continue;
+		if (ruleSelection === "sidecar" && sidecarRuleIdFilter !== void 0 && !sidecarRuleIdFilter.has(registryEntry.id)) continue;
 		if (rule.scan !== void 0) continue;
 		if (customRulesOnly && registryEntry.originallyExternal) continue;
 		if (rule.framework !== "global" && !rule.requires) continue;
@@ -42007,33 +42194,152 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		}
 	};
 };
-const atomicWriteJson = (filePath, value) => {
+const validateDiagnostic$1 = decodeUnknownSync(Diagnostic);
+const decodeFileDiagnostics = (raw) => {
+	if (!Array.isArray(raw)) return null;
 	try {
-		NFS.mkdirSync(Path.dirname(filePath), { recursive: true });
-		const temporaryPath = `${filePath}.${process.pid}.tmp`;
-		NFS.writeFileSync(temporaryPath, JSON.stringify(value));
-		NFS.renameSync(temporaryPath, filePath);
+		for (const entry of raw) validateDiagnostic$1(entry);
+		return raw;
 	} catch {
-		return;
+		return null;
 	}
 };
-const failOpenReadJson = (filePath, fallback) => {
+const emptyCache$1 = () => ({
+	version: 1,
+	rulesets: {}
+});
+const loadRulesetEntries$1 = (cacheFilePath, rulesetHash) => {
+	const entries = /* @__PURE__ */ new Map();
+	const persisted = failOpenReadJson(cacheFilePath, emptyCache$1());
+	if (persisted.version !== 1 || !isRecord$1(persisted.rulesets)) return entries;
+	const bucket = persisted.rulesets[rulesetHash];
+	if (!isRecord$1(bucket) || !isRecord$1(bucket.files)) return entries;
+	for (const [fileKey, rawDiagnostics] of Object.entries(bucket.files)) {
+		const decoded = decodeFileDiagnostics(rawDiagnostics);
+		if (decoded !== null) entries.set(fileKey, decoded);
+	}
+	return entries;
+};
+const createFileLintCache = (cacheDirectory, rulesetHash) => {
+	const cacheFilePath = Path.join(cacheDirectory, FILE_LINT_CACHE_FILENAME);
+	const entries = loadRulesetEntries$1(cacheFilePath, rulesetHash);
+	return {
+		lookup: (fileKey) => entries.get(fileKey) ?? null,
+		store: (fileKey, diagnostics) => {
+			entries.delete(fileKey);
+			entries.set(fileKey, diagnostics);
+		},
+		persist: () => {
+			const onDisk = failOpenReadJson(cacheFilePath, emptyCache$1());
+			const rulesets = onDisk.version === 1 && isRecord$1(onDisk.rulesets) ? { ...onDisk.rulesets } : {};
+			const existingBucket = rulesets[rulesetHash];
+			const existingFiles = isRecord$1(existingBucket) && isRecord$1(existingBucket.files) ? existingBucket.files : {};
+			const ourFiles = {};
+			for (const [fileKey, diagnostics] of entries) ourFiles[fileKey] = diagnostics;
+			const cappedEntries = Object.entries({
+				...existingFiles,
+				...ourFiles
+			}).slice(-FILE_LINT_CACHE_MAX_FILE_COUNT);
+			rulesets[rulesetHash] = {
+				updatedAtMs: Date.now(),
+				files: Object.fromEntries(cappedEntries)
+			};
+			atomicWriteJson(cacheFilePath, {
+				version: 1,
+				rulesets: Object.fromEntries(Object.entries(rulesets).filter(([, bucket]) => isRecord$1(bucket) && typeof bucket.updatedAtMs === "number").sort(([, first], [, second]) => second.updatedAtMs - first.updatedAtMs).slice(0, 8))
+			});
+		}
+	};
+};
+const hashFileContents = (filePath) => {
 	try {
-		return JSON.parse(NFS.readFileSync(filePath, "utf8"));
+		return crypto.createHash("sha1").update(NFS.readFileSync(filePath)).digest("hex");
 	} catch {
-		return fallback;
+		return null;
 	}
 };
+const ABSENT_CONTENT_ANSWER = "absent";
+/**
+* Answers dependency probes for the sidecar lint cache — used both when
+* STORING an entry (turn the collector's probe paths into answers) and when
+* VERIFYING one (re-answer each stored probe against the current tree).
+* Store and verify must agree exactly, so both go through this one resolver.
+*
+*   - `content` — SHA-1 of the file's bytes, `"absent"` when unreadable
+*     (missing, a directory, permission failure). Source files reuse the
+*     hashes the cache-partition loop already computed
+*     (`contentHashByRelativePath`); everything else (package.json,
+*     tsconfig, ignored files) is hashed on demand.
+*   - `exists` — the existence class a module-resolution candidate probe
+*     sees: `"file"`, `"dir"`, or `"none"` (missing or an exotic entry —
+*     `statSync` follows symlinks, matching the resolvers).
+*
+* Answers are memoized per scan: the filesystem is frozen for the run, and
+* hot dependency paths (a barrel imported by hundreds of files, the shared
+* tsconfig chain) repeat across many files' probe sets.
+*/
+const createSidecarProbeAnswerResolver = (input) => {
+	const contentAnswerByPath = /* @__PURE__ */ new Map();
+	const existsAnswerByPath = /* @__PURE__ */ new Map();
+	const toRelativePath = (absolutePath) => Path.relative(input.rootDirectory, absolutePath).replaceAll("\\", "/");
+	const contentAnswer = (relativePath) => {
+		const memoized = contentAnswerByPath.get(relativePath);
+		if (memoized !== void 0) return memoized;
+		const answer = input.contentHashByRelativePath.get(relativePath) ?? hashFileContents(Path.resolve(input.rootDirectory, relativePath)) ?? ABSENT_CONTENT_ANSWER;
+		contentAnswerByPath.set(relativePath, answer);
+		return answer;
+	};
+	const existsAnswer = (relativePath) => {
+		const memoized = existsAnswerByPath.get(relativePath);
+		if (memoized !== void 0) return memoized;
+		let answer;
+		try {
+			const stat = NFS.statSync(Path.resolve(input.rootDirectory, relativePath));
+			answer = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "none";
+		} catch {
+			answer = "none";
+		}
+		existsAnswerByPath.set(relativePath, answer);
+		return answer;
+	};
+	return {
+		answerFor: (kind, relativePath) => kind === "content" ? contentAnswer(relativePath) : existsAnswer(relativePath),
+		toRelativePath
+	};
+};
 const validateDiagnostic = decodeUnknownSync(Diagnostic);
-const decodeFileDiagnostics = (raw) => {
-	if (!Array.isArray(raw)) return null;
+const isProbeKind = (value) => value === "content" || value === "exists";
+const decodeSidecarFileEntry = (raw) => {
+	if (!isRecord$1(raw) || !Array.isArray(raw.probes) || !Array.isArray(raw.diagnostics)) return null;
+	const probes = [];
+	for (const rawProbe of raw.probes) {
+		if (!Array.isArray(rawProbe) || rawProbe.length !== 3) return null;
+		const [kind, probePath, answer] = rawProbe;
+		if (!isProbeKind(kind) || typeof probePath !== "string" || typeof answer !== "string") return null;
+		probes.push({
+			kind,
+			path: probePath,
+			answer
+		});
+	}
 	try {
-		for (const entry of raw) validateDiagnostic(entry);
-		return raw;
+		for (const entry of raw.diagnostics) validateDiagnostic(entry);
 	} catch {
 		return null;
 	}
+	return {
+		probes,
+		diagnostics: raw.diagnostics
+	};
 };
+const encodeSidecarFileEntry = (entry) => ({
+	probes: entry.probes.map((probe) => [
+		probe.kind,
+		probe.path,
+		probe.answer
+	]),
+	diagnostics: entry.diagnostics
+});
 const emptyCache = () => ({
 	version: 1,
 	rulesets: {}
@@ -42044,20 +42350,20 @@ const loadRulesetEntries = (cacheFilePath, rulesetHash) => {
 	if (persisted.version !== 1 || !isRecord$1(persisted.rulesets)) return entries;
 	const bucket = persisted.rulesets[rulesetHash];
 	if (!isRecord$1(bucket) || !isRecord$1(bucket.files)) return entries;
-	for (const [fileKey, rawDiagnostics] of Object.entries(bucket.files)) {
-		const decoded = decodeFileDiagnostics(rawDiagnostics);
+	for (const [fileKey, rawEntry] of Object.entries(bucket.files)) {
+		const decoded = decodeSidecarFileEntry(rawEntry);
 		if (decoded !== null) entries.set(fileKey, decoded);
 	}
 	return entries;
 };
-const createFileLintCache = (cacheDirectory, rulesetHash) => {
-	const cacheFilePath = Path.join(cacheDirectory, FILE_LINT_CACHE_FILENAME);
+const createSidecarLintCache = (cacheDirectory, rulesetHash) => {
+	const cacheFilePath = Path.join(cacheDirectory, SIDECAR_LINT_CACHE_FILENAME);
 	const entries = loadRulesetEntries(cacheFilePath, rulesetHash);
 	return {
 		lookup: (fileKey) => entries.get(fileKey) ?? null,
-		store: (fileKey, diagnostics) => {
+		store: (fileKey, entry) => {
 			entries.delete(fileKey);
-			entries.set(fileKey, diagnostics);
+			entries.set(fileKey, entry);
 		},
 		persist: () => {
 			const onDisk = failOpenReadJson(cacheFilePath, emptyCache());
@@ -42065,7 +42371,7 @@ const createFileLintCache = (cacheDirectory, rulesetHash) => {
 			const existingBucket = rulesets[rulesetHash];
 			const existingFiles = isRecord$1(existingBucket) && isRecord$1(existingBucket.files) ? existingBucket.files : {};
 			const ourFiles = {};
-			for (const [fileKey, diagnostics] of entries) ourFiles[fileKey] = diagnostics;
+			for (const [fileKey, entry] of entries) ourFiles[fileKey] = encodeSidecarFileEntry(entry);
 			const cappedEntries = Object.entries({
 				...existingFiles,
 				...ourFiles
@@ -42081,7 +42387,7 @@ const createFileLintCache = (cacheDirectory, rulesetHash) => {
 		}
 	};
 };
-const bundledRequire$2 = createRequire(import.meta.url);
+const bundledRequire$3 = createRequire(import.meta.url);
 const childNodeVersionByBinaryPath = /* @__PURE__ */ new Map();
 const resolveChildNodeVersion = (nodeBinaryPath) => {
 	if (nodeBinaryPath === process.execPath) return process.version;
@@ -42107,7 +42413,7 @@ const TOOLCHAIN_PACKAGE_SPECIFIERS$1 = [
 const resolveOxlintToolchainVersions = (nodeBinaryPath = process.execPath) => {
 	const versions = [`node=${resolveChildNodeVersion(nodeBinaryPath)}`];
 	for (const specifier of TOOLCHAIN_PACKAGE_SPECIFIERS$1) try {
-		const packageJson = bundledRequire$2(specifier);
+		const packageJson = bundledRequire$3(specifier);
 		const version = typeof packageJson.version === "string" ? packageJson.version : "unknown";
 		versions.push(`${specifier}=${version}`);
 	} catch {
@@ -43080,13 +43386,6 @@ const validateRuleRegistration = () => {
 	].filter((entry) => entry !== null).join("; ");
 	console.warn(`[react-doctor] rule-registration drift: ${detail}`);
 };
-const hashFileContents = (filePath) => {
-	try {
-		return crypto.createHash("sha1").update(NFS.readFileSync(filePath)).digest("hex");
-	} catch {
-		return null;
-	}
-};
 /**
 * Balanced LPT (longest-processing-time-first) lint batch planner. Where
 * `batchIncludePaths` greedily fills 100-file batches and leaves a small
@@ -43151,21 +43450,6 @@ const planLintBatches = ({ baseArgs, files, sizeByFile }) => {
 	}
 	return batches.filter((batch) => batch.fileIndexes.length > 0).map((batch) => batch.fileIndexes.sort((leftIndex, rightIndex) => leftIndex - rightIndex).map((fileIndex) => files[fileIndex]));
 };
-const projectCacheSubdir = (projectDirectory) => crypto.createHash("sha256").update(projectDirectory).digest("hex").slice(0, 16);
-const resolveReactDoctorCacheDir = (projectDirectory) => {
-	const cacheDirOverride = process.env["REACT_DOCTOR_CACHE_DIR"]?.trim();
-	if (cacheDirOverride) return Path.join(cacheDirOverride, projectCacheSubdir(projectDirectory));
-	const nodeModulesDirectory = Path.join(projectDirectory, "node_modules");
-	if (NFS.existsSync(nodeModulesDirectory)) return Path.join(nodeModulesDirectory, ".cache", "react-doctor");
-	return Path.join(os.tmpdir(), `react-doctor-cache-${resolveUserCacheScope()}`, projectCacheSubdir(projectDirectory));
-};
-const resolveUserCacheScope = () => {
-	try {
-		return String(process.getuid?.() ?? os.userInfo().username);
-	} catch {
-		return "shared";
-	}
-};
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -43183,6 +43467,106 @@ const writeOxlintConfig = (configPath, configToWrite) => {
 		NFS.closeSync(fileHandle);
 	}
 };
+/**
+* Attributes diagnostics back to the file that produced them by the
+* normalized path oxlint echoes. Returns `null` when ANY diagnostic can't be
+* attributed — the path forms don't align, so the caller must skip its cache
+* store rather than risk caching a wrong empty result for a file that
+* actually had diagnostics.
+*/
+const attributeDiagnosticsToFiles = (diagnostics, files) => {
+	const fileByNormalizedPath = /* @__PURE__ */ new Map();
+	for (const file of files) fileByNormalizedPath.set(file.replaceAll("\\", "/"), file);
+	const diagnosticsByFile = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const file = fileByNormalizedPath.get(diagnostic.filePath);
+		if (file === void 0) return null;
+		const fileDiagnostics = diagnosticsByFile.get(file) ?? [];
+		fileDiagnostics.push(diagnostic);
+		diagnosticsByFile.set(file, fileDiagnostics);
+	}
+	return diagnosticsByFile;
+};
+/**
+* Collects each file's cross-file dependency probes (via the plugin's
+* collectors) with their current answers. Fail-open per file: an unreadable /
+* unparseable / collector-failing file maps to `null` (no entry stored — it
+* re-lints next scan). The filesystem is frozen for the scan, so this can run
+* CONCURRENTLY with an oxlint child-process await — the caller starts it
+* unawaited before a lint pass and awaits it at store time, hiding the
+* in-process parse + resolution cost under the subprocess wait. The loop
+* yields on the cooperative time budget so the child's stdout handling (and
+* sibling fibers) keep flowing; each per-file collection is synchronous, so
+* the module-level probe recorder never sees interleaved use. Never rejects.
+*/
+const collectSidecarProbesForFiles = async (input) => {
+	const buildProbes = (file) => {
+		const absoluteFilePath = Path.resolve(input.rootDirectory, file);
+		let trace;
+		try {
+			trace = collectCrossFileDependencyProbes({
+				absoluteFilePath,
+				sourceText: NFS.readFileSync(absoluteFilePath, "utf8"),
+				ruleIds: input.boundedSidecarRuleIds
+			});
+		} catch {
+			return null;
+		}
+		if (trace === null) return null;
+		const probes = [];
+		for (const contentPath of trace.contentPaths) {
+			const relativePath = input.probeAnswers.toRelativePath(contentPath);
+			probes.push({
+				kind: "content",
+				path: relativePath,
+				answer: input.probeAnswers.answerFor("content", relativePath)
+			});
+		}
+		for (const existencePath of trace.existencePaths) {
+			const relativePath = input.probeAnswers.toRelativePath(existencePath);
+			probes.push({
+				kind: "exists",
+				path: relativePath,
+				answer: input.probeAnswers.answerFor("exists", relativePath)
+			});
+		}
+		return probes;
+	};
+	const probesByFile = /* @__PURE__ */ new Map();
+	let collectSliceStartedAt = performance.now();
+	for (const file of input.files) {
+		probesByFile.set(file, buildProbes(file));
+		if (performance.now() - collectSliceStartedAt >= 12) {
+			await yieldToEventLoop();
+			collectSliceStartedAt = performance.now();
+		}
+	}
+	return probesByFile;
+};
+/**
+* Stores each freshly-linted file's probe set + cross-file diagnostics so
+* the next scan can replay instead of re-linting.
+*/
+const storeSidecarEntries = (input) => {
+	let didStoreAnyEntry = false;
+	for (const pass of input.storablePasses) {
+		if (!pass.isTrusted) continue;
+		const diagnosticsByFile = attributeDiagnosticsToFiles(pass.diagnostics, pass.files);
+		if (diagnosticsByFile === null) continue;
+		for (const file of pass.files) {
+			const cacheKey = input.cacheKeyByFile.get(file);
+			if (cacheKey === void 0) continue;
+			const probes = pass.probesByFile.get(file);
+			if (probes === void 0 || probes === null) continue;
+			input.sidecarCache.store(cacheKey, {
+				probes,
+				diagnostics: diagnosticsByFile.get(file) ?? []
+			});
+			didStoreAnyEntry = true;
+		}
+	}
+	if (didStoreAnyEntry) input.sidecarCache.persist();
+};
 const REACT_HOOKS_JS_DROP_PREFIX = "React Compiler rules (react-hooks-js/*) skipped — eslint-plugin-react-hooks failed to load in this environment";
 /**
 * Detects an oxlint config-load crash caused by the optional
@@ -43224,7 +43608,7 @@ const reactHooksJsPluginDropNote = (error) => {
 *   6. always restore disable directives + clean up the temp dir
 */
 const runOxlint = async (options) => {
-	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
+	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, sidecarLintCacheEnabled = false, onCacheStats, onSidecarStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
@@ -43242,7 +43626,8 @@ const runOxlint = async (options) => {
 		severityControls,
 		userPlugins,
 		disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin,
-		ruleSelection: overrides.ruleSelection
+		ruleSelection: overrides.ruleSelection,
+		sidecarRuleIdFilter: overrides.sidecarRuleIdFilter
 	});
 	const restoreDisableDirectives = respectInlineDisables ? () => {} : await neutralizeDisableDirectives(rootDirectory, includePaths);
 	const configDirectory = NFS.mkdtempSync(Path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
@@ -43345,15 +43730,18 @@ const runOxlint = async (options) => {
 			});
 			const cache = createFileLintCache(resolveReactDoctorCacheDir(rootDirectory), rulesetHash);
 			const cacheKeyByFile = /* @__PURE__ */ new Map();
+			const contentHashByRelativePath = /* @__PURE__ */ new Map();
 			const missFiles = [];
 			const replayedDiagnostics = [];
 			let hashSliceStartedAt = performance.now();
 			for (const candidateFile of candidateFiles) {
-				const contentHash = hashFileContents(Path.resolve(rootDirectory, candidateFile));
+				const absoluteCandidatePath = Path.resolve(rootDirectory, candidateFile);
+				const contentHash = hashFileContents(absoluteCandidatePath);
 				if (contentHash === null) {
 					missFiles.push(candidateFile);
 					continue;
 				}
+				contentHashByRelativePath.set(Path.relative(rootDirectory, absoluteCandidatePath).replaceAll("\\", "/"), contentHash);
 				const cacheKey = `${candidateFile.replaceAll("\\", "/")}\u0000${contentHash}`;
 				cacheKeyByFile.set(candidateFile, cacheKey);
 				const cachedDiagnostics = cache.lookup(cacheKey);
@@ -43365,43 +43753,111 @@ const runOxlint = async (options) => {
 				}
 			}
 			const cacheHitFileCount = candidateFiles.length - missFiles.length;
+			const enabledSidecarRuleIds = Object.keys(buildConfig({
+				extendsPaths: [],
+				ruleSelection: "sidecar"
+			}).rules).map((ruleKey) => ruleKey.slice(ruleKey.lastIndexOf("/") + 1)).filter((ruleId) => CROSS_FILE_RULE_IDS.has(ruleId));
+			const boundedSidecarRuleIds = enabledSidecarRuleIds.filter((ruleId) => CROSS_FILE_DEPENDENCY_COLLECTORS.has(ruleId));
+			const boundedSidecarRuleIdSet = new Set(boundedSidecarRuleIds);
+			const unboundedSidecarRuleIds = enabledSidecarRuleIds.filter((ruleId) => !CROSS_FILE_DEPENDENCY_COLLECTORS.has(ruleId));
+			const useSidecarCache = sidecarLintCacheEnabled && boundedSidecarRuleIds.length > 0;
+			const sidecarCache = useSidecarCache ? createSidecarLintCache(resolveReactDoctorCacheDir(rootDirectory), computeRulesetHash({
+				config: buildConfig({
+					extendsPaths: [],
+					ruleSelection: "sidecar",
+					sidecarRuleIdFilter: boundedSidecarRuleIdSet
+				}),
+				toolchainVersions: resolveOxlintToolchainVersions(nodeBinaryPath),
+				ignorePatterns: combinedPatterns,
+				tsconfigContent
+			})) : null;
+			const probeAnswers = createSidecarProbeAnswerResolver({
+				rootDirectory,
+				contentHashByRelativePath
+			});
+			const missProbesTask = sidecarCache === null ? null : collectSidecarProbesForFiles({
+				files: missFiles,
+				rootDirectory,
+				boundedSidecarRuleIds,
+				probeAnswers
+			});
 			const fullResult = await runConfigOverFiles((overrides) => buildConfig({
 				extendsPaths: [],
 				disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin
 			}), "oxlintrc.full.json", missFiles, options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(scannedFileCount, candidateFiles.length)));
 			const missFileSet = new Set(missFiles);
-			const sidecarResult = await runConfigOverFiles(() => buildConfig({
+			const hitFiles = candidateFiles.filter((candidateFile) => !missFileSet.has(candidateFile));
+			const sidecarReplayedDiagnostics = [];
+			const sidecarLintFiles = [];
+			if (sidecarCache === null) sidecarLintFiles.push(...hitFiles);
+			else {
+				let verifySliceStartedAt = performance.now();
+				for (const hitFile of hitFiles) {
+					const cacheKey = cacheKeyByFile.get(hitFile);
+					const entry = cacheKey === void 0 ? null : sidecarCache.lookup(cacheKey);
+					if (entry !== null && entry.probes.every((probe) => probeAnswers.answerFor(probe.kind, probe.path) === probe.answer)) sidecarReplayedDiagnostics.push(...entry.diagnostics);
+					else sidecarLintFiles.push(hitFile);
+					if (performance.now() - verifySliceStartedAt >= 12) {
+						await yieldToEventLoop();
+						verifySliceStartedAt = performance.now();
+					}
+				}
+			}
+			const sidecarProbesTask = sidecarCache === null ? null : collectSidecarProbesForFiles({
+				files: sidecarLintFiles,
+				rootDirectory,
+				boundedSidecarRuleIds,
+				probeAnswers
+			});
+			const sidecarReplayedFileCount = hitFiles.length - sidecarLintFiles.length;
+			if (sidecarReplayedFileCount > 0) options.onFileProgress?.(missFiles.length + sidecarReplayedFileCount, candidateFiles.length);
+			const boundedSidecarResult = await runConfigOverFiles(() => buildConfig({
 				extendsPaths: [],
-				ruleSelection: "sidecar"
-			}), "oxlintrc.sidecar.json", candidateFiles.filter((candidateFile) => !missFileSet.has(candidateFile)), options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(missFiles.length + scannedFileCount, candidateFiles.length)));
+				ruleSelection: "sidecar",
+				...useSidecarCache ? { sidecarRuleIdFilter: boundedSidecarRuleIdSet } : {}
+			}), "oxlintrc.sidecar.json", sidecarLintFiles, options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(missFiles.length + sidecarReplayedFileCount + scannedFileCount, candidateFiles.length)));
+			const unboundedSidecarResult = useSidecarCache && unboundedSidecarRuleIds.length > 0 ? await runConfigOverFiles(() => buildConfig({
+				extendsPaths: [],
+				ruleSelection: "sidecar",
+				sidecarRuleIdFilter: new Set(unboundedSidecarRuleIds)
+			}), "oxlintrc.sidecar-unbounded.json", hitFiles, void 0) : {
+				diagnostics: [],
+				didDropReactHooksJsPlugin: false,
+				hadPartialFailure: false
+			};
 			const freshCacheableDiagnostics = [];
 			for (const diagnostic of fullResult.diagnostics) if (!CROSS_FILE_RULE_IDS.has(diagnostic.rule)) freshCacheableDiagnostics.push(diagnostic);
 			onCacheStats?.(cacheHitFileCount, candidateFiles.length);
-			const missFileByNormalizedPath = /* @__PURE__ */ new Map();
-			for (const missFile of missFiles) missFileByNormalizedPath.set(missFile.replaceAll("\\", "/"), missFile);
-			const freshDiagnosticsByFile = /* @__PURE__ */ new Map();
-			let isAttributionSound = true;
-			for (const diagnostic of freshCacheableDiagnostics) {
-				const missFile = missFileByNormalizedPath.get(diagnostic.filePath);
-				if (missFile === void 0) {
-					isAttributionSound = false;
-					break;
-				}
-				const fileDiagnostics = freshDiagnosticsByFile.get(missFile) ?? [];
-				fileDiagnostics.push(diagnostic);
-				freshDiagnosticsByFile.set(missFile, fileDiagnostics);
-			}
-			if (!fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure && isAttributionSound) {
+			if (sidecarCache !== null) onSidecarStats?.(hitFiles.length - sidecarLintFiles.length, hitFiles.length);
+			const freshDiagnosticsByFile = attributeDiagnosticsToFiles(freshCacheableDiagnostics, missFiles);
+			if (!fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure && freshDiagnosticsByFile !== null) {
 				for (const missFile of missFiles) {
 					const cacheKey = cacheKeyByFile.get(missFile);
 					if (cacheKey !== void 0) cache.store(cacheKey, freshDiagnosticsByFile.get(missFile) ?? []);
 				}
 				cache.persist();
 			}
+			if (sidecarCache !== null && missProbesTask !== null && sidecarProbesTask !== null) storeSidecarEntries({
+				sidecarCache,
+				cacheKeyByFile,
+				storablePasses: [{
+					files: sidecarLintFiles,
+					diagnostics: boundedSidecarResult.diagnostics,
+					isTrusted: !boundedSidecarResult.hadPartialFailure,
+					probesByFile: await sidecarProbesTask
+				}, {
+					files: missFiles,
+					diagnostics: fullResult.diagnostics.filter((diagnostic) => boundedSidecarRuleIdSet.has(diagnostic.rule)),
+					isTrusted: !fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure,
+					probesByFile: await missProbesTask
+				}]
+			});
 			return dedupeDiagnostics([
 				...replayedDiagnostics,
 				...fullResult.diagnostics,
-				...sidecarResult.diagnostics
+				...sidecarReplayedDiagnostics,
+				...boundedSidecarResult.diagnostics,
+				...unboundedSidecarResult.diagnostics
 			]);
 		}
 		const baseArgs = makeBaseArgs(configPath);
@@ -43499,6 +43955,7 @@ var Linter = class Linter extends Service()("react-doctor/Linter") {
 		const concurrency = yield* OxlintConcurrency;
 		const lintBatchOrdering = yield* LintBatchOrdering;
 		const perFileLintCacheEnabled = yield* PerFileLintCacheEnabled;
+		const sidecarLintCacheEnabled = yield* SidecarLintCacheEnabled;
 		const collectedFailures = [];
 		const diagnostics = yield* tryPromise({
 			try: (signal) => runOxlint({
@@ -43517,7 +43974,9 @@ var Linter = class Linter extends Service()("react-doctor/Linter") {
 				},
 				onFileProgress: input.onFileProgress,
 				perFileLintCacheEnabled,
+				sidecarLintCacheEnabled,
 				onCacheStats: input.onCacheStats,
+				onSidecarStats: input.onSidecarStats,
 				spawnTimeoutMs,
 				outputMaxBytes,
 				concurrency,
@@ -44292,7 +44751,14 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	const buildCollectDeadCode = (deadCodeTimeout) => runCollect(applyPerElementPipeline(deadCodeService.run({
 		rootDirectory: scanDirectory,
 		parseConcurrency: deadCodeParseConcurrency,
-		workerTimeoutMs: deadCodeTimeout.workerTimeoutMs
+		workerTimeoutMs: deadCodeTimeout.workerTimeoutMs,
+		onCacheOutcome: (didHitCache) => {
+			deadCodeCacheHit = didHitCache;
+		},
+		onSummaryCacheStats: (stats) => {
+			deadCodeSummaryCacheHits = stats.hits;
+			deadCodeSummaryCacheMisses = stats.misses;
+		}
 	}).pipe(catchTag("ReactDoctorError", (error) => unwrap(gen(function* () {
 		yield* set(deadCodeFailure, {
 			didFail: true,
@@ -44320,6 +44786,11 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	let lastReportedTotalFileCount = 0;
 	let lintCacheHitFileCount = null;
 	let lintCacheTotalFileCount = null;
+	let lintSidecarReplayedFileCount = null;
+	let lintSidecarTotalFileCount = null;
+	let deadCodeCacheHit = null;
+	let deadCodeSummaryCacheHits = null;
+	let deadCodeSummaryCacheMisses = null;
 	const baseLintStream = linterService.run({
 		rootDirectory: scanDirectory,
 		project,
@@ -44339,6 +44810,10 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 			lintCacheHitFileCount = cacheHitFileCount;
 			lintCacheTotalFileCount = totalConsideredFileCount;
 		},
+		onSidecarStats: (sidecarReplayedFileCount, sidecarConsideredFileCount) => {
+			lintSidecarReplayedFileCount = sidecarReplayedFileCount;
+			lintSidecarTotalFileCount = sidecarConsideredFileCount;
+		},
 		deadlineEpochMs: input.deadlineEpochMs
 	}).pipe(catchTag("ReactDoctorError", (error) => unwrap(gen(function* () {
 		yield* set(lintFailure, {
@@ -44449,6 +44924,11 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		securityScanFailed,
 		lintCacheHitFileCount,
 		lintCacheTotalFileCount,
+		lintSidecarReplayedFileCount,
+		lintSidecarTotalFileCount,
+		deadCodeCacheHit: lintFailureState.didFail ? null : deadCodeCacheHit,
+		deadCodeSummaryCacheHits: lintFailureState.didFail ? null : deadCodeSummaryCacheHits,
+		deadCodeSummaryCacheMisses: lintFailureState.didFail ? null : deadCodeSummaryCacheMisses,
 		suppressedRuleCounts: transform.summarizeSuppressions()
 	};
 }).pipe(withSpan("runInspect", { attributes: {
@@ -45230,6 +45710,7 @@ const isNonInteractiveEnvironment = () => NON_INTERACTIVE_ENVIRONMENT_VARIABLES.
 const REACT_DOCTOR_CONFIG_PROJECT_NAME = "react-doctor";
 const STAGED_FILES_TEMP_DIR_PREFIX = "react-doctor-staged-";
 const BASELINE_FILES_TEMP_DIR_PREFIX = "react-doctor-baseline-";
+const RUN_GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 const GH_DEFAULT_BRANCH_PROBE_TIMEOUT_MS = 5e3;
 const CI_TRUST_COMPANIES = "PayPal, Rippling, and Alibaba";
 const WELCOME_EXPLANATION_HOLD_MS = 1e3;
@@ -45320,7 +45801,7 @@ const makeNoopConsole = () => ({
 });
 //#endregion
 //#region src/cli/utils/version.ts
-const VERSION = "0.6.3-dev.8325343";
+const VERSION = "0.6.3-dev.bdf8074";
 //#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
@@ -45689,13 +46170,13 @@ const isDevVersion = (version) => version === "0.0.0" || version.includes("-");
 * uploads source-map artifacts under, so stack frames symbolicate. Honors the
 * standard `SENTRY_RELEASE` override.
 */
-const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.6.3-dev.8325343`;
+const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.6.3-dev.bdf8074`;
 /**
 * Deployment environment shown in Sentry's environment filter. Defaults to
 * `production` for tagged releases and `development` for dev/unbuilt versions,
 * overridable via the standard `SENTRY_ENVIRONMENT` env var.
 */
-const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.6.3-dev.8325343") ? "development" : "production");
+const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.6.3-dev.bdf8074") ? "development" : "production");
 /**
 * Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
 * (set to `0` to disable tracing) and falls back to
@@ -45896,7 +46377,8 @@ const runGit = (projectRoot, args) => {
 				"ignore",
 				"pipe",
 				"ignore"
-			]
+			],
+			maxBuffer: RUN_GIT_MAX_BUFFER_BYTES
 		}).trim();
 	} catch {
 		return null;
@@ -57772,6 +58254,284 @@ const buildRuleBlastRadii = (diagnostics) => buildSortedRuleGroups(diagnostics).
 })).toSorted((left, right) => right.fileCount - left.fileCount);
 const findMigrationScaleBuckets = (diagnostics) => buildRuleBlastRadii(diagnostics).filter((bucket) => bucket.fileCount >= 40);
 //#endregion
+//#region src/cli/utils/scan-result-cache.ts
+const CACHE_DISABLED_VALUES = new Set(["1", "true"]);
+const TOOLCHAIN_PACKAGE_SPECIFIERS = [
+	"oxlint",
+	"oxlint/package.json",
+	"oxlint-plugin-react-doctor",
+	"deslop-js/package.json",
+	"eslint-plugin-react-hooks/package.json"
+];
+const bundledRequire = createRequire(import.meta.url);
+const normalizeForStableJson = (value) => {
+	if (value === null) return null;
+	if (value === void 0) return void 0;
+	const valueType = typeof value;
+	if (valueType === "string" || valueType === "number" || valueType === "boolean") return value;
+	if (valueType === "bigint" || valueType === "function" || valueType === "symbol") throw new Error("Unsupported cache key value");
+	if (Array.isArray(value)) return value.map((item) => {
+		const normalized = normalizeForStableJson(item);
+		return normalized === void 0 ? null : normalized;
+	});
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new Error("Unsupported cache key object");
+	if (!isRecord(value)) throw new Error("Unsupported cache key object");
+	const normalizedRecord = {};
+	for (const key of Object.keys(value).sort()) {
+		const normalized = normalizeForStableJson(value[key]);
+		if (normalized !== void 0) normalizedRecord[key] = normalized;
+	}
+	return normalizedRecord;
+};
+const stringifyStableJson = (value) => {
+	try {
+		return JSON.stringify(normalizeForStableJson(value));
+	} catch {
+		return null;
+	}
+};
+const hashString = (value) => crypto.createHash("sha1").update(value).digest("hex");
+const readHeadSha = (projectDirectory) => runGit(projectDirectory, ["rev-parse", "HEAD"]);
+const parseWorktreeStatusRecords = (statusOutput) => {
+	const entries = [];
+	const tokens = statusOutput.split("\0");
+	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
+		let record = tokens[tokenIndex];
+		if (record.length === 0) continue;
+		if (record.length < 3 || record[2] !== " ") {
+			if (tokenIndex !== 0) return null;
+			record = ` ${record}`;
+		}
+		if (record.length < 4 || record[2] !== " ") return null;
+		const statusCode = record.slice(0, 2);
+		const recordPath = record.slice(3);
+		if (statusCode.includes("R") || statusCode.includes("C")) {
+			tokenIndex += 1;
+			const originPath = tokens[tokenIndex];
+			if (originPath === void 0 || originPath.length === 0) return null;
+			entries.push({
+				statusCode,
+				path: recordPath,
+				originPath
+			});
+			continue;
+		}
+		entries.push({
+			statusCode,
+			path: recordPath
+		});
+	}
+	return entries;
+};
+const buildDirtyPathContentFingerprint = (absolutePath, statusCode) => {
+	let stats;
+	try {
+		stats = fs.lstatSync(absolutePath);
+	} catch {
+		return statusCode.includes("D") ? "deleted" : null;
+	}
+	if (stats.isSymbolicLink()) try {
+		return `link:${fs.readlinkSync(absolutePath)}`;
+	} catch {
+		return null;
+	}
+	if (!stats.isFile()) return null;
+	if (stats.size > 10485760) return `stat:${stats.mtimeMs}:${stats.size}`;
+	return hashFileContents(absolutePath);
+};
+const buildWorktreeFingerprint = (projectDirectory) => {
+	const statusOutput = runGit(projectDirectory, [
+		"status",
+		"--porcelain=v1",
+		"-z",
+		"--untracked-files=all"
+	]);
+	if (statusOutput === null) return null;
+	if (statusOutput.length === 0) return [];
+	const statusEntries = parseWorktreeStatusRecords(statusOutput);
+	if (statusEntries === null) return null;
+	if (statusEntries.length > 300) return null;
+	const repositoryRoot = runGit(projectDirectory, ["rev-parse", "--show-toplevel"]);
+	if (repositoryRoot === null) return null;
+	const dirtyEntries = [];
+	for (const statusEntry of statusEntries) {
+		const contentFingerprint = buildDirtyPathContentFingerprint(path.join(repositoryRoot, statusEntry.path), statusEntry.statusCode);
+		if (contentFingerprint === null) return null;
+		dirtyEntries.push({
+			...statusEntry,
+			contentFingerprint
+		});
+	}
+	return dirtyEntries.sort((firstEntry, secondEntry) => {
+		const firstSortKey = `${firstEntry.path}
${firstEntry.statusCode}`;
+		const secondSortKey = `${secondEntry.path}
${secondEntry.statusCode}`;
+		return firstSortKey < secondSortKey ? -1 : firstSortKey > secondSortKey ? 1 : 0;
+	});
+};
+const DOTENV_FILE_NAME_PATTERN = /^\.env(\.|$)/;
+const resolveDotenvFingerprint = (projectDirectory) => {
+	try {
+		return fs.readdirSync(projectDirectory).filter((entryName) => DOTENV_FILE_NAME_PATTERN.test(entryName)).sort().map((entryName) => `${entryName}=${fileFingerprint(path.join(projectDirectory, entryName)) ?? "unreadable"}`);
+	} catch {
+		return [];
+	}
+};
+const hasHiddenTrackedFileState = (projectDirectory) => {
+	const output = runGit(projectDirectory, ["ls-files", "-v"]);
+	if (output === null) return true;
+	return output.split("\n").some((line) => line.length > 0 && line[0] !== "H");
+};
+const resolveCacheFilePath = (projectDirectory) => {
+	const nodeModulesDirectory = path.join(projectDirectory, "node_modules");
+	if (fs.existsSync(nodeModulesDirectory)) return path.join(nodeModulesDirectory, ".cache", "react-doctor", "scan-cache.json");
+	const projectHash = hashString(projectDirectory).slice(0, 16);
+	return path.join(os.tmpdir(), "react-doctor-cache", `scan-${projectHash}.json`);
+};
+const readPersistedCache = (cacheFilePath) => {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(cacheFilePath, "utf8"));
+		if (!isRecord(parsed) || parsed.version !== 3) return {
+			version: 3,
+			entries: []
+		};
+		if (!Array.isArray(parsed.entries)) return {
+			version: 3,
+			entries: []
+		};
+		const entries = [];
+		for (const entry of parsed.entries) {
+			if (!isRecord(entry) || typeof entry.key !== "string" || typeof entry.createdAtMs !== "number") continue;
+			if (!isRecord(entry.payload) || !Array.isArray(entry.payload.diagnostics)) continue;
+			entries.push(entry);
+		}
+		return {
+			version: 3,
+			entries
+		};
+	} catch {
+		return {
+			version: 3,
+			entries: []
+		};
+	}
+};
+const writePersistedCache = (cacheFilePath, cache) => {
+	try {
+		fs.mkdirSync(path.dirname(cacheFilePath), { recursive: true });
+		const tempPath = `${cacheFilePath}.${process.pid}.tmp`;
+		fs.writeFileSync(tempPath, JSON.stringify(cache));
+		fs.renameSync(tempPath, cacheFilePath);
+	} catch {
+		return;
+	}
+};
+/**
+* The global cache off-switch (`REACT_DOCTOR_NO_CACHE`), which disables every
+* cache subsystem: this whole-repo scan cache plus core's per-file lint,
+* sidecar, and dead-code caches (their `Context.Reference` defaults read the
+* same variable). Exported for the wide event's `cache.temperature`
+* derivation, which reports `"disabled"` instead of `"cold"` when the switch
+* is on. Granular knobs (`REACT_DOCTOR_NO_FILE_CACHE`, …) are deliberately
+* not consulted — they leave the other subsystems live.
+*/
+const isCacheGloballyDisabled = () => CACHE_DISABLED_VALUES.has(process.env.REACT_DOCTOR_NO_CACHE?.toLowerCase() ?? "");
+const resolveProjectIdentity = (projectDirectory) => {
+	try {
+		return fs.realpathSync.native(projectDirectory);
+	} catch {
+		return path.resolve(projectDirectory);
+	}
+};
+const fileFingerprint = (filePath) => {
+	try {
+		const stat = fs.statSync(filePath);
+		return `${filePath}:${stat.mtimeMs}:${stat.size}`;
+	} catch {
+		return null;
+	}
+};
+const resolveToolchainFingerprint = (nodeBinaryPath) => {
+	const fingerprints = [];
+	if (nodeBinaryPath !== null) {
+		const fingerprint = fileFingerprint(nodeBinaryPath);
+		if (fingerprint !== null) fingerprints.push(`node=${fingerprint}`);
+	}
+	for (const specifier of TOOLCHAIN_PACKAGE_SPECIFIERS) try {
+		const fingerprint = fileFingerprint(bundledRequire.resolve(specifier));
+		if (fingerprint !== null) fingerprints.push(`${specifier}=${fingerprint}`);
+	} catch {
+		continue;
+	}
+	return fingerprints;
+};
+const buildScanResultCacheKey = (input) => {
+	if (isCacheGloballyDisabled()) return null;
+	if (hasHiddenTrackedFileState(input.projectDirectory)) return null;
+	const worktreeFingerprint = buildWorktreeFingerprint(input.projectDirectory);
+	if (worktreeFingerprint === null) return null;
+	const headSha = readHeadSha(input.projectDirectory);
+	if (headSha === null) return null;
+	if (stringifyStableJson(input.userConfig) === null) return null;
+	const cacheKeyJson = stringifyStableJson({
+		schemaVersion: 3,
+		projectIdentity: resolveProjectIdentity(input.projectDirectory),
+		headSha,
+		worktreeFingerprint,
+		dotenvFingerprint: resolveDotenvFingerprint(input.projectDirectory),
+		reactDoctorVersion: input.version,
+		nodeVersion: process.version,
+		toolchainFingerprint: resolveToolchainFingerprint(input.nodeBinaryPath),
+		configFingerprint: computeConfigFingerprint(input.projectDirectory, input.version),
+		hasConfigOverride: input.hasConfigOverride,
+		configSourceDirectory: input.configSourceDirectory,
+		userConfig: input.userConfig,
+		engineOptions: {
+			lint: input.options.lint,
+			deadCode: input.options.deadCode,
+			includePaths: [...input.options.includePaths].sort(),
+			customRulesOnly: input.options.customRulesOnly,
+			respectInlineDisables: input.options.respectInlineDisables,
+			warnings: input.options.warnings,
+			adoptExistingLintConfig: input.options.adoptExistingLintConfig,
+			ignoredTags: [...input.options.ignoredTags].sort(),
+			concurrency: input.options.concurrency,
+			lintBatchOrdering: resolveLintBatchOrdering(),
+			baselineRef: input.options.baseline?.ref,
+			changedLineRanges: input.options.changedLineRanges ?? void 0,
+			noScore: input.options.noScore,
+			isCi: input.options.isCi,
+			suppressRendering: input.options.suppressRendering,
+			supplyChainManifestChanged: input.options.supplyChainManifestChanged
+		}
+	});
+	return cacheKeyJson === null ? null : hashString(cacheKeyJson);
+};
+const createScanResultCache = (projectDirectory) => {
+	const cacheFilePath = resolveCacheFilePath(projectDirectory);
+	const persistedCache = readPersistedCache(cacheFilePath);
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of persistedCache.entries) entries.set(entry.key, entry);
+	const persist = () => {
+		writePersistedCache(cacheFilePath, {
+			version: 3,
+			entries: [...entries.values()].sort((firstEntry, secondEntry) => secondEntry.createdAtMs - firstEntry.createdAtMs).slice(0, 20)
+		});
+	};
+	return {
+		lookup: (key) => entries.get(key)?.payload ?? null,
+		store: (key, payload) => {
+			entries.set(key, {
+				key,
+				createdAtMs: Date.now(),
+				payload
+			});
+			persist();
+		}
+	};
+};
+const shouldStoreScanPayload = (payload) => !payload.didLintFail && !payload.didDeadCodeFail && payload.lintPartialFailures.length === 0 && !payload.supplyChainOverlapTimedOut && payload.securityScanFailed !== true;
+//#endregion
 //#region src/cli/utils/should-block-ci.ts
 const shouldBlockCi = (diagnostics, blockingLevel) => {
 	if (blockingLevel === "none") return false;
@@ -57813,6 +58573,63 @@ const readEnvBoolean = (name) => {
 	if (value === void 0) return null;
 	return value.toLowerCase() === "true" || value === "1";
 };
+const ratioOf = (numerator, denominator) => denominator != null && denominator > 0 ? (numerator ?? 0) / denominator : null;
+const resolveDeadCodeReuseRatio = (result) => {
+	if (result.deadCodeCacheHit === true) return 1;
+	const summaryTotal = (result.deadCodeSummaryCacheHits ?? 0) + (result.deadCodeSummaryCacheMisses ?? 0);
+	if (summaryTotal > 0) return (result.deadCodeSummaryCacheHits ?? 0) / summaryTotal;
+	return result.deadCodeCacheHit === false ? 0 : null;
+};
+/**
+* One queryable cache temperature per scan, derived from the whole stack:
+*
+*   - `"turbo"`    — whole-repo scan-result replay (the explicit
+*                    `wholeRepoCacheHit` flag from the CLI's cachedPayload
+*                    branch; no scan work ran).
+*   - `"warm"`     — any incremental reuse: per-file lint hits, sidecar
+*                    replays, a dead-code whole-result hit, or dead-code
+*                    summary-cache hits.
+*   - `"disabled"` — zero reuse because the global `REACT_DOCTOR_NO_CACHE`
+*                    off-switch is on. Granular per-cache opt-outs
+*                    (`REACT_DOCTOR_NO_FILE_CACHE`, …) still read warm/cold,
+*                    since the other subsystems stay live.
+*   - `"cold"`     — caches on, zero reuse (first scan / everything changed).
+*
+* `cache.warmth` is the headline reuse magnitude in [0, 1]: the plain mean of
+* the subsystem reuse fractions known this run (lint hit ratio, sidecar
+* replay ratio, dead-code reuse), skipping subsystems that never consulted a
+* cache; `1` on turbo, dropped when nothing consulted any cache. Deliberately
+* unweighted — the per-subsystem dims stay the precise signal; warmth is the
+* p50/p90-able summary. Emitted only on the success path.
+*/
+const buildCacheAttributes = (input) => {
+	if (input.result === void 0) return {};
+	if (input.wholeRepoCacheHit) return withNamespace("cache", {
+		wholeRepoHit: true,
+		temperature: "turbo",
+		warmth: 1
+	});
+	const result = input.result;
+	const subsystemReuseRatios = [
+		ratioOf(result.lintCacheHitFileCount, result.lintCacheTotalFileCount),
+		ratioOf(result.lintSidecarReplayedFileCount, result.lintSidecarTotalFileCount),
+		resolveDeadCodeReuseRatio(result)
+	];
+	let knownSubsystemCount = 0;
+	let reuseRatioSum = 0;
+	for (const reuseRatio of subsystemReuseRatios) {
+		if (reuseRatio === null) continue;
+		knownSubsystemCount += 1;
+		reuseRatioSum += reuseRatio;
+	}
+	const warmth = knownSubsystemCount > 0 ? reuseRatioSum / knownSubsystemCount : null;
+	const temperature = warmth !== null && warmth > 0 ? "warm" : isCacheGloballyDisabled() ? "disabled" : "cold";
+	return withNamespace("cache", {
+		wholeRepoHit: input.wholeRepoCacheHit ?? null,
+		temperature,
+		warmth
+	});
+};
 const resolveVersionPin = (versionInput) => {
 	if (versionInput === void 0 || versionInput.trim() === "") return null;
 	if (versionInput === "latest") return "latest";
@@ -57918,11 +58735,17 @@ const buildOutcomeAttributes = (input) => {
 			deadlineSkippedFileCount: input.lintDeadlineSkippedFileCount ?? null,
 			cacheHitFiles: result.lintCacheHitFileCount ?? null,
 			cacheTotalFiles: result.lintCacheTotalFileCount ?? null,
-			cacheHitRatio: result.lintCacheTotalFileCount != null && result.lintCacheTotalFileCount > 0 ? (result.lintCacheHitFileCount ?? 0) / result.lintCacheTotalFileCount : null
+			cacheHitRatio: ratioOf(result.lintCacheHitFileCount, result.lintCacheTotalFileCount),
+			sidecarReplayedFiles: result.lintSidecarReplayedFileCount ?? null,
+			sidecarTotalFiles: result.lintSidecarTotalFileCount ?? null,
+			sidecarReplayRatio: ratioOf(result.lintSidecarReplayedFileCount, result.lintSidecarTotalFileCount)
 		}),
 		...withNamespace("deadCode", {
 			failed: input.didDeadCodeFail ?? null,
-			overlapped: input.deadCodeOverlapped ?? null
+			overlapped: input.deadCodeOverlapped ?? null,
+			cacheHit: result.deadCodeCacheHit ?? null,
+			summaryCacheHits: result.deadCodeSummaryCacheHits ?? null,
+			summaryCacheMisses: result.deadCodeSummaryCacheMisses ?? null
 		}),
 		...withNamespace("supplyChain", { overlapTimedOut: input.supplyChainOverlapTimedOut ?? null }),
 		...withNamespace("securityScan", { failed: input.securityScanFailed ?? null }),
@@ -57982,7 +58805,7 @@ const buildScanAttributes = (input) => {
 * Projects a scan into the namespaced attribute set for its root span — the
 * canonical per-scan "wide event". Every attribute carries a dotted namespace
 * that groups it by concept (`scan.*` config, `action.*` CI knobs, `outcome.*`
-* verdict, `diag.*` findings, `score.*`, `lint.*`, `deadCode.*`,
+* verdict, `diag.*` findings, `score.*`, `lint.*`, `deadCode.*`, `cache.*`,
 * `supplyChain.*`, `timing.*`, `migration.*`, `baseline.*`) so the attributes
 * tree up in Sentry's attribute browser and stay filter-/group-/aggregate-able
 * in the Spans dataset. Pure and exported so the projection (outcome
@@ -57996,7 +58819,8 @@ const buildScanAttributes = (input) => {
 const buildRunEventAttributes = (input) => toSpanAttributes({
 	...buildScanAttributes(input),
 	...buildActionAttributes(),
-	...buildOutcomeAttributes(input)
+	...buildOutcomeAttributes(input),
+	...buildCacheAttributes(input)
 });
 /**
 * Stamps the wide-event attributes onto the run's root span. A guarded no-op
@@ -59206,196 +60030,6 @@ const resolveCliCategories = (categoryFlag) => {
 	return resolvedCategories.length > 0 ? resolvedCategories : void 0;
 };
 //#endregion
-//#region src/cli/utils/scan-result-cache.ts
-const CACHE_DISABLED_VALUES = new Set(["1", "true"]);
-const TOOLCHAIN_PACKAGE_SPECIFIERS = [
-	"oxlint",
-	"oxlint/package.json",
-	"oxlint-plugin-react-doctor",
-	"deslop-js/package.json",
-	"eslint-plugin-react-hooks/package.json"
-];
-const bundledRequire = createRequire(import.meta.url);
-const normalizeForStableJson = (value) => {
-	if (value === null) return null;
-	if (value === void 0) return void 0;
-	const valueType = typeof value;
-	if (valueType === "string" || valueType === "number" || valueType === "boolean") return value;
-	if (valueType === "bigint" || valueType === "function" || valueType === "symbol") throw new Error("Unsupported cache key value");
-	if (Array.isArray(value)) return value.map((item) => {
-		const normalized = normalizeForStableJson(item);
-		return normalized === void 0 ? null : normalized;
-	});
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) throw new Error("Unsupported cache key object");
-	if (!isRecord(value)) throw new Error("Unsupported cache key object");
-	const normalizedRecord = {};
-	for (const key of Object.keys(value).sort()) {
-		const normalized = normalizeForStableJson(value[key]);
-		if (normalized !== void 0) normalizedRecord[key] = normalized;
-	}
-	return normalizedRecord;
-};
-const stringifyStableJson = (value) => {
-	try {
-		return JSON.stringify(normalizeForStableJson(value));
-	} catch {
-		return null;
-	}
-};
-const hashString = (value) => crypto.createHash("sha1").update(value).digest("hex");
-const readHeadSha = (projectDirectory) => runGit(projectDirectory, ["rev-parse", "HEAD"]);
-const isWorktreeClean = (projectDirectory) => {
-	const status = runGit(projectDirectory, [
-		"status",
-		"--porcelain=v1",
-		"--untracked-files=normal"
-	]);
-	return status !== null && status.length === 0;
-};
-const hasHiddenTrackedFileState = (projectDirectory) => {
-	const output = runGit(projectDirectory, ["ls-files", "-v"]);
-	if (output === null) return true;
-	return output.split("\n").some((line) => line.length > 0 && line[0] !== "H");
-};
-const resolveCacheFilePath = (projectDirectory) => {
-	const nodeModulesDirectory = path.join(projectDirectory, "node_modules");
-	if (fs.existsSync(nodeModulesDirectory)) return path.join(nodeModulesDirectory, ".cache", "react-doctor", "scan-cache.json");
-	const projectHash = hashString(projectDirectory).slice(0, 16);
-	return path.join(os.tmpdir(), "react-doctor-cache", `scan-${projectHash}.json`);
-};
-const readPersistedCache = (cacheFilePath) => {
-	try {
-		const parsed = JSON.parse(fs.readFileSync(cacheFilePath, "utf8"));
-		if (!isRecord(parsed) || parsed.version !== 3) return {
-			version: 3,
-			entries: []
-		};
-		if (!Array.isArray(parsed.entries)) return {
-			version: 3,
-			entries: []
-		};
-		const entries = [];
-		for (const entry of parsed.entries) {
-			if (!isRecord(entry) || typeof entry.key !== "string" || typeof entry.createdAtMs !== "number") continue;
-			if (!isRecord(entry.payload) || !Array.isArray(entry.payload.diagnostics)) continue;
-			entries.push(entry);
-		}
-		return {
-			version: 3,
-			entries
-		};
-	} catch {
-		return {
-			version: 3,
-			entries: []
-		};
-	}
-};
-const writePersistedCache = (cacheFilePath, cache) => {
-	try {
-		fs.mkdirSync(path.dirname(cacheFilePath), { recursive: true });
-		const tempPath = `${cacheFilePath}.${process.pid}.tmp`;
-		fs.writeFileSync(tempPath, JSON.stringify(cache));
-		fs.renameSync(tempPath, cacheFilePath);
-	} catch {
-		return;
-	}
-};
-const isScanResultCacheDisabled = () => CACHE_DISABLED_VALUES.has(process.env.REACT_DOCTOR_NO_CACHE?.toLowerCase() ?? "");
-const resolveProjectIdentity = (projectDirectory) => {
-	try {
-		return fs.realpathSync.native(projectDirectory);
-	} catch {
-		return path.resolve(projectDirectory);
-	}
-};
-const fileFingerprint = (filePath) => {
-	try {
-		const stat = fs.statSync(filePath);
-		return `${filePath}:${stat.mtimeMs}:${stat.size}`;
-	} catch {
-		return null;
-	}
-};
-const resolveToolchainFingerprint = (nodeBinaryPath) => {
-	const fingerprints = [];
-	if (nodeBinaryPath !== null) {
-		const fingerprint = fileFingerprint(nodeBinaryPath);
-		if (fingerprint !== null) fingerprints.push(`node=${fingerprint}`);
-	}
-	for (const specifier of TOOLCHAIN_PACKAGE_SPECIFIERS) try {
-		const fingerprint = fileFingerprint(bundledRequire.resolve(specifier));
-		if (fingerprint !== null) fingerprints.push(`${specifier}=${fingerprint}`);
-	} catch {
-		continue;
-	}
-	return fingerprints;
-};
-const buildScanResultCacheKey = (input) => {
-	if (isScanResultCacheDisabled()) return null;
-	if (!isWorktreeClean(input.projectDirectory)) return null;
-	if (hasHiddenTrackedFileState(input.projectDirectory)) return null;
-	const headSha = readHeadSha(input.projectDirectory);
-	if (headSha === null) return null;
-	if (stringifyStableJson(input.userConfig) === null) return null;
-	const cacheKeyJson = stringifyStableJson({
-		schemaVersion: 3,
-		projectIdentity: resolveProjectIdentity(input.projectDirectory),
-		headSha,
-		reactDoctorVersion: input.version,
-		nodeVersion: process.version,
-		toolchainFingerprint: resolveToolchainFingerprint(input.nodeBinaryPath),
-		configFingerprint: computeConfigFingerprint(input.projectDirectory, input.version),
-		hasConfigOverride: input.hasConfigOverride,
-		configSourceDirectory: input.configSourceDirectory,
-		userConfig: input.userConfig,
-		engineOptions: {
-			lint: input.options.lint,
-			deadCode: input.options.deadCode,
-			includePaths: [...input.options.includePaths].sort(),
-			customRulesOnly: input.options.customRulesOnly,
-			respectInlineDisables: input.options.respectInlineDisables,
-			warnings: input.options.warnings,
-			adoptExistingLintConfig: input.options.adoptExistingLintConfig,
-			ignoredTags: [...input.options.ignoredTags].sort(),
-			concurrency: input.options.concurrency,
-			lintBatchOrdering: resolveLintBatchOrdering(),
-			baselineRef: input.options.baseline?.ref,
-			changedLineRanges: input.options.changedLineRanges ?? void 0,
-			noScore: input.options.noScore,
-			isCi: input.options.isCi,
-			suppressRendering: input.options.suppressRendering,
-			supplyChainManifestChanged: input.options.supplyChainManifestChanged
-		}
-	});
-	return cacheKeyJson === null ? null : hashString(cacheKeyJson);
-};
-const createScanResultCache = (projectDirectory) => {
-	const cacheFilePath = resolveCacheFilePath(projectDirectory);
-	const persistedCache = readPersistedCache(cacheFilePath);
-	const entries = /* @__PURE__ */ new Map();
-	for (const entry of persistedCache.entries) entries.set(entry.key, entry);
-	const persist = () => {
-		writePersistedCache(cacheFilePath, {
-			version: 3,
-			entries: [...entries.values()].sort((firstEntry, secondEntry) => secondEntry.createdAtMs - firstEntry.createdAtMs).slice(0, 20)
-		});
-	};
-	return {
-		lookup: (key) => entries.get(key)?.payload ?? null,
-		store: (key, payload) => {
-			entries.set(key, {
-				key,
-				createdAtMs: Date.now(),
-				payload
-			});
-			persist();
-		}
-	};
-};
-const shouldStoreScanPayload = (payload) => !payload.didLintFail && !payload.didDeadCodeFail && payload.lintPartialFailures.length === 0 && !payload.supplyChainOverlapTimedOut && payload.securityScanFailed !== true;
-//#endregion
 //#region src/inspect.ts
 const silentConsole = makeNoopConsole();
 const runConsole = (effect) => {
@@ -59625,7 +60259,8 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 			startTime,
 			rootSentrySpan,
 			scanMode: cachedPayload.baselineDelta ? "baseline" : isDiffMode ? "diff" : "full",
-			baselineDegraded
+			baselineDegraded,
+			wholeRepoCacheHit: true
 		});
 		recordOnboardingCompletion(options);
 		return result;
@@ -59734,8 +60369,14 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 		rootSentrySpan,
 		scanMode: baselineDelta ? "baseline" : isDiffMode ? "diff" : "full",
 		baselineDegraded,
+		wholeRepoCacheHit: false,
 		lintCacheHitFileCount: output.lintCacheHitFileCount,
-		lintCacheTotalFileCount: output.lintCacheTotalFileCount
+		lintCacheTotalFileCount: output.lintCacheTotalFileCount,
+		lintSidecarReplayedFileCount: output.lintSidecarReplayedFileCount,
+		lintSidecarTotalFileCount: output.lintSidecarTotalFileCount,
+		deadCodeCacheHit: output.deadCodeCacheHit,
+		deadCodeSummaryCacheHits: output.deadCodeSummaryCacheHits,
+		deadCodeSummaryCacheMisses: output.deadCodeSummaryCacheMisses
 	});
 	recordOnboardingCompletion(options);
 	return result;
@@ -59770,6 +60411,11 @@ const renderAndRecordScan = async (input) => {
 		scanElapsedMilliseconds: input.payload.scanElapsedMilliseconds,
 		lintCacheHitFileCount: input.lintCacheHitFileCount ?? null,
 		lintCacheTotalFileCount: input.lintCacheTotalFileCount ?? null,
+		lintSidecarReplayedFileCount: input.lintSidecarReplayedFileCount ?? null,
+		lintSidecarTotalFileCount: input.lintSidecarTotalFileCount ?? null,
+		deadCodeCacheHit: input.deadCodeCacheHit ?? null,
+		deadCodeSummaryCacheHits: input.deadCodeSummaryCacheHits ?? null,
+		deadCodeSummaryCacheMisses: input.deadCodeSummaryCacheMisses ?? null,
 		baselineDelta: input.payload.baselineDelta
 	}), input.options.silent));
 	const { workerCount: resolvedWorkerCount, parallel } = resolveWorkerTelemetry(input.payload.scanConcurrency, input.options.concurrency);
@@ -59794,6 +60440,7 @@ const renderAndRecordScan = async (input) => {
 		result,
 		mode: input.scanMode,
 		gateExempt: input.baselineDegraded,
+		wholeRepoCacheHit: input.wholeRepoCacheHit,
 		didLintFail: input.payload.didLintFail,
 		lintFailureReasonKind: input.payload.lintFailureReasonKind,
 		lintPartialFailureCount: input.payload.lintPartialFailures.length,
@@ -59808,7 +60455,7 @@ const renderAndRecordScan = async (input) => {
 	return result;
 };
 const finalizeAndRender = (input) => gen(function* () {
-	const { options, elapsedMilliseconds, diagnostics, score, project, userConfig, didLintFail, lintFailureReason, lintPartialFailures, didDeadCodeFail, deadCodeFailureReason, directory, scannedFileCount, scannedFilePaths, scanElapsedMilliseconds, lintCacheHitFileCount, lintCacheTotalFileCount, baselineDelta } = input;
+	const { options, elapsedMilliseconds, diagnostics, score, project, userConfig, didLintFail, lintFailureReason, lintPartialFailures, didDeadCodeFail, deadCodeFailureReason, directory, scannedFileCount, scannedFilePaths, scanElapsedMilliseconds, lintCacheHitFileCount, lintCacheTotalFileCount, lintSidecarReplayedFileCount, lintSidecarTotalFileCount, deadCodeCacheHit, deadCodeSummaryCacheHits, deadCodeSummaryCacheMisses, baselineDelta } = input;
 	const { skippedChecks, skippedCheckReasons } = buildSkippedChecks({
 		didLintFail,
 		lintFailureReason,
@@ -59832,6 +60479,15 @@ const finalizeAndRender = (input) => gen(function* () {
 			lintCacheHitFileCount,
 			lintCacheTotalFileCount
 		} : {},
+		...lintSidecarTotalFileCount !== null ? {
+			lintSidecarReplayedFileCount,
+			lintSidecarTotalFileCount
+		} : {},
+		...deadCodeCacheHit !== null ? { deadCodeCacheHit } : {},
+		...deadCodeSummaryCacheHits !== null && deadCodeSummaryCacheMisses !== null ? {
+			deadCodeSummaryCacheHits,
+			deadCodeSummaryCacheMisses
+		} : {},
 		...baselineDelta ? { baselineDelta } : {}
 	});
 	if (options.suppressRendering) return buildResult();
@@ -63678,4 +64334,4 @@ Promise.resolve().then(() => assertNoRemovedFlags(process.argv)).then(() => prog
 export {};
 
 //# sourceMappingURL=cli.js.map
-//# debugId=2921b8ff-14cf-5604-8ae5-b65b4f1347fc
+//# debugId=4d2b3e2c-ffb8-5da4-bf5d-833e608822bb