react-doctor 0.6.3-dev.ea9a775 → 0.7.0-dev.574cba6

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]="d9c72b21-3e94-5923-b692-077f137a0078")}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]="a88b7ed4-e1d2-587a-a826-36b16313d032")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as NodeChildProcess from "node:child_process";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
@@ -36130,13 +36130,14 @@ 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 CORE_PACKAGE_VERSION = "0.7.0";
 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";
 const SUPPLY_CHAIN_OVERLAP_TIMEOUT_MS = 9e4;
+const SUPPLY_CHAIN_CACHE_TTL_MS = 864e5;
 const SUPPLY_CHAIN_CACHE_SUBDIR = "supply-chain";
 const SUPPLY_CHAIN_IGNORED_PACKAGES = new Set(["next"]);
 const hasIgnoredPathSegment = (relativePath) => relativePath.split(/[/\\]/).slice(0, -1).some((segment) => IGNORED_DIRECTORIES.has(segment));
@@ -40608,22 +40609,37 @@ const failOpenReadJson = (filePath, fallback) => {
 		return fallback;
 	}
 };
+const hashFileContents = (filePath) => {
+	try {
+		return crypto.createHash("sha1").update(NFS.readFileSync(filePath)).digest("hex");
+	} catch {
+		return null;
+	}
+};
 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 = [];
