react-doctor 0.2.14-dev.4bc8a73 → 0.2.14-dev.5976266

package/dist/index.d.ts

@@ -5,13 +5,35 @@ import * as Cause from "effect/Cause";
 //#region src/types/config.d.ts
 type FailOnLevel = "error" | "warning" | "none";
 interface ReactDoctorIgnoreOverride {
+  /** Glob patterns the override applies to (e.g. `["src/legacy/**"]`). */
   files: string[];
+  /**
+   * Rule keys to suppress for the matched files. Omit (or leave empty) to
+   * suppress every rule for those files.
+   */
   rules?: string[];
 }
 interface ReactDoctorIgnoreConfig {
+  /**
+   * Fully-qualified rule keys (`"<plugin>/<rule>"`) whose diagnostics are
+   * dropped AFTER linting. The rule still runs; its findings are filtered
+   * out. To stop a rule from running at all, set it to `"off"` in the
+   * top-level `rules` map instead. Prefer `react-doctor rules disable
+   * <rule>` to edit this safely.
+   */
   rules?: string[];
+  /**
+   * Glob patterns whose files are excluded from scanning entirely (matched
+   * against paths relative to the scanned directory).
+   */
   files?: string[];
+  /** Per-path rule suppressions — narrower than the top-level `rules`/`files`. */
   overrides?: ReactDoctorIgnoreOverride[];
+  /**
+   * Behavioral tags whose rules are disabled BEFORE linting, skipping a
+   * whole family at once (e.g. `["design", "test-noise", "migration-hint"]`).
+   * Prefer `react-doctor rules ignore-tag <tag>` to edit this safely.
+   */
   tags?: string[];
 }
 /**
@@ -100,11 +122,11 @@ interface ReactDoctorConfig {
   deadCode?: boolean;
   verbose?: boolean;
   /**
-   * Whether to surface `"warning"`-severity diagnostics. Default: `false`
-   * — only `"error"`-severity findings reach any surface (CLI, PR comment,
-   * score, `--fail-on`).
+   * Whether to surface `"warning"`-severity diagnostics. Default: `true`
+   * — every warning reaches every surface (CLI, PR comment, score,
+   * `--fail-on`).
    *
-   * Set to `true` to surface every warning on every surface. This is the
+   * Set to `false` to surface only `"error"`-severity findings. This is the
    * master toggle and runs after per-rule / per-category severity
    * overrides: a rule the user explicitly restamps to `"warn"` (via
    * `rules` / `categories`) still shows even when `warnings` is `false`.
@@ -122,7 +144,7 @@ interface ReactDoctorConfig {
    * the redirect is stable no matter where the CLI / `diagnose()` is
    * run from. Absolute paths are used as-is.
    *
-   * Typical use: a monorepo root holds the only `react-doctor.config.json`
+   * Typical use: a monorepo root holds the only `doctor.config.*`
    * (so editor tooling and child commands all find it), but the React
    * app lives in `apps/web`. Setting `"rootDir": "apps/web"` makes
    * every invocation that loads this config scan that subproject
@@ -420,8 +442,8 @@ interface DiagnoseOptions {
   respectInlineDisables?: boolean;
   /**
    * Per-call override for `ReactDoctorConfig.warnings`. See that field's
-   * docs — `"warning"`-severity diagnostics are hidden unless this (or
-   * the config) opts them back in.
+   * docs — `"warning"`-severity diagnostics surface by default unless this
+   * (or the config) opts out via `false`.
    */
   warnings?: boolean;
 }
@@ -444,7 +466,7 @@ interface DiagnoseResult {
  * Scan options (`deadCode`, `lint`, etc.) are flat on the entry and
  * layer on top of the global defaults — omitted fields fall through.
  * `config` is a full `ReactDoctorConfig` override that replaces the
- * on-disk `react-doctor.config.json` for this project's scan.
+ * on-disk `doctor.config.*` for this project's scan.
  */
 //#endregion
 //#region src/types/inspect.d.ts
@@ -742,7 +764,7 @@ interface BuildJsonReportInput {
   totalElapsedMilliseconds: number;
 }
 declare const buildJsonReport: (input: BuildJsonReportInput) => JsonReport; //#endregion
-//#region src/can-oxlint-extend-config.d.ts
+//#region src/build-skipped-checks.d.ts
 //#endregion
 //#region src/get-diff-files.d.ts
 /**

package/dist/index.js

@@ -14,7 +14,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 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";
@@ -26,7 +29,6 @@ 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 from "node:os";
 import * as ts from "typescript";
 import { gzipSync } from "node:zlib";
 //#region \0rolldown/runtime.js
@@ -3289,7 +3291,14 @@ 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"
 ];
@@ -4271,6 +4280,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
@@ -4290,6 +4310,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",
@@ -4446,69 +4490,109 @@ const validateConfigTypes = (config) => {
 const warn = (message) => {
 	Effect.runSync(Console.warn(message));
 };
-const CONFIG_FILENAME = "react-doctor.config.json";
+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 = "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 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
+			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 clearConfigCache = () => {
 	cachedConfigs.clear();
 };
-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 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 resolveConfigRootDir = (config, configSourceDirectory) => {
 	if (!config || !configSourceDirectory) return null;
 	const rawRootDir = config.rootDir;
@@ -4536,8 +4620,7 @@ const resolveDiagnoseTarget = (directory, options = {}) => {
 * (`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
@@ -4555,9 +4638,9 @@ const resolveDiagnoseTarget = (directory, options = {}) => {
 * via its own cache). Routing through `resolveScanTarget` keeps every
 * shell in agreement on what "the scan directory" means.
 */
-const resolveScanTarget = (requestedDirectory, options = {}) => {
+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);
@@ -5607,8 +5690,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,
@@ -6483,6 +6566,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_*";
@@ -7165,6 +7286,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 = [];
@@ -7184,23 +7306,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(", ");
@@ -7327,7 +7457,8 @@ const runOxlint = async (options) => {
 			onPartialFailure,
 			onFileProgress: options.onFileProgress,
 			spawnTimeoutMs,
-			outputMaxBytes
+			outputMaxBytes,
+			concurrency: options.concurrency
 		});
 		writeOxlintConfig(configPath, buildConfig(extendsPaths));
 		try {
@@ -7395,6 +7526,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({
@@ -7413,7 +7545,8 @@ var Linter = class Linter extends Context.Service()("react-doctor/Linter") {
 				},
 				onFileProgress: input.onFileProgress,
 				spawnTimeoutMs,
-				outputMaxBytes
+				outputMaxBytes,
+				concurrency
 			}),
 			catch: ensureReactDoctorError
 		});
