react-doctor 0.2.14-dev.8b313ba → 0.2.14-dev.9777f1a

package/dist/cli.js

@@ -15,7 +15,10 @@ import * as Redacted from "effect/Redacted";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as Otlp from "effect/unstable/observability/Otlp";
 import * as Context from "effect/Context";
+import os, { tmpdir } from "node:os";
 import * as Console from "effect/Console";
+import { parseJSON5 } from "confbox";
+import { createJiti } from "jiti";
 import * as Fiber from "effect/Fiber";
 import * as Filter from "effect/Filter";
 import * as Option from "effect/Option";
@@ -27,9 +30,9 @@ import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath from "@effect/platform-node-shared/NodePath";
 import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
-import os, { tmpdir } from "node:os";
 import * as ts from "typescript";
 import { gzipSync } from "node:zlib";
+import * as Sentry from "@sentry/node";
 import { performance } from "node:perf_hooks";
 import { stripVTControlCharacters } from "node:util";
 import tty from "node:tty";
@@ -39,6 +42,8 @@ import basePrompts from "prompts";
 import { SKILL_MANIFEST_FILE, detectInstalledSkillAgents, getSkillAgentConfig, getSkillAgentTypes, installSkillsFromSource } from "agent-install";
 import { fileURLToPath } from "node:url";
 import Conf from "conf";
+import { generateCode, loadFile, writeFile } from "magicast";
+import { getConfigFromVariableDeclaration, getDefaultExportOptions } from "magicast/helpers";
 //#region \0rolldown/runtime.js
 var __create$1 = Object.create;
 var __defProp$1 = Object.defineProperty;
@@ -5892,29 +5897,34 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 		framework: rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceInfo.framework
 	};
 };