+/**
+* Stat snapshot of every file the analysis reads, keyed by root-relative
+* `/`-separated path. Taken BEFORE the (long) analysis so a stored result is
+* verified against the tree it started from.
+*/
+const collectAnalyzedFileStats = (rootDirectory) => {
+	const statByRelativePath = /* @__PURE__ */ new Map();
 	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}`);
+			statByRelativePath.set(relativePath, {
+				mtimeMs: fileStat.mtimeMs,
+				size: fileStat.size
+			});
 		} catch {}
 	}
-	return fingerprints.sort();
+	return statByRelativePath;
 };
 const bundledRequire$2 = createRequire(import.meta.url);
 const resolveDeslopVersion = () => {
@@ -40635,14 +40651,13 @@ const resolveDeslopVersion = () => {
 	}
 };
 const computeDeadCodeCacheKey = (input) => crypto.createHash("sha1").update(JSON.stringify({
-	schemaVersion: 1,
+	schemaVersion: 2,
 	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)
+	tsConfigFile: input.tsConfigPath === void 0 ? null : Path.relative(input.rootDirectory, input.tsConfigPath).replace(/\\/g, "/")
 })).digest("hex");
 const validateDiagnostic$2 = decodeUnknownSync(Diagnostic);
 const decodeCachedDiagnostics = (raw) => {
@@ -40653,16 +40668,68 @@ const decodeCachedDiagnostics = (raw) => {
 		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 isPersistedFileIdentity = (value) => Array.isArray(value) && value.length === 3 && typeof value[0] === "number" && typeof value[1] === "number" && typeof value[2] === "string";
+const lookupDeadCodeResultCache = (input) => {
+	const cacheFilePath = Path.join(input.cacheDirectory, DEAD_CODE_CACHE_FILENAME);
+	const persisted = failOpenReadJson(cacheFilePath, null);
+	if (persisted === null || !isRecord$1(persisted) || persisted.version !== 2 || persisted.key !== input.cacheKey || !isRecord$1(persisted.files) || !Array.isArray(persisted.diagnostics)) return null;
+	const storedFileEntries = Object.entries(persisted.files);
+	if (storedFileEntries.length !== input.currentFileStats.size) return null;
+	const repairedFiles = {};
+	let repairedCount = 0;
+	for (const [relativePath, storedIdentity] of storedFileEntries) {
+		if (!isPersistedFileIdentity(storedIdentity)) return null;
+		const currentStat = input.currentFileStats.get(relativePath);
+		if (currentStat === void 0) return null;
+		const [storedMtimeMs, storedSize, storedContentHash] = storedIdentity;
+		if (currentStat.mtimeMs === storedMtimeMs && currentStat.size === storedSize) {
+			repairedFiles[relativePath] = storedIdentity;
+			continue;
+		}
+		if (currentStat.size !== storedSize) return null;
+		const currentContentHash = hashFileContents(Path.join(input.rootDirectory, relativePath));
+		if (currentContentHash === null || currentContentHash !== storedContentHash) return null;
+		repairedFiles[relativePath] = [
+			currentStat.mtimeMs,
+			currentStat.size,
+			storedContentHash
+		];
+		repairedCount += 1;
+	}
+	const diagnostics = decodeCachedDiagnostics(persisted.diagnostics);
+	if (diagnostics === null) return null;
+	if (repairedCount > 0) atomicWriteJson(cacheFilePath, {
+		version: 2,
+		key: input.cacheKey,
+		files: repairedFiles,
+		diagnostics: persisted.diagnostics
+	});
+	return diagnostics;
 };
-const storeDeadCodeResultCache = (cacheDirectory, cacheKey, diagnostics) => {
-	atomicWriteJson(Path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME), {
-		version: 1,
-		key: cacheKey,
-		diagnostics
+const storeDeadCodeResultCache = (input) => {
+	const persistedFiles = {};
+	for (const [relativePath, snapshotStat] of input.snapshotFileStats) {
+		const absolutePath = Path.join(input.rootDirectory, relativePath);
+		const contentHash = hashFileContents(absolutePath);
+		if (contentHash === null) return;
+		let currentStat;
+		try {
+			currentStat = NFS.statSync(absolutePath);
+		} catch {
+			return;
+		}
+		if (currentStat.mtimeMs !== snapshotStat.mtimeMs || currentStat.size !== snapshotStat.size) return;
+		persistedFiles[relativePath] = [
+			snapshotStat.mtimeMs,
+			snapshotStat.size,
+			contentHash
+		];
+	}
+	atomicWriteJson(Path.join(input.cacheDirectory, DEAD_CODE_CACHE_FILENAME), {
+		version: 2,
+		key: input.cacheKey,
+		files: persistedFiles,
+		diagnostics: input.diagnostics
 	});
 };
 const readSystemFacts = () => ({
@@ -41072,16 +41139,22 @@ const checkDeadCode = async (options) => {
 	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory);
 	const tsConfigPath = resolveTsConfigPath(rootDirectory);
 	const deslopJsModuleSpecifier = options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js");
-	const cacheKey = options.cacheEnabled ? computeDeadCodeCacheKey({
+	const fileStatsSnapshot = options.cacheEnabled ? collectAnalyzedFileStats(rootDirectory) : null;
+	const cacheKey = fileStatsSnapshot === null ? null : computeDeadCodeCacheKey({
 		rootDirectory,
 		entryPatterns,
 		ignorePatterns,
 		tsConfigPath,
 		deslopJsModuleSpecifier,
 		coreVersion: CORE_PACKAGE_VERSION
-	}) : null;
-	if (cacheKey !== null) {
-		const cachedDiagnostics = lookupDeadCodeResultCache(resolveReactDoctorCacheDir(rootDirectory), cacheKey);
+	});
+	if (cacheKey !== null && fileStatsSnapshot !== null) {
+		const cachedDiagnostics = lookupDeadCodeResultCache({
+			cacheDirectory: resolveReactDoctorCacheDir(rootDirectory),
+			cacheKey,
+			rootDirectory,
+			currentFileStats: fileStatsSnapshot
+		});
 		options.onCacheOutcome?.(cachedDiagnostics !== null);
 		if (cachedDiagnostics !== null) return [...cachedDiagnostics];
 	}
@@ -41155,7 +41228,13 @@ const checkDeadCode = async (options) => {
 			category: DEAD_CODE_CATEGORY
 		});
 	}
-	if (cacheKey !== null) storeDeadCodeResultCache(resolveReactDoctorCacheDir(rootDirectory), cacheKey, diagnostics);
+	if (cacheKey !== null && fileStatsSnapshot !== null) storeDeadCodeResultCache({
+		cacheDirectory: resolveReactDoctorCacheDir(rootDirectory),
+		cacheKey,
+		rootDirectory,
+		snapshotFileStats: fileStatsSnapshot,
+		diagnostics
+	});
 	return diagnostics;
 };
 const DEAD_CODE_RULE_KEY_PREFIX = `${DEAD_CODE_PLUGIN}/`;
@@ -42251,13 +42330,6 @@ const createFileLintCache = (cacheDirectory, rulesetHash) => {
 		}
 	};
 };
-const hashFileContents = (filePath) => {
-	try {
-		return crypto.createHash("sha1").update(NFS.readFileSync(filePath)).digest("hex");
-	} catch {
-		return null;
-	}
-};
 const ABSENT_CONTENT_ANSWER = "absent";
 /**
 * Answers dependency probes for the sidecar lint cache — used both when
@@ -44398,6 +44470,20 @@ const writeCachedSocketBody = (cacheFile, body) => {
 		}));
 	} catch {}
 };
+const pruneExpiredSocketCache = (cacheDirectory) => {
+	try {
+		const supplyChainCacheDirectory = Path.join(cacheDirectory, SUPPLY_CHAIN_CACHE_SUBDIR);
+		const expiryThresholdMs = Date.now() - SUPPLY_CHAIN_CACHE_TTL_MS;
+		for (const entryName of NFS.readdirSync(supplyChainCacheDirectory)) {
+			const entryPath = Path.join(supplyChainCacheDirectory, entryName);
+			try {
+				if (NFS.statSync(entryPath).mtimeMs < expiryThresholdMs) NFS.rmSync(entryPath);
+			} catch {
+				continue;
+			}
+		}
+	} catch {}
+};
 const fetchSocketArtifact = (dependency, cacheDirectory) => tryPromise(async (signal) => {
 	const cacheFile = cacheDirectory === null ? null : supplyChainCacheFile(cacheDirectory, dependency);
 	if (cacheFile !== null) {
@@ -44525,6 +44611,7 @@ const checkSupplyChain = (input) => gen(function* () {
 	const dependencies = collectDependenciesToScore(readPackageJson$1(packageJsonPath), readPackageJsonText(packageJsonPath), options.includeDevDependencies);
 	if (dependencies.length === 0) return [];
 	const cacheDirectory = isSupplyChainCacheDisabled() ? null : resolveReactDoctorCacheDir(input.rootDirectory);
+	if (cacheDirectory !== null) pruneExpiredSocketCache(cacheDirectory);
 	const artifacts = yield* forEach$1(dependencies, (dependency) => fetchSocketArtifact(dependency, cacheDirectory), { concurrency: 8 }).pipe(timeoutOption(input.totalTimeoutMs ?? 9e4), map$3((maybeArtifacts) => getOrElse$1(maybeArtifacts, () => [])));
 	const diagnostics = [];
 	for (let index = 0; index < dependencies.length; index += 1) {
@@ -45410,11 +45497,9 @@ const computeConfigFingerprint = (projectDirectory, version) => {
 	const parts = [`v=${version}`];
 	let directory = projectDirectory;
 	for (;;) {
-		for (const filename of CONFIG_FINGERPRINT_FILENAMES) try {
-			const stat = fs.statSync(path.join(directory, filename));
-			parts.push(`${directory}/${filename}=${stat.mtimeMs}:${stat.size}`);
-		} catch {
-			continue;
+		for (const filename of CONFIG_FINGERPRINT_FILENAMES) {
+			const contentHash = hashFileContents(path.join(directory, filename));
+			if (contentHash !== null) parts.push(`${directory}/${filename}=${contentHash}`);
 		}
 		const parent = path.dirname(directory);
 		if (parent === directory) break;
@@ -45710,6 +45795,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 SCAN_RESULT_CACHE_FILENAME = "scan-cache.json";
 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";
@@ -45801,7 +45887,7 @@ const makeNoopConsole = () => ({
 });
 //#endregion
 //#region src/cli/utils/version.ts
-const VERSION = "0.6.3-dev.ea9a775";
+const VERSION = "0.7.0-dev.574cba6";
 //#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
@@ -46170,13 +46256,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.ea9a775`;
+const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.7.0-dev.574cba6`;
 /**
 * 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.ea9a775") ? "development" : "production");
+const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.7.0-dev.574cba6") ? "development" : "production");
 /**
 * Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
 * (set to `0` to disable tracing) and falls back to
@@ -58254,6 +58340,276 @@ 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/package.json",
+	"oxlint-plugin-react-doctor/package.json",
+	"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}=${hashFileContents(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) => path.join(resolveReactDoctorCacheDir(projectDirectory), SCAN_RESULT_CACHE_FILENAME);
+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) fingerprints.push(nodeBinaryPath === process.execPath ? `node=${process.version}` : `node=${fileFingerprint(nodeBinaryPath) ?? "unreadable"}`);
+	for (const specifier of TOOLCHAIN_PACKAGE_SPECIFIERS) try {
+		const packageJson = bundledRequire(specifier);
+		const version = typeof packageJson.version === "string" ? packageJson.version : "unknown";
+		fingerprints.push(`${specifier}=${version}`);
+	} catch {
+		fingerprints.push(`${specifier}=missing`);
+	}
+	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;
@@ -58295,6 +58651,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";
@@ -58400,10 +58813,10 @@ 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: result.lintSidecarTotalFileCount != null && result.lintSidecarTotalFileCount > 0 ? (result.lintSidecarReplayedFileCount ?? 0) / result.lintSidecarTotalFileCount : null
+			sidecarReplayRatio: ratioOf(result.lintSidecarReplayedFileCount, result.lintSidecarTotalFileCount)
 		}),
 		...withNamespace("deadCode", {
 			failed: input.didDeadCodeFail ?? null,
@@ -58470,7 +58883,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
@@ -58484,7 +58897,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
@@ -59694,275 +60108,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 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;
-	}
-};
-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 (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/inspect.ts
 const silentConsole = makeNoopConsole();
 const runConsole = (effect) => {
@@ -60139,7 +60284,7 @@ const runBaselineComparison = async (params) => {
 			suppressScanSummary: true,
 			supplyChainManifestChanged: params.options.supplyChainManifestChanged,
 			deadlineEpochMs: params.deadlineEpochMs ?? void 0
-		}, {}).pipe(provide(baseLayers), provideService$2(Console, silentConsole))));
+		}, {}).pipe(provide(baseLayers), provideService$2(PerFileLintCacheEnabled, false), provideService$2(SidecarLintCacheEnabled, false), provideService$2(Console, silentConsole))));
 		if (baseOutput.didLintFail || countIncompleteLintFiles(baseOutput.lintPartialFailures) > 0) return null;
 		const delta = computeDiagnosticDelta({
 			headDiagnostics: params.headDiagnostics,
@@ -60192,7 +60337,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;
@@ -60301,6 +60447,7 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 		rootSentrySpan,
 		scanMode: baselineDelta ? "baseline" : isDiffMode ? "diff" : "full",
 		baselineDegraded,
+		wholeRepoCacheHit: false,
 		lintCacheHitFileCount: output.lintCacheHitFileCount,
 		lintCacheTotalFileCount: output.lintCacheTotalFileCount,
 		lintSidecarReplayedFileCount: output.lintSidecarReplayedFileCount,
@@ -60371,6 +60518,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,
@@ -64264,4 +64412,4 @@ Promise.resolve().then(() => assertNoRemovedFlags(process.argv)).then(() => prog
 export {};
 
 //# sourceMappingURL=cli.js.map
-//# debugId=d9c72b21-3e94-5923-b692-077f137a0078
+//# debugId=a88b7ed4-e1d2-587a-a826-36b16313d032