@@ -7737,7 +7870,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,
@@ -7762,6 +7895,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;
@@ -7778,7 +7913,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, {
@@ -7810,7 +7945,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,
@@ -7862,7 +7997,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 {
@@ -8161,6 +8295,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`).
@@ -8266,7 +8420,7 @@ import_picocolors.default.red, import_picocolors.default.yellow, import_picocolo
 const clearAutoSuppressionCaches = () => {};
 //#endregion
 //#region ../api/dist/index.js
-const DEFAULT_LAYER = Layer.mergeAll(Project.layerNode, Config.layerNode, DeadCode.layerNode, Files.layerNode, Git.layerNode, Linter.layerOxlint, LintPartialFailures.layerLive, Progress.layerNoop, Reporter.layerNoop, Score.layerHttp);
+const buildDiagnoseLayer = (configLayer = Config.layerNode) => Layer.mergeAll(Project.layerNode, configLayer, DeadCode.layerNode, Files.layerNode, Git.layerNode, Linter.layerOxlint, LintPartialFailures.layerLive, Progress.layerNoop, Reporter.layerNoop, Score.layerHttp);
 const buildInspectProgram = (scanTarget, options, configOverride) => {
 	const effectiveConfig = configOverride ?? scanTarget.userConfig;
 	const includePaths = options.includePaths ?? [];
@@ -8275,7 +8429,7 @@ const buildInspectProgram = (scanTarget, options, configOverride) => {
 		includePaths,
 		customRulesOnly: effectiveConfig?.customRulesOnly ?? false,
 		respectInlineDisables: options.respectInlineDisables ?? effectiveConfig?.respectInlineDisables ?? true,
-		warnings: options.warnings ?? effectiveConfig?.warnings ?? false,
+		warnings: options.warnings ?? effectiveConfig?.warnings ?? true,
 		adoptExistingLintConfig: effectiveConfig?.adoptExistingLintConfig ?? true,
 		ignoredTags: new Set(effectiveConfig?.ignore?.tags ?? []),
 		runDeadCode: options.deadCode ?? effectiveConfig?.deadCode ?? true,
@@ -8285,13 +8439,7 @@ const buildInspectProgram = (scanTarget, options, configOverride) => {
 };
 const outputToDiagnoseResult = (output, elapsedMilliseconds) => {
 	if (output.didLintFail && output.lintFailureReason !== null) console.error("Lint failed:", output.lintFailureReason);
-	const skippedChecks = [];
-	if (output.didLintFail) skippedChecks.push("lint");
-	if (output.didDeadCodeFail) skippedChecks.push("dead-code");
-	const skippedCheckReasons = {};
-	if (output.didLintFail && output.lintFailureReason !== null) skippedCheckReasons.lint = output.lintFailureReason;
-	else if (output.lintPartialFailures.length > 0) skippedCheckReasons["lint:partial"] = output.lintPartialFailures.join("; ");
-	if (output.didDeadCodeFail && output.deadCodeFailureReason !== null) skippedCheckReasons["dead-code"] = output.deadCodeFailureReason;
+	const { skippedChecks, skippedCheckReasons } = buildSkippedChecks(output);
 	return {
 		diagnostics: [...output.diagnostics],
 		score: output.score,
@@ -8303,8 +8451,8 @@ const outputToDiagnoseResult = (output, elapsedMilliseconds) => {
 };
 const diagnose = async (directory, options = {}) => {
 	const startTime = globalThis.performance.now();
-	const program = buildInspectProgram(resolveScanTarget(directory), options);
-	return outputToDiagnoseResult(await Effect.runPromise(restoreLegacyThrow(program.pipe(Effect.provide(DEFAULT_LAYER), Effect.provide(layerOtlp)))), globalThis.performance.now() - startTime);
+	const program = buildInspectProgram(await resolveScanTarget(directory), options);
+	return outputToDiagnoseResult(await Effect.runPromise(restoreLegacyThrow(program.pipe(Effect.provide(buildDiagnoseLayer()), Effect.provide(layerOtlp)))), globalThis.performance.now() - startTime);
 };
 //#endregion
 //#region src/index.ts