-const someWorkspacePackageJson = (rootDirectory, rootPackageJson, predicate) => {
-	if (predicate(rootPackageJson)) return true;
+const findInWorkspacePackageJsons = (rootDirectory, rootPackageJson, select) => {
+	const rootValue = select(rootPackageJson);
+	if (rootValue !== null) return rootValue;
 	const patterns = getWorkspacePatterns(rootDirectory, rootPackageJson);
-	if (patterns.length === 0) return false;
+	if (patterns.length === 0) return null;
 	const visitedDirectories = /* @__PURE__ */ new Set();
 	for (const pattern of patterns) {
-		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		const directories = [...resolveWorkspaceDirectories(rootDirectory, pattern)].sort();
 		for (const workspaceDirectory of directories) {
 			if (visitedDirectories.has(workspaceDirectory)) continue;
 			visitedDirectories.add(workspaceDirectory);
-			if (predicate(readPackageJson$1(path.join(workspaceDirectory, "package.json")))) return true;
+			const value = select(readPackageJson$1(path.join(workspaceDirectory, "package.json")));
+			if (value !== null) return value;
 		}
 	}
-	return false;
+	return null;
 };
+const someWorkspacePackageJson = (rootDirectory, rootPackageJson, predicate) => findInWorkspacePackageJsons(rootDirectory, rootPackageJson, (packageJson) => predicate(packageJson) ? true : null) !== null;
 const NAMES = new Set([
 	"react-native",
 	"react-native-tvos",
-	"expo",
-	"expo-router",
-	"@expo/cli",
-	"@expo/metro-config",
-	"@expo/metro-runtime",
+	...new Set([
+		"expo",
+		"expo-router",
+		"@expo/cli",
+		"@expo/metro-config",
+		"@expo/metro-runtime"
+	]),
 	"react-native-windows",
 	"react-native-macos"
 ]);
@@ -5938,6 +5948,11 @@ const isPackageJsonReactNativeAware = (packageJson) => {
 	return false;
 };
 const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => someWorkspacePackageJson(rootDirectory, rootPackageJson, isPackageJsonReactNativeAware);
+const getExpoDependencySpec = (packageJson) => {
+	const spec = packageJson.dependencies?.expo ?? packageJson.devDependencies?.expo ?? packageJson.peerDependencies?.expo ?? packageJson.optionalDependencies?.expo;
+	return typeof spec === "string" ? spec : null;
+};
+const findExpoVersion = (rootDirectory, rootPackageJson) => findInWorkspacePackageJsons(rootDirectory, rootPackageJson, getExpoDependencySpec);
 const getPreactVersion = (packageJson) => {
 	return {
 		...packageJson.peerDependencies,
@@ -6174,6 +6189,19 @@ const discoverProject = (directory) => {
 	const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
 	const sourceFileCount = countSourceFiles(directory);
 	const hasReactNativeWorkspace = framework === "expo" || framework === "react-native" || hasReactNativeWorkspaceAnywhere(directory, packageJson);
+	let expoVersion = hasReactNativeWorkspace ? findExpoVersion(directory, packageJson) : null;
+	if (expoVersion !== null && isCatalogReference(expoVersion)) {
+		const catalogName = extractCatalogName(expoVersion);
+		let resolvedExpoVersion = resolveCatalogVersion(packageJson, "expo", directory, catalogName);
+		if (!resolvedExpoVersion) {
+			const monorepoRoot = findMonorepoRoot(directory);
+			if (monorepoRoot) {
+				const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
+				if (isFile(monorepoPackageJsonPath)) resolvedExpoVersion = resolveCatalogVersion(readPackageJson$1(monorepoPackageJsonPath), "expo", monorepoRoot, catalogName);
+			}
+		}
+		expoVersion = resolvedExpoVersion ?? expoVersion;
+	}
 	const hasReanimated = hasReactNativeWorkspace && someWorkspacePackageJson(directory, packageJson, isPackageJsonReanimatedAware);
 	const preactVersion = getPreactVersion(packageJson);
 	const projectInfo = {
@@ -6191,6 +6219,7 @@ const discoverProject = (directory) => {
 		preactVersion,
 		preactMajorVersion: parseReactMajor(preactVersion),
 		hasReactNativeWorkspace,
+		expoVersion,
 		hasReanimated,
 		sourceFileCount
 	};
@@ -6266,7 +6295,8 @@ const MILLISECONDS_PER_SECOND = 1e3;
 const SCORE_API_URL = "https://www.react.doctor/api/score";
 const ENTERPRISE_CONTACT_URL = "https://react.doctor/enterprise";
 const SHARE_BASE_URL = "https://react.doctor/share";
-const PROMPTS_RULES_BASE_URL = "https://www.react.doctor/prompts/rules";
+const DOCS_URL = "https://www.react.doctor/docs";
+const DOCS_RULES_BASE_URL = `${DOCS_URL}/rules`;
 const FETCH_TIMEOUT_MS = 1e4;
 const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
 const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
@@ -6284,11 +6314,19 @@ const STAGED_FILES_PROJECT_CONFIG_FILENAMES = [
 	"tsconfig.json",
 	"tsconfig.base.json",
 	"package.json",
-	"react-doctor.config.json",
+	"doctor.config.ts",
+	"doctor.config.mts",
+	"doctor.config.cts",
+	"doctor.config.js",
+	"doctor.config.mjs",
+	"doctor.config.cjs",
+	"doctor.config.json",
+	"doctor.config.jsonc",
 	"oxlint.json",
 	".oxlintrc.json"
 ];
 const CANONICAL_GITHUB_URL = "https://github.com/millionco/react-doctor";
+const CANONICAL_DISCORD_URL = "https://react.doctor/discord";
 const SKILL_NAME = "react-doctor";
 const OXLINT_OUTPUT_MAX_BYTES = 50 * 1024 * 1024;
 const OXLINT_SPAWN_TIMEOUT_MS = 6e4;
@@ -6301,6 +6339,9 @@ const DIAGNOSTIC_CATEGORY_BUCKETS = [
 	"Accessibility",
 	"Maintainability"
 ];
+const APP_ONLY_RULE_KEYS = new Set(["react-hooks-js/static-components", "react-doctor/no-render-prop-children"]);
+const COMPILER_CLEANUP_BUCKET = "compiler-cleanup";
+const COMPILER_CLEANUP_RULE_KEYS = new Set(["react-doctor/react-compiler-no-manual-memoization"]);
 const MAX_GLOB_PATTERN_LENGTH_CHARS = 1024;
 const CONFIG_CACHE_TTL_MS = 300 * 1e3;
 var InvalidGlobPatternError = class extends Error {
@@ -6420,10 +6461,11 @@ const restampSeverity = (diagnostic, override) => {
 */
 const buildRuleSeverityControls = (config) => {
 	if (!config) return void 0;
-	if (config.rules === void 0 && config.categories === void 0) return void 0;
+	if (config.rules === void 0 && config.categories === void 0 && config.buckets === void 0) return;
 	return {
 		...config.rules !== void 0 ? { rules: config.rules } : {},
-		...config.categories !== void 0 ? { categories: config.categories } : {}
+		...config.categories !== void 0 ? { categories: config.categories } : {},
+		...config.buckets !== void 0 ? { buckets: config.buckets } : {}
 	};
 };
 const JSX_OPENER_TAG_PATTERN = /<[A-Za-z][\w.]*/g;
@@ -6787,6 +6829,65 @@ const resolveRuleSeverityOverride = (input, controls) => {
 	}
 	return input.category !== void 0 ? controls.categories?.[input.category] : void 0;
 };
+const cachedRoleByPackageDirectory = /* @__PURE__ */ new Map();
+const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
+const findNearestPackageDirectory$1 = (filename) => {
+	if (!filename) return null;
+	const fromCache = cachedPackageDirectoryByFilename.get(filename);
+	if (fromCache !== void 0) return fromCache;
+	let currentDirectory = path.dirname(filename);
+	while (true) {
+		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+		let hasPackageJson = false;
+		try {
+			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
+		} catch {
+			hasPackageJson = false;
+		}
+		if (hasPackageJson) {
+			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
+			return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			cachedPackageDirectoryByFilename.set(filename, null);
+			return null;
+		}
+		currentDirectory = parentDirectory;
+	}
+};
+const readManifest = (packageJsonPath) => {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+};
+const hasPublishContract = (manifest) => typeof manifest.name === "string" && manifest.name.length > 0 && manifest.exports !== void 0 && manifest.exports !== null && manifest.private !== true;
+const classifyByDirectoryCohort = (packageDirectory) => {
+	let current = packageDirectory;
+	while (true) {
+		if (path.basename(current) === "apps") return "app";
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+};
+const classifyPackageRole = (filename) => {
+	if (!filename) return "unknown";
+	const packageDirectory = findNearestPackageDirectory$1(filename);
+	if (!packageDirectory) return "unknown";
+	const cached = cachedRoleByPackageDirectory.get(packageDirectory);
+	if (cached !== void 0) return cached;
+	const manifest = readManifest(path.join(packageDirectory, "package.json"));
+	let result;
+	if (manifest && hasPublishContract(manifest)) result = "library";
+	else result = classifyByDirectoryCohort(path.dirname(packageDirectory)) ?? "unknown";
+	cachedRoleByPackageDirectory.set(packageDirectory, result);
+	return result;
+};
 /**
 * Resolves the absolute path to read for a diagnostic's `filePath`,
 * accounting for the various shapes oxlint emits:
@@ -6949,6 +7050,15 @@ const buildDiagnosticPipeline = (input) => {
 	const hasRawTextWrappers = rawTextWrapperComponentNames.size > 0;
 	const fileLinesCache = /* @__PURE__ */ new Map();
 	const testFileCache = /* @__PURE__ */ new Map();
+	const libraryFileCache = /* @__PURE__ */ new Map();
+	const isLibraryFile = (filePath) => {
+		let cached = libraryFileCache.get(filePath);
+		if (cached === void 0) {
+			cached = classifyPackageRole(resolveCandidateReadPath(rootDirectory, filePath)) === "library";
+			libraryFileCache.set(filePath, cached);
+		}
+		return cached;
+	};
 	const getFileLines = (filePath) => {
 		const cached = fileLinesCache.get(filePath);
 		if (cached !== void 0) return cached;
@@ -6975,6 +7085,10 @@ const buildDiagnosticPipeline = (input) => {
 		for (const ignored of ignoredRules) if (isSameRuleKey(ignored, ruleIdentifier)) return true;
 		return false;
 	};
+	const isAppOnlyRule = (ruleIdentifier) => {
+		for (const appOnlyRuleKey of APP_ONLY_RULE_KEYS) if (isSameRuleKey(appOnlyRuleKey, ruleIdentifier)) return true;
+		return false;
+	};
 	const isRnRawTextSuppressedByConfig = (diagnostic) => {
 		if (diagnostic.rule !== "rn-no-raw-text") return false;
 		if (diagnostic.line <= 0) return false;
@@ -6989,8 +7103,10 @@ const buildDiagnosticPipeline = (input) => {
 		if (shouldAutoSuppress(diagnostic)) return null;
 		let current = diagnostic;
 		let explicitSeverityOverride;
+		let explicitRuleOverride;
 		if (severityControls) {
 			const { ruleKey, category } = getDiagnosticRuleIdentity(current);
+			explicitRuleOverride = resolveRuleSeverityOverride({ ruleKey }, severityControls);
 			explicitSeverityOverride = resolveRuleSeverityOverride({
 				ruleKey,
 				category
@@ -6998,6 +7114,9 @@ const buildDiagnosticPipeline = (input) => {
 			if (explicitSeverityOverride === "off") return null;
 			if (explicitSeverityOverride !== void 0) current = restampSeverity(current, explicitSeverityOverride);
 		}
+		if (explicitRuleOverride === void 0) {
+			if (isAppOnlyRule(`${current.plugin}/${current.rule}`) && isLibraryFile(current.filePath)) return null;
+		}
 		if (!showWarnings && current.severity === "warning" && explicitSeverityOverride !== "warn") return null;
 		if (userConfig) {
 			if (isRuleIgnored(`${current.plugin}/${current.rule}`)) return null;
@@ -7183,6 +7302,17 @@ const layerOtlp = Layer.unwrap(Effect.gen(function* () {
 	}).pipe(Layer.provide(FetchHttpClient.layer));
 }).pipe(Effect.orDie));
 /**
+* Resolves a requested lint worker count to a clamped integer within
+* `[MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY]`. `"auto"` uses the
+* machine's CPU cores; out-of-range or non-finite requests degrade to
+* `MIN_SCAN_CONCURRENCY` rather than oversubscribing or running zero workers.
+*/
+const resolveScanConcurrency = (requested) => {
+	const desired = requested === "auto" ? os.availableParallelism() : requested;
+	if (!Number.isFinite(desired) || desired < 1) return 1;
+	return Math.max(1, Math.min(Math.floor(desired), 16));
+};
+/**
 * Per-batch oxlint wall-clock budget. Reads from the env var on
 * startup so the eval harness can raise the budget under sandbox
 * microVMs without recompiling react-doctor. Tests override via
@@ -7202,6 +7332,30 @@ var OxlintSpawnTimeoutMs = class extends Context.Reference("react-doctor/OxlintS
 * tests that exercise the cap behavior.
 */
 var OxlintOutputMaxBytes = class extends Context.Reference("react-doctor/OxlintOutputMaxBytes", { defaultValue: () => OXLINT_OUTPUT_MAX_BYTES }) {};
+/**
+* Number of oxlint subprocesses the lint pass runs in parallel. Defaults
+* to `1` (serial — the historical behavior) so resource usage is opt-in.
+* The CLI's `--experimental-parallel` flag overrides this via `Layer.succeed`; the
+* `REACT_DOCTOR_PARALLEL` env var seeds the default for programmatic /
+* CI callers that never touch the flag:
+*
+*   - unset / `0` / `false` / `off` → `1` (serial)
+*   - `auto` / `true` / `on`        → available CPU cores (clamped)
+*   - a positive integer            → that many workers (clamped)
+*
+* The resolved value is always within
+* `[MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY]`.
+*/
+var OxlintConcurrency = class extends Context.Reference("react-doctor/OxlintConcurrency", { defaultValue: () => {
+	const raw = process.env["REACT_DOCTOR_PARALLEL"];
+	if (raw === void 0) return 1;
+	const normalized = raw.trim().toLowerCase();
+	if (normalized === "" || normalized === "0" || normalized === "false" || normalized === "off") return 1;
+	if (normalized === "auto" || normalized === "true" || normalized === "on") return resolveScanConcurrency("auto");
+	const parsed = Number.parseInt(normalized, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) return 1;
+	return resolveScanConcurrency(parsed);
+} }) {};
 const DIAGNOSTIC_SURFACES = [
 	"cli",
 	"prComment",
@@ -7358,66 +7512,135 @@ const validateConfigTypes = (config) => {
 const warn = (message) => {
 	Effect.runSync(Console.warn(message));
 };
-const CONFIG_FILENAME = "react-doctor.config.json";
-const PACKAGE_JSON_CONFIG_KEY = "reactDoctor";
-const loadConfigFromDirectory = (directory) => {
-	const configFilePath = path.join(directory, CONFIG_FILENAME);
-	if (isFile(configFilePath)) try {
-		const fileContent = fs.readFileSync(configFilePath, "utf-8");
-		const parsed = JSON.parse(fileContent);
-		if (isPlainObject(parsed)) return {
-			config: validateConfigTypes(parsed),
-			sourceDirectory: directory
-		};
-		warn(`${CONFIG_FILENAME} must be a JSON object, ignoring.`);
-	} catch (error) {
-		warn(`Failed to parse ${CONFIG_FILENAME}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const packageJsonPath = path.join(directory, "package.json");
-	if (isFile(packageJsonPath)) try {
-		const fileContent = fs.readFileSync(packageJsonPath, "utf-8");
-		const packageJson = JSON.parse(fileContent);
+const CONFIG_BASENAME = "doctor.config";
+const CONFIG_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs",
+	"json",
+	"jsonc"
+];
+const DATA_CONFIG_EXTENSIONS = new Set(["json", "jsonc"]);
+const PACKAGE_JSON_FILENAME = "package.json";
+const PACKAGE_JSON_CONFIG_KEY$1 = "reactDoctor";
+const LEGACY_CONFIG_FILENAME = "react-doctor.config.json";
+const jiti = createJiti(import.meta.url);
+const formatError = (error) => error instanceof Error ? error.message : String(error);
+const loadModuleConfig = async (filePath) => {
+	const imported = await jiti.import(filePath);
+	return imported?.default ?? imported;
+};
+const readDataConfig = (filePath) => parseJSON5(fs.readFileSync(filePath, "utf-8"));
+const readEmbeddedPackageJsonConfig = (directory) => {
+	const packageJsonPath = path.join(directory, PACKAGE_JSON_FILENAME);
+	if (!isFile(packageJsonPath)) return null;
+	try {
+		const packageJson = parseJSON5(fs.readFileSync(packageJsonPath, "utf-8"));
 		if (isPlainObject(packageJson)) {
-			const embeddedConfig = packageJson[PACKAGE_JSON_CONFIG_KEY];
-			if (isPlainObject(embeddedConfig)) return {
-				config: validateConfigTypes(embeddedConfig),
-				sourceDirectory: directory
+			const embeddedConfig = packageJson[PACKAGE_JSON_CONFIG_KEY$1];
+			if (isPlainObject(embeddedConfig)) return embeddedConfig;
+		}
+	} catch {}
+	return null;
+};
+const loadPackageJsonConfig = (directory) => {
+	const embeddedConfig = readEmbeddedPackageJsonConfig(directory);
+	if (!embeddedConfig) return null;
+	return {
+		config: validateConfigTypes(embeddedConfig),
+		sourceDirectory: directory,
+		configFilePath: path.join(directory, PACKAGE_JSON_FILENAME),
+		format: "package-json"
+	};
+};
+const loadConfigFromDirectory = async (directory) => {
+	let sawBrokenConfigFile = false;
+	for (const extension of CONFIG_EXTENSIONS) {
+		const filePath = path.join(directory, `${CONFIG_BASENAME}.${extension}`);
+		if (!isFile(filePath)) continue;
+		const isDataFile = DATA_CONFIG_EXTENSIONS.has(extension);
+		try {
+			const parsed = isDataFile ? readDataConfig(filePath) : await loadModuleConfig(filePath);
+			if (isPlainObject(parsed)) return {
+				status: "found",
+				loaded: {
+					config: validateConfigTypes(parsed),
+					sourceDirectory: directory,
+					configFilePath: filePath,
+					format: isDataFile ? "json" : "module"
+				}
 			};
+			warn(`${CONFIG_BASENAME}.${extension} must export an object, ignoring.`);
+			sawBrokenConfigFile = true;
+		} catch (error) {
+			warn(`Failed to load ${CONFIG_BASENAME}.${extension}: ${formatError(error)}`);
+			sawBrokenConfigFile = true;
 		}
-	} catch {
-		return null;
 	}
-	return null;
+	const packageJsonConfig = loadPackageJsonConfig(directory);
+	if (packageJsonConfig) return {
+		status: "found",
+		loaded: packageJsonConfig
+	};
+	if (isFile(path.join(directory, LEGACY_CONFIG_FILENAME))) warn(`${LEGACY_CONFIG_FILENAME} is no longer read — rename it to ${CONFIG_BASENAME}.json (or author a ${CONFIG_BASENAME}.ts).`);
+	return {
+		status: sawBrokenConfigFile ? "invalid" : "absent",
+		loaded: null
+	};
 };
 const cachedConfigs = /* @__PURE__ */ new Map();
-const loadConfigWithSource = (rootDirectory) => {
-	const cached = cachedConfigs.get(rootDirectory);
-	if (cached !== void 0) return cached;
-	const localConfig = loadConfigFromDirectory(rootDirectory);
-	if (localConfig) {
-		cachedConfigs.set(rootDirectory, localConfig);
-		return localConfig;
-	}
-	if (isProjectBoundary(rootDirectory)) {
-		cachedConfigs.set(rootDirectory, null);
-		return null;
-	}
+const clearConfigCache = () => {
+	cachedConfigs.clear();
+};
+const loadConfigWalkingUp = async (rootDirectory) => {
+	const localResult = await loadConfigFromDirectory(rootDirectory);
+	if (localResult.status === "found") return localResult.loaded;
+	if (localResult.status === "invalid" || isProjectBoundary(rootDirectory)) return null;
 	let ancestorDirectory = path.dirname(rootDirectory);
 	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
-		const ancestorConfig = loadConfigFromDirectory(ancestorDirectory);
-		if (ancestorConfig) {
-			cachedConfigs.set(rootDirectory, ancestorConfig);
-			return ancestorConfig;
-		}
-		if (isProjectBoundary(ancestorDirectory)) {
-			cachedConfigs.set(rootDirectory, null);
-			return null;
-		}
+		const ancestorResult = await loadConfigFromDirectory(ancestorDirectory);
+		if (ancestorResult.status === "found") return ancestorResult.loaded;
+		if (isProjectBoundary(ancestorDirectory)) return null;
 		ancestorDirectory = path.dirname(ancestorDirectory);
 	}
-	cachedConfigs.set(rootDirectory, null);
 	return null;
 };
+const loadConfigWithSource = (rootDirectory) => {
+	const cached = cachedConfigs.get(rootDirectory);
+	if (cached !== void 0) return cached;
+	const loadPromise = loadConfigWalkingUp(rootDirectory);
+	cachedConfigs.set(rootDirectory, loadPromise);
+	return loadPromise;
+};
+const directoryHasCurrentConfig = (directory) => {
+	for (const extension of CONFIG_EXTENSIONS) if (isFile(path.join(directory, `${CONFIG_BASENAME}.${extension}`))) return true;
+	return readEmbeddedPackageJsonConfig(directory) !== null;
+};
+/**
+* Walks up from `rootDirectory` (same boundary semantics as
+* `loadConfigWithSource`) looking for a pre-migration
+* `react-doctor.config.json` that is no longer read. Returns the first one
+* found, or `null` when a current-format config supersedes it or none exists
+* before a project boundary. Detection only — the CLI performs the rename.
+*/
+const findLegacyConfig = (rootDirectory) => {
+	let directory = rootDirectory;
+	while (true) {
+		if (directoryHasCurrentConfig(directory)) return null;
+		const legacyFilePath = path.join(directory, LEGACY_CONFIG_FILENAME);
+		if (isFile(legacyFilePath)) return {
+			legacyFilePath,
+			directory
+		};
+		if (isProjectBoundary(directory)) return null;
+		const parentDirectory = path.dirname(directory);
+		if (parentDirectory === directory) return null;
+		directory = parentDirectory;
+	}
+};
 const resolveConfigRootDir = (config, configSourceDirectory) => {
 	if (!config || !configSourceDirectory) return null;
 	const rawRootDir = config.rootDir;
@@ -7432,11 +7655,12 @@ const resolveConfigRootDir = (config, configSourceDirectory) => {
 	}
 	return resolvedRootDir;
 };
-const resolveDiagnoseTarget = (directory) => {
+const resolveDiagnoseTarget = (directory, options = {}) => {
 	if (isFile(path.join(directory, "package.json"))) return directory;
 	const reactSubprojects = discoverReactSubprojects(directory);
 	if (reactSubprojects.length === 0) return null;
 	if (reactSubprojects.length === 1) return reactSubprojects[0].directory;
+	if (options.allowAmbiguous === true) return null;
 	throw new AmbiguousProjectError(directory, reactSubprojects.map((subproject) => path.relative(directory, subproject.directory)).toSorted());
 };
 /**
@@ -7444,13 +7668,13 @@ const resolveDiagnoseTarget = (directory) => {
 * (`inspect()`, `diagnose()`, and the CLI's `inspectAction`):
 *
 *   1. Resolve the requested directory to absolute.
-*   2. Load `react-doctor.config.(json|js)` / `package.json#reactDoctor`
-*      if present.
+*   2. Load `doctor.config.*` / `package.json#reactDoctor` if present.
 *   3. Honor `config.rootDir` to redirect the scan to a nested
 *      project root, if configured.
 *   4. Walk into a nested React subproject when the requested
 *      directory has no `package.json` of its own (raises
-*      `AmbiguousProjectError` when multiple candidates exist).
+*      `AmbiguousProjectError` when multiple candidates exist unless
+*      the caller opts into keeping the wrapper directory).
 *
 * Throws `ProjectNotFoundError` when neither the requested directory
 * nor any discoverable nested project has a `package.json`.
@@ -7462,14 +7686,14 @@ const resolveDiagnoseTarget = (directory) => {
 * via its own cache). Routing through `resolveScanTarget` keeps every
 * shell in agreement on what "the scan directory" means.
 */
-const resolveScanTarget = (requestedDirectory) => {
+const resolveScanTarget = async (requestedDirectory, options = {}) => {
 	const absoluteRequested = path.resolve(requestedDirectory);
-	const loadedConfig = loadConfigWithSource(absoluteRequested);
+	const loadedConfig = await loadConfigWithSource(absoluteRequested);
 	const userConfig = loadedConfig?.config ?? null;
 	const configSourceDirectory = loadedConfig?.sourceDirectory ?? null;
 	const redirectedDirectory = resolveConfigRootDir(userConfig, configSourceDirectory);
 	const directoryAfterRedirect = redirectedDirectory ?? absoluteRequested;
-	const resolvedDirectory = resolveDiagnoseTarget(directoryAfterRedirect) ?? directoryAfterRedirect;
+	const resolvedDirectory = resolveDiagnoseTarget(directoryAfterRedirect, options) ?? directoryAfterRedirect;
 	if (!isDirectory(resolvedDirectory)) throw existsSync(resolvedDirectory) ? new NotADirectoryError(resolvedDirectory) : new ProjectNotFoundError(resolvedDirectory);
 	return {
 		resolvedDirectory,
@@ -7479,6 +7703,359 @@ const resolveScanTarget = (requestedDirectory) => {
 		didRedirectViaRootDir: redirectedDirectory !== null
 	};
 };
+const getDirectDependencyNames = (packageJson) => new Set([...Object.keys(packageJson.dependencies ?? {}), ...Object.keys(packageJson.devDependencies ?? {})]);
+const buildExpoCheckContext = (rootDirectory, expoVersion) => {
+	const packageJson = readPackageJson$1(path.join(rootDirectory, "package.json"));
+	return {
+		rootDirectory,
+		packageJson,
+		directDependencyNames: getDirectDependencyNames(packageJson),
+		expoSdkMajor: getLowestDependencyMajor(expoVersion)
+	};
+};
+const buildExpoDiagnostic = (input) => ({
+	filePath: input.filePath ?? "package.json",
+	plugin: "react-doctor",
+	rule: input.rule,
+	severity: input.severity ?? "warning",
+	message: input.message,
+	help: input.help,
+	line: input.line ?? 0,
+	column: input.column ?? 0,
+	category: input.category ?? "Correctness"
+});
+const CRITICAL_OVERRIDE_NAMES = new Set([
+	"@expo/cli",
+	"@expo/config",
+	"@expo/metro-config",
+	"@expo/metro-runtime",
+	"@expo/metro",
+	"metro"
+]);
+const isCriticalOverrideName = (packageName) => CRITICAL_OVERRIDE_NAMES.has(packageName) || packageName.startsWith("metro-");
+const collectOverrideNames = (packageJson) => new Set([
+	...Object.keys(packageJson.overrides ?? {}),
+	...Object.keys(packageJson.resolutions ?? {}),
+	...Object.keys(packageJson.pnpm?.overrides ?? {})
+]);
+const checkExpoDependencyOverrides = (context) => {
+	const overriddenCriticalNames = [...collectOverrideNames(context.packageJson)].filter(isCriticalOverrideName).sort();
+	if (overriddenCriticalNames.length === 0) return [];
+	const quotedNames = overriddenCriticalNames.map((name) => `"${name}"`).join(", ");
+	return [buildExpoDiagnostic({
+		rule: "expo-no-conflicting-dependency-override",
+		message: `package.json pins SDK-critical ${overriddenCriticalNames.length === 1 ? "package" : "packages"} via overrides/resolutions (${quotedNames}) — these versions are tied to the Expo SDK release and overriding them is unsupported and may break Metro or native builds`,
+		help: `Remove the override/resolution for ${quotedNames} and reinstall so the Expo-pinned versions are used`
+	})];
+};
+const isPathGitIgnored = (rootDirectory, absolutePath) => {
+	const result = spawnSync("git", [
+		"check-ignore",
+		"-q",
+		absolutePath
+	], {
+		cwd: rootDirectory,
+		stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		]
+	});
+	if (result.error) return null;
+	if (result.status === 0) return true;
+	if (result.status === 1) return false;
+	return null;
+};
+const LOCAL_ENV_FILE_NAMES = [
+	".env.local",
+	".env.development.local",
+	".env.production.local",
+	".env.test.local"
+];
+const checkExpoEnvLocalFiles = (context) => {
+	const { rootDirectory } = context;
+	const committedEnvFiles = LOCAL_ENV_FILE_NAMES.filter((fileName) => {
+		const filePath = path.join(rootDirectory, fileName);
+		if (!isFile(filePath)) return false;
+		return isPathGitIgnored(rootDirectory, filePath) === false;
+	});
+	if (committedEnvFiles.length === 0) return [];
+	return [buildExpoDiagnostic({
+		rule: "expo-env-local-not-gitignored",
+		category: "Security",
+		message: `Local environment ${committedEnvFiles.length === 1 ? "file" : "files"} (${committedEnvFiles.join(", ")}) ${committedEnvFiles.length === 1 ? "is" : "are"} not ignored by Git — committing \`.env*.local\` risks leaking secrets and overriding committed defaults for everyone who clones the project`,
+		help: `Add \`.env*.local\` to your .gitignore. If already committed, untrack with \`git rm --cached ${committedEnvFiles.join(" ")}\``
+	})];
+};
+const isExpoSdkAtLeast = (expoSdkMajor, minMajor) => expoSdkMajor !== null && expoSdkMajor >= minMajor;
+const UNIMODULES_HELP = "Remove every `@unimodules/*` and `react-native-unimodules` package — their functionality now lives in `expo-modules-core`. See https://expo.fyi/r/sdk-44-remove-unimodules";
+const FIREBASE_HELP = "Use the Firebase JS SDK or React Native Firebase directly. See https://expo.fyi/firebase-migration-guide";
+const unimodulesEntry = (packageName) => ({
+	packageName,
+	rule: "expo-no-unimodules-packages",
+	message: `"${packageName}" is a legacy unimodules package that is incompatible with Expo SDK 44+ and will break native builds`,
+	help: UNIMODULES_HELP
+});
+const FLAGGED_DEPENDENCIES = [
+	unimodulesEntry("@unimodules/core"),
+	unimodulesEntry("@unimodules/react-native-adapter"),
+	unimodulesEntry("react-native-unimodules"),
+	{
+		packageName: "expo-cli",
+		rule: "expo-no-cli-dependencies",
+		message: "`expo-cli` (the legacy global CLI) is a project dependency — the CLI now ships inside the `expo` package, and keeping `expo-cli` causes failures such as `unknown option --fix` when running `npx expo install --fix`",
+		help: "Remove `expo-cli` from your dependencies and use the bundled CLI via `npx expo`"
+	},
+	{
+		packageName: "eas-cli",
+		rule: "expo-no-cli-dependencies",
+		message: "`eas-cli` is a project dependency — pinning it in package.json drifts from the latest EAS CLI and bloats installs",
+		help: "Remove `eas-cli` from your dependencies and run it on demand with `npx eas-cli` (or install it globally)"
+	},
+	{
+		packageName: "expo-modules-autolinking",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-modules-autolinking\" should not be a direct dependency — Expo installs it transitively as needed",
+		help: "Remove `expo-modules-autolinking` from your package.json"
+	},
+	{
+		packageName: "expo-dev-launcher",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-dev-launcher\" should not be a direct dependency — it is pulled in by `expo-dev-client`",
+		help: "Remove `expo-dev-launcher` and depend on `expo-dev-client` instead"
+	},
+	{
+		packageName: "expo-dev-menu",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-dev-menu\" should not be a direct dependency — it is pulled in by `expo-dev-client`",
+		help: "Remove `expo-dev-menu` and depend on `expo-dev-client` instead"
+	},
+	{
+		packageName: "expo-modules-core",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-modules-core\" should not be a direct dependency — use the API re-exported from the `expo` package",
+		help: "Remove `expo-modules-core` from your package.json and import from `expo` instead"
+	},
+	{
+		packageName: "@expo/metro-config",
+		rule: "expo-no-redundant-dependency",
+		message: "\"@expo/metro-config\" should not be a direct dependency — use the `expo/metro-config` sub-export of the `expo` package",
+		help: "Remove `@expo/metro-config` and import `expo/metro-config` in your metro.config.js"
+	},
+	{
+		packageName: "@types/react-native",
+		rule: "expo-no-redundant-dependency",
+		message: "\"@types/react-native\" should not be installed — React Native ships its own types since SDK 48",
+		help: "Remove `@types/react-native` from your package.json",
+		minSdkMajor: 48
+	},
+	{
+		packageName: "@expo/config-plugins",
+		rule: "expo-no-redundant-dependency",
+		message: "\"@expo/config-plugins\" should not be a direct dependency — use the `expo/config-plugins` sub-export of the `expo` package",
+		help: "Remove `@expo/config-plugins`; config-plugin authors should import from `expo/config-plugins`. See https://github.com/expo/expo/pull/18855",
+		minSdkMajor: 48
+	},
+	{
+		packageName: "@expo/prebuild-config",
+		rule: "expo-no-redundant-dependency",
+		message: "\"@expo/prebuild-config\" should not be a direct dependency — Expo installs it transitively",
+		help: "Remove `@expo/prebuild-config` from your package.json",
+		minSdkMajor: 53
+	},
+	{
+		packageName: "expo-permissions",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-permissions\" was deprecated in SDK 41 and may no longer compile — permissions moved onto each module (e.g. `MediaLibrary.requestPermissionsAsync()`)",
+		help: "Remove `expo-permissions` and request permissions from the relevant module instead",
+		minSdkMajor: 50
+	},
+	{
+		packageName: "expo-app-loading",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-app-loading\" was removed in SDK 49",
+		help: "Remove `expo-app-loading` and use `expo-splash-screen` instead. See https://docs.expo.dev/versions/latest/sdk/splash-screen/",
+		minSdkMajor: 49
+	},
+	{
+		packageName: "expo-firebase-analytics",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-firebase-analytics\" was removed in SDK 48",
+		help: FIREBASE_HELP,
+		minSdkMajor: 48
+	},
+	{
+		packageName: "expo-firebase-recaptcha",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-firebase-recaptcha\" was removed in SDK 48",
+		help: FIREBASE_HELP,
+		minSdkMajor: 48
+	},
+	{
+		packageName: "expo-firebase-core",
+		rule: "expo-no-redundant-dependency",
+		message: "\"expo-firebase-core\" was removed in SDK 48",
+		help: FIREBASE_HELP,
+		minSdkMajor: 48
+	}
+];
+const checkExpoFlaggedDependencies = (context) => FLAGGED_DEPENDENCIES.filter((flaggedDependency) => {
+	if (!context.directDependencyNames.has(flaggedDependency.packageName)) return false;
+	if (flaggedDependency.minSdkMajor === void 0) return true;
+	return isExpoSdkAtLeast(context.expoSdkMajor, flaggedDependency.minSdkMajor);
+}).map((flaggedDependency) => buildExpoDiagnostic({
+	rule: flaggedDependency.rule,
+	message: flaggedDependency.message,
+	help: flaggedDependency.help
+}));
+const findLocalModuleNativeFiles = (rootDirectory) => {
+	const modulesDirectory = path.join(rootDirectory, "modules");
+	if (!isDirectory(modulesDirectory)) return [];
+	const nativeFilePaths = [];
+	for (const moduleEntry of readDirectoryEntries(modulesDirectory)) {
+		if (!moduleEntry.isDirectory()) continue;
+		const moduleDirectory = path.join(modulesDirectory, moduleEntry.name);
+		const gradlePath = path.join(moduleDirectory, "android", "build.gradle");
+		if (isFile(gradlePath)) nativeFilePaths.push(gradlePath);
+		const iosDirectory = path.join(moduleDirectory, "ios");
+		if (isDirectory(iosDirectory)) {
+			for (const iosEntry of readDirectoryEntries(iosDirectory)) if (iosEntry.isFile() && iosEntry.name.endsWith(".podspec")) nativeFilePaths.push(path.join(iosDirectory, iosEntry.name));
+		}
+	}
+	return nativeFilePaths;
+};
+const checkExpoGitignore = (context) => {
+	const { rootDirectory } = context;
+	const diagnostics = [];
+	const expoStateDirectory = path.join(rootDirectory, ".expo");
+	if (isDirectory(expoStateDirectory) && isPathGitIgnored(rootDirectory, expoStateDirectory) === false) diagnostics.push(buildExpoDiagnostic({
+		rule: "expo-gitignore",
+		message: "The `.expo` directory is not ignored by Git — it holds machine-specific device history and dev-server settings that should not be committed",
+		help: "Add `.expo/` to your .gitignore"
+	}));
+	if (findLocalModuleNativeFiles(rootDirectory).find((nativeFilePath) => isPathGitIgnored(rootDirectory, nativeFilePath) === true) !== void 0) diagnostics.push(buildExpoDiagnostic({
+		rule: "expo-gitignore",
+		message: "The native `ios`/`android` directories of a local Expo module under `modules/` are gitignored — usually caused by an overly broad `ios`/`android` ignore rule",
+		help: "Use anchored patterns like `/ios` and `/android` in .gitignore so only the top-level native directories are excluded, not those inside `modules/`"
+	}));
+	return diagnostics;
+};
+const LOCKFILE_NAMES = [
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"package-lock.json",
+	"bun.lockb",
+	"bun.lock"
+];
+const checkExpoLockfile = (context) => {
+	const workspaceRoot = isMonorepoRoot(context.rootDirectory) ? context.rootDirectory : findMonorepoRoot(context.rootDirectory) ?? context.rootDirectory;
+	const presentLockfiles = LOCKFILE_NAMES.filter((lockfileName) => isFile(path.join(workspaceRoot, lockfileName)));
+	if (presentLockfiles.length === 0) return [buildExpoDiagnostic({
+		rule: "expo-lockfile",
+		message: "No lock file detected at the project root — installs are not reproducible, and EAS Build cannot infer your package manager",
+		help: "Install dependencies with your package manager to generate a lock file, then commit it"
+	})];
+	if (presentLockfiles.length > 1) return [buildExpoDiagnostic({
+		rule: "expo-lockfile",
+		message: `Multiple lock files detected (${presentLockfiles.join(", ")}) — CI environments such as EAS Build infer the package manager from the lock file, so this is ambiguous`,
+		help: "Delete the lock files for the package managers you are not using and keep only one"
+	})];
+	return [];
+};
+const METRO_CONFIG_FILE_NAMES = [
+	"metro.config.js",
+	"metro.config.cjs",
+	"metro.config.mjs",
+	"metro.config.ts"
+];
+const EXPO_METRO_CONFIG_EXTEND_SIGNALS = [
+	"expo/metro-config",
+	"@sentry/react-native/metro",
+	"getSentryExpoConfig"
+];
+const checkExpoMetroConfig = (context) => {
+	const metroConfigPath = METRO_CONFIG_FILE_NAMES.map((fileName) => path.join(context.rootDirectory, fileName)).find((candidatePath) => isFile(candidatePath));
+	if (metroConfigPath === void 0) return [];
+	let contents;
+	try {
+		contents = fs.readFileSync(metroConfigPath, "utf-8");
+	} catch {
+		return [];
+	}
+	if (EXPO_METRO_CONFIG_EXTEND_SIGNALS.some((signal) => contents.includes(signal))) return [];
+	return [buildExpoDiagnostic({
+		rule: "expo-metro-config",
+		filePath: path.basename(metroConfigPath),
+		message: "Your metro.config does not extend `expo/metro-config` — a custom Metro config that doesn't extend Expo's leads to unexpected, hard-to-debug bundling issues",
+		help: "Update your metro config to extend `expo/metro-config`. See https://docs.expo.dev/guides/customizing-metro/"
+	})];
+};
+const CONFLICTING_SCRIPT_NAMES = ["expo", "react-native"];
+const checkExpoPackageJsonConflicts = (context) => {
+	const { packageJson } = context;
+	const diagnostics = [];
+	const conflictingScriptNames = CONFLICTING_SCRIPT_NAMES.filter((scriptName) => Boolean(packageJson.scripts?.[scriptName]));
+	if (conflictingScriptNames.length > 0) {
+		const quotedNames = conflictingScriptNames.map((name) => `"${name}"`).join(", ");
+		const shadowsExpoCli = conflictingScriptNames.includes("expo");
+		diagnostics.push(buildExpoDiagnostic({
+			rule: "expo-package-json-conflict",
+			message: `package.json defines ${quotedNames} ${conflictingScriptNames.length === 1 ? "as a script that conflicts" : "as scripts that conflict"} with binaries in node_modules/.bin${shadowsExpoCli ? " — a `expo` script shadows the Expo CLI and will likely cause build failures" : ""}`,
+			help: "Rename these scripts so they don't collide with the `expo` / `react-native` binaries"
+		}));
+	}
+	const packageName = packageJson.name;
+	if (typeof packageName === "string" && context.directDependencyNames.has(packageName)) diagnostics.push(buildExpoDiagnostic({
+		rule: "expo-package-json-conflict",
+		message: `package.json "name" is "${packageName}", which collides with a dependency of the same name`,
+		help: "Rename your package so it no longer matches one of its dependencies"
+	}));
+	return diagnostics;
+};
+const EXPO_ROUTER_REACT_NAVIGATION_MIN_SDK_MAJOR = 56;
+const EXPO_ROUTER_REACT_NAVIGATION_MAX_SDK_MAJOR_EXCLUSIVE = 57;
+const checkExpoRouterReactNavigation = (context) => {
+	const { expoSdkMajor } = context;
+	if (!isExpoSdkAtLeast(expoSdkMajor, EXPO_ROUTER_REACT_NAVIGATION_MIN_SDK_MAJOR)) return [];
+	if (expoSdkMajor !== null && expoSdkMajor >= EXPO_ROUTER_REACT_NAVIGATION_MAX_SDK_MAJOR_EXCLUSIVE) return [];
+	if (!context.directDependencyNames.has("expo-router")) return [];
+	const reactNavigationNames = [...context.directDependencyNames].filter((packageName) => packageName.startsWith("@react-navigation/")).sort();
+	if (reactNavigationNames.length === 0) return [];
+	return [buildExpoDiagnostic({
+		rule: "expo-router-no-react-navigation",
+		message: `As of SDK 56, expo-router is no longer compatible with react-navigation, but ${reactNavigationNames.map((name) => `"${name}"`).join(", ")} ${reactNavigationNames.length === 1 ? "is" : "are"} installed as direct ${reactNavigationNames.length === 1 ? "dependency" : "dependencies"}`,
+		help: "Remove these `@react-navigation/*` packages and replace direct imports with their expo-router equivalents. See https://docs.expo.dev/router/migrate/sdk-55-to-56/"
+	})];
+};
+const VECTOR_ICONS_MIN_SDK_MAJOR = 56;
+const SCOPED_VECTOR_ICONS_NAMESPACE = "@react-native-vector-icons/";
+const CONFLICTING_VECTOR_ICONS_PACKAGES = ["@expo/vector-icons", "react-native-vector-icons"];
+const checkExpoVectorIcons = (context) => {
+	if (!isExpoSdkAtLeast(context.expoSdkMajor, VECTOR_ICONS_MIN_SDK_MAJOR)) return [];
+	const hasScopedPackage = [...context.directDependencyNames].some((packageName) => packageName.startsWith(SCOPED_VECTOR_ICONS_NAMESPACE));
+	const hasConflictingPackage = CONFLICTING_VECTOR_ICONS_PACKAGES.some((packageName) => context.directDependencyNames.has(packageName));
+	if (!hasScopedPackage || !hasConflictingPackage) return [];
+	return [buildExpoDiagnostic({
+		rule: "expo-vector-icons-conflict",
+		message: "This project installs both the scoped `@react-native-vector-icons/*` packages and `@expo/vector-icons` (or the deprecated `react-native-vector-icons`) — mixing them causes icon-rendering conflicts",
+		help: "Migrate to the scoped packages by running `npx @react-native-vector-icons/codemod`, then remove the conflicting package"
+	})];
+};
+const checkExpoProject = (rootDirectory, project) => {
+	if (project.expoVersion === null) return [];
+	const context = buildExpoCheckContext(rootDirectory, project.expoVersion);
+	return [
+		...checkExpoFlaggedDependencies(context),
+		...checkExpoDependencyOverrides(context),
+		...checkExpoRouterReactNavigation(context),
+		...checkExpoVectorIcons(context),
+		...checkExpoPackageJsonConflicts(context),
+		...checkExpoLockfile(context),
+		...checkExpoGitignore(context),
+		...checkExpoEnvLocalFiles(context),
+		...checkExpoMetroConfig(context)
+	];
+};
 const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
 const PNPM_LOCKFILE = "pnpm-lock.yaml";
 const PACKAGE_JSON_FILE = "package.json";
@@ -8158,8 +8735,8 @@ var Config = class Config extends Context.Service()("react-doctor/Config") {
 		const cache = yield* Cache.make({
 			capacity: 16,
 			timeToLive: CONFIG_CACHE_TTL_MS,
-			lookup: (directory) => Effect.sync(() => {
-				const loaded = loadConfigWithSource(directory);
+			lookup: (directory) => Effect.promise(async () => {
+				const loaded = await loadConfigWithSource(directory);
 				const redirected = resolveConfigRootDir(loaded?.config ?? null, loaded?.sourceDirectory ?? null);
 				return {
 					config: loaded?.config ?? null,
@@ -8756,6 +9333,7 @@ const buildCapabilities = (project) => {
 	const capabilities = /* @__PURE__ */ new Set();
 	capabilities.add(project.framework);
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
+	if (project.expoVersion !== null) capabilities.add("expo");
 	const reactMajor = project.reactMajorVersion;
 	if (reactMajor !== null) {
 		const cappedReactMajor = Math.min(reactMajor, 30);
@@ -8927,10 +9505,14 @@ const resolveSettingsRootDirectory = (rootDirectory) => {
 	if (!fs.existsSync(rootDirectory)) return rootDirectory;
 	return fs.realpathSync(rootDirectory);
 };
+const resolveCompilerCleanupBucketSeverity = (ruleKey, severityControls) => {
+	if (!COMPILER_CLEANUP_RULE_KEYS.has(ruleKey)) return void 0;
+	return severityControls?.buckets?.[COMPILER_CLEANUP_BUCKET];
+};
 const applyRuleSeverityControls = (rules, severityControls) => {
 	const enabledRules = {};
 	for (const [ruleKey, defaultSeverity] of Object.entries(rules)) {
-		const severity = resolveRuleSeverityOverride({ ruleKey }, severityControls) ?? defaultSeverity;
+		const severity = resolveRuleSeverityOverride({ ruleKey }, severityControls) ?? resolveCompilerCleanupBucketSeverity(ruleKey, severityControls) ?? defaultSeverity;
 		if (severity === "off") continue;
 		enabledRules[ruleKey] = severity;
 	}
@@ -8972,7 +9554,7 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 			category: rule.category
 		}, severityControls);
 		if (rule.defaultEnabled === false && explicitSeverity === void 0) continue;
-		const severity = explicitSeverity ?? rule.severity;
+		const severity = explicitSeverity ?? resolveCompilerCleanupBucketSeverity(registryEntry.key, severityControls) ?? rule.severity;
 		if (severity === "off") continue;
 		enabledReactDoctorRules[registryEntry.key] = severity;
 	}
@@ -9029,6 +9611,44 @@ const dedupeDiagnostics = (diagnostics) => {
 	}
 	return uniqueDiagnostics;
 };
+/**
+* Runs `task` over `items` with at most `concurrency` tasks in flight at
+* once, returning results in input order. A pool of workers each pulls the
+* next not-yet-started index until the list drains — so a worker that
+* finishes a fast task immediately picks up the next one (greedy load
+* balancing), which matters when tasks have uneven durations (oxlint
+* batches do).
+*
+* Failure semantics mirror a bounded `Promise.all`: on the first rejection
+* no further tasks are started, the already-in-flight tasks are awaited to
+* settle (so no subprocess is orphaned mid-write), and the returned promise
+* rejects with that first error. This keeps the caller's fail-fast retry
+* path (e.g. oxlint's retry-without-extends) from spawning a second wave on
+* top of a still-running first one.
+*/
+const mapWithConcurrency = async (items, concurrency, task) => {
+	const results = new Array(items.length);
+	if (items.length === 0) return results;
+	const workerCount = Math.min(Math.max(1, Math.floor(concurrency) || 1), items.length);
+	let nextIndex = 0;
+	const errors = [];
+	const runWorker = async () => {
+		while (errors.length === 0) {
+			const index = nextIndex;
+			nextIndex += 1;
+			if (index >= items.length) return;
+			try {
+				results[index] = await task(items[index], index);
+			} catch (error) {
+				errors.push(error);
+				return;
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: workerCount }, runWorker));
+	if (errors.length > 0) throw errors[0];
+	return results;
+};
 const getPublicEnvPrefix = (framework) => {
 	switch (framework) {
 		case "nextjs": return "NEXT_PUBLIC_*";
@@ -9711,6 +10331,7 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath, spawnTimeoutMs = OXLIN
 */
 const spawnLintBatches = async (input) => {
 	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes } = input;
+	const concurrency = resolveScanConcurrency(input.concurrency ?? 1);
 	const totalFileCount = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
 	const allDiagnostics = [];
 	const droppedFiles = [];
@@ -9730,23 +10351,31 @@ const spawnLintBatches = async (input) => {
 			return [...await spawnLintBatch(batch.slice(0, splitIndex)), ...await spawnLintBatch(batch.slice(splitIndex))];
 		}
 	};
+	let startedFileCount = 0;
 	let scannedFileCount = 0;
-	for (const batch of fileBatches) {
-		let batchFileIndex = 0;
-		const progressInterval = onFileProgress && batch.length > 1 ? setInterval(() => {
-			if (batchFileIndex < batch.length) {
-				batchFileIndex += 1;
-				onFileProgress(scannedFileCount + batchFileIndex, totalFileCount);
-			}
-		}, 50) : null;
-		try {
+	let displayedFileCount = 0;
+	const progressTimer = onFileProgress && totalFileCount > 1 ? setInterval(() => {
+		const ceiling = Math.min(startedFileCount, totalFileCount - 1);
+		if (displayedFileCount < ceiling) {
+			displayedFileCount += 1;
+			onFileProgress(displayedFileCount, totalFileCount);
+		}
+	}, 50) : null;
+	progressTimer?.unref?.();
+	try {
+		const batchResults = await mapWithConcurrency(fileBatches, concurrency, async (batch) => {
+			startedFileCount += batch.length;
 			const batchDiagnostics = await spawnLintBatch(batch);
-			allDiagnostics.push(...batchDiagnostics);
 			scannedFileCount += batch.length;
-			onFileProgress?.(scannedFileCount, totalFileCount);
-		} finally {
-			if (progressInterval !== null) clearInterval(progressInterval);
-		}
+			if (onFileProgress) {
+				displayedFileCount = Math.min(Math.max(displayedFileCount, scannedFileCount), totalFileCount);
+				onFileProgress(displayedFileCount, totalFileCount);
+			}
+			return batchDiagnostics;
+		});
+		for (const batchDiagnostics of batchResults) allDiagnostics.push(...batchDiagnostics);
+	} finally {
+		if (progressTimer !== null) clearInterval(progressTimer);
 	}
 	if (droppedFiles.length > 0 && onPartialFailure) {
 		const previewFiles = droppedFiles.slice(0, 3).join(", ");
@@ -9873,7 +10502,8 @@ const runOxlint = async (options) => {
 			onPartialFailure,
 			onFileProgress: options.onFileProgress,
 			spawnTimeoutMs,
-			outputMaxBytes
+			outputMaxBytes,
+			concurrency: options.concurrency
 		});
 		writeOxlintConfig(configPath, buildConfig(extendsPaths));
 		try {
@@ -9941,6 +10571,7 @@ var Linter = class Linter extends Context.Service()("react-doctor/Linter") {
 		const partialFailures = yield* LintPartialFailures;
 		const spawnTimeoutMs = yield* OxlintSpawnTimeoutMs;
 		const outputMaxBytes = yield* OxlintOutputMaxBytes;
+		const concurrency = yield* OxlintConcurrency;
 		const collectedFailures = [];
 		const diagnostics = yield* Effect.tryPromise({
 			try: () => runOxlint({
@@ -9959,7 +10590,8 @@ var Linter = class Linter extends Context.Service()("react-doctor/Linter") {
 				},
 				onFileProgress: input.onFileProgress,
 				spawnTimeoutMs,
-				outputMaxBytes
+				outputMaxBytes,
+				concurrency
 			}),
 			catch: ensureReactDoctorError
 		});
@@ -10283,7 +10915,7 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	const afterLint = hooks.afterLint ?? NO_HOOKS.afterLint;
 	yield* beforeLint(project, lintIncludePaths ?? void 0);
 	const isDiffMode = input.includePaths.length > 0;
-	const showWarnings = input.warnings ?? resolvedConfig.config?.warnings ?? false;
+	const showWarnings = input.warnings ?? resolvedConfig.config?.warnings ?? true;
 	const transform = buildDiagnosticPipeline({
 		rootDirectory: scanDirectory,
 		userConfig: resolvedConfig.config,
@@ -10292,7 +10924,11 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		showWarnings
 	});
 	const applyPerElementPipeline = (rawStream) => rawStream.pipe(Stream.filterMap(filterMapNullable(transform.apply)), Stream.tap((diagnostic) => reporterService.emit(diagnostic)));
-	const environmentDiagnostics = isDiffMode ? [] : [...checkReducedMotion(scanDirectory), ...checkPnpmHardening(scanDirectory)];
+	const environmentDiagnostics = isDiffMode ? [] : [
+		...checkReducedMotion(scanDirectory),
+		...checkPnpmHardening(scanDirectory),
+		...checkExpoProject(scanDirectory, project)
+	];
 	const envCollected = yield* Stream.runCollect(applyPerElementPipeline(Stream.fromIterable(environmentDiagnostics)));
 	const lintFailure = yield* Ref.make({
 		didFail: false,
@@ -10304,6 +10940,8 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		didFail: false,
 		reason: null
 	});
+	const scanConcurrency = yield* OxlintConcurrency;
+	const workerCountSuffix = scanConcurrency > 1 ? ` · ${scanConcurrency} workers` : "";
 	const scanProgress = yield* progressService.start("Scanning...");
 	const scanStartTime = Date.now();
 	let lastReportedTotalFileCount = 0;
@@ -10320,7 +10958,7 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		configSourceDirectory: resolvedConfig.configSourceDirectory ?? void 0,
 		onFileProgress: (scannedFileCount, totalFileCount) => {
 			lastReportedTotalFileCount = totalFileCount;
-			Effect.runSync(scanProgress.update(`Scanning files (${scannedFileCount}/${totalFileCount})...`));
+			Effect.runSync(scanProgress.update(`Scanning files (${scannedFileCount}/${totalFileCount})${workerCountSuffix}...`));
 		}
 	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
 		yield* Ref.set(lintFailure, {
@@ -10352,7 +10990,7 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	const totalFileCount = lastReportedTotalFileCount || (lintIncludePaths?.length ?? project.sourceFileCount);
 	if (!lintFailureState.didFail) if (deadCodeFailureState.didFail) yield* scanProgress.fail(DEAD_CODE_FAIL_TEXT);
 	else if (input.suppressScanSummary) yield* scanProgress.stop();
-	else yield* scanProgress.succeed(`Scanned ${totalFileCount} ${totalFileCount === 1 ? "file" : "files"} in ${scanElapsedSeconds}s`);
+	else yield* scanProgress.succeed(`Scanned ${totalFileCount} ${totalFileCount === 1 ? "file" : "files"} in ${scanElapsedSeconds}s${workerCountSuffix}`);
 	yield* reporterService.finalize;
 	const finalDiagnostics = [
 		...envCollected,
@@ -10404,7 +11042,6 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	"inspect.isCi": input.isCi,
 	"inspect.scoreSurface": input.scoreSurface ?? "score"
 } }));
-Layer.mergeAll(Project.layerNode, Config.layerNode, DeadCode.layerNode, Files.layerNode, Git.layerNode, Linter.layerOxlint, LintPartialFailures.layerLive, Progress.layerNoop, Reporter.layerNoop, Score.layerHttp);
 const parseNodeVersion = (versionString) => {
 	const [major = 0, minor = 0, patch = 0] = versionString.replace(/^v/, "").trim().split(".").map(Number);
 	return {
@@ -10727,6 +11364,26 @@ const buildJsonReport = (input) => {
 	};
 };
 /**
+* Single source of truth for the skipped-check accounting shared by the
+* CLI renderer (`react-doctor/src/inspect.ts → finalizeAndRender`) and the
+* programmatic shell (`@react-doctor/api → diagnose()`). Both surface a
+* failed lint / dead-code pass instead of a false "all clear", so the
+* branch logic lives here once.
+*/
+const buildSkippedChecks = (input) => {
+	const skippedChecks = [];
+	if (input.didLintFail) skippedChecks.push("lint");
+	if (input.didDeadCodeFail) skippedChecks.push("dead-code");
+	const skippedCheckReasons = {};
+	if (input.didLintFail && input.lintFailureReason !== null) skippedCheckReasons.lint = input.lintFailureReason;
+	else if (input.lintPartialFailures.length > 0) skippedCheckReasons["lint:partial"] = input.lintPartialFailures.join("; ");
+	if (input.didDeadCodeFail && input.deadCodeFailureReason !== null) skippedCheckReasons["dead-code"] = input.deadCodeFailureReason;
+	return {
+		skippedChecks,
+		skippedCheckReasons
+	};
+};
+/**
 * Programmatic façade over `Git.diffSelection`. Async because the
 * Git service runs through Effect's `ChildProcess` (true subprocess
 * spawn, not `spawnSync`).
@@ -10831,12 +11488,32 @@ const highlighter = {
 	bold: import_picocolors.default.bold
 };
 /**
-* Canonical URL for a rule's reviewer-tested fix recipe, served at
-* `https://www.react.doctor/prompts/rules/<plugin>/<rule>.md`. The
-* `/doctor` playbook fetches it on demand so each fix follows the
-* canonical recipe instead of being improvised per diagnostic.
+* Override picocolors' automatic color detection. picocolors decides
+* once, at import time, from `NO_COLOR` / `FORCE_COLOR` / `TERM` / TTY.
+* This lets the CLI honor an explicit `--color` / `--no-color` flag
+* (clig.dev, Output: "Disable color … if the user requested it") by
+* swapping in a fresh set of formatters. Call it before any colored
+* output is produced. Every call site reads `highlighter.<method>` at
+* call time, so reassigning the properties propagates everywhere.
+*/
+const setColorEnabled = (enabled) => {
+	const colors = import_picocolors.default.createColors(enabled);
+	highlighter.error = colors.red;
+	highlighter.warn = colors.yellow;
+	highlighter.info = colors.cyan;
+	highlighter.success = colors.green;
+	highlighter.dim = colors.dim;
+	highlighter.gray = colors.gray;
+	highlighter.bold = colors.bold;
+};
+/**
+* Canonical URL for a rule's documentation page — its reviewer-tested fix
+* recipe rendered for humans — served at
+* `https://www.react.doctor/docs/rules/<plugin>/<rule>`. The CLI links here
+* from its fix-recipe directive so each fix follows the canonical recipe
+* instead of being improvised per diagnostic.
 */
-const buildRulePromptUrl = (plugin, rule) => `${PROMPTS_RULES_BASE_URL}/${plugin}/${rule}.md`;
+const buildRuleDocsUrl = (plugin, rule) => `${DOCS_RULES_BASE_URL}/${plugin}/${rule}`;
 const groupBy = (items, keyFn) => {
 	const groups = /* @__PURE__ */ new Map();
 	for (const item of items) {
@@ -10849,8 +11526,8 @@ const groupBy = (items, keyFn) => {
 };
 /**
 * Whether a diagnostic's rule has a published per-rule fix recipe at
-* `${PROMPTS_RULES_BASE_URL}/react-doctor/<rule>.md`
-* (see `buildRulePromptUrl`).
+* `${DOCS_RULES_BASE_URL}/react-doctor/<rule>`
+* (see `buildRuleDocsUrl`).
 *
 * Recipes are generated from react-doctor's own engine rules, so only
 * those resolve. Dead-code (`deslop`), the synthetic environment and
@@ -10862,6 +11539,46 @@ const groupBy = (items, keyFn) => {
 */
 const hasPublishedFixRecipe = (diagnostic) => diagnostic.plugin === "react-doctor" && Object.hasOwn(reactDoctorPlugin.rules, diagnostic.rule);
 //#endregion
+//#region src/cli/utils/constants.ts
+const STAGED_FILES_TEMP_DIR_PREFIX = "react-doctor-staged-";
+const INTERNAL_ERROR_JSON_FALLBACK = "{\"schemaVersion\":1,\"ok\":false,\"error\":{\"message\":\"Internal error\",\"name\":\"Error\",\"chain\":[]}}\n";
+const SENTRY_DSN = "https://f253d570240a59b8dbd77b7a548ef133@o4510226365743104.ingest.us.sentry.io/4511487817809920";
+//#endregion
+//#region src/cli/utils/version.ts
+const VERSION = "0.2.14-dev.9777f1a";
+//#endregion
+//#region src/instrument.ts
+let isInitialized = false;
+const shouldEnableSentry = () => {
+	if (process.argv.includes("--no-score") || process.argv.includes("--no-telemetry")) return false;
+	if (process.env.VITEST || process.env.NODE_ENV === "test") return false;
+	return true;
+};
+/**
+* Initializes the Sentry Node SDK for CLI crash reporting. Invoked as
+* the first statement of the CLI entry (`cli/index.ts`) so the SDK's
+* global `uncaughtException` / `unhandledRejection` handlers are armed
+* before any command runs.
+*
+* Exported as a function rather than a bare side-effecting import
+* because the package declares `"sideEffects": false`, which lets the
+* bundler tree-shake side-effect-only modules. An explicit call keeps
+* the initialization in the published `dist/cli.js`.
+*
+* Scoped to the CLI application only — the programmatic
+* `@react-doctor/api` library never initializes Sentry, so importing
+* `diagnose()` into a consumer app can't hijack their telemetry.
+*/
+const initializeSentry = () => {
+	if (isInitialized || !shouldEnableSentry()) return;
+	isInitialized = true;
+	Sentry.init({
+		dsn: SENTRY_DSN,
+		sendDefaultPii: true,
+		release: VERSION
+	});
+};
+//#endregion
 //#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 const ANSI_BACKGROUND_OFFSET = 10;
 const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
@@ -13815,23 +14532,60 @@ const CI_ENVIRONMENT_VARIABLES = [
 	"GITLAB_CI",
 	"CIRCLECI"
 ];
-const CODING_AGENT_ENVIRONMENT_VARIABLES = [
-	"CLAUDECODE",
-	"CLAUDE_CODE",
-	"CURSOR_AGENT",
-	"CODEX_CI",
-	"CODEX_SANDBOX",
-	"CODEX_SANDBOX_NETWORK_DISABLED",
-	"OPENCODE",
-	"GOOSE_TERMINAL",
-	"AGENT_SESSION_ID",
-	"AMP_THREAD_ID",
-	"AGENT_THREAD_ID"
+const CI_PROVIDER_BY_ENVIRONMENT_VARIABLE = [
+	["GITHUB_ACTIONS", "github-actions"],
+	["GITLAB_CI", "gitlab-ci"],
+	["CIRCLECI", "circleci"],
+	["BUILDKITE", "buildkite"],
+	["JENKINS_URL", "jenkins"],
+	["TF_BUILD", "azure-pipelines"],
+	["CODEBUILD_BUILD_ID", "aws-codebuild"],
+	["TEAMCITY_VERSION", "teamcity"],
+	["BITBUCKET_BUILD_NUMBER", "bitbucket"],
+	["TRAVIS", "travis"],
+	["DRONE", "drone"]
+];
+const CODING_AGENT_BY_ENVIRONMENT_VARIABLE = [
+	["CLAUDECODE", "claude-code"],
+	["CLAUDE_CODE", "claude-code"],
+	["CURSOR_AGENT", "cursor"],
+	["CODEX_CI", "codex"],
+	["CODEX_SANDBOX", "codex"],
+	["CODEX_SANDBOX_NETWORK_DISABLED", "codex"],
+	["OPENCODE", "opencode"],
+	["GOOSE_TERMINAL", "goose"],
+	["AMP_THREAD_ID", "amp"]
 ];
+const GENERIC_CODING_AGENT_ENVIRONMENT_VARIABLES = ["AGENT_SESSION_ID", "AGENT_THREAD_ID"];
 const CODING_AGENT_ENVIRONMENT_VALUE_VARIABLES = ["AGENT"];
 const CODING_AGENT_ENVIRONMENT_VALUES = { AGENT: ["amp", "goose"] };
-const isCiEnvironment = () => CI_ENVIRONMENT_VARIABLES.some((envVariable) => Boolean(process.env[envVariable])) || process.env.CI === "true";
-const isCodingAgentEnvironment = () => CODING_AGENT_ENVIRONMENT_VARIABLES.some((envVariable) => Boolean(process.env[envVariable])) || CODING_AGENT_ENVIRONMENT_VALUE_VARIABLES.some((envVariable) => CODING_AGENT_ENVIRONMENT_VALUES[envVariable].some((value) => process.env[envVariable]?.toLowerCase() === value));
+[...CODING_AGENT_BY_ENVIRONMENT_VARIABLE.map(([environmentVariable]) => environmentVariable), ...GENERIC_CODING_AGENT_ENVIRONMENT_VARIABLES];
+const FALSY_CI_FLAG_VALUES = new Set([
+	"",
+	"0",
+	"false"
+]);
+const isCiFlagSet = (value) => value !== void 0 && !FALSY_CI_FLAG_VALUES.has(value.toLowerCase());
+const isCiEnvironment = () => CI_ENVIRONMENT_VARIABLES.some((environmentVariable) => Boolean(process.env[environmentVariable])) || isCiFlagSet(process.env.CI);
+const detectCiProvider = () => {
+	for (const [environmentVariable, provider] of CI_PROVIDER_BY_ENVIRONMENT_VARIABLE) if (process.env[environmentVariable]) return provider;
+	return isCiFlagSet(process.env.CI) ? "unknown" : null;
+};
+const detectCodingAgentFromValue = () => {
+	for (const environmentVariable of CODING_AGENT_ENVIRONMENT_VALUE_VARIABLES) {
+		const value = process.env[environmentVariable]?.toLowerCase();
+		if (value && CODING_AGENT_ENVIRONMENT_VALUES[environmentVariable].includes(value)) return value;
+	}
+	return null;
+};
+const detectCodingAgent = () => {
+	for (const [environmentVariable, agent] of CODING_AGENT_BY_ENVIRONMENT_VARIABLE) if (process.env[environmentVariable]) return agent;
+	const agentFromValue = detectCodingAgentFromValue();
+	if (agentFromValue) return agentFromValue;
+	if (GENERIC_CODING_AGENT_ENVIRONMENT_VARIABLES.some((environmentVariable) => process.env[environmentVariable])) return "unknown";
+	return null;
+};
+const isCodingAgentEnvironment = () => detectCodingAgent() !== null;
 const isCiOrCodingAgentEnvironment = () => isCiEnvironment() || isCodingAgentEnvironment();
 //#endregion
 //#region src/cli/utils/is-non-interactive-environment.ts
@@ -13933,9 +14687,8 @@ const buildSpinnerProgressHandle = (text) => {
 * construction and post-scan rendering — layer wiring is its own
 * concern with its own contract.
 *
-* Same shape as `core/src/run-inspect.ts → layerInspectLive`
-* (the default for `@react-doctor/api → diagnose()`) with the
-* differences specific to the CLI path:
+* Same service shape as `@react-doctor/api → diagnose()`'s
+* `buildDiagnoseLayer`, with the differences specific to the CLI path:
 *
 * - **Config**: when the caller passes `configOverride`, the
 *   already-loaded config is provided via `Config.layerOf` instead
@@ -13961,7 +14714,8 @@ const buildRuntimeLayers = (input) => {
 		resolvedDirectory: input.directory,
 		configSourceDirectory: input.configSourceDirectory
 	}) : Config.layerNode;
-	return Layer.mergeAll(Project.layerNode, configLayer, Files.layerNode, Git.layerNode, linterLayer, LintPartialFailures.layerLive, deadCodeLayer, progressLayer, Reporter.layerNoop, scoreLayer);
+	const baseLayers = Layer.mergeAll(Project.layerNode, configLayer, Files.layerNode, Git.layerNode, linterLayer, LintPartialFailures.layerLive, deadCodeLayer, progressLayer, Reporter.layerNoop, scoreLayer);
+	return input.oxlintConcurrency === void 0 ? baseLayers : Layer.mergeAll(baseLayers, Layer.succeed(OxlintConcurrency, input.oxlintConcurrency));
 };
 //#endregion
 //#region src/cli/utils/noop-console.ts
@@ -14048,8 +14802,10 @@ const compareByRulePriority = (ruleKeyA, ruleKeyB, rulePriority) => {
 	return priorityB - priorityA;
 };
 const sortRuleGroupsByImportance = (diagnosticGroups, rulePriority) => diagnosticGroups.toSorted(([ruleKeyA], [ruleKeyB]) => compareByRulePriority(ruleKeyA, ruleKeyB, rulePriority));
-const FETCH_FIX_RECIPE_LABEL = "Fetch & follow the canonical fix recipe before fixing";
-const formatFixRecipeLine = (diagnostic) => hasPublishedFixRecipe(diagnostic) ? `${FETCH_FIX_RECIPE_LABEL}: ${buildRulePromptUrl(diagnostic.plugin, diagnostic.rule)}` : null;
+const buildSortedRuleGroups = (diagnostics, rulePriority) => sortRuleGroupsByImportance([...groupBy([...diagnostics], (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`)], rulePriority);
+const FIX_RECIPE_DIRECTIVE_LABEL = "Curl with no cache & follow the canonical fix and false positive check recipe before fixing";
+const formatFixRecipeLine = (diagnostic) => hasPublishedFixRecipe(diagnostic) ? `${FIX_RECIPE_DIRECTIVE_LABEL}: ${buildRuleDocsUrl(diagnostic.plugin, diagnostic.rule)}` : null;
+const formatLearnMoreLine = (diagnostic) => hasPublishedFixRecipe(diagnostic) ? `Learn more: ${buildRuleDocsUrl(diagnostic.plugin, diagnostic.rule)}` : null;
 //#endregion
 //#region src/cli/utils/box-text.ts
 const ESCAPE = String.fromCharCode(27);
@@ -14180,15 +14936,17 @@ const buildVerboseSiteMap = (diagnostics) => {
 	return fileSites;
 };
 const formatSiteCountBadge = (count) => count > 1 ? `×${count}` : "";
+const formatTrailingSiteBadge = (count) => {
+	const badge = formatSiteCountBadge(count);
+	return badge.length > 0 ? ` ${highlighter.gray(badge)}` : "";
+};
 const categoryTopRuleKey = (categoryGroup) => categoryGroup.ruleGroups[0][0];
 const buildCategoryDiagnosticGroups = (diagnostics, rulePriority) => {
-	return [...groupBy(diagnostics, (diagnostic) => diagnostic.category).entries()].map(([category, categoryDiagnostics]) => {
-		return {
-			category,
-			diagnostics: categoryDiagnostics,
-			ruleGroups: sortRuleGroupsByImportance([...groupBy(categoryDiagnostics, (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`).entries()], rulePriority)
-		};
-	}).toSorted((categoryGroupA, categoryGroupB) => {
+	return [...groupBy(diagnostics, (diagnostic) => diagnostic.category).entries()].map(([category, categoryDiagnostics]) => ({
+		category,
+		diagnostics: categoryDiagnostics,
+		ruleGroups: buildSortedRuleGroups(categoryDiagnostics, rulePriority)
+	})).toSorted((categoryGroupA, categoryGroupB) => {
 		const priorityDelta = compareByRulePriority(categoryTopRuleKey(categoryGroupA), categoryTopRuleKey(categoryGroupB), rulePriority);
 		if (priorityDelta !== 0) return priorityDelta;
 		return categoryGroupA.category.localeCompare(categoryGroupB.category);
@@ -14204,6 +14962,7 @@ const buildCompactCategoryLine = (categoryGroup) => {
 };
 const TOP_ERROR_DETAIL_INDENT = "    ";
 const pickRepresentativeDiagnostic = (ruleDiagnostics) => ruleDiagnostics.find((diagnostic) => diagnostic.line > 0) ?? ruleDiagnostics[0];
+const isErrorRuleGroup = (ruleDiagnostics) => pickRepresentativeDiagnostic(ruleDiagnostics).severity === "error";
 const FRAME_CONTEXT_REACH_LINES = 3;
 const clusterNearbyDiagnostics = (diagnostics) => {
 	const byFile = groupBy(diagnostics, (diagnostic) => diagnostic.filePath);
@@ -14235,17 +14994,17 @@ const formatClusterLocation = (cluster) => {
 	if (cluster.endLine > cluster.startLine) return `${filePath}:${cluster.startLine}-${cluster.endLine}`;
 	return `${filePath}:${cluster.startLine}`;
 };
-const buildDiagnosticClusterLines = (cluster, resolveSourceRoot) => {
+const buildDiagnosticClusterLines = (cluster, resolveSourceRoot, renderCodeFrame) => {
 	const lead = cluster.diagnostics[0];
 	const isMultiSite = cluster.diagnostics.length > 1;
 	const lines = ["", highlighter.gray(`${TOP_ERROR_DETAIL_INDENT}${formatClusterLocation(cluster)}`)];
-	const codeFrame = buildCodeFrame({
+	const codeFrame = renderCodeFrame ? buildCodeFrame({
 		filePath: lead.filePath,
 		line: cluster.startLine,
 		column: isMultiSite ? 0 : lead.column,
 		endLine: isMultiSite ? cluster.endLine : void 0,
 		rootDirectory: resolveSourceRoot(lead)
-	});
+	}) : null;
 	if (codeFrame) lines.push(indentMultilineText(boxText(codeFrame, 60), TOP_ERROR_DETAIL_INDENT));
 	const seenHints = /* @__PURE__ */ new Set();
 	for (const diagnostic of cluster.diagnostics) if (diagnostic.suppressionHint && !seenHints.has(diagnostic.suppressionHint)) {
@@ -14257,23 +15016,60 @@ const buildDiagnosticClusterLines = (cluster, resolveSourceRoot) => {
 const buildRuleDetailBlock = (ruleKey, ruleDiagnostics, resolveSourceRoot, renderEverySite) => {
 	const representative = pickRepresentativeDiagnostic(ruleDiagnostics);
 	const { severity } = representative;
-	const siteCountBadge = formatSiteCountBadge(ruleDiagnostics.length);
-	const trailingBadge = siteCountBadge.length > 0 ? ` ${highlighter.gray(siteCountBadge)}` : "";
+	const trailingBadge = formatTrailingSiteBadge(ruleDiagnostics.length);
 	const headline = colorizeBySeverity(`${representative.category}: ${representative.title ?? ruleKey}`, severity);
 	const lines = [`  ${colorizeBySeverity(severity === "error" ? "✗" : "⚠", severity)} ${headline}${trailingBadge}`];
 	if (!renderEverySite) for (const explanationLine of wrapTextToWidth(representative.message, 60, { breakLongWords: false })) lines.push(`${TOP_ERROR_DETAIL_INDENT}${explanationLine}`);
 	if (representative.help) for (const fixLine of wrapTextToWidth(`→ ${representative.help}`, 60, { breakLongWords: false })) lines.push(highlighter.dim(`${TOP_ERROR_DETAIL_INDENT}${fixLine}`));
+	const renderCodeFrame = severity === "error";
 	const sites = renderEverySite ? ruleDiagnostics : [representative];
-	for (const cluster of clusterNearbyDiagnostics(sites)) lines.push(...buildDiagnosticClusterLines(cluster, resolveSourceRoot));
+	for (const cluster of clusterNearbyDiagnostics(sites)) lines.push(...buildDiagnosticClusterLines(cluster, resolveSourceRoot, renderCodeFrame));
+	return lines;
+};
+const WARNING_DETAIL_INDENT = "      ";
+const computeRuleNameColumnWidth = (ruleKeys) => ruleKeys.reduce((widest, ruleKey) => Math.max(widest, ruleKey.length), 36);
+const padRuleNameToColumn = (ruleName, columnWidth) => ruleName.length >= columnWidth ? ruleName : ruleName + " ".repeat(columnWidth - ruleName.length);
+const buildWarningHeaderLine = (ruleKey, siteCount, ruleNameColumnWidth) => {
+	const ruleName = formatSiteCountBadge(siteCount).length > 0 ? padRuleNameToColumn(ruleKey, ruleNameColumnWidth) : ruleKey;
+	return `  ${highlighter.warn("⚠")} ${ruleName}${formatTrailingSiteBadge(siteCount)}`;
+};
+const buildWarningRuleBlock = (ruleKey, ruleDiagnostics, ruleNameColumnWidth, isAgentEnvironment) => {
+	const representative = pickRepresentativeDiagnostic(ruleDiagnostics);
+	const lines = [buildWarningHeaderLine(ruleKey, ruleDiagnostics.length, ruleNameColumnWidth)];
+	if (!isAgentEnvironment) {
+		const learnMoreLine = formatLearnMoreLine(representative);
+		if (learnMoreLine) lines.push(`${WARNING_DETAIL_INDENT}${highlighter.info(learnMoreLine)}`);
+	}
+	lines.push(highlighter.gray(indentMultilineText(representative.message, WARNING_DETAIL_INDENT)));
+	if (representative.help) lines.push(highlighter.gray(indentMultilineText(`→ ${representative.help}`, WARNING_DETAIL_INDENT)));
+	if (isAgentEnvironment) {
+		const fixRecipeLine = formatFixRecipeLine(representative);
+		if (fixRecipeLine) lines.push(highlighter.gray(`${WARNING_DETAIL_INDENT}${fixRecipeLine}`));
+	}
+	for (const [filePath, sites] of buildVerboseSiteMap(ruleDiagnostics)) {
+		if (sites.length === 0) {
+			lines.push(highlighter.gray(`${WARNING_DETAIL_INDENT}${filePath}`));
+			continue;
+		}
+		for (const site of sites) {
+			lines.push(highlighter.gray(`${WARNING_DETAIL_INDENT}${filePath}:${site.line}`));
+			if (site.suppressionHint) lines.push(highlighter.gray(`${WARNING_DETAIL_INDENT}  ↳ ${site.suppressionHint}`));
+		}
+	}
 	return lines;
 };
-const selectTopErrorRuleGroups = (diagnostics, limit, rulePriority) => {
-	return sortRuleGroupsByImportance([...groupBy(diagnostics.filter((diagnostic) => diagnostic.severity === "error"), (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`).entries()], rulePriority).slice(0, limit);
+const selectErrorRuleGroups = (diagnostics, rulePriority) => buildSortedRuleGroups(diagnostics.filter((diagnostic) => diagnostic.severity === "error"), rulePriority);
+const selectTopErrorRuleGroups = (diagnostics, limit, rulePriority) => selectErrorRuleGroups(diagnostics, rulePriority).slice(0, limit);
+const buildMoreRulesLine = (hiddenRuleCount, severityNoun, accent) => {
+	const ruleNoun = hiddenRuleCount === 1 ? "rule" : "rules";
+	return `  ${highlighter.bold(accent(`+${hiddenRuleCount} more ${ruleNoun}`))} ${highlighter.dim("— run")} ${highlighter.bold(highlighter.info("--verbose"))} ${highlighter.dim(`to view the rest of the ${severityNoun} and details about each`)}`;
 };
 const getTopErrorRuleKeys = (diagnostics, limit, rulePriority) => new Set(selectTopErrorRuleGroups(diagnostics, limit, rulePriority).map(([ruleKey]) => ruleKey));
 const buildTopErrorsLines = (diagnostics, resolveSourceRoot, rulePriority) => {
-	const topRuleGroups = selectTopErrorRuleGroups(diagnostics, 3, rulePriority);
+	const errorRuleGroups = selectErrorRuleGroups(diagnostics, rulePriority);
+	const topRuleGroups = errorRuleGroups.slice(0, 3);
 	if (topRuleGroups.length === 0) return [];
+	const hiddenRuleCount = errorRuleGroups.length - topRuleGroups.length;
 	const lines = [
 		highlighter.dim(`  ${"─".repeat(60)}`),
 		`  ${highlighter.bold(`Top ${topRuleGroups.length} ${topRuleGroups.length === 1 ? "error" : "errors"} you should fix`)}`,
@@ -14283,12 +15079,29 @@ const buildTopErrorsLines = (diagnostics, resolveSourceRoot, rulePriority) => {
 		lines.push(...buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, false));
 		lines.push("");
 	}
+	if (hiddenRuleCount > 0) lines.push(buildMoreRulesLine(hiddenRuleCount, "errors", highlighter.error));
 	return lines;
 };
-const buildCategoryBreakdownLines = (diagnostics, rulePriority) => buildCategoryDiagnosticGroups(diagnostics, rulePriority).map(buildCompactCategoryLine);
-const joinSections = (...sections) => {
-	const lines = [];
-	for (const section of sections) {
+const buildWarningsListLines = (diagnostics, rulePriority) => {
+	const warningDiagnostics = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+	if (warningDiagnostics.length === 0) return [];
+	const sortedRuleGroups = buildSortedRuleGroups(warningDiagnostics, rulePriority);
+	const shownRuleGroups = sortedRuleGroups.slice(0, 10);
+	const hiddenRuleCount = sortedRuleGroups.length - shownRuleGroups.length;
+	const ruleNameColumnWidth = computeRuleNameColumnWidth(shownRuleGroups.map(([ruleKey]) => ruleKey));
+	const lines = [
+		highlighter.dim(`  ${"─".repeat(60)}`),
+		`  ${highlighter.bold(`${warningDiagnostics.length} ${warningDiagnostics.length === 1 ? "warning" : "warnings"}`)}`,
+		""
+	];
+	for (const [ruleKey, ruleDiagnostics] of shownRuleGroups) lines.push(buildWarningHeaderLine(ruleKey, ruleDiagnostics.length, ruleNameColumnWidth));
+	if (hiddenRuleCount > 0) lines.push(buildMoreRulesLine(hiddenRuleCount, "warnings", highlighter.warn));
+	return lines;
+};
+const buildCategoryBreakdownLines = (diagnostics, rulePriority) => buildCategoryDiagnosticGroups(diagnostics, rulePriority).map(buildCompactCategoryLine);
+const joinSections = (...sections) => {
+	const lines = [];
+	for (const section of sections) {
 		if (section.length === 0) continue;
 		if (lines.length > 0) lines.push("");
 		lines.push(...section);
@@ -14309,12 +15122,18 @@ const buildCountsSummaryLines = (diagnostics) => {
 * single Effect.forEach over Console.log so failures or fiber
 * interruption produce predictable partial output.
 */
-const printDiagnostics = (diagnostics, isVerbose, sourceRoot, rulePriority) => Effect.gen(function* () {
+const printDiagnostics = (diagnostics, isVerbose, sourceRoot, rulePriority, isAgentEnvironment = false) => Effect.gen(function* () {
 	const resolveSourceRoot = typeof sourceRoot === "function" ? sourceRoot : () => sourceRoot;
 	let detailLines;
 	if (!isVerbose) detailLines = buildTopErrorsLines(diagnostics, resolveSourceRoot, rulePriority);
-	else detailLines = sortRuleGroupsByImportance([...groupBy(diagnostics, (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`).entries()], rulePriority).flatMap(([ruleKey, ruleDiagnostics]) => [...buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, true), ""]);
-	const lines = joinSections(buildCategoryBreakdownLines(diagnostics, rulePriority), buildCountsSummaryLines(diagnostics), detailLines);
+	else {
+		const sortedRuleGroups = buildSortedRuleGroups(diagnostics, rulePriority);
+		const warningRuleNameColumnWidth = computeRuleNameColumnWidth(sortedRuleGroups.filter(([, ruleDiagnostics]) => !isErrorRuleGroup(ruleDiagnostics)).map(([ruleKey]) => ruleKey));
+		detailLines = sortedRuleGroups.flatMap(([ruleKey, ruleDiagnostics]) => {
+			return [...isErrorRuleGroup(ruleDiagnostics) ? buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, true) : buildWarningRuleBlock(ruleKey, ruleDiagnostics, warningRuleNameColumnWidth, isAgentEnvironment), ""];
+		});
+	}
+	const lines = joinSections(buildCategoryBreakdownLines(diagnostics, rulePriority), buildCountsSummaryLines(diagnostics), detailLines, isVerbose ? [] : buildWarningsListLines(diagnostics, rulePriority));
 	for (const line of lines) yield* Console.log(line);
 });
 const formatElapsedTime = (elapsedMilliseconds) => {
@@ -14364,10 +15183,6 @@ const colorizeByScore = (text, score) => {
 	return highlighter.error(text);
 };
 //#endregion
-//#region src/cli/utils/constants.ts
-const STAGED_FILES_TEMP_DIR_PREFIX = "react-doctor-staged-";
-const INTERNAL_ERROR_JSON_FALLBACK = "{\"schemaVersion\":1,\"ok\":false,\"error\":{\"message\":\"Internal error\",\"name\":\"Error\",\"chain\":[]}}\n";
-//#endregion
 //#region src/cli/utils/render-score-header.ts
 const RAINBOW_HUE_SHIFT_PER_FRAME = 9;
 const RAINBOW_GRADIENT_WIDTH = 80;
@@ -14560,8 +15375,7 @@ const printNoScoreHeader = (noScoreMessage) => Effect.gen(function* () {
 const writeDiagnosticsDirectory = (diagnostics) => {
 	const outputDirectory = join(tmpdir(), `react-doctor-${randomUUID()}`);
 	mkdirSync(outputDirectory, { recursive: true });
-	const sortedRuleGroups = sortRuleGroupsByImportance([...groupBy(diagnostics, (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`).entries()]);
-	for (const [ruleKey, ruleDiagnostics] of sortedRuleGroups) writeFileSync(join(outputDirectory, ruleKey.replace(/\//g, "--") + ".txt"), formatRuleSummary(ruleKey, ruleDiagnostics));
+	for (const [ruleKey, ruleDiagnostics] of buildSortedRuleGroups(diagnostics)) writeFileSync(join(outputDirectory, ruleKey.replace(/\//g, "--") + ".txt"), formatRuleSummary(ruleKey, ruleDiagnostics));
 	writeFileSync(join(outputDirectory, "diagnostics.json"), JSON.stringify(diagnostics));
 	return outputDirectory;
 };
@@ -14581,7 +15395,14 @@ const buildShareUrl = (diagnostics, scoreResult, projectName) => {
 };
 const printVerboseTip = (diagnostics, isVerbose) => Effect.gen(function* () {
 	if (isVerbose || diagnostics.length === 0) return;
-	yield* Console.log(highlighter.dim(`  Tip: Run ${highlighter.info("npx react-doctor@latest --verbose")} to list every issue`));
+	const command = highlighter.info("npx react-doctor@latest --verbose");
+	const message = diagnostics.some((diagnostic) => diagnostic.severity === "warning") ? `Run ${command} to see each warning explained with its fix` : `Run ${command} to see each issue explained with its fix`;
+	yield* Console.log(highlighter.dim(`  Tip: ${message}`));
+});
+const printDocsNote = () => Effect.gen(function* () {
+	yield* Console.log("");
+	yield* Console.log(`  ${highlighter.bold("Docs:")} ${highlighter.info(DOCS_URL)}`);
+	yield* Console.log(highlighter.dim("  Set up CI/CD, suppress rules with a config file, and scan diffs or PRs."));
 });
 const printSummary = (input) => Effect.gen(function* () {
 	if (input.scoreResult) {
@@ -14752,9 +15573,6 @@ const resolveOxlintNodeEffect = (isLintEnabled, isQuiet) => Effect.gen(function*
 });
 const resolveOxlintNode = (isLintEnabled, isQuiet) => Effect.runPromise(resolveOxlintNodeEffect(isLintEnabled, isQuiet).pipe(Effect.provide(NodeResolver.layerNode)));
 //#endregion
-//#region src/cli/utils/version.ts
-const VERSION = "0.2.14-dev.8b313ba";
-//#endregion
 //#region src/inspect.ts
 const silentConsole = makeNoopConsole();
 const runConsole = (effect) => {
@@ -14779,11 +15597,12 @@ const mergeInspectOptions = (inputOptions, userConfig) => ({
 	customRulesOnly: userConfig?.customRulesOnly ?? false,
 	share: userConfig?.share ?? true,
 	respectInlineDisables: inputOptions.respectInlineDisables ?? userConfig?.respectInlineDisables ?? true,
-	warnings: inputOptions.warnings ?? userConfig?.warnings ?? false,
+	warnings: inputOptions.warnings ?? userConfig?.warnings ?? true,
 	adoptExistingLintConfig: userConfig?.adoptExistingLintConfig ?? true,
 	ignoredTags: buildIgnoredTags(userConfig),
 	outputSurface: inputOptions.outputSurface ?? "cli",
-	suppressRendering: inputOptions.suppressRendering ?? false
+	suppressRendering: inputOptions.suppressRendering ?? false,
+	concurrency: inputOptions.concurrency
 });
 const inspect = async (directory, inputOptions = {}) => {
 	const startTime = performance.now();
@@ -14796,7 +15615,7 @@ const inspect = async (directory, inputOptions = {}) => {
 		userConfig = inputOptions.configOverride ?? null;
 		configSourceDirectory = null;
 	} else {
-		const scanTarget = resolveScanTarget(directory);
+		const scanTarget = await resolveScanTarget(directory);
 		scanDirectory = scanTarget.resolvedDirectory;
 		userConfig = scanTarget.userConfig;
 		configSourceDirectory = scanTarget.configSourceDirectory;
@@ -14823,7 +15642,8 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 		shouldSkipLint: !options.lint || lintBindingMissing,
 		shouldRunDeadCode: options.deadCode,
 		shouldComputeScore: !options.noScore,
-		shouldShowProgressSpinners
+		shouldShowProgressSpinners,
+		oxlintConcurrency: options.concurrency
 	});
 	const program = runInspect({
 		directory,
@@ -14879,15 +15699,15 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 };
 const finalizeAndRender = (input) => Effect.gen(function* () {
 	const { options, elapsedMilliseconds, diagnostics, score, project, userConfig, didLintFail, lintFailureReason, lintPartialFailures, didDeadCodeFail, deadCodeFailureReason, directory, scannedFileCount, scannedFilePaths, scanElapsedMilliseconds } = input;
-	const skippedChecks = [];
-	if (didLintFail) skippedChecks.push("lint");
-	if (didDeadCodeFail) skippedChecks.push("dead-code");
+	const { skippedChecks, skippedCheckReasons } = buildSkippedChecks({
+		didLintFail,
+		lintFailureReason,
+		lintPartialFailures,
+		didDeadCodeFail,
+		deadCodeFailureReason
+	});
 	const hasSkippedChecks = skippedChecks.length > 0;
 	const noScoreMessage = buildNoScoreMessage(options.noScore);
-	const skippedCheckReasons = {};
-	if (didLintFail && lintFailureReason !== null) skippedCheckReasons.lint = lintFailureReason;
-	else if (lintPartialFailures.length > 0) skippedCheckReasons["lint:partial"] = lintPartialFailures.join("; ");
-	if (didDeadCodeFail && deadCodeFailureReason !== null) skippedCheckReasons["dead-code"] = deadCodeFailureReason;
 	const buildResult = () => ({
 		diagnostics: [...diagnostics],
 		score,
@@ -14923,7 +15743,7 @@ const finalizeAndRender = (input) => Effect.gen(function* () {
 		return buildResult();
 	}
 	yield* Console.log("");
-	yield* printDiagnostics([...surfaceDiagnostics], options.verbose, directory, buildRulePriorityMap([score]));
+	yield* printDiagnostics([...surfaceDiagnostics], options.verbose, directory, buildRulePriorityMap([score]), isCodingAgentEnvironment());
 	if (options.isNonInteractiveEnvironment && options.outputSurface !== "prComment") yield* printAgentGuidance();
 	if (demotedDiagnosticCount > 0) {
 		yield* Console.log(highlighter.gray(`  ${demotedDiagnosticCount} demoted from the ${options.outputSurface} surface (e.g. design cleanup) — run \`npx react-doctor@latest .\` locally for the full list.`));
@@ -14948,6 +15768,7 @@ const finalizeAndRender = (input) => Effect.gen(function* () {
 		yield* Console.warn(highlighter.warn(`  Note: ${skippedLabel} checks failed — score may be incomplete.`));
 	}
 	yield* printVerboseTip([...surfaceDiagnostics], options.verbose);
+	yield* printDocsNote();
 	return buildResult();
 });
 //#endregion
@@ -15041,6 +15862,7 @@ const handleErrorEffect = (error) => Effect.gen(function* () {
 	yield* Console.error("");
 	yield* Console.error(highlighter.error("Something went wrong. Please check the error below for more details."));
 	yield* Console.error(highlighter.error(`If the problem persists, please open this prefilled issue: ${buildErrorIssueUrl(error)}`));
+	yield* Console.error(highlighter.error(`You can also ask for help in Discord: ${CANONICAL_DISCORD_URL}`));
 	yield* Console.error("");
 	yield* Console.error(highlighter.error(formatErrorForReport(error)));
 	yield* Console.error("");
@@ -15058,7 +15880,7 @@ const handleError = (error, options = { shouldExit: true }) => {
 //#endregion
 //#region src/cli/utils/build-handoff-payload.ts
 const buildHandoffPayload = (input) => {
-	const topGroups = sortRuleGroupsByImportance([...groupBy([...input.diagnostics], (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`)]).slice(0, 3);
+	const topGroups = buildSortedRuleGroups(input.diagnostics).slice(0, 3);
 	let diagnosticsDirectory = null;
 	try {
 		diagnosticsDirectory = writeDiagnosticsDirectory([...input.diagnostics]);
@@ -15301,7 +16123,7 @@ const CURSOR_HOOKS_RELATIVE_PATH = ".cursor/hooks.json";
 const CURSOR_HOOK_RELATIVE_PATH = ".cursor/hooks/react-doctor.sh";
 const CURSOR_HOOK_MATCHER = "Write|Edit|MultiEdit|ApplyPatch";
 const CURSOR_HOOKS_SCHEMA_VERSION = 1;
-const JSON_INDENT_SPACES = 2;
+const JSON_INDENT_SPACES$1 = 2;
 const isSupportedAgent = (agent) => agent === CLAUDE_AGENT || agent === CURSOR_AGENT;
 const readJsonFile = (filePath, fallback) => {
 	if (!existsSync(filePath)) return fallback;
@@ -15311,7 +16133,7 @@ const readJsonFile = (filePath, fallback) => {
 };
 const writeJsonFile = (filePath, value) => {
 	mkdirSync(path.dirname(filePath), { recursive: true });
-	writeFileSync(filePath, `${JSON.stringify(value, null, JSON_INDENT_SPACES)}\n`);
+	writeFileSync(filePath, `${JSON.stringify(value, null, JSON_INDENT_SPACES$1)}\n`);
 };
 const writeHookScript = (filePath) => {
 	mkdirSync(path.dirname(filePath), { recursive: true });
@@ -16077,6 +16899,29 @@ const getSkillSourceDirectory = () => {
 	const distDirectory = path.dirname(fileURLToPath(import.meta.url));
 	return path.join(distDirectory, "skills", SKILL_NAME);
 };
+const findBundledSiblingSkills = (primarySkillDir) => {
+	const skillsParent = path.dirname(primarySkillDir);
+	if (!existsSync(skillsParent)) return [];
+	const resolvedPrimary = path.resolve(primarySkillDir);
+	return readdirSync(skillsParent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => ({
+		name: entry.name,
+		source: path.join(skillsParent, entry.name)
+	})).filter((sibling) => path.resolve(sibling.source) !== resolvedPrimary && existsSync(path.join(sibling.source, SKILL_MANIFEST_FILE)));
+};
+const installBundledSiblingSkills = async (primarySkillDir, agents, projectRoot) => {
+	const installedSkillNames = [];
+	for (const sibling of findBundledSiblingSkills(primarySkillDir)) {
+		const result = await installSkillsFromSource({
+			source: sibling.source,
+			agents: [...agents],
+			cwd: projectRoot,
+			mode: "copy"
+		});
+		if (result.failed.length > 0) throw new Error(result.failed.map((failure) => `${getSkillAgentConfig(failure.agent).displayName}: ${failure.error}`).join("\n"));
+		if (result.skills.length > 0) installedSkillNames.push(sibling.name);
+	}
+	return installedSkillNames;
+};
 const canInstallNativeAgentHooks = (agents) => agents.some((agent) => agent === "claude-code" || agent === "cursor");
 const buildWorkflowContent = () => [
 	"name: React Doctor",
@@ -16183,6 +17028,7 @@ const runInstallReactDoctor = async (options = {}) => {
 		cliLogger.log(`Dry run — would install ${SKILL_NAME} skill for:`);
 		for (const agent of selectedAgents) cliLogger.dim(`  - ${getSkillAgentConfig(agent).displayName}`);
 		cliLogger.dim(`  Source: ${sourceDir}`);
+		for (const sibling of findBundledSiblingSkills(sourceDir)) cliLogger.dim(`  Also installs skill: ${sibling.name}`);
 		cliLogger.dim("  Package script: doctor (or react-doctor if doctor exists)");
 		cliLogger.dim("  Dev dependency: react-doctor");
 		if (shouldInstallGitHook) cliLogger.dim(`  Git hook: ${gitHookPath}`);
@@ -16205,6 +17051,12 @@ const runInstallReactDoctor = async (options = {}) => {
 		installSpinner.fail(`Failed to install ${SKILL_NAME} skill.`);
 		throw error;
 	}
+	try {
+		const installedSiblingSkills = await installBundledSiblingSkills(sourceDir, selectedAgents, projectRoot);
+		if (installedSiblingSkills.length > 0) cliLogger.dim(`  Also installed the ${installedSiblingSkills.join(", ")} skill.`);
+	} catch {
+		cliLogger.dim("  Skipped bundled sibling skills (install error).");
+	}
 	await installReactDoctorPackageSetup(projectRoot, options.installDependencyRunner);
 	if (shouldInstallGitHook && gitHookTarget !== null && gitHookTarget !== void 0) {
 		const hookSpinner = spinner("Installing React Doctor pre-commit hook...").start();
@@ -16390,6 +17242,70 @@ const handoffToAgent = async (input) => {
 	}
 };
 //#endregion
+//#region src/cli/utils/read-object-file.ts
+/**
+* Reads a JSON / JSONC file as a plain object, or `null` when it is missing,
+* unparseable, or not an object. JSON5 parsing tolerates comments and
+* trailing commas so hand-edited config files round-trip.
+*/
+const readObjectFile = (filePath) => {
+	try {
+		const parsed = parseJSON5(readFileSync(filePath, "utf-8"));
+		return isPlainObject(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/cli/utils/serialize-ts-object-literal.ts
+const SAFE_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const INDENT_UNIT = "  ";
+const serializeKey = (key) => SAFE_IDENTIFIER_PATTERN.test(key) ? key : JSON.stringify(key);
+/**
+* Serializes a JSON-compatible value as an idiomatic TypeScript literal:
+* identifier-shaped object keys stay unquoted, two-space indented, no blank
+* lines. Intended for JSON-sourced config values (string / number / boolean /
+* null / array / plain object); any other type falls back to its JSON form.
+*/
+const serializeTsObjectLiteral = (value, depth = 0) => {
+	const indent = INDENT_UNIT.repeat(depth);
+	const childIndent = INDENT_UNIT.repeat(depth + 1);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		return `[\n${value.map((item) => `${childIndent}${serializeTsObjectLiteral(item, depth + 1)}`).join(",\n")}\n${indent}]`;
+	}
+	if (isPlainObject(value)) {
+		const keys = Object.keys(value);
+		if (keys.length === 0) return "{}";
+		return `{\n${keys.map((key) => `${childIndent}${serializeKey(key)}: ${serializeTsObjectLiteral(value[key], depth + 1)}`).join(",\n")}\n${indent}}`;
+	}
+	return JSON.stringify(value);
+};
+//#endregion
+//#region src/cli/utils/migrate-legacy-config.ts
+const MIGRATED_CONFIG_FILENAME = "doctor.config.ts";
+/**
+* Renames a pre-migration `react-doctor.config.json` to a typed
+* `doctor.config.ts`, preserving the user's settings as the default export.
+* `$schema` is dropped — the `ReactDoctorConfig` type supersedes it for
+* editor autocomplete. Returns the new file's absolute path, or `null` when
+* the legacy file can't be parsed as an object (left untouched so the user
+* can resolve it by hand).
+*/
+const migrateLegacyConfig = (legacy) => {
+	const parsed = readObjectFile(legacy.legacyFilePath);
+	if (!parsed) return null;
+	const config = { ...parsed };
+	delete config.$schema;
+	const targetPath = path.join(legacy.directory, MIGRATED_CONFIG_FILENAME);
+	writeFileSync(targetPath, `import type { ReactDoctorConfig } from "react-doctor/api";
+
+export default ${serializeTsObjectLiteral(config)} satisfies ReactDoctorConfig;
+`);
+	rmSync(legacy.legacyFilePath, { force: true });
+	return targetPath;
+};
+//#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
 /**
@@ -16490,6 +17406,78 @@ const printBrandedHeader = Effect.gen(function* () {
 	yield* Console.log("");
 });
 //#endregion
+//#region src/cli/utils/build-run-context.ts
+const ROOT_SUBCOMMANDS = new Set(["install", "setup"]);
+const detectOrigin = () => {
+	if (process.env.GIT_DIR) return "git-hook";
+	if (isCodingAgentEnvironment()) return "agent";
+	if (isCiEnvironment()) return "ci";
+	return "cli";
+};
+const detectCommand = (userArguments) => {
+	for (const argument of userArguments) {
+		if (argument === "--") break;
+		if (argument.startsWith("-")) continue;
+		return ROOT_SUBCOMMANDS.has(argument) ? argument : "inspect";
+	}
+	return "inspect";
+};
+/**
+* Snapshot of the current invocation, attached to Sentry events as the
+* `run` context to make crashes triage-able (which version, platform,
+* CI/agent, how it was invoked). Every field is cheap, synchronous, and
+* safe to read at any point — cwd reads fall back, env reads are
+* booleans — so it's rebuilt lazily at capture time when runtime-only
+* signals like `jsonMode` are finally known.
+*/
+const buildRunContext = () => {
+	const userArguments = process.argv.slice(2);
+	return {
+		version: VERSION,
+		origin: detectOrigin(),
+		command: detectCommand(userArguments),
+		argv: userArguments.join(" "),
+		cwd: process.cwd(),
+		node: process.version,
+		platform: process.platform,
+		arch: process.arch,
+		ci: isCiEnvironment(),
+		ciProvider: detectCiProvider(),
+		codingAgent: detectCodingAgent(),
+		interactive: !isNonInteractiveEnvironment(),
+		jsonMode: isJsonModeActive()
+	};
+};
+//#endregion
+//#region src/cli/utils/report-error.ts
+/**
+* Sends an error to Sentry, enriched with a snapshot of the current run
+* (version, platform, CI/agent, invocation), and waits for delivery
+* before the caller exits. The CLI tears down the process synchronously
+* after rendering an error, so the awaited `flush` is what actually gets
+* the event off the machine (see the Sentry CLI/serverless flush
+* contract).
+*
+* Returns early when Sentry was never initialized (`--no-score`, tests,
+* or a missing DSN), and swallows any transport failure so telemetry can
+* never mask the user's original error.
+*/
+const reportErrorToSentry = async (error) => {
+	if (!Sentry.isInitialized()) return;
+	try {
+		const runContext = buildRunContext();
+		Sentry.setContext("run", { ...runContext });
+		Sentry.setTags({
+			origin: runContext.origin,
+			command: runContext.command,
+			ciProvider: runContext.ciProvider,
+			codingAgent: runContext.codingAgent
+		});
+		Sentry.captureException(error);
+		await Sentry.flush(2e3);
+	} catch {}
+};
+//#endregion
 //#region src/cli/utils/path-format.ts
 const toForwardSlashes = (filePath) => filePath.replaceAll("\\", "/");
 //#endregion
@@ -16557,7 +17545,7 @@ const printMultiProjectSummary = (input) => Effect.gen(function* () {
 	yield* Console.log(`${highlighter.success("✔")} Scanned ${totalScannedFileCount} ${totalScannedFileCount === 1 ? "file" : "files"} in ${formatElapsedTime(totalScanElapsedMilliseconds)}`);
 	if (surfaceDiagnostics.length > 0) {
 		yield* Console.log("");
-		yield* printDiagnostics(surfaceDiagnostics, verbose, resolveDiagnosticSourceRoot, buildRulePriorityMap(completedScans.map((scan) => scan.result.score)));
+		yield* printDiagnostics(surfaceDiagnostics, verbose, resolveDiagnosticSourceRoot, buildRulePriorityMap(completedScans.map((scan) => scan.result.score)), isCodingAgentEnvironment());
 	}
 	const lowestScoredScan = findLowestScoredScan(completedScans);
 	const aggregateScore = lowestScoredScan?.result.score ?? null;
@@ -16587,6 +17575,7 @@ const printMultiProjectSummary = (input) => Effect.gen(function* () {
 	for (const entry of entries) yield* Console.log(buildSummaryLine(entry, longestProjectNameLength));
 	yield* Console.log("");
 	yield* printVerboseTip(surfaceDiagnostics, verbose);
+	yield* printDocsNote();
 });
 //#endregion
 //#region src/cli/utils/prompt-install-setup.ts
@@ -16634,6 +17623,34 @@ const printAgentInstallHint = (writeLine = defaultWriteLine) => {
 	for (const line of AGENT_INSTALL_HINT_LINES) writeLine(line);
 };
 //#endregion
+//#region src/cli/utils/resolve-parallel-flag.ts
+/**
+* Translates the `--experimental-parallel [workers]` flag into a concrete
+* worker count for `InspectOptions.concurrency`:
+*
+*   - flag absent (`undefined`)            → `undefined` (defer to the ambient
+*     default: serial unless `REACT_DOCTOR_PARALLEL` is set)
+*   - bare flag / `auto`                    → auto-detect CPU cores
+*   - `--experimental-parallel <n>`         → `n` workers (clamped)
+*   - `false` / `off` / `0`                 → serial (an explicit opt-out, so
+*     it overrides an env-enabled default rather than deferring to it)
+*   - an unparseable value                  → auto-detect cores
+*
+* Commander yields `true` for a bare flag, the raw string for an explicit
+* value, and `undefined` when the flag is omitted.
+*/
+const resolveParallelFlag = (parallel) => {
+	if (parallel === void 0) return void 0;
+	if (parallel === true) return resolveScanConcurrency("auto");
+	if (parallel === false) return 1;
+	const normalized = parallel.trim().toLowerCase();
+	if (normalized === "" || normalized === "auto" || normalized === "true") return resolveScanConcurrency("auto");
+	if (normalized === "false" || normalized === "off" || normalized === "0") return 1;
+	const parsed = Number.parseInt(normalized, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) return resolveScanConcurrency("auto");
+	return resolveScanConcurrency(parsed);
+};
+//#endregion
 //#region src/cli/utils/resolve-cli-inspect-options.ts
 /**
 * Translates CLI flags into the `InspectOptions` contract `inspect()`
@@ -16656,10 +17673,11 @@ const resolveCliInspectOptions = (flags, userConfig) => {
 		respectInlineDisables: flags.respectInlineDisables,
 		warnings: flags.warnings ?? (wantsWarningGate ? true : void 0),
 		scoreOnly: flags.score === true,
-		noScore: flags.score === false || (userConfig?.noScore ?? false),
+		noScore: flags.score === false || flags.telemetry === false || (userConfig?.noScore ?? false),
 		isCi: isCiEnvironment(),
 		silent: Boolean(flags.json),
-		outputSurface: flags.prComment ? "prComment" : "cli"
+		outputSurface: flags.prComment ? "prComment" : "cli",
+		concurrency: resolveParallelFlag(flags.experimentalParallel)
 	};
 };
 //#endregion
@@ -16818,11 +17836,9 @@ const parseFileLineArgument = (rawArgument) => {
 //#endregion
 //#region src/cli/utils/select-projects.ts
 const selectProjects = async (rootDirectory, projectFlag, skipPrompts) => {
+	const hasRootPackageJson = isFile(path.join(rootDirectory, "package.json"));
 	let packages = listWorkspacePackages(rootDirectory);
-	if (packages.length === 0) {
-		if (!isMonorepoRoot(rootDirectory)) return [rootDirectory];
-		packages = discoverReactSubprojects(rootDirectory);
-	}
+	if (packages.length === 0 && (!hasRootPackageJson || isMonorepoRoot(rootDirectory))) packages = discoverReactSubprojects(rootDirectory);
 	if (packages.length === 0) return [rootDirectory];
 	if (packages.length === 1) {
 		cliLogger.log(`${highlighter.success("✔")} Select projects ${highlighter.dim("›")} ${packages[0].name}`);
@@ -16926,6 +17942,7 @@ const validateModeFlags = (flags) => {
 	if (exclusiveModes.length > 1) throw new Error(`Cannot combine ${exclusiveModes.join(" and ")}; pick one mode.`);
 	if (flags.yes && flags.full) throw new Error("Cannot combine --yes and --full; pick one.");
 	if (flags.score && flags.json) throw new Error("Cannot combine --score and --json; pick one output mode.");
+	if (flags.score && flags.telemetry === false) throw new Error("Cannot combine --score with --no-telemetry; --score prints the score that --no-telemetry disables.");
 	if (flags.prComment && (flags.json || flags.score)) throw new Error("--pr-comment cannot be combined with --json or --score.");
 	if (flags.annotations && flags.score) throw new Error("--annotations cannot be combined with --score.");
 	if (flags.explain !== void 0 && flags.why !== void 0) throw new Error("Use --explain or --why, not both — they're aliases of the same flag.");
@@ -16959,6 +17976,24 @@ const buildChangedFilesDiffInfo = (changedFiles) => ({
 	changedFiles,
 	isCurrentChanges: false
 });
+/**
+* On an interactive human run, rename a pre-migration
+* `react-doctor.config.json` to `doctor.config.ts` before config is loaded,
+* so the scan reads the renamed file and the user is told once. CI, coding
+* agents, JSON/score output, pre-commit (`--staged`) hooks, and non-TTY runs
+* are left untouched — the loader's warning still nudges them — so a scan
+* never mutates the repo unattended.
+*/
+const maybeMigrateLegacyConfig = (requestedDirectory, { isQuiet, isStaged }) => {
+	if (!(!isQuiet && !isStaged && process.stdout.isTTY === true && !isCiOrCodingAgentEnvironment())) return;
+	const legacyConfig = findLegacyConfig(requestedDirectory);
+	if (!legacyConfig) return;
+	const migratedPath = migrateLegacyConfig(legacyConfig);
+	if (!migratedPath) return;
+	cliLogger.success("Migrated react-doctor.config.json → doctor.config.ts");
+	cliLogger.dim(`  Your settings were preserved. Review ${toRelativePath(migratedPath, requestedDirectory)} and commit it.`);
+	cliLogger.break();
+};
 const inspectAction = async (directory, flags) => {
 	const isScoreOnly = Boolean(flags.score);
 	const isJsonMode = Boolean(flags.json);
@@ -16971,7 +18006,11 @@ const inspectAction = async (directory, flags) => {
 	});
 	try {
 		validateModeFlags(flags);
-		const scanTarget = resolveScanTarget(requestedDirectory);
+		maybeMigrateLegacyConfig(requestedDirectory, {
+			isQuiet,
+			isStaged: Boolean(flags.staged)
+		});
+		const scanTarget = await resolveScanTarget(requestedDirectory, { allowAmbiguous: true });
 		const userConfig = scanTarget.userConfig;
 		const resolvedDirectory = scanTarget.resolvedDirectory;
 		setJsonReportDirectory(resolvedDirectory);
@@ -17145,6 +18184,7 @@ const inspectAction = async (directory, flags) => {
 			})) printAgentInstallHint();
 		}
 	} catch (error) {
+		await reportErrorToSentry(error);
 		if (isJsonMode) {
 			writeJsonErrorReport(error);
 			process.exitCode = 1;
@@ -17166,10 +18206,573 @@ const installAction = async (options, command) => {
 			projectRoot: options.cwd ?? process.cwd()
 		});
 	} catch (error) {
+		await reportErrorToSentry(error);
 		handleError(error);
 	}
 };
 //#endregion
+//#region src/cli/utils/rule-catalog.ts
+const buildRuleCatalog = () => REACT_DOCTOR_RULES.map((entry) => ({
+	key: entry.key,
+	id: entry.id,
+	category: entry.rule.category ?? "Other",
+	defaultSeverity: entry.rule.severity,
+	framework: entry.rule.framework ?? "global",
+	tags: entry.rule.tags ?? [],
+	recommendation: entry.rule.recommendation,
+	defaultEnabled: entry.rule.defaultEnabled !== false
+}));
+/**
+* Resolves a user-supplied rule reference to a catalog entry. Accepts the
+* fully-qualified key (`react-doctor/no-danger`), the bare id (`no-danger`),
+* and legacy plugin keys (`react/no-danger`) via the shared alias map.
+*/
+const findRuleInCatalog = (catalog, ruleQuery) => {
+	const normalizedQuery = ruleQuery.trim();
+	if (normalizedQuery.length === 0) return void 0;
+	const directMatch = catalog.find((entry) => entry.key === normalizedQuery || entry.id === normalizedQuery);
+	if (directMatch) return directMatch;
+	return catalog.find((entry) => isSameRuleKey(entry.key, normalizedQuery));
+};
+const listRuleCategories = (catalog) => [...new Set(catalog.map((entry) => entry.category))].sort();
+const listRuleTags = (catalog) => [...new Set(catalog.flatMap((entry) => [...entry.tags]))].sort();
+//#endregion
+//#region src/cli/utils/render-rule-catalog.ts
+const SEVERITY_COLUMN_WIDTH_CHARS = 6;
+const colorizeSeverity = (severity, text) => {
+	if (severity === "error") return highlighter.error(text);
+	if (severity === "warn") return highlighter.warn(text);
+	return highlighter.gray(text);
+};
+const formatSourceNote = (effective) => effective.source === "default" ? highlighter.dim("(default)") : highlighter.dim(`(${effective.source})`);
+const renderRuleCatalog = (rows) => {
+	if (rows.length === 0) return highlighter.dim("No rules match the given filters.");
+	const rowsByCategory = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const bucket = rowsByCategory.get(row.entry.category) ?? [];
+		bucket.push(row);
+		rowsByCategory.set(row.entry.category, bucket);
+	}
+	const lines = [];
+	for (const category of [...rowsByCategory.keys()].sort()) {
+		const categoryRows = (rowsByCategory.get(category) ?? []).sort((leftRow, rightRow) => leftRow.entry.key.localeCompare(rightRow.entry.key));
+		lines.push(highlighter.bold(`${category} ${highlighter.dim(`(${categoryRows.length})`)}`));
+		for (const row of categoryRows) {
+			const severityBadge = colorizeSeverity(row.effective.value, row.effective.value.padEnd(SEVERITY_COLUMN_WIDTH_CHARS));
+			const tagSuffix = row.entry.tags.length > 0 ? highlighter.dim(`  [${row.entry.tags.join(", ")}]`) : "";
+			lines.push(`  ${severityBadge} ${row.entry.key} ${formatSourceNote(row.effective)}${tagSuffix}`);
+		}
+		lines.push("");
+	}
+	lines.push(highlighter.dim(`${rows.length} rule${rows.length === 1 ? "" : "s"} shown.`));
+	return lines.join("\n");
+};
+const DETAIL_LABEL_COLUMN_WIDTH_CHARS = 18;
+const formatDetailRow = (label, value) => `  ${highlighter.dim(label.padEnd(DETAIL_LABEL_COLUMN_WIDTH_CHARS))}${value}`;
+const renderRuleExplanation = (row) => {
+	const { entry, effective } = row;
+	const lines = [highlighter.bold(entry.key), ""];
+	lines.push(formatDetailRow("Category", entry.category));
+	lines.push(formatDetailRow("Default severity", entry.defaultSeverity));
+	lines.push(formatDetailRow("Current severity", `${colorizeSeverity(effective.value, effective.value)} ${formatSourceNote(effective)}`));
+	lines.push(formatDetailRow("Framework", entry.framework));
+	lines.push(formatDetailRow("Tags", entry.tags.length > 0 ? entry.tags.join(", ") : "none"));
+	lines.push(formatDetailRow("Default enabled", entry.defaultEnabled ? "yes" : "no (opt-in)"));
+	lines.push("");
+	lines.push(highlighter.bold("Why it matters"));
+	lines.push(`  ${entry.recommendation ?? "No additional guidance recorded for this rule yet."}`);
+	lines.push("");
+	lines.push(highlighter.bold("Configure"));
+	lines.push(highlighter.dim(`  react-doctor rules disable ${entry.key}`));
+	lines.push(highlighter.dim(`  react-doctor rules enable ${entry.key} --severity error`));
+	lines.push(highlighter.dim(`  react-doctor rules set ${entry.key} warn`));
+	lines.push("");
+	lines.push(highlighter.bold("Learn more"));
+	lines.push(highlighter.dim(`  ${buildRuleDocsUrl("react-doctor", entry.id)}`));
+	return lines.join("\n");
+};
+//#endregion
+//#region src/cli/utils/rule-config-file.ts
+const NEW_CONFIG_FILENAME = "doctor.config.json";
+const PACKAGE_JSON_CONFIG_KEY = "reactDoctor";
+const JSON_INDENT_SPACES = 2;
+const MANAGED_KEYS = [
+	"rules",
+	"categories",
+	"ignore"
+];
+/**
+* Decides where a rule-config mutation should be written. Discovery
+* reuses `loadConfigWithSource` (the loader the scan uses) so edits land
+* in the file the scan reads — `doctor.config.{ts,js,…}` is preferred,
+* then `package.json#reactDoctor`. When nothing exists, a fresh
+* `doctor.config.json` is targeted at `projectRoot`. Data configs are
+* re-read raw so unrelated fields round-trip untouched.
+*/
+const resolveRuleConfigTarget = async (projectRoot) => {
+	clearConfigCache();
+	const loaded = await loadConfigWithSource(projectRoot);
+	if (loaded) {
+		if (loaded.format === "package-json") {
+			const embedded = (readObjectFile(loaded.configFilePath) ?? {})[PACKAGE_JSON_CONFIG_KEY];
+			return {
+				format: "package-json",
+				filePath: loaded.configFilePath,
+				directory: loaded.sourceDirectory,
+				exists: true,
+				config: isPlainObject(embedded) ? embedded : {}
+			};
+		}
+		if (loaded.format === "json") return {
+			format: "json",
+			filePath: loaded.configFilePath,
+			directory: loaded.sourceDirectory,
+			exists: true,
+			config: readObjectFile(loaded.configFilePath) ?? {}
+		};
+		return {
+			format: "module",
+			filePath: loaded.configFilePath,
+			directory: loaded.sourceDirectory,
+			exists: true,
+			config: loaded.config
+		};
+	}
+	return {
+		format: "json",
+		filePath: path.join(projectRoot, NEW_CONFIG_FILENAME),
+		directory: projectRoot,
+		exists: false,
+		config: {}
+	};
+};
+const writeJsonConfig = (filePath, nextConfig) => {
+	const { $schema, ...rest } = nextConfig;
+	writeFileSync(filePath, `${JSON.stringify({
+		$schema: $schema ?? "https://react.doctor/schema/config.json",
+		...rest
+	}, null, JSON_INDENT_SPACES)}\n`);
+};
+const writePackageJsonConfig = (filePath, nextConfig) => {
+	const packageJson = readObjectFile(filePath) ?? {};
+	writeFileSync(filePath, `${JSON.stringify({
+		...packageJson,
+		[PACKAGE_JSON_CONFIG_KEY]: nextConfig
+	}, null, JSON_INDENT_SPACES)}\n`);
+};
+const syncManagedKeys = (target, nextConfig) => {
+	for (const key of MANAGED_KEYS) {
+		const value = nextConfig[key];
+		if (value === void 0) {
+			if (target[key] !== void 0) delete target[key];
+		} else target[key] = value;
+	}
+};
+const assignNodeSource = (owner, key, code) => {
+	owner[key] = code;
+};
+const editVariableDeclarationConfig = (declaration, config, nextConfig) => {
+	syncManagedKeys(config, nextConfig);
+	const initializer = declaration.init;
+	if (!initializer) return false;
+	const generatedSource = generateCode(config).code;
+	if (initializer.type === "ObjectExpression") {
+		assignNodeSource(declaration, "init", generatedSource);
+		return true;
+	}
+	if (initializer.type === "TSSatisfiesExpression" && initializer.expression.type === "ObjectExpression") {
+		assignNodeSource(initializer, "expression", generatedSource);
+		return true;
+	}
+	return false;
+};
+const writeModuleConfig = async (filePath, nextConfig) => {
+	try {
+		const module = await loadFile(filePath);
+		if (module.exports.default?.$type === "identifier") {
+			const { declaration, config } = getConfigFromVariableDeclaration(module);
+			if (!config || !editVariableDeclarationConfig(declaration, config, nextConfig)) return false;
+		} else syncManagedKeys(getDefaultExportOptions(module), nextConfig);
+		await writeFile(module, filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const writeRuleConfig = async (target, nextConfig) => {
+	if (target.format === "module") {
+		const written = await writeModuleConfig(target.filePath, nextConfig);
+		if (written) clearConfigCache();
+		return { written };
+	}
+	if (target.format === "package-json") writePackageJsonConfig(target.filePath, nextConfig);
+	else writeJsonConfig(target.filePath, nextConfig);
+	clearConfigCache();
+	return { written: true };
+};
+//#endregion
+//#region src/cli/utils/resolve-effective-rule-severity.ts
+/**
+* Resolves what a rule will actually do under the current config without
+* running a scan. `ignore.tags` is a pre-lint gate: a rule carrying an
+* ignored tag is dropped (via `shouldEnableRule`) before any severity is
+* read, so it wins over every override. Among rules that survive the gate,
+* the scanner's order is `rules` > `categories` > `buckets` > the registry
+* default.
+*/
+const resolveEffectiveRuleSeverity = (config, entry) => {
+	const ignoredTags = config?.ignore?.tags ?? [];
+	if (entry.tags.some((tag) => ignoredTags.includes(tag))) return {
+		value: "off",
+		source: "tag"
+	};
+	const ruleOverrides = config?.rules ?? {};
+	for (const equivalentKey of getEquivalentRuleKeys(entry.key)) {
+		const override = ruleOverrides[equivalentKey];
+		if (override !== void 0) return {
+			value: override,
+			source: "rule"
+		};
+	}
+	const categoryOverride = config?.categories?.[entry.category];
+	if (categoryOverride !== void 0) return {
+		value: categoryOverride,
+		source: "category"
+	};
+	if (COMPILER_CLEANUP_RULE_KEYS.has(entry.key)) {
+		const bucketOverride = config?.buckets?.[COMPILER_CLEANUP_BUCKET];
+		if (bucketOverride !== void 0) return {
+			value: bucketOverride,
+			source: "bucket"
+		};
+	}
+	return {
+		value: entry.defaultEnabled ? entry.defaultSeverity : "off",
+		source: "default"
+	};
+};
+//#endregion
+//#region src/cli/utils/update-rule-config.ts
+/**
+* Sets a per-rule severity, replacing any existing entry for the same
+* rule (including legacy-aliased keys, so a config still targeting
+* `react/no-danger` is rewritten to the canonical key instead of
+* leaving a dead duplicate).
+*/
+const setRuleSeverity = (config, ruleKey, severity) => {
+	const equivalentKeys = new Set(getEquivalentRuleKeys(ruleKey));
+	const nextRules = {};
+	for (const [existingKey, existingSeverity] of Object.entries(config.rules ?? {})) if (!equivalentKeys.has(existingKey)) nextRules[existingKey] = existingSeverity;
+	nextRules[ruleKey] = severity;
+	return {
+		...config,
+		rules: nextRules
+	};
+};
+const setCategorySeverity = (config, category, severity) => ({
+	...config,
+	categories: {
+		...config.categories,
+		[category]: severity
+	}
+});
+const addIgnoredTag = (config, tag) => {
+	const currentTags = config.ignore?.tags ?? [];
+	if (currentTags.includes(tag)) return config;
+	return {
+		...config,
+		ignore: {
+			...config.ignore,
+			tags: [...new Set([...currentTags, tag])].sort()
+		}
+	};
+};
+const removeIgnoredTag = (config, tag) => {
+	const currentTags = config.ignore?.tags ?? [];
+	if (!currentTags.includes(tag)) return config;
+	const remainingTags = currentTags.filter((existingTag) => existingTag !== tag);
+	const { tags: _removed, ...remainingIgnore } = config.ignore ?? {};
+	if (remainingTags.length === 0) {
+		if (Object.keys(remainingIgnore).length === 0) {
+			const { ignore: _ignore, ...configWithoutIgnore } = config;
+			return configWithoutIgnore;
+		}
+		return {
+			...config,
+			ignore: remainingIgnore
+		};
+	}
+	return {
+		...config,
+		ignore: {
+			...remainingIgnore,
+			tags: remainingTags
+		}
+	};
+};
+//#endregion
+//#region src/cli/commands/rules.ts
+const SEVERITY_VALUES = [
+	"off",
+	"warn",
+	"error"
+];
+const resolveProjectRoot = (options) => {
+	const requestedDirectory = path.resolve(options.cwd ?? process.cwd());
+	return findNearestPackageDirectory(requestedDirectory) ?? requestedDirectory;
+};
+const parseSeverity = (value) => SEVERITY_VALUES.includes(value) ? value : null;
+const reportInvalidSeverity = (value) => {
+	cliLogger.error(`Invalid severity "${value}". Expected one of: ${SEVERITY_VALUES.join(", ")}.`);
+	process.exitCode = 1;
+};
+const reportRuleNotFound = (ruleQuery) => {
+	cliLogger.error(`Unknown rule "${ruleQuery}".`);
+	cliLogger.dim("  Run `react-doctor rules list` to see every available rule.");
+	process.exitCode = 1;
+};
+const describeTargetPath = (target) => {
+	const relativePath = path.relative(process.cwd(), target.filePath);
+	const displayPath = relativePath.length > 0 && !relativePath.startsWith("..") ? relativePath : target.filePath;
+	return target.exists ? displayPath : `${displayPath} ${highlighter.dim("(created)")}`;
+};
+const applyConfigChange = async (options, change) => {
+	const target = await resolveRuleConfigTarget(resolveProjectRoot(options));
+	const nextConfig = change(target.config);
+	const { written } = await writeRuleConfig(target, nextConfig);
+	return {
+		target,
+		nextConfig,
+		written
+	};
+};
+const reportManualEdit = (target, nextConfig) => {
+	const managed = {};
+	for (const key of [
+		"rules",
+		"categories",
+		"ignore"
+	]) if (nextConfig[key] !== void 0) managed[key] = nextConfig[key];
+	cliLogger.error(`Couldn't automatically edit ${describeTargetPath(target)} (dynamic config).`);
+	cliLogger.dim("  Apply this to your config's default export, then re-run:");
+	for (const line of JSON.stringify(managed, null, 2).split("\n")) cliLogger.dim(`  ${line}`);
+	process.exitCode = 1;
+};
+const rulesListAction = async (options) => {
+	const catalog = buildRuleCatalog();
+	const config = validateConfigTypes((await resolveRuleConfigTarget(resolveProjectRoot(options))).config);
+	const categoryFilter = options.category?.toLowerCase();
+	const frameworkFilter = options.framework?.toLowerCase();
+	const rows = catalog.filter((entry) => {
+		if (categoryFilter && entry.category.toLowerCase() !== categoryFilter) return false;
+		if (frameworkFilter && entry.framework.toLowerCase() !== frameworkFilter) return false;
+		if (options.tag && !entry.tags.includes(options.tag)) return false;
+		return true;
+	}).map((entry) => ({
+		entry,
+		effective: resolveEffectiveRuleSeverity(config, entry)
+	})).filter((row) => options.configured ? row.effective.source !== "default" : true);
+	if (options.json) {
+		const payload = rows.map((row) => ({
+			key: row.entry.key,
+			id: row.entry.id,
+			category: row.entry.category,
+			framework: row.entry.framework,
+			tags: row.entry.tags,
+			defaultSeverity: row.entry.defaultSeverity,
+			defaultEnabled: row.entry.defaultEnabled,
+			severity: row.effective.value,
+			source: row.effective.source
+		}));
+		cliLogger.log(JSON.stringify(payload, null, 2));
+		return;
+	}
+	cliLogger.log(renderRuleCatalog(rows));
+};
+const rulesExplainAction = async (ruleQuery, options) => {
+	const entry = findRuleInCatalog(buildRuleCatalog(), ruleQuery);
+	if (!entry) {
+		reportRuleNotFound(ruleQuery);
+		return;
+	}
+	const effective = resolveEffectiveRuleSeverity(validateConfigTypes((await resolveRuleConfigTarget(resolveProjectRoot(options))).config), entry);
+	if (options.json) {
+		cliLogger.log(JSON.stringify({
+			key: entry.key,
+			id: entry.id,
+			category: entry.category,
+			framework: entry.framework,
+			tags: entry.tags,
+			defaultSeverity: entry.defaultSeverity,
+			defaultEnabled: entry.defaultEnabled,
+			severity: effective.value,
+			source: effective.source,
+			recommendation: entry.recommendation ?? null,
+			learnMoreUrl: buildRuleDocsUrl("react-doctor", entry.id)
+		}, null, 2));
+		return;
+	}
+	cliLogger.log(renderRuleExplanation({
+		entry,
+		effective
+	}));
+};
+const setRuleSeverityAndReport = async (entry, severity, options) => {
+	const { target, nextConfig, written } = await applyConfigChange(options, (config) => setRuleSeverity(config, entry.key, severity));
+	if (!written) {
+		reportManualEdit(target, nextConfig);
+		return;
+	}
+	cliLogger.success(`Set ${entry.key} → ${severity}`);
+	cliLogger.dim(`  Updated ${describeTargetPath(target)}`);
+};
+const rulesSetAction = async (ruleQuery, severityValue, options) => {
+	const severity = parseSeverity(severityValue);
+	if (!severity) {
+		reportInvalidSeverity(severityValue);
+		return;
+	}
+	const entry = findRuleInCatalog(buildRuleCatalog(), ruleQuery);
+	if (!entry) {
+		reportRuleNotFound(ruleQuery);
+		return;
+	}
+	await setRuleSeverityAndReport(entry, severity, options);
+};
+const rulesEnableAction = async (ruleQuery, options) => {
+	const entry = findRuleInCatalog(buildRuleCatalog(), ruleQuery);
+	if (!entry) {
+		reportRuleNotFound(ruleQuery);
+		return;
+	}
+	if (options.severity === void 0) {
+		await setRuleSeverityAndReport(entry, entry.defaultSeverity, options);
+		return;
+	}
+	const severity = parseSeverity(options.severity);
+	if (!severity) {
+		reportInvalidSeverity(options.severity);
+		return;
+	}
+	if (severity === "off") {
+		cliLogger.error("`enable` cannot set a rule to off. Use `react-doctor rules disable` instead.");
+		process.exitCode = 1;
+		return;
+	}
+	await setRuleSeverityAndReport(entry, severity, options);
+};
+const rulesDisableAction = async (ruleQuery, options) => {
+	const entry = findRuleInCatalog(buildRuleCatalog(), ruleQuery);
+	if (!entry) {
+		reportRuleNotFound(ruleQuery);
+		return;
+	}
+	await setRuleSeverityAndReport(entry, "off", options);
+};
+const rulesCategoryAction = async (categoryQuery, severityValue, options) => {
+	const severity = parseSeverity(severityValue);
+	if (!severity) {
+		reportInvalidSeverity(severityValue);
+		return;
+	}
+	const knownCategories = listRuleCategories(buildRuleCatalog());
+	const matchedCategory = knownCategories.find((category) => category.toLowerCase() === categoryQuery.toLowerCase());
+	if (!matchedCategory) {
+		cliLogger.error(`Unknown category "${categoryQuery}".`);
+		cliLogger.dim(`  Known categories: ${knownCategories.join(", ")}`);
+		process.exitCode = 1;
+		return;
+	}
+	const { target, nextConfig, written } = await applyConfigChange(options, (config) => setCategorySeverity(config, matchedCategory, severity));
+	if (!written) {
+		reportManualEdit(target, nextConfig);
+		return;
+	}
+	cliLogger.success(`Set category "${matchedCategory}" → ${severity}`);
+	cliLogger.dim(`  Updated ${describeTargetPath(target)}`);
+};
+const rulesIgnoreTagAction = async (tag, options) => {
+	const knownTags = listRuleTags(buildRuleCatalog());
+	if (!knownTags.includes(tag)) {
+		cliLogger.error(`Unknown tag "${tag}".`);
+		cliLogger.dim(`  Known tags: ${knownTags.join(", ")}`);
+		process.exitCode = 1;
+		return;
+	}
+	const { target, nextConfig, written } = await applyConfigChange(options, (config) => addIgnoredTag(config, tag));
+	if (!written) {
+		reportManualEdit(target, nextConfig);
+		return;
+	}
+	cliLogger.success(`Ignoring tag "${tag}" (rules with this tag are skipped before linting)`);
+	cliLogger.dim(`  Updated ${describeTargetPath(target)}`);
+};
+const rulesUnignoreTagAction = async (tag, options) => {
+	const target = await resolveRuleConfigTarget(resolveProjectRoot(options));
+	if (!(target.config.ignore?.tags ?? []).includes(tag)) {
+		cliLogger.dim(`Tag "${tag}" was not being ignored; nothing to change.`);
+		return;
+	}
+	const nextConfig = removeIgnoredTag(target.config, tag);
+	const { written } = await writeRuleConfig(target, nextConfig);
+	if (!written) {
+		reportManualEdit(target, nextConfig);
+		return;
+	}
+	cliLogger.success(`Tag "${tag}" is no longer ignored`);
+	cliLogger.dim(`  Updated ${describeTargetPath(target)}`);
+};
+//#endregion
+//#region src/cli/commands/version.ts
+/**
+* oclif-style version line. 12-factor CLI Apps (#3, "What version am I
+* on?"): the `version` command is the primary place users grab debugging
+* info, so it carries the Node runtime and platform alongside the CLI
+* version. The `-v` / `-V` / `--version` flags stay terse (just the
+* number) so scripts can parse them.
+*/
+const buildVersionString = () => `react-doctor/${VERSION} ${process.platform}-${process.arch} node-${process.version}`;
+const versionAction = () => {
+	process.stdout.write(`${buildVersionString()}\n`);
+};
+//#endregion
+//#region src/cli/utils/apply-color-preference.ts
+/**
+* Resolve an explicit color preference from `--color` / `--no-color` or the
+* app-specific `REACT_DOCTOR_NO_COLOR` / `REACT_DOCTOR_FORCE_COLOR` env vars
+* (clig.dev Output; 12-factor #6), overriding picocolors' own
+* `NO_COLOR` / `FORCE_COLOR` / `TERM` / TTY detection. Flags win over env
+* vars; with neither set, picocolors' detection stands.
+*
+* A resolved preference is mirrored onto the standard `NO_COLOR` /
+* `FORCE_COLOR` env vars in addition to our picocolors highlighter, so
+* libraries with their own color stacks (the `ora` spinner, `prompts`)
+* honor it too rather than only the scan report. Scanning argv directly
+* (not Commander's parsed options) applies the preference before Commander
+* parses, so it reaches every later path. The scan stops at `--`.
+*/
+const applyColorPreference = (argv, env = process.env) => {
+	let enabled;
+	for (const argument of argv) {
+		if (argument === "--") break;
+		if (argument === "--no-color") enabled = false;
+		else if (argument === "--color") enabled = true;
+	}
+	if (enabled === void 0) {
+		if (env.REACT_DOCTOR_NO_COLOR) enabled = false;
+		else if (env.REACT_DOCTOR_FORCE_COLOR) enabled = true;
+	}
+	if (enabled === void 0) return;
+	if (enabled) {
+		env.FORCE_COLOR = "1";
+		delete env.NO_COLOR;
+	} else {
+		env.NO_COLOR = "1";
+		delete env.FORCE_COLOR;
+	}
+	setColorEnabled(enabled);
+};
+//#endregion
 //#region src/cli/utils/exit-gracefully.ts
 const exitGracefully = () => {
 	try {
@@ -17179,21 +18782,54 @@ const exitGracefully = () => {
 	process.exit(130);
 };
 //#endregion
+//#region src/cli/utils/normalize-help-command.ts
+/**
+* 12-factor CLI Apps (#1, "Great help is essential"): `mycli help` and
+* `mycli help <command>` must display help. Commander doesn't wire this
+* up once the root command has its own default action plus a positional
+* argument — it treats a leading `help` as the `[directory]` to scan,
+* which then errors with "No React project found in ./help".
+*
+* We rewrite the argv up front so the existing `--help` paths handle it:
+*   `react-doctor help`         -> `react-doctor --help`
+*   `react-doctor help install` -> `react-doctor install --help`
+*
+* Only a *leading* `help` token is rewritten, so a flag value such as
+* `--project help` is never mistaken for the help command. The target is
+* the first non-flag token after `help`, so intervening flags like
+* `help --no-color install` still resolve to `install`. An unknown target
+* (`help bogus`) falls back to root help rather than erroring.
+*/
+const normalizeHelpInvocation = (argv, knownCommands) => {
+	const nodeArguments = argv.slice(0, 2);
+	const userArguments = argv.slice(2);
+	if (userArguments[0] !== "help") return [...argv];
+	const target = userArguments.slice(1).find((argument) => !argument.startsWith("-"));
+	if (target !== void 0 && knownCommands.includes(target)) return [
+		...nodeArguments,
+		target,
+		"--help"
+	];
+	return [...nodeArguments, "--help"];
+};
+//#endregion
 //#region src/cli/utils/strip-unknown-cli-flags.ts
-const NODE_ARGUMENT_COUNT = 2;
 const ROOT_FLAG_SPEC = {
 	longOptionsWithoutValues: new Set([
 		"--annotations",
+		"--color",
 		"--dead-code",
 		"--full",
 		"--help",
 		"--json",
 		"--json-compact",
 		"--lint",
+		"--no-color",
 		"--no-dead-code",
 		"--no-lint",
 		"--no-respect-inline-disables",
 		"--no-score",
+		"--no-telemetry",
 		"--no-warnings",
 		"--pr-comment",
 		"--respect-inline-disables",
@@ -17211,7 +18847,7 @@ const ROOT_FLAG_SPEC = {
 		"--project",
 		"--why"
 	]),
-	longOptionsWithOptionalValues: new Set(["--diff"]),
+	longOptionsWithOptionalValues: new Set(["--diff", "--experimental-parallel"]),
 	shortOptionsWithoutValues: new Set([
 		"-h",
 		"-v",
@@ -17222,8 +18858,10 @@ const ROOT_FLAG_SPEC = {
 const INSTALL_FLAG_SPEC = {
 	longOptionsWithoutValues: new Set([
 		"--agent-hooks",
+		"--color",
 		"--dry-run",
 		"--help",
+		"--no-color",
 		"--yes"
 	]),
 	longOptionsWithRequiredValues: new Set(["--cwd"]),
@@ -17231,7 +18869,40 @@ const INSTALL_FLAG_SPEC = {
 	shortOptionsWithoutValues: new Set(["-h", "-y"]),
 	shortOptionsWithRequiredValues: new Set(["-c"])
 };
-const COMMAND_FLAG_SPECS = new Map([["install", INSTALL_FLAG_SPEC], ["setup", INSTALL_FLAG_SPEC]]);
+const COMMAND_FLAG_SPECS = new Map([
+	["install", INSTALL_FLAG_SPEC],
+	["setup", INSTALL_FLAG_SPEC],
+	["version", {
+		longOptionsWithoutValues: new Set([
+			"--color",
+			"--help",
+			"--no-color"
+		]),
+		longOptionsWithRequiredValues: /* @__PURE__ */ new Set(),
+		longOptionsWithOptionalValues: /* @__PURE__ */ new Set(),
+		shortOptionsWithoutValues: new Set(["-h"]),
+		shortOptionsWithRequiredValues: /* @__PURE__ */ new Set()
+	}],
+	["rules", {
+		longOptionsWithoutValues: new Set([
+			"--color",
+			"--configured",
+			"--help",
+			"--json",
+			"--no-color"
+		]),
+		longOptionsWithRequiredValues: new Set([
+			"--category",
+			"--cwd",
+			"--framework",
+			"--severity",
+			"--tag"
+		]),
+		longOptionsWithOptionalValues: /* @__PURE__ */ new Set(),
+		shortOptionsWithoutValues: new Set(["-h"]),
+		shortOptionsWithRequiredValues: new Set(["-c"])
+	}]
+]);
 const isFlagLike = (argument) => argument.startsWith("-") && argument !== "-";
 const getLongOptionName = (argument) => {
 	const equalsIndex = argument.indexOf("=");
@@ -17285,8 +18956,8 @@ const stripUnknownFlags = (userArguments, flagSpec) => {
 	return sanitizedArguments;
 };
 const stripUnknownCliFlags = (argv) => {
-	const nodeArguments = argv.slice(0, NODE_ARGUMENT_COUNT);
-	const userArguments = argv.slice(NODE_ARGUMENT_COUNT);
+	const nodeArguments = argv.slice(0, 2);
+	const userArguments = argv.slice(2);
 	const commandIndex = findCommandIndex(userArguments);
 	if (commandIndex === null) return [...nodeArguments, ...stripUnknownFlags(userArguments, ROOT_FLAG_SPEC)];
 	const commandName = userArguments[commandIndex];
@@ -17300,23 +18971,75 @@ const stripUnknownCliFlags = (argv) => {
 };
 //#endregion
 //#region src/cli/index.ts
+initializeSentry();
 process.on("SIGINT", exitGracefully);
 process.on("SIGTERM", exitGracefully);
 unrefStdin();
-const program = new Command().name("react-doctor").description("Diagnose React codebase health").version(VERSION, "-v, --version", "display the version number").argument("[directory]", "project directory to scan", ".").option("--lint", "enable linting").option("--no-lint", "skip linting").option("--dead-code", "enable dead-code analysis (default)").option("--no-dead-code", "skip dead-code analysis (unused files / exports / dependencies, circular imports)").option("--verbose", "show every rule and per-file details (default shows top 3 rules)").option("--score", "output only the score").option("--json", "output a single structured JSON report (suppresses other output)").option("--json-compact", "with --json, emit compact JSON (no indentation)").option("-y, --yes", "skip prompts, scan all workspace projects").option("--full", "force a full scan (overrides any `diff` value in config or `--diff`)").option("--project <name>", "select workspace project (comma-separated for multiple)").option("--diff [base]", "scan only files changed vs base branch (pass `false` to disable; overridden by --full)").option("--changed-files-from <file>", "internal: scan source files listed in a newline-delimited changed-files file").option("--no-score", "skip the score API and the share URL").option("--staged", "scan only staged (git index) files for pre-commit hooks").option("--fail-on <level>", "exit with error code on diagnostics: error, warning, none (default: none)").option("--annotations", "output diagnostics as GitHub Actions annotations").option("--pr-comment", "tune CLI output for sticky PR comments (drops weak-signal rule families like `design` from the printed list and the fail-on gate; configure via config.surfaces)").option("--explain <file:line>", "diagnose why a rule fired or why a suppression didn't apply at a specific location").option("--why <file:line>", "alias for --explain").option("--respect-inline-disables", "respect inline `// eslint-disable*` / `// oxlint-disable*` comments (default)").option("--no-respect-inline-disables", "audit mode: neutralize inline lint suppressions before scanning").option("--warnings", "show warning-severity diagnostics (errors always show)").option("--no-warnings", "hide warning-severity diagnostics (default)").addHelpText("after", `
+const formatExampleLines = (examples) => {
+	const width = Math.max(...examples.map(([command]) => command.length));
+	return examples.map(([command, description]) => `  $ ${command.padEnd(width)}  ${highlighter.dim(`# ${description}`)}`).join("\n");
+};
+const renderRootHelpEpilog = () => `
+${highlighter.dim("Examples:")}
+${formatExampleLines([
+	["react-doctor", "scan the current project"],
+	["react-doctor ./apps/web", "scan a specific directory"],
+	["react-doctor --diff main", "scan only files changed vs. main"],
+	["react-doctor --staged", "scan staged files (pre-commit hook)"],
+	["react-doctor --fail-on warning", "exit non-zero on warnings (CI gate)"],
+	["react-doctor --json > report.json", "write a machine-readable report"],
+	["react-doctor --explain src/App.tsx:42", "explain why a rule fired there"],
+	["react-doctor install", "set up the agent skill and git hook"]
+])}
+
 ${highlighter.dim("Configuration:")}
-  Place a ${highlighter.info("react-doctor.config.json")} (or ${highlighter.info("\"reactDoctor\"")} key in your package.json) in the project root.
-  CLI flags always override config values. See the README for the full schema.
+  Add a ${highlighter.info("doctor.config.ts")} (or .js/.mjs/.json — or a ${highlighter.info("\"reactDoctor\"")} key in your package.json) in the project root.
+  Use ${highlighter.info("react-doctor rules")} to list, explain, and configure rules. CLI flags always override config values.
+
+${highlighter.dim("Feedback & bug reports:")}
+  ${highlighter.info(`${CANONICAL_GITHUB_URL}/issues`)}
 
 ${highlighter.dim("Learn more:")}
   ${highlighter.info(CANONICAL_GITHUB_URL)}
-`);
+`;
+const renderInstallHelpEpilog = () => `
+${highlighter.dim("Examples:")}
+${formatExampleLines([
+	["react-doctor install", "interactive setup"],
+	["react-doctor install --yes", "non-interactive; all detected agents"],
+	["react-doctor install --dry-run", "preview without writing files"],
+	["react-doctor install --agent-hooks", "also install native agent hooks"]
+])}
+
+${highlighter.dim("Learn more:")}
+  ${highlighter.info(CANONICAL_GITHUB_URL)}
+`;
+const program = new Command().name("react-doctor").description("Diagnose React codebase health").version(VERSION, "-v, --version", "display the version number").argument("[directory]", "project directory to scan", ".").option("--lint", "enable linting").option("--no-lint", "skip linting").option("--dead-code", "enable dead-code analysis (default)").option("--no-dead-code", "skip dead-code analysis (unused files / exports / dependencies, circular imports)").option("--verbose", "show every rule and per-file details (default shows top 3 rules)").option("--score", "output only the score").option("--json", "output a single structured JSON report (suppresses other output)").option("--json-compact", "with --json, emit compact JSON (no indentation)").option("-y, --yes", "skip prompts, scan all workspace projects").option("--full", "force a full scan (overrides any `diff` value in config or `--diff`)").option("--experimental-parallel [workers]", "experimental: lint with N parallel workers (default: auto-detect CPU cores) — speeds up large repos").option("--project <name>", "select workspace project (comma-separated for multiple)").option("--diff [base]", "scan only files changed vs base branch (pass `false` to disable; overridden by --full)").option("--changed-files-from <file>", "internal: scan source files listed in a newline-delimited changed-files file").option("--no-score", "skip the score API, the share URL, and crash reporting").option("--no-telemetry", "alias for --no-score (skip the score API, share URL, and crash reporting)").option("--staged", "scan only staged (git index) files for pre-commit hooks").option("--fail-on <level>", "exit with error code on diagnostics: error, warning, none (default: none)").option("--annotations", "output diagnostics as GitHub Actions annotations").option("--pr-comment", "tune CLI output for sticky PR comments (drops weak-signal rule families like `design` from the printed list and the fail-on gate; configure via config.surfaces)").option("--explain <file:line>", "diagnose why a rule fired or why a suppression didn't apply at a specific location").option("--why <file:line>", "alias for --explain").option("--respect-inline-disables", "respect inline `// eslint-disable*` / `// oxlint-disable*` comments (default)").option("--no-respect-inline-disables", "audit mode: neutralize inline lint suppressions before scanning").option("--warnings", "show warning-severity diagnostics (default)").option("--no-warnings", "hide warning-severity diagnostics (errors only)").option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").addHelpText("after", renderRootHelpEpilog);
 program.action(inspectAction);
-program.command("install").alias("setup").description("Install the react-doctor skill into your coding agents and optional git hook").option("-y, --yes", "skip prompts, install for all detected agents").option("--dry-run", "show what would be installed without writing files").option("--agent-hooks", "install native non-blocking agent hooks for Claude Code and Cursor").option("-c, --cwd <cwd>", "working directory", process.cwd()).action(installAction);
+program.command("install").alias("setup").description("Install the react-doctor skill into your coding agents and optional git hook").option("-y, --yes", "skip prompts, install for all detected agents").option("--dry-run", "show what would be installed without writing files").option("--agent-hooks", "install native non-blocking agent hooks for Claude Code and Cursor").option("-c, --cwd <cwd>", "working directory", process.cwd()).option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").addHelpText("after", renderInstallHelpEpilog).action(installAction);
+program.command("version").description("show the version with Node and platform info").option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").action(versionAction);
+const rules = program.command("rules").description("List, explain, and configure which React Doctor rules run");
+rules.command("list").description("List rules and the severity they run at under your config").option("--category <name>", "only show rules in a category (e.g. Performance)").option("--tag <name>", "only show rules with a tag (e.g. design, test-noise)").option("--framework <name>", "only show rules for a framework (e.g. global, nextjs)").option("--configured", "only show rules your config has changed from the default").option("--json", "output a structured JSON array").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((_options, command) => rulesListAction(command.optsWithGlobals()));
+rules.command("explain <rule>").description("Explain why a rule matters, its current severity, and how to configure it").option("--json", "output a structured JSON object").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((rule, _options, command) => rulesExplainAction(rule, command.optsWithGlobals()));
+rules.command("set <rule> <severity>").description("Set a rule's severity: off, warn, or error").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((rule, severity, _options, command) => rulesSetAction(rule, severity, command.optsWithGlobals()));
+rules.command("enable <rule>").description("Enable a rule at its recommended severity (or pass --severity)").option("--severity <level>", "severity to enable at: warn or error").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((rule, _options, command) => rulesEnableAction(rule, command.optsWithGlobals()));
+rules.command("disable <rule>").description("Disable a rule so it never runs").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((rule, _options, command) => rulesDisableAction(rule, command.optsWithGlobals()));
+rules.command("category <category> <severity>").description("Set the severity for a whole category (off, warn, error)").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((category, severity, _options, command) => rulesCategoryAction(category, severity, command.optsWithGlobals()));
+rules.command("ignore-tag <tag>").description("Skip a whole rule family by tag before linting (e.g. design)").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((tag, _options, command) => rulesIgnoreTagAction(tag, command.optsWithGlobals()));
+rules.command("unignore-tag <tag>").description("Stop ignoring a tag previously skipped via ignore-tag").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((tag, _options, command) => rulesUnignoreTagAction(tag, command.optsWithGlobals()));
 process.stdout.on("error", (error) => {
 	if (error.code === "EPIPE") process.exit(0);
 });
-program.parseAsync(stripUnknownCliFlags(process.argv)).catch((error) => {
+const knownCommands = program.commands.flatMap((command) => [command.name(), ...command.aliases()]);
+const strippedArgv = stripUnknownCliFlags(process.argv);
+if (process.argv.includes("-V") && !strippedArgv.includes("-V")) {
+	process.stdout.write(`${VERSION}\n`);
+	process.exit(0);
+}
+applyColorPreference(strippedArgv);
+const argv = normalizeHelpInvocation(strippedArgv, knownCommands);
+program.parseAsync(argv).catch(async (error) => {
+	await reportErrorToSentry(error);
 	if (isJsonModeActive()) {
 		writeJsonErrorReport(error);
 		process.exit(1);