react-doctor 0.9.2 → 0.9.3-dev.02e3188

package/dist/run-scan-app-DtYeufgr.js

@@ -0,0 +1,2195 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e34d02bb-f20a-5479-99b2-18946ed44afb")}catch(e){}}();
+import { $ as highlighter, A as hasLintHardFailure, B as isUnicodeSupported, C as shouldRecordOnboarding, D as buildCodeFrame, E as formatElapsedTime, F as resolveBlockingLevel, G as isCiEnvironment, H as METRIC, I as isReactDoctorWorkflowInstalled, J as Progress, K as DIAGNOSTIC_CATEGORY_BUCKETS, L as recordCount, M as buildSortedRuleGroups, N as formatFixRecipeLine, O as buildEmptyReportMessage, P as formatLearnMoreLine, Q as hasPublishedFixRecipe, R as toForwardSlashes, S as isOnboardingForced, T as computeProjectedScore, U as TUI_REPORT_COMPACT_MAX_ROWS, V as CI_TRUST_COMPANIES, W as TUI_REPORT_DETAIL_WIDTH_FRACTION, X as buildRuleDocsUrl, Y as Reporter, Z as getCategoryImpact, _ as printFooter, a as resolveCliInspectOptions, at as void_, b as markOnboardingComplete, c as setUpGitHubActions, d as CLI_AGENT_BINARIES, et as mapWithConcurrency, f as copyToClipboard, g as createInvocationInspect, h as isShareOptedOut, i as selectProjects, it as sync, j as buildRulePriorityMap, k as buildNoScoreMessage, l as openUrl, m as buildHandoffPayload, n as shouldFailScanGate, nt as resolveScanTarget, o as filterScansForSurface, ot as succeed, p as launchCliAgent, q as GITHUB_ACTIONS_SETUP_URL, r as discoverWorkspacePackages, rt as runPromise, s as countUniqueScannedFiles, t as exitGracefully, tt as mergeReactDoctorConfigs, u as detectLaunchableAgents, v as easeOutCubic, w as filterDiagnosticsByCategories, x as canAnimateOnboarding, y as doctorFace, z as findNearestPackageDirectory } from "./cli.js";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { getSkillAgentConfig } from "agent-install";
+import { Box, Text, render, useApp, useInput, useStdout } from "ink";
+import figures from "figures";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import Link from "ink-link";
+import Spinner from "ink-spinner";
+//#region src/cli/utils/pluralize.ts
+const pluralize = (count, singularNoun) => `${count} ${singularNoun}${count === 1 ? "" : "s"}`;
+//#endregion
+//#region src/cli/utils/select-report-diagnostics.ts
+const selectReportDiagnostics = (input) => {
+	const surfaceDiagnostics = filterScansForSurface([input.scan], input.surface ?? "cli");
+	return {
+		diagnostics: filterDiagnosticsByCategories(surfaceDiagnostics, new Set(input.categoryFilters)),
+		demotedDiagnosticCount: input.scan.result.diagnostics.length - surfaceDiagnostics.length
+	};
+};
+//#endregion
+//#region src/cli/utils/clamp-number.ts
+const clampNumber = (value, minimum, maximum) => Math.max(minimum, Math.min(maximum, value));
+//#endregion
+//#region src/cli/utils/is-printable-input.ts
+const isPrintableInput = (input) => input.length > 0 && [...input].every((character) => character.charCodeAt(0) >= 32);
+//#endregion
+//#region src/cli/utils/resolve-visible-start.ts
+const resolveVisibleStart = ({ itemCount, offset, selectedIndex, viewportHeight }) => {
+	if (viewportHeight <= 0) return 0;
+	const boundedOffset = clampNumber(offset, 0, Math.max(0, itemCount - viewportHeight));
+	if (selectedIndex < boundedOffset) return selectedIndex;
+	if (selectedIndex >= boundedOffset + viewportHeight) return Math.max(0, selectedIndex - viewportHeight + 1);
+	return boundedOffset;
+};
+//#endregion
+//#region src/cli/ink/hooks/use-exit-on-ctrl-c.ts
+const SHOW_CURSOR = "\x1B[?25h";
+const useExitOnCtrlC = () => {
+	const { exit } = useApp();
+	useInput((input, key) => {
+		if (key.ctrl && input === "c") {
+			recordCount(METRIC.tuiCancelled, 1, { resourceFooter: true });
+			exit();
+			process.stdin.setRawMode?.(false);
+			process.stdout.write(SHOW_CURSOR);
+			exitGracefully();
+		}
+	});
+};
+//#endregion
+//#region src/cli/ink/hooks/use-stdout-dimensions.ts
+const readDimensions = (stdout) => ({
+	columns: stdout?.columns ?? 80,
+	rows: stdout?.rows ?? 24
+});
+const useStdoutDimensions = () => {
+	const { stdout } = useStdout();
+	const [dimensions, setDimensions] = useState(() => readDimensions(stdout));
+	useEffect(() => {
+		if (!stdout) return;
+		const onResize = () => setDimensions(readDimensions(stdout));
+		stdout.on("resize", onResize);
+		return () => {
+			stdout.off("resize", onResize);
+		};
+	}, [stdout]);
+	return dimensions;
+};
+//#endregion
+//#region src/cli/ink/lib/fuzzy-match.ts
+const fuzzyMatch = (query, target) => {
+	if (query.length === 0) return {
+		score: 0,
+		matchedIndices: []
+	};
+	const lowerQuery = query.toLowerCase();
+	const lowerTarget = target.toLowerCase();
+	const matchedIndices = [];
+	let score = 0;
+	let queryIndex = 0;
+	let previousMatchIndex = Number.NEGATIVE_INFINITY;
+	for (let targetIndex = 0; targetIndex < lowerTarget.length && queryIndex < lowerQuery.length; targetIndex++) {
+		if (lowerTarget[targetIndex] !== lowerQuery[queryIndex]) continue;
+		matchedIndices.push(targetIndex);
+		if (targetIndex === previousMatchIndex + 1) score += 5;
+		const previousCharacter = target[targetIndex - 1];
+		if (targetIndex === 0 || previousCharacter === "-" || previousCharacter === "_" || previousCharacter === "/" || previousCharacter === " ") score += 10;
+		previousMatchIndex = targetIndex;
+		queryIndex++;
+	}
+	if (queryIndex < lowerQuery.length) return null;
+	score -= matchedIndices[0] * 1;
+	return {
+		score,
+		matchedIndices
+	};
+};
+//#endregion
+//#region src/cli/ink/components/project-select.tsx
+const MatchedName = ({ name, matchedIndices, isSelected }) => {
+	if (matchedIndices.length === 0) return /* @__PURE__ */ jsx(Text, {
+		bold: isSelected,
+		wrap: "truncate-end",
+		children: name
+	});
+	const matchedIndexSet = new Set(matchedIndices);
+	return /* @__PURE__ */ jsx(Text, {
+		bold: isSelected,
+		wrap: "truncate-end",
+		children: [...name].map((character, index) => matchedIndexSet.has(index) ? /* @__PURE__ */ jsx(Text, {
+			color: "yellow",
+			children: character
+		}, index) : character)
+	});
+};
+const ProjectSelect = ({ packages, rootDirectory, onSubmit }) => {
+	const { rows: terminalRows } = useStdoutDimensions();
+	useExitOnCtrlC();
+	const [selectionMode, setSelectionMode] = useState("list");
+	const [searchQuery, setSearchQuery] = useState("");
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const [scrollOffset, setScrollOffset] = useState(0);
+	const [checkedDirectories, setCheckedDirectories] = useState(() => /* @__PURE__ */ new Set());
+	const didRecordProjectPathContext = useRef(false);
+	const matchedPackages = useMemo(() => {
+		const scoredPackages = packages.flatMap((workspacePackage) => {
+			const result = fuzzyMatch(searchQuery, workspacePackage.name);
+			return result ? [{
+				workspacePackage,
+				result
+			}] : [];
+		});
+		if (searchQuery.length > 0) scoredPackages.sort((leftPackage, rightPackage) => rightPackage.result.score - leftPackage.result.score);
+		return scoredPackages.map(({ workspacePackage, result }) => ({
+			workspacePackage,
+			matchedIndices: result.matchedIndices,
+			relativeDirectory: path.relative(rootDirectory, workspacePackage.directory) || "."
+		}));
+	}, [
+		packages,
+		rootDirectory,
+		searchQuery
+	]);
+	const hasProjectPathContext = matchedPackages.some(({ relativeDirectory, workspacePackage }) => relativeDirectory !== workspacePackage.name);
+	useEffect(() => {
+		if (!hasProjectPathContext || didRecordProjectPathContext.current) return;
+		didRecordProjectPathContext.current = true;
+		recordCount(METRIC.tuiProjectPathContextShown);
+	}, [hasProjectPathContext]);
+	const isSearching = selectionMode === "search";
+	const hasFilterLine = isSearching || searchQuery.length > 0;
+	const listHeight = Math.max(1, Math.min(Math.max(matchedPackages.length, 1), terminalRows - 3 - (hasFilterLine ? 1 : 0)));
+	const selectedPackageIndex = matchedPackages.length === 0 ? 0 : clampNumber(selectedIndex, 0, matchedPackages.length - 1);
+	const selectedWorkspacePackage = matchedPackages[selectedPackageIndex]?.workspacePackage;
+	const updateFilter = (nextSearchQuery) => {
+		setSearchQuery(nextSearchQuery);
+		setSelectedIndex(0);
+		setScrollOffset(0);
+	};
+	const moveSelection = (indexDelta) => {
+		if (matchedPackages.length === 0) return;
+		const nextSelectedIndex = clampNumber(selectedPackageIndex + indexDelta, 0, matchedPackages.length - 1);
+		setSelectedIndex(nextSelectedIndex);
+		setScrollOffset((currentOffset) => {
+			if (nextSelectedIndex < currentOffset) return nextSelectedIndex;
+			if (nextSelectedIndex >= currentOffset + listHeight) return nextSelectedIndex - listHeight + 1;
+			return currentOffset;
+		});
+	};
+	const toggleCheckedDirectory = (directory) => {
+		setCheckedDirectories((currentCheckedDirectories) => {
+			const updatedCheckedDirectories = new Set(currentCheckedDirectories);
+			if (updatedCheckedDirectories.has(directory)) updatedCheckedDirectories.delete(directory);
+			else updatedCheckedDirectories.add(directory);
+			return updatedCheckedDirectories;
+		});
+	};
+	const submitDirectories = (directories) => {
+		onSubmit([...directories]);
+	};
+	const submitSelection = () => {
+		if (checkedDirectories.size > 0) {
+			const selectedDirectories = [];
+			for (const workspacePackage of packages) if (checkedDirectories.has(workspacePackage.directory)) selectedDirectories.push(workspacePackage.directory);
+			return submitDirectories(selectedDirectories);
+		}
+		if (selectedWorkspacePackage) submitDirectories([selectedWorkspacePackage.directory]);
+	};
+	useInput((input, key) => {
+		if (isSearching) {
+			if (key.return) return setSelectionMode("list");
+			if (key.escape) {
+				updateFilter("");
+				return setSelectionMode("list");
+			}
+			if (key.downArrow || key.ctrl && input === "n") return moveSelection(1);
+			if (key.upArrow || key.ctrl && input === "p") return moveSelection(-1);
+			if (key.backspace || key.delete) return updateFilter(searchQuery.slice(0, -1));
+			if (isPrintableInput(input) && !key.ctrl && !key.meta) updateFilter(searchQuery + input);
+			return;
+		}
+		if (input === "/") return setSelectionMode("search");
+		if (input === " ") {
+			if (selectedWorkspacePackage) toggleCheckedDirectory(selectedWorkspacePackage.directory);
+			return;
+		}
+		if (input === "a") {
+			if (matchedPackages.length === 0) return;
+			setCheckedDirectories((currentCheckedDirectories) => {
+				const updatedCheckedDirectories = new Set(currentCheckedDirectories);
+				const shouldClearMatches = matchedPackages.every((matchedPackage) => currentCheckedDirectories.has(matchedPackage.workspacePackage.directory));
+				for (const matchedPackage of matchedPackages) if (shouldClearMatches) updatedCheckedDirectories.delete(matchedPackage.workspacePackage.directory);
+				else updatedCheckedDirectories.add(matchedPackage.workspacePackage.directory);
+				return updatedCheckedDirectories;
+			});
+			return;
+		}
+		if (input === "q") return submitDirectories([]);
+		if (key.escape) {
+			if (searchQuery.length > 0) return updateFilter("");
+			if (checkedDirectories.size > 0) return setCheckedDirectories(/* @__PURE__ */ new Set());
+			return submitDirectories([]);
+		}
+		if (key.return) return submitSelection();
+		if (key.downArrow || input === "j") return moveSelection(1);
+		if (key.upArrow || input === "k") return moveSelection(-1);
+		if (key.pageDown) return moveSelection(listHeight);
+		if (key.pageUp) return moveSelection(-listHeight);
+	});
+	const visibleStart = resolveVisibleStart({
+		itemCount: matchedPackages.length,
+		offset: scrollOffset,
+		selectedIndex: selectedPackageIndex,
+		viewportHeight: listHeight
+	});
+	const visibleMatches = matchedPackages.slice(visibleStart, visibleStart + listHeight);
+	const longestNameLength = Math.max(0, ...packages.map((workspacePackage) => workspacePackage.name.length));
+	let filterLine = null;
+	if (isSearching) filterLine = /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: "cyan",
+				children: "/ "
+			}),
+			searchQuery.length > 0 ? /* @__PURE__ */ jsx(Text, { children: searchQuery }) : null,
+			/* @__PURE__ */ jsx(Text, {
+				inverse: true,
+				children: " "
+			})
+		]
+	});
+	else if (searchQuery.length > 0) filterLine = /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		wrap: "truncate-end",
+		children: `filter: ${searchQuery}`
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: "Select projects to scan"
+				}), /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						"  ",
+						checkedDirectories.size,
+						"/",
+						packages.length
+					]
+				})]
+			}),
+			filterLine,
+			/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				height: listHeight,
+				children: matchedPackages.length === 0 ? /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "No matching projects"
+				}) : visibleMatches.map((matchedPackage, visiblePackageIndex) => {
+					const isSelected = visibleStart + visiblePackageIndex === selectedPackageIndex;
+					const isChecked = checkedDirectories.has(matchedPackage.workspacePackage.directory);
+					const shouldShowRelativeDirectory = matchedPackage.relativeDirectory !== matchedPackage.workspacePackage.name;
+					return /* @__PURE__ */ jsxs(Text, {
+						wrap: "truncate-end",
+						children: [
+							/* @__PURE__ */ jsx(Text, {
+								color: isSelected ? "cyan" : void 0,
+								children: isSelected ? `${figures.pointer} ` : "  "
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								color: isChecked ? "green" : void 0,
+								children: isChecked ? `${figures.radioOn} ` : `${figures.radioOff} `
+							}),
+							/* @__PURE__ */ jsx(MatchedName, {
+								name: matchedPackage.workspacePackage.name,
+								matchedIndices: matchedPackage.matchedIndices,
+								isSelected
+							}),
+							shouldShowRelativeDirectory ? /* @__PURE__ */ jsxs(Text, {
+								dimColor: true,
+								children: [" ".repeat(longestNameLength - matchedPackage.workspacePackage.name.length + 2), matchedPackage.relativeDirectory]
+							}) : null
+						]
+					}, matchedPackage.workspacePackage.directory);
+				})
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					wrap: "truncate-end",
+					children: isSearching ? "type to filter · enter confirm · esc clear" : /* @__PURE__ */ jsxs(Fragment, { children: [
+						"space select · a all · / search · ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: "enter"
+						}),
+						" to submit · q cancel"
+					] })
+				})
+			})
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/hooks/use-report-reveal.ts
+const useReportReveal = ({ issueCount, onRevealComplete }) => {
+	const { stdout } = useStdout();
+	const shouldAnimate = issueCount > 0 && canAnimateOnboarding(stdout ?? void 0);
+	const streamStepCount = Math.min(12, Math.max(issueCount, 8));
+	const [streamStep, setStreamStep] = useState(0);
+	const [didRevealActions, setDidRevealActions] = useState(false);
+	const didNotifyRevealComplete = useRef(false);
+	const isStreaming = shouldAnimate && streamStep < streamStepCount;
+	const didReachActions = shouldAnimate ? didRevealActions : stdout?.isTTY === true;
+	useEffect(() => {
+		if (!shouldAnimate) return;
+		let nextStreamStep = 0;
+		const intervalId = setInterval(() => {
+			nextStreamStep = Math.min(streamStepCount, nextStreamStep + 1);
+			setStreamStep(nextStreamStep);
+			if (nextStreamStep === streamStepCount) clearInterval(intervalId);
+		}, 125);
+		return () => clearInterval(intervalId);
+	}, [shouldAnimate, streamStepCount]);
+	useEffect(() => {
+		if (!shouldAnimate || isStreaming) return;
+		const timeoutId = setTimeout(() => setDidRevealActions(true), 850);
+		return () => clearTimeout(timeoutId);
+	}, [isStreaming, shouldAnimate]);
+	useEffect(() => {
+		if (!didReachActions || didNotifyRevealComplete.current) return;
+		didNotifyRevealComplete.current = true;
+		onRevealComplete?.();
+	}, [didReachActions, onRevealComplete]);
+	if (!shouldAnimate) return {
+		phase: "actions",
+		streamSelectedIndex: 0
+	};
+	if (isStreaming) return {
+		phase: "streaming",
+		streamSelectedIndex: streamStep % issueCount
+	};
+	return {
+		phase: didRevealActions ? "actions" : "score",
+		streamSelectedIndex: 0
+	};
+};
+//#endregion
+//#region src/cli/ink/lib/diagnostic-list-entries.ts
+const CATEGORY_RANK = new Map(DIAGNOSTIC_CATEGORY_BUCKETS.map((category, index) => [category, index]));
+const buildDiagnosticListEntries = (rows) => {
+	const rowsByCategory = /* @__PURE__ */ new Map();
+	for (const [rowIndex, row] of rows.entries()) {
+		const categoryRows = rowsByCategory.get(row.category) ?? [];
+		categoryRows.push({
+			row,
+			rowIndex
+		});
+		rowsByCategory.set(row.category, categoryRows);
+	}
+	const orderedCategories = [...rowsByCategory.keys()].sort((categoryA, categoryB) => {
+		const rankDelta = (CATEGORY_RANK.get(categoryA) ?? Number.MAX_SAFE_INTEGER) - (CATEGORY_RANK.get(categoryB) ?? Number.MAX_SAFE_INTEGER);
+		return rankDelta !== 0 ? rankDelta : categoryA.localeCompare(categoryB);
+	});
+	const entries = [];
+	for (const category of orderedCategories) {
+		const categoryRows = rowsByCategory.get(category) ?? [];
+		entries.push({
+			kind: "header",
+			category
+		});
+		for (const indexedRow of categoryRows) entries.push({
+			kind: "item",
+			...indexedRow
+		});
+	}
+	return entries;
+};
+//#endregion
+//#region src/cli/utils/format-diagnostic-site.ts
+const formatDiagnosticSite = (site) => site.line > 0 ? `${site.filePath}:${site.line}` : site.filePath;
+//#endregion
+//#region src/cli/ink/lib/diagnostic-rows.ts
+const buildDiagnosticRows = (diagnostics, scores) => {
+	return buildSortedRuleGroups(diagnostics, buildRulePriorityMap(scores)).map(([ruleKey, ruleDiagnostics]) => {
+		const representative = ruleDiagnostics.find((diagnostic) => diagnostic.line > 0) ?? ruleDiagnostics[0];
+		return {
+			ruleKey,
+			diagnostics: ruleDiagnostics,
+			severity: representative.severity === "error" ? "error" : "warning",
+			category: representative.category,
+			title: representative.title ?? ruleKey,
+			location: formatDiagnosticSite(representative),
+			siteCount: ruleDiagnostics.length,
+			representative,
+			ruleGuideUrl: hasPublishedFixRecipe(representative) ? buildRuleDocsUrl(representative.plugin, representative.rule) : null
+		};
+	});
+};
+//#endregion
+//#region src/cli/ink/lib/resolve-report-layout.ts
+const STACKED_FIXED_ROWS = 9;
+const resolveReportLayout = ({ columns, diagnosticEntryCount, terminalRows }) => {
+	const width = Math.max(1, columns - 2);
+	const reportRows = Math.max(0, terminalRows - 1);
+	const isWide = columns >= 120 && terminalRows >= 22;
+	const isCompact = !isWide && terminalRows <= TUI_REPORT_COMPACT_MAX_ROWS;
+	const showsViewerScoreHeader = !isCompact || reportRows >= 8;
+	const detailHeight = Math.max(0, isWide ? reportRows - 3 : Math.min(15, reportRows - STACKED_FIXED_ROWS - 3));
+	const availableListHeight = isWide ? Math.max(3, detailHeight - 4 - 1) : Math.max(3, reportRows - STACKED_FIXED_ROWS - detailHeight);
+	const isStackedReportCapped = !isCompact && !isWide && availableListHeight > 16;
+	let listHeight = availableListHeight;
+	if (isCompact) {
+		const viewerScoreHeaderRows = showsViewerScoreHeader ? 4 : 0;
+		listHeight = Math.min(diagnosticEntryCount, Math.max(3, reportRows - 1 - viewerScoreHeaderRows));
+	} else if (!isWide) listHeight = Math.min(diagnosticEntryCount, 16, availableListHeight);
+	const detailColumnWidth = Math.max(20, Math.floor(width * TUI_REPORT_DETAIL_WIDTH_FRACTION));
+	const listColumnWidth = Math.max(20, width - detailColumnWidth - 3);
+	let layout = "stacked";
+	if (isCompact) layout = "compact";
+	else if (isWide) layout = "split";
+	return {
+		detailColumnWidth,
+		detailHeight,
+		isStackedReportCapped,
+		layout,
+		listColumnWidth,
+		listHeight,
+		showsViewerScoreHeader,
+		width
+	};
+};
+//#endregion
+//#region src/cli/ink/components/action-menu.tsx
+const ActionMenu = ({ actions, selectedIndex: controlledSelectedIndex, onSelectionChange, onEscape, onQuit }) => {
+	const [internalSelectedIndex, setInternalSelectedIndex] = useState(0);
+	const selectedIndex = controlledSelectedIndex ?? internalSelectedIndex;
+	const changeSelection = onSelectionChange ?? setInternalSelectedIndex;
+	useInput((input, key) => {
+		if (input === "q") return onQuit();
+		if (key.escape) return onEscape();
+		if (actions.length === 0) return;
+		if (key.upArrow || input === "k") return changeSelection(Math.max(0, selectedIndex - 1));
+		if (key.downArrow || input === "j") return changeSelection(Math.min(actions.length - 1, selectedIndex + 1));
+		if (key.return) actions[selectedIndex]?.onSelect();
+	});
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		marginTop: 1,
+		children: actions.map((action, index) => {
+			const isSelected = index === selectedIndex;
+			return /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginBottom: index < actions.length - 1 ? 1 : void 0,
+				children: [/* @__PURE__ */ jsxs(Text, {
+					color: isSelected ? "cyan" : void 0,
+					bold: isSelected,
+					children: [
+						isSelected ? figures.pointer : figures.pointerSmall,
+						" ",
+						action.label
+					]
+				}), isSelected ? action.description : null]
+			}, action.id);
+		})
+	});
+};
+//#endregion
+//#region src/cli/ink/components/agent-handoff.tsx
+const AgentHandoff = ({ agents, onSelect, onBack, onQuit }) => {
+	const actions = agents.map((agentId) => ({
+		id: agentId,
+		label: getSkillAgentConfig(agentId).displayName,
+		onSelect: () => onSelect(agentId)
+	}));
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Box, {
+				paddingLeft: 2,
+				children: /* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: "Choose an agent"
+				})
+			}),
+			/* @__PURE__ */ jsx(ActionMenu, {
+				actions,
+				onEscape: onBack,
+				onQuit
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "↑/↓ move · enter select · esc back · q quit"
+				})
+			})
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/tui-link.tsx
+const TuiLink = ({ children, url }) => /* @__PURE__ */ jsx(Link, {
+	url,
+	fallback: false,
+	children
+});
+//#endregion
+//#region src/cli/ink/components/ci-justification.tsx
+const CiJustification = () => /* @__PURE__ */ jsxs(Box, {
+	flexDirection: "column",
+	paddingLeft: 2,
+	children: [
+		/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "Scan every pull request to prevent new React issues while you fix the backlog."
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				"Used by teams at ",
+				CI_TRUST_COMPANIES,
+				"."
+			]
+		}),
+		/* @__PURE__ */ jsx(TuiLink, {
+			url: GITHUB_ACTIONS_SETUP_URL,
+			children: /* @__PURE__ */ jsx(Text, {
+				color: "cyan",
+				children: GITHUB_ACTIONS_SETUP_URL
+			})
+		})
+	]
+});
+//#endregion
+//#region src/cli/ink/components/ci-setup.tsx
+const CiSetup = ({ feedback, onConfirm, onLearnMore, onBack, onQuit }) => {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				children: [/* @__PURE__ */ jsx(Text, {
+					color: "cyan",
+					children: "?"
+				}), " Add React Doctor to GitHub Actions?"]
+			}),
+			/* @__PURE__ */ jsx(CiJustification, {}),
+			/* @__PURE__ */ jsx(ActionMenu, {
+				actions: [{
+					id: "confirm",
+					label: "Yes, add the workflow",
+					onSelect: onConfirm
+				}, {
+					id: "learn-more",
+					label: "Open the GitHub Actions guide",
+					onSelect: onLearnMore
+				}],
+				onEscape: onBack,
+				onQuit
+			}),
+			feedback ? /* @__PURE__ */ jsx(Text, {
+				color: feedback.didSucceed ? "green" : "yellow",
+				children: feedback.didSucceed ? feedback.message : /* @__PURE__ */ jsx(TuiLink, {
+					url: GITHUB_ACTIONS_SETUP_URL,
+					children: feedback.message
+				})
+			}) : null,
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "↑/↓ move · enter select · esc back · q quit"
+				})
+			})
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/hooks/use-scroll-viewport.ts
+const useScrollViewport = (options) => {
+	const { itemCount, height, initialSelectedIndex = 0, isActive = true, isSelectable, onSelectedIndexChange } = options;
+	const canSelect = (index) => index >= 0 && index < itemCount && (isSelectable ? isSelectable(index) : true);
+	const seekSelectable = (start, step) => {
+		for (let index = start; index >= 0 && index < itemCount; index += step) if (canSelect(index)) return index;
+		return -1;
+	};
+	const nearestSelectable = (target, step) => {
+		const ahead = seekSelectable(target, step);
+		if (ahead !== -1) return ahead;
+		const behind = seekSelectable(target, -step);
+		return behind === -1 ? target : behind;
+	};
+	const [selectedIndex, setSelectedIndex] = useState(() => {
+		const first = seekSelectable(clampNumber(initialSelectedIndex, 0, itemCount - 1), 1);
+		return first === -1 ? 0 : first;
+	});
+	const [offset, setOffset] = useState(0);
+	const awaitingSecondG = useRef(false);
+	const moveTo = (rawIndex, step) => {
+		const nextSelectedIndex = nearestSelectable(clampNumber(rawIndex, 0, itemCount - 1), step);
+		setSelectedIndex(nextSelectedIndex);
+		onSelectedIndexChange?.(nextSelectedIndex);
+		setOffset((currentOffset) => {
+			if (nextSelectedIndex < currentOffset) return nextSelectedIndex;
+			if (nextSelectedIndex >= currentOffset + height) return nextSelectedIndex - height + 1;
+			return currentOffset;
+		});
+	};
+	useInput((input, key) => {
+		if (itemCount === 0) return;
+		const isSecondG = awaitingSecondG.current && input === "g";
+		if (input !== "g") awaitingSecondG.current = false;
+		if (key.downArrow || input === "j") return moveTo(selectedIndex + 1, 1);
+		if (key.upArrow || input === "k") return moveTo(selectedIndex - 1, -1);
+		if (key.pageDown) return moveTo(selectedIndex + height, 1);
+		if (key.pageUp) return moveTo(selectedIndex - height, -1);
+		if (key.ctrl && input === "d") return moveTo(selectedIndex + Math.floor(height / 2), 1);
+		if (key.ctrl && input === "u") return moveTo(selectedIndex - Math.floor(height / 2), -1);
+		if (input === "G") return moveTo(itemCount - 1, -1);
+		if (isSecondG) {
+			awaitingSecondG.current = false;
+			return moveTo(0, 1);
+		}
+		if (input === "g") awaitingSecondG.current = true;
+	}, { isActive });
+	const resolvedSelected = canSelect(selectedIndex) ? selectedIndex : nearestSelectable(clampNumber(selectedIndex, 0, itemCount - 1), 1);
+	const visibleStart = resolveVisibleStart({
+		itemCount,
+		offset,
+		selectedIndex: resolvedSelected,
+		viewportHeight: height
+	});
+	return {
+		selectedIndex: resolvedSelected,
+		visibleStart,
+		visibleEnd: Math.min(itemCount, visibleStart + height)
+	};
+};
+//#endregion
+//#region src/cli/ink/lib/build-issue-prompt.ts
+const buildIssuePrompt = ({ row, projectName }) => {
+	const { representative } = row;
+	const severityLabel = row.severity === "error" ? "ERROR" : "WARN";
+	const uniqueSites = [...new Set(row.diagnostics.map(formatDiagnosticSite))];
+	const inlineSites = uniqueSites.slice(0, 8);
+	const remainingSiteCount = uniqueSites.length - inlineSites.length;
+	const lines = [
+		`Fix exactly one React Doctor rule in ${projectName}:`,
+		"",
+		`${severityLabel} ${row.category}: ${row.title} (${row.ruleKey}, ×${row.siteCount})`,
+		representative.message
+	];
+	if (representative.help) lines.push("", `Suggested fix: ${representative.help}`);
+	const fixRecipeLine = formatFixRecipeLine(representative);
+	if (fixRecipeLine) lines.push("", fixRecipeLine);
+	lines.push("", "Scope:", `- Fix only ${row.ruleKey}.`, "- Fix the root cause; do not suppress, disable, or silence the rule.", "- Keep unrelated refactors out of this pass.", "", "Affected sites:", ...inlineSites.map((site) => `- ${site}`));
+	if (remainingSiteCount > 0) lines.push(`- +${remainingSiteCount} more sites`);
+	const learnMoreLine = formatLearnMoreLine(representative);
+	if (learnMoreLine) lines.push("", learnMoreLine);
+	lines.push("", `Verify with \`npx react-doctor@latest --verbose\` and confirm ${row.ruleKey} is gone before moving on.`);
+	return lines.join("\n");
+};
+//#endregion
+//#region src/cli/ink/lib/severity-variants.ts
+const ICONS = isUnicodeSupported() ? {
+	error: "✖",
+	warning: "⚠"
+} : {
+	error: "x",
+	warning: "!"
+};
+const severityVariant = (severity) => severity === "error" ? {
+	color: "red",
+	icon: ICONS.error,
+	label: "error"
+} : {
+	color: "yellow",
+	icon: ICONS.warning,
+	label: "warning"
+};
+//#endregion
+//#region src/cli/ink/components/diagnostic-detail.tsx
+const DiagnosticDetail = ({ row, rootDirectory }) => {
+	const codeFrame = useMemo(() => {
+		if (!row) return null;
+		const { representative } = row;
+		return buildCodeFrame({
+			filePath: representative.filePath,
+			line: representative.line,
+			column: representative.column,
+			rootDirectory
+		});
+	}, [row, rootDirectory]);
+	if (!row) return null;
+	const variant = severityVariant(row.severity);
+	const { representative } = row;
+	const impact = getCategoryImpact(row.category);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Text, {
+			wrap: "truncate-end",
+			children: [
+				/* @__PURE__ */ jsxs(Text, {
+					color: variant.color,
+					children: [variant.icon, " "]
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					color: variant.color,
+					bold: true,
+					children: row.title
+				}),
+				row.siteCount > 1 ? /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [" ×", row.siteCount]
+				}) : null
+			]
+		}), /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			paddingLeft: 2,
+			children: [
+				/* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					wrap: "truncate-end",
+					children: [
+						row.category,
+						" · ",
+						variant.label,
+						" · ",
+						row.location,
+						representative.fileContext ? ` · ${representative.fileContext} file` : ""
+					]
+				}),
+				impact ? /* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsxs(Text, {
+						wrap: "wrap",
+						children: [/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: "Impact "
+						}), impact]
+					})
+				}) : null,
+				/* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsxs(Text, {
+						wrap: "wrap",
+						children: [/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: "Why "
+						}), representative.message]
+					})
+				}),
+				codeFrame ? /* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsx(Text, { children: codeFrame })
+				}) : null,
+				representative.help ? /* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsxs(Text, {
+						wrap: "wrap",
+						children: [/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: "Fix "
+						}), representative.help]
+					})
+				}) : null,
+				row.ruleGuideUrl ? /* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsx(Text, {
+						color: "blue",
+						wrap: "truncate-end",
+						children: /* @__PURE__ */ jsxs(TuiLink, {
+							url: row.ruleGuideUrl,
+							children: ["Rule guide: ", row.ruleGuideUrl]
+						})
+					})
+				}) : null
+			]
+		})]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/diagnostic-item.tsx
+const DiagnosticItem = ({ row, isSelected, isRead }) => {
+	const variant = severityVariant(row.severity);
+	const shouldHighlightSeverity = isSelected || !isRead;
+	let marker = "• ";
+	if (isRead) marker = "  ";
+	if (isSelected) marker = "› ";
+	let markerColor = shouldHighlightSeverity ? variant.color : void 0;
+	if (isSelected) markerColor = "cyan";
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		dimColor: isRead && !isSelected,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: markerColor,
+				children: marker
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: shouldHighlightSeverity ? variant.color : void 0,
+				children: `${variant.icon} `
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: shouldHighlightSeverity ? variant.color : void 0,
+				bold: isSelected,
+				children: row.title
+			}),
+			row.siteCount > 1 ? /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [" ×", row.siteCount]
+			}) : null
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/status-bar.tsx
+const StatusBar = ({ total, errorCount, warningCount, position, issueCount, unreadCount, projectCount, keyHints = /* @__PURE__ */ jsx(Text, {
+	dimColor: true,
+	children: "↑/↓ to move"
+}), exitHint = "q to quit", compact = false }) => {
+	const counts = /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: pluralize(total, "finding")
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "  "
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: "red",
+			children: pluralize(errorCount, "error")
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "  "
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: "yellow",
+			children: pluralize(warningCount, "warning")
+		})
+	] });
+	if (compact) return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			counts,
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					"  ·  ",
+					"issue ",
+					position,
+					"/",
+					issueCount,
+					"  ·  "
+				]
+			}),
+			keyHints,
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [" · ", exitHint]
+			})
+		]
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Text, {
+			wrap: "truncate-end",
+			children: [
+				counts,
+				/* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						"  ·  ",
+						"issue ",
+						position,
+						"/",
+						issueCount
+					]
+				}),
+				projectCount !== void 0 ? /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: ["  ·  ", pluralize(projectCount, "project")]
+				}) : null
+			]
+		}), /* @__PURE__ */ jsxs(Text, {
+			wrap: "truncate-end",
+			children: [
+				unreadCount !== void 0 ? /* @__PURE__ */ jsxs(Text, {
+					color: unreadCount > 0 ? "cyan" : void 0,
+					dimColor: unreadCount === 0,
+					children: [
+						pluralize(unreadCount, "issue"),
+						" unread",
+						"  ·  "
+					]
+				}) : null,
+				keyHints,
+				/* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [" · ", exitHint]
+				})
+			]
+		})]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/diagnostic-list.tsx
+const DIAGNOSTIC_KEY_HINTS = /* @__PURE__ */ jsxs(Fragment, { children: [
+	/* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: "↑/↓ move · "
+	}),
+	/* @__PURE__ */ jsx(Text, {
+		color: "cyan",
+		children: "enter"
+	}),
+	/* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: " copy context"
+	})
+] });
+const DiagnosticList = ({ header, rows, entries, width, listColumnWidth, detailColumnWidth, listHeight, detailHeight, layout, rootDirectory, projectName, projectCount, initialSelectedRowIndex, readRuleKeys, onSelectedRowIndexChange, onQuit, onBack = onQuit, exitHint }) => {
+	const isSplit = layout === "split";
+	const isCompact = layout === "compact";
+	const initialSelectedEntryIndex = initialSelectedRowIndex === null ? 0 : Math.max(0, entries.findIndex((entry) => entry.kind === "item" && entry.rowIndex === initialSelectedRowIndex));
+	const { selectedIndex: selectedEntryIndex, visibleStart: visibleEntryStart, visibleEnd: visibleEntryEnd } = useScrollViewport({
+		itemCount: entries.length,
+		height: listHeight,
+		initialSelectedIndex: initialSelectedEntryIndex,
+		isSelectable: (entryIndex) => entries[entryIndex]?.kind === "item",
+		onSelectedIndexChange: (entryIndex) => {
+			const entry = entries[entryIndex];
+			if (entry?.kind === "item") onSelectedRowIndexChange(entry.rowIndex);
+		}
+	});
+	const visibleEntries = entries.slice(visibleEntryStart, visibleEntryEnd);
+	const selectedEntry = entries[selectedEntryIndex];
+	const selected = selectedEntry?.kind === "item" ? selectedEntry.row : null;
+	const selectedRuleKey = selected?.ruleKey ?? null;
+	const initialSelectedRuleKey = useRef(selectedRuleKey);
+	const didRecordFindingNavigation = useRef(false);
+	const [copiedRuleKey, setCopiedRuleKey] = useState(null);
+	const [copyFailedRuleKey, setCopyFailedRuleKey] = useState(null);
+	const effectiveReadRuleKeys = useMemo(() => {
+		if (!selectedRuleKey || readRuleKeys.has(selectedRuleKey)) return readRuleKeys;
+		return new Set(readRuleKeys).add(selectedRuleKey);
+	}, [readRuleKeys, selectedRuleKey]);
+	useEffect(() => {
+		if (!selectedRuleKey || selectedRuleKey === initialSelectedRuleKey.current || didRecordFindingNavigation.current) return;
+		didRecordFindingNavigation.current = true;
+		recordCount(METRIC.tuiFindingNavigated);
+	}, [selectedRuleKey]);
+	const copySelectedIssueContext = () => {
+		if (!selected) return;
+		const issuePrompt = buildIssuePrompt({
+			row: selected,
+			projectName
+		});
+		const ruleKey = selected.ruleKey;
+		copyToClipboard(issuePrompt).then((didCopyIssueContext) => {
+			if (didCopyIssueContext) {
+				setCopiedRuleKey(ruleKey);
+				setCopyFailedRuleKey(null);
+				return;
+			}
+			recordCount(METRIC.tuiReportActionSelected, 1, { action: "copy-issue-context-failed" });
+			setCopiedRuleKey(null);
+			setCopyFailedRuleKey(ruleKey);
+		});
+	};
+	useInput((input, key) => {
+		if (input === "q") return onQuit();
+		if (key.escape) return onBack();
+		if (key.return && selected) {
+			recordCount(METRIC.tuiReportActionSelected, 1, { action: "copy-issue-context" });
+			copySelectedIssueContext();
+		}
+	});
+	let totalFindingCount = 0;
+	let errorFindingCount = 0;
+	let warningFindingCount = 0;
+	for (const row of rows) {
+		totalFindingCount += row.siteCount;
+		if (row.severity === "error") errorFindingCount += row.siteCount;
+		else warningFindingCount += row.siteCount;
+	}
+	const selectedIssuePosition = entries.slice(0, selectedEntryIndex + 1).filter((entry) => entry.kind === "item").length;
+	const unreadIssueCount = rows.length - rows.filter((row) => effectiveReadRuleKeys.has(row.ruleKey)).length;
+	const listColumn = /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		height: listHeight,
+		width: isSplit ? listColumnWidth : width,
+		children: visibleEntries.map((entry, index) => {
+			const entryIndex = visibleEntryStart + index;
+			if (entry.kind === "header") return /* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: entry.category
+			}, `header-${entry.category}`);
+			return /* @__PURE__ */ jsx(DiagnosticItem, {
+				row: entry.row,
+				isSelected: entryIndex === selectedEntryIndex,
+				isRead: effectiveReadRuleKeys.has(entry.row.ruleKey)
+			}, entry.row.ruleKey);
+		})
+	});
+	let copyFeedback = null;
+	if (copiedRuleKey === selectedRuleKey) copyFeedback = /* @__PURE__ */ jsx(Box, {
+		marginTop: 1,
+		children: /* @__PURE__ */ jsx(Text, {
+			color: "green",
+			children: "✓ Copied issue context"
+		})
+	});
+	else if (copyFailedRuleKey === selectedRuleKey) copyFeedback = /* @__PURE__ */ jsx(Box, {
+		marginTop: 1,
+		children: /* @__PURE__ */ jsx(Text, {
+			color: "yellow",
+			children: "Couldn't copy issue context. Press Enter to try again."
+		})
+	});
+	const detailContent = /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(DiagnosticDetail, {
+		row: selected,
+		rootDirectory
+	}), copyFeedback] });
+	let visibleKeyHints = DIAGNOSTIC_KEY_HINTS;
+	if (isCompact && copiedRuleKey === selectedRuleKey) visibleKeyHints = /* @__PURE__ */ jsx(Text, {
+		color: "green",
+		children: "✓ Copied issue context"
+	});
+	else if (isCompact && copyFailedRuleKey === selectedRuleKey) visibleKeyHints = /* @__PURE__ */ jsx(Text, {
+		color: "yellow",
+		children: "Copy failed · enter retry"
+	});
+	const statusBar = /* @__PURE__ */ jsx(Box, {
+		marginTop: isCompact ? 0 : 1,
+		children: /* @__PURE__ */ jsx(StatusBar, {
+			total: totalFindingCount,
+			errorCount: errorFindingCount,
+			warningCount: warningFindingCount,
+			position: selectedIssuePosition,
+			issueCount: rows.length,
+			unreadCount: unreadIssueCount,
+			projectCount,
+			keyHints: visibleKeyHints,
+			exitHint,
+			compact: isCompact
+		})
+	});
+	if (isCompact) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width,
+		children: [
+			header,
+			listColumn,
+			statusBar
+		]
+	});
+	if (isSplit) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width,
+		children: [/* @__PURE__ */ jsxs(Box, {
+			flexDirection: "row",
+			maxHeight: detailHeight,
+			overflowY: "hidden",
+			children: [/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				width: listColumnWidth,
+				marginRight: 1,
+				children: [header, /* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: listColumn
+				})]
+			}), /* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				width: detailColumnWidth,
+				borderStyle: "single",
+				borderColor: "gray",
+				borderTop: false,
+				borderRight: false,
+				borderBottom: false,
+				paddingLeft: 1,
+				overflowY: "hidden",
+				children: detailContent
+			})]
+		}), statusBar]
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width,
+		children: [
+			header,
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: listColumn
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "─".repeat(width)
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				maxHeight: detailHeight,
+				overflowY: "hidden",
+				children: detailContent
+			}),
+			statusBar
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/handoff-ci-recommendation.tsx
+const HandoffCiRecommendation = ({ onAddToCi, onContinue, onQuit }) => {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Box, {
+				paddingLeft: 2,
+				children: /* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: "Add React Doctor to GitHub Actions first"
+				})
+			}),
+			/* @__PURE__ */ jsx(CiJustification, {}),
+			/* @__PURE__ */ jsx(ActionMenu, {
+				actions: [{
+					id: "add-to-ci",
+					label: "Add to GitHub Actions first (Recommended)",
+					onSelect: onAddToCi
+				}, {
+					id: "continue",
+					label: "Continue without GitHub Actions",
+					onSelect: onContinue
+				}],
+				onEscape: onContinue,
+				onQuit
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "↑/↓ move · enter select · esc skip · q quit"
+				})
+			})
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/report-landing.tsx
+const ReportLanding = ({ header, phase, issueCount, emptyStateMessage, lintFailureReason, skippedChecks, actions, selectedIndex, onSelectionChange, onQuit }) => {
+	const showScore = phase === "actions" || phase === "score";
+	const skippedCheckLabel = skippedChecks?.join(" and ");
+	useInput((input) => {
+		if (input === "q") onQuit();
+	}, { isActive: phase !== "actions" });
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			showScore ? header : null,
+			issueCount === 0 ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: lintFailureReason ? /* @__PURE__ */ jsxs(Text, {
+					color: "yellow",
+					children: ["⚠ Lint did not run: ", lintFailureReason]
+				}) : skippedCheckLabel ? /* @__PURE__ */ jsxs(Text, {
+					color: "yellow",
+					children: [
+						"⚠ No issues detected, but ",
+						skippedCheckLabel,
+						" checks failed — results are incomplete."
+					]
+				}) : /* @__PURE__ */ jsxs(Text, {
+					color: "green",
+					children: ["✔ ", emptyStateMessage ?? "No issues found. Nice work."]
+				})
+			}) : null,
+			phase === "actions" ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(ActionMenu, {
+				actions,
+				selectedIndex,
+				onSelectionChange,
+				onEscape: onQuit,
+				onQuit
+			}), /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: actions.length === 0 ? "q quit" : "↑/↓ move · enter select · q quit"
+				})
+			})] }) : null
+		]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/report-issue-stream.tsx
+const ReportIssueStream = ({ rows, selectedIndex, width }) => {
+	const visibleRowCount = Math.min(rows.length, 3);
+	const visibleRows = Array.from({ length: visibleRowCount }, (_, visibleRowIndex) => {
+		const rowIndex = (selectedIndex - visibleRowCount + visibleRowIndex + 1 + rows.length) % rows.length;
+		return {
+			row: rows[rowIndex],
+			rowIndex
+		};
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width: Math.min(width, 60),
+		children: [/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: "Reviewing issues"
+		}), visibleRows.map(({ row, rowIndex }) => {
+			if (!row) return null;
+			const variant = severityVariant(row.severity);
+			const isSelected = rowIndex === selectedIndex;
+			return /* @__PURE__ */ jsxs(Text, {
+				dimColor: !isSelected,
+				wrap: "truncate-end",
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						color: isSelected ? variant.color : void 0,
+						children: [isSelected ? "›" : " ", " "]
+					}),
+					/* @__PURE__ */ jsxs(Text, {
+						color: isSelected ? variant.color : void 0,
+						bold: isSelected,
+						children: [
+							row.category,
+							": ",
+							row.title
+						]
+					}),
+					row.siteCount > 1 ? /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [" ×", row.siteCount]
+					}) : null
+				]
+			}, row.ruleKey);
+		})]
+	});
+};
+//#endregion
+//#region src/cli/ink/hooks/use-animated-score.ts
+const useAnimatedScore = ({ score, projectedScore, shouldAnimate }) => {
+	const projectionTarget = projectedScore ?? score;
+	const hasProjection = projectionTarget > score;
+	const initialProjectedScore = !shouldAnimate && hasProjection ? projectionTarget : null;
+	const [displayScore, setDisplayScore] = useState(shouldAnimate ? 0 : score);
+	const [displayProjectedScore, setDisplayProjectedScore] = useState(initialProjectedScore);
+	useEffect(() => {
+		if (!shouldAnimate) {
+			setDisplayScore(score);
+			setDisplayProjectedScore(hasProjection ? projectionTarget : null);
+			return;
+		}
+		let timeoutId;
+		const runProjection = () => {
+			let projectionFrame = 1;
+			const renderProjectionFrame = () => {
+				const progress = easeOutCubic(projectionFrame / 16);
+				setDisplayProjectedScore(score + (projectionTarget - score) * progress);
+				if (projectionFrame < 16) {
+					projectionFrame += 1;
+					timeoutId = setTimeout(renderProjectionFrame, 35);
+				} else setDisplayProjectedScore(projectionTarget);
+			};
+			renderProjectionFrame();
+		};
+		let scoreFrame = 0;
+		const renderScoreFrame = () => {
+			const progress = easeOutCubic(scoreFrame / 40);
+			setDisplayScore(Math.round(score * progress));
+			if (scoreFrame < 40) {
+				scoreFrame += 1;
+				timeoutId = setTimeout(renderScoreFrame, 50);
+				return;
+			}
+			setDisplayScore(score);
+			if (hasProjection) runProjection();
+		};
+		renderScoreFrame();
+		return () => {
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+		};
+	}, [
+		shouldAnimate,
+		score,
+		projectionTarget,
+		hasProjection
+	]);
+	return {
+		displayScore,
+		displayProjectedScore
+	};
+};
+//#endregion
+//#region src/cli/ink/lib/score-color.ts
+const scoreColorName = (score) => {
+	if (score >= 75) return "green";
+	if (score >= 50) return "yellow";
+	return "red";
+};
+//#endregion
+//#region src/cli/ink/components/score-header.tsx
+const REACT_DOCTOR_URL = "https://react.doctor";
+const ReactDoctorLink = () => /* @__PURE__ */ jsxs(TuiLink, {
+	url: REACT_DOCTOR_URL,
+	children: ["React Doctor ", /* @__PURE__ */ jsxs(Text, {
+		dimColor: true,
+		children: [
+			"(",
+			REACT_DOCTOR_URL,
+			")"
+		]
+	})]
+});
+const ScoreHeader = ({ variant, score, projectedScore, projectName, issueCount, noScoreMessage, width }) => {
+	const { columns } = useStdoutDimensions();
+	const availableWidth = width ?? columns;
+	const { stdout } = useStdout();
+	const shouldAnimateScore = canAnimateOnboarding(stdout ?? void 0);
+	const visibleProjectedScore = variant === "landing" ? projectedScore : null;
+	const { displayScore, displayProjectedScore } = useAnimatedScore({
+		score: score?.score ?? 0,
+		projectedScore: visibleProjectedScore,
+		shouldAnimate: variant === "landing" && shouldAnimateScore && score !== null
+	});
+	if (!score) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		paddingLeft: 2,
+		children: [/* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			children: /* @__PURE__ */ jsx(ReactDoctorLink, {})
+		}), /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			wrap: "truncate-end",
+			children: noScoreMessage ?? `${pluralize(issueCount, "finding")} · ${projectName}`
+		})]
+	});
+	const scoreColor = scoreColorName(score.score);
+	const scoreSummaryLine = /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: scoreColor,
+				bold: true,
+				children: displayScore
+			}),
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					" / ",
+					100,
+					" "
+				]
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: scoreColor,
+				children: score.label
+			}),
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: ["  ·  ", projectName]
+			})
+		]
+	});
+	if (availableWidth < 23) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width: availableWidth,
+		children: [scoreSummaryLine, /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			children: /* @__PURE__ */ jsx(ReactDoctorLink, {})
+		})]
+	});
+	const barWidth = Math.max(10, Math.min(50, availableWidth - 11 - 2));
+	const filledBarWidth = Math.round(displayScore / 100 * barWidth);
+	const projectedBarWidth = displayProjectedScore != null ? Math.min(barWidth, Math.round(displayProjectedScore / 100 * barWidth)) : filledBarWidth;
+	const projectedGainWidth = Math.max(0, projectedBarWidth - filledBarWidth);
+	const emptyBarWidth = Math.max(0, barWidth - filledBarWidth - projectedGainWidth);
+	const [eyes, mouth] = doctorFace(score.score);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Box, {
+			paddingLeft: 2,
+			children: [/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				marginRight: 2,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: scoreColor,
+					children: `┌─────┐\n│ ${eyes} │\n│ ${mouth} │\n└─────┘`
+				})
+			}), /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [
+					scoreSummaryLine,
+					/* @__PURE__ */ jsxs(Text, {
+						wrap: "truncate-end",
+						children: [
+							/* @__PURE__ */ jsx(Text, {
+								color: scoreColor,
+								children: "█".repeat(filledBarWidth)
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								color: scoreColor,
+								dimColor: true,
+								children: "▓".repeat(projectedGainWidth)
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								dimColor: true,
+								children: "░".repeat(emptyBarWidth)
+							})
+						]
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						wrap: "truncate-end",
+						children: /* @__PURE__ */ jsx(ReactDoctorLink, {})
+					}),
+					/* @__PURE__ */ jsx(Text, { children: " " })
+				]
+			})]
+		}), variant === "landing" && projectedScore != null && projectedScore > score.score ? /* @__PURE__ */ jsxs(Text, {
+			wrap: "truncate-end",
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "  Potential score "
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					color: scoreColorName(projectedScore),
+					children: projectedScore
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: " after priority fixes "
+				}),
+				/* @__PURE__ */ jsxs(Text, {
+					color: scoreColorName(projectedScore),
+					children: ["+", projectedScore - score.score]
+				})
+			]
+		}) : null]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/report.tsx
+const EMPTY_LAUNCHABLE_AGENTS = [];
+const recordReportAction = (action) => {
+	recordCount(METRIC.tuiReportActionSelected, 1, { action });
+};
+const completeReportOnboarding = () => {
+	if (shouldRecordOnboarding({
+		paceOnboardingSections: true,
+		forceOnboarding: isOnboardingForced(),
+		verbose: false,
+		isNonInteractiveEnvironment: false
+	})) markOnboardingComplete();
+};
+const Report = ({ report, onExit, onQuit = onExit, launchableAgents = EMPTY_LAUNCHABLE_AGENTS, onHandoff, canAddToCi, onAddToCi, projectCount, priorityScores, exitHint = "q to quit" }) => {
+	const { rows: terminalRows, columns } = useStdoutDimensions();
+	const diagnosticRows = useMemo(() => buildDiagnosticRows(report.diagnostics, priorityScores ?? [report.score]), [
+		report.diagnostics,
+		report.score,
+		priorityScores
+	]);
+	const diagnosticListEntries = useMemo(() => buildDiagnosticListEntries(diagnosticRows), [diagnosticRows]);
+	const reportLayout = resolveReportLayout({
+		columns,
+		diagnosticEntryCount: diagnosticListEntries.length,
+		terminalRows
+	});
+	const reportReveal = useReportReveal({
+		issueCount: diagnosticRows.length,
+		onRevealComplete: completeReportOnboarding
+	});
+	const [activeReportScreen, setActiveReportScreen] = useState("landing");
+	const [ciSetupFeedback, setCiSetupFeedback] = useState();
+	const [landingSelectedIndex, setLandingSelectedIndex] = useState(0);
+	const [viewerSelectedRowIndex, setViewerSelectedRowIndex] = useState(null);
+	const [viewerReadRuleKeys, setViewerReadRuleKeys] = useState(() => /* @__PURE__ */ new Set());
+	const [isCiSetupQueued, setIsCiSetupQueued] = useState(false);
+	const [shouldShowIssueStream, setShouldShowIssueStream] = useState(true);
+	const didRecordCompactReport = useRef(false);
+	const didRecordIssueStream = useRef(false);
+	const didRecordStackedReportCap = useRef(false);
+	const isCompact = reportLayout.layout === "compact";
+	const isWide = reportLayout.layout === "split";
+	useEffect(() => {
+		if (!isCompact || didRecordCompactReport.current) return;
+		didRecordCompactReport.current = true;
+		recordCount(METRIC.tuiCompactReportShown);
+	}, [isCompact]);
+	useEffect(() => {
+		if (!reportLayout.isStackedReportCapped || didRecordStackedReportCap.current) return;
+		didRecordStackedReportCap.current = true;
+		recordCount(METRIC.tuiStackedReportCapped);
+	}, [reportLayout.isStackedReportCapped]);
+	useEffect(() => {
+		if (reportReveal.phase !== "streaming" || didRecordIssueStream.current) return;
+		didRecordIssueStream.current = true;
+		recordCount(METRIC.tuiIssueStreamShown);
+	}, [reportReveal.phase]);
+	const scoreHeaderProps = {
+		score: report.score,
+		projectedScore: report.projectedScore,
+		projectName: report.projectName,
+		issueCount: report.diagnostics.length,
+		noScoreMessage: report.noScoreMessage,
+		width: isWide ? reportLayout.listColumnWidth : reportLayout.width
+	};
+	const isCiSetupAvailable = Boolean(canAddToCi && onAddToCi && !isCiSetupQueued);
+	const isHandoffAvailable = diagnosticRows.length > 0 && launchableAgents.length > 0 && Boolean(onHandoff);
+	const firstDiagnosticEntry = diagnosticListEntries.find((entry) => entry.kind === "item");
+	const resolvedViewerSelectedRowIndex = viewerSelectedRowIndex ?? (firstDiagnosticEntry?.kind === "item" ? firstDiagnosticEntry.rowIndex : null);
+	const markViewerRuleRead = (index) => {
+		const ruleKey = diagnosticRows[index]?.ruleKey;
+		if (!ruleKey) return;
+		setViewerReadRuleKeys((previous) => previous.has(ruleKey) ? previous : new Set(previous).add(ruleKey));
+	};
+	const handleViewerSelectionChange = (index) => {
+		setViewerSelectedRowIndex(index);
+		markViewerRuleRead(index);
+	};
+	const openReportScreen = (nextScreen) => {
+		setShouldShowIssueStream(false);
+		setCiSetupFeedback(void 0);
+		setActiveReportScreen(nextScreen);
+	};
+	const landingActions = [];
+	if (report.diagnostics.length > 0) landingActions.push({
+		id: "view-issues",
+		label: `Review ${pluralize(diagnosticRows.length, "issue")}`,
+		onSelect: () => {
+			recordReportAction("view-issues");
+			if (resolvedViewerSelectedRowIndex !== null) {
+				setViewerSelectedRowIndex(resolvedViewerSelectedRowIndex);
+				markViewerRuleRead(resolvedViewerSelectedRowIndex);
+			}
+			openReportScreen("issues");
+		}
+	});
+	if (isCiSetupAvailable) landingActions.push({
+		id: "add-to-ci",
+		label: "Add to GitHub Actions (Recommended)",
+		description: /* @__PURE__ */ jsx(CiJustification, {}),
+		onSelect: () => {
+			recordReportAction("add-to-ci");
+			openReportScreen("ci");
+		}
+	});
+	if (isHandoffAvailable) landingActions.push({
+		id: "handoff",
+		label: "Hand off to an agent",
+		onSelect: () => {
+			recordReportAction("handoff");
+			openReportScreen(isCiSetupAvailable ? "handoff-ci" : "handoff");
+		}
+	});
+	const postReviewLandingActionIndex = landingActions.findIndex((action) => action.id !== "view-issues");
+	const resolvedLandingSelectedIndex = Math.min(landingSelectedIndex, Math.max(0, landingActions.length - 1));
+	const issueStream = reportReveal.phase === "streaming" ? /* @__PURE__ */ jsx(ReportIssueStream, {
+		rows: diagnosticRows,
+		selectedIndex: reportReveal.streamSelectedIndex,
+		width: reportLayout.width
+	}) : null;
+	let activeScreenContent;
+	if (activeReportScreen === "ci") activeScreenContent = /* @__PURE__ */ jsx(CiSetup, {
+		feedback: ciSetupFeedback,
+		onConfirm: () => {
+			onAddToCi?.();
+			onExit();
+		},
+		onLearnMore: () => {
+			recordReportAction("ci-learn-more");
+			openUrl(GITHUB_ACTIONS_SETUP_URL).then((didOpen) => {
+				setCiSetupFeedback({
+					didSucceed: didOpen,
+					message: didOpen ? "✓ Opened the GitHub Actions guide in your browser" : `Couldn't open a browser. Visit ${GITHUB_ACTIONS_SETUP_URL}`
+				});
+			});
+		},
+		onBack: () => {
+			setCiSetupFeedback(void 0);
+			setActiveReportScreen("landing");
+		},
+		onQuit
+	});
+	else if (activeReportScreen === "handoff") activeScreenContent = /* @__PURE__ */ jsx(AgentHandoff, {
+		agents: launchableAgents,
+		onSelect: (agentId) => {
+			if (!onHandoff) return;
+			onHandoff({
+				agentId,
+				prompt: buildHandoffPayload({
+					diagnostics: report.diagnostics,
+					projectName: report.projectName
+				})
+			});
+			onExit();
+		},
+		onBack: () => setActiveReportScreen("landing"),
+		onQuit
+	});
+	else if (activeReportScreen === "handoff-ci") activeScreenContent = /* @__PURE__ */ jsx(HandoffCiRecommendation, {
+		onAddToCi: () => {
+			onAddToCi?.();
+			setIsCiSetupQueued(true);
+			setActiveReportScreen("handoff");
+		},
+		onContinue: () => setActiveReportScreen("handoff"),
+		onQuit
+	});
+	else if (activeReportScreen === "landing") activeScreenContent = /* @__PURE__ */ jsx(ReportLanding, {
+		header: /* @__PURE__ */ jsx(ScoreHeader, {
+			variant: "landing",
+			...scoreHeaderProps
+		}),
+		phase: reportReveal.phase,
+		issueCount: report.diagnostics.length,
+		emptyStateMessage: report.emptyStateMessage,
+		lintFailureReason: report.lintFailureReason,
+		skippedChecks: report.skippedChecks,
+		actions: landingActions,
+		selectedIndex: resolvedLandingSelectedIndex,
+		onSelectionChange: setLandingSelectedIndex,
+		onQuit
+	});
+	else activeScreenContent = /* @__PURE__ */ jsx(DiagnosticList, {
+		header: reportLayout.showsViewerScoreHeader ? /* @__PURE__ */ jsx(ScoreHeader, {
+			variant: "viewer",
+			...scoreHeaderProps
+		}) : null,
+		rows: diagnosticRows,
+		entries: diagnosticListEntries,
+		width: reportLayout.width,
+		listColumnWidth: reportLayout.listColumnWidth,
+		detailColumnWidth: reportLayout.detailColumnWidth,
+		listHeight: reportLayout.listHeight,
+		detailHeight: reportLayout.detailHeight,
+		layout: reportLayout.layout,
+		rootDirectory: report.rootDirectory,
+		projectName: report.projectName,
+		projectCount,
+		initialSelectedRowIndex: resolvedViewerSelectedRowIndex,
+		readRuleKeys: viewerReadRuleKeys,
+		onSelectedRowIndexChange: handleViewerSelectionChange,
+		onQuit,
+		onBack: () => {
+			setLandingSelectedIndex(Math.max(0, postReviewLandingActionIndex));
+			setActiveReportScreen("landing");
+		},
+		exitHint: `esc back · ${exitHint}`
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [activeReportScreen === "landing" && shouldShowIssueStream ? issueStream : null, activeScreenContent] });
+};
+//#endregion
+//#region src/cli/ink/components/scanning.tsx
+const Scanning = ({ progressText, liveCount, recent }) => {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Text, {
+			wrap: "truncate-end",
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: "cyan",
+					children: /* @__PURE__ */ jsx(Spinner, { type: "dots" })
+				}),
+				/* @__PURE__ */ jsxs(Text, { children: [" ", progressText ?? "Scanning…"] }),
+				liveCount > 0 ? /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						"  ·  ",
+						liveCount,
+						" found"
+					]
+				}) : null
+			]
+		}), recent.map((diagnostic, diagnosticIndex) => {
+			const variant = severityVariant(diagnostic.severity === "error" ? "error" : "warning");
+			const location = formatDiagnosticSite(diagnostic);
+			return /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				children: [
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						color: variant.color,
+						children: variant.icon
+					}),
+					/* @__PURE__ */ jsxs(Text, { children: [" ", diagnostic.title ?? `${diagnostic.plugin}/${diagnostic.rule}`] }),
+					/* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: ["  ", location]
+					})
+				]
+			}, `${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.plugin}:${diagnostic.rule}:${diagnosticIndex}`);
+		})]
+	});
+};
+//#endregion
+//#region src/cli/ink/components/summary.tsx
+const Summary = ({ summary, onExit, onQuit, launchableAgents, onHandoff, canAddToCi, onAddToCi }) => {
+	return /* @__PURE__ */ jsx(Report, {
+		report: {
+			diagnostics: summary.combinedDiagnostics,
+			score: summary.aggregateScore,
+			projectedScore: summary.projectedScore,
+			projectName: summary.projectName,
+			rootDirectory: summary.rootDirectory,
+			scannedFileCount: summary.scannedFileCount,
+			elapsedMilliseconds: summary.elapsedMilliseconds,
+			isOffline: summary.isOffline,
+			noScoreMessage: summary.noScoreMessage,
+			skippedChecks: [...new Set(summary.projects.flatMap((project) => project.skippedChecks ?? []))],
+			...summary.emptyStateMessage ? { emptyStateMessage: summary.emptyStateMessage } : {},
+			...summary.lintFailureReason ? { lintFailureReason: summary.lintFailureReason } : {}
+		},
+		onExit,
+		onQuit,
+		launchableAgents,
+		onHandoff,
+		canAddToCi,
+		onAddToCi,
+		projectCount: summary.projects.length,
+		priorityScores: summary.projects.map((project) => project.score)
+	});
+};
+//#endregion
+//#region src/cli/ink/hooks/use-scan-store.ts
+const useScanStore = (store) => useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+//#endregion
+//#region src/cli/ink/scan-app.tsx
+const ScanApp = ({ store, launchableAgents, onHandoff, canAddToCi, onAddToCi, onQuit }) => {
+	const snapshot = useScanStore(store);
+	const { exit } = useApp();
+	useExitOnCtrlC();
+	const handleQuit = () => {
+		onQuit?.();
+		exit();
+	};
+	if (snapshot.phase === "summary" && snapshot.summary) return /* @__PURE__ */ jsx(Summary, {
+		summary: snapshot.summary,
+		launchableAgents,
+		onHandoff,
+		canAddToCi,
+		onAddToCi,
+		onExit: exit,
+		onQuit: handleQuit
+	});
+	if (snapshot.phase === "report" && snapshot.report) return /* @__PURE__ */ jsx(Report, {
+		report: snapshot.report,
+		launchableAgents,
+		onHandoff,
+		canAddToCi,
+		onAddToCi,
+		onExit: exit,
+		onQuit: handleQuit
+	});
+	return /* @__PURE__ */ jsx(Scanning, {
+		progressText: snapshot.progress,
+		liveCount: snapshot.liveCount,
+		recent: snapshot.liveDiagnostics.slice(-5)
+	});
+};
+//#endregion
+//#region src/cli/ink/scan-bridge-layers.ts
+const reporterLayerForStore = (store) => succeed(Reporter, Reporter.of({
+	emit: (diagnostic) => sync(() => store.emitDiagnostic(diagnostic)),
+	finalize: void_
+}));
+const progressHandleForStore = (store) => (text) => {
+	store.setProgress(text);
+	return {
+		update: (displayText) => sync(() => store.setProgress(displayText)),
+		succeed: (displayText) => sync(() => store.setProgress(displayText)),
+		fail: (displayText) => sync(() => store.setProgress(displayText)),
+		stop: () => sync(() => store.setProgress(null))
+	};
+};
+const progressLayerForStore = (store) => Progress.layerOra(progressHandleForStore(store));
+//#endregion
+//#region src/cli/ink/scan-store.ts
+const INITIAL_SNAPSHOT = {
+	phase: "scanning",
+	liveDiagnostics: [],
+	liveCount: 0,
+	progress: null,
+	report: null,
+	summary: null
+};
+const createScanStore = () => {
+	let snapshot = INITIAL_SNAPSHOT;
+	const listeners = /* @__PURE__ */ new Set();
+	const commit = (next) => {
+		snapshot = next;
+		for (const listener of listeners) listener();
+	};
+	return {
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		getSnapshot: () => snapshot,
+		emitDiagnostic: (diagnostic) => commit({
+			...snapshot,
+			liveDiagnostics: [...snapshot.liveDiagnostics, diagnostic].slice(-25),
+			liveCount: snapshot.liveCount + 1
+		}),
+		setProgress: (progress) => commit({
+			...snapshot,
+			progress
+		}),
+		setReport: (report) => commit({
+			...snapshot,
+			report,
+			phase: "report"
+		}),
+		setSummary: (summary) => commit({
+			...snapshot,
+			summary,
+			phase: "summary"
+		})
+	};
+};
+//#endregion
+//#region src/cli/ink/run-scan-app.tsx
+const resolveProjectScan = async (rootScanTarget, projectDirectory) => {
+	const projectScanTarget = projectDirectory === rootScanTarget.resolvedDirectory ? rootScanTarget : await resolveScanTarget(projectDirectory, { allowAmbiguous: true });
+	const config = projectDirectory === rootScanTarget.resolvedDirectory ? rootScanTarget.userConfig : mergeReactDoctorConfigs(rootScanTarget.userConfig, projectScanTarget.userConfig ?? void 0);
+	const configSourceDirectory = projectScanTarget.userConfig?.plugins === void 0 ? rootScanTarget.configSourceDirectory : projectScanTarget.configSourceDirectory;
+	return {
+		directory: projectScanTarget.resolvedDirectory,
+		config,
+		configSourceDirectory
+	};
+};
+const qualifyDiagnosticPaths = (diagnostics, rootDirectory, projectDirectory) => {
+	const prefix = path.relative(rootDirectory, projectDirectory);
+	if (prefix === "" || prefix.startsWith("..")) return [...diagnostics];
+	return diagnostics.map((diagnostic) => path.isAbsolute(diagnostic.filePath) ? diagnostic : {
+		...diagnostic,
+		filePath: toForwardSlashes(path.join(prefix, diagnostic.filePath))
+	});
+};
+const resolveScanPresentation = (input, projectScans) => {
+	const isScoreDisabled = input.options?.noScore === true || projectScans.some((projectScan) => projectScan.config?.noScore === true);
+	return {
+		isOffline: isCiEnvironment() || input.share === false || isShareOptedOut(projectScans, input.options?.noScore),
+		noScoreMessage: buildNoScoreMessage(isScoreDisabled),
+		shouldRecommendCi: projectScans.length > 1 || projectScans.some((projectScan) => isCiUnconfigured(projectScan.directory))
+	};
+};
+const resolveTuiInspectOptions = (input, config) => {
+	const warnings = resolveCliInspectOptions({
+		blocking: input.blocking,
+		warnings: input.options?.warnings
+	}, config).warnings;
+	return warnings === void 0 ? { ...input.options } : {
+		...input.options,
+		warnings
+	};
+};
+const resolveSelectedDirectories = async (rootDirectory, input) => {
+	const packages = discoverWorkspacePackages(rootDirectory);
+	if (!(packages.length > 1 && !input.projectFlag && !input.skipPrompts && (input.configProjects ?? []).length === 0 && process.stdin.isTTY === true)) return selectProjects(rootDirectory, input.projectFlag, input.skipPrompts ?? false, input.configProjects);
+	return promptProjectSelection(packages, rootDirectory);
+};
+const promptProjectSelection = (packages, rootDirectory) => new Promise((resolve) => {
+	const instance = render(/* @__PURE__ */ jsx(ProjectSelect, {
+		packages,
+		rootDirectory,
+		onSubmit: (directories) => {
+			instance.clear();
+			instance.unmount();
+			resolve(directories);
+		}
+	}), { exitOnCtrlC: false });
+});
+const resolveLintFailureReason = (results) => {
+	for (const result of results) {
+		if (!hasLintHardFailure(result)) continue;
+		return result.skippedCheckReasons?.lint ?? "Lint failed before diagnostics were produced.";
+	}
+	return null;
+};
+const toScanReport = ({ result, diagnostics, rootDirectory, projectedScore, isOffline, noScoreMessage, emptyStateMessage }) => {
+	const lintFailureReason = resolveLintFailureReason([result]);
+	return {
+		diagnostics: diagnostics ?? result.diagnostics,
+		score: result.score,
+		projectedScore,
+		projectName: result.project.projectName,
+		rootDirectory,
+		scannedFileCount: result.scannedFileCount ?? 0,
+		elapsedMilliseconds: result.elapsedMilliseconds,
+		isOffline,
+		noScoreMessage,
+		emptyStateMessage,
+		skippedChecks: result.skippedChecks,
+		...lintFailureReason ? { lintFailureReason } : {}
+	};
+};
+const findLowestScoredReport = (reports) => {
+	let lowestScoredReport = null;
+	for (const report of reports) {
+		if (report.score === null) continue;
+		if (lowestScoredReport === null || report.score.score < lowestScoredReport.score.score) lowestScoredReport = {
+			score: report.score,
+			scoreDiagnostics: report.scoreDiagnostics
+		};
+	}
+	return lowestScoredReport;
+};
+const resolveEmptyStateMessage = (input, demotedDiagnosticCount) => buildEmptyReportMessage({
+	categoryFilters: input.options?.categoryFilters ?? [],
+	demotedDiagnosticCount,
+	outputSurface: input.options?.outputSurface ?? "cli"
+});
+const printExitFooter = async (input) => {
+	process.stdout.write(`${highlighter.success("✔")} Scanned ${pluralize(input.scannedFileCount, "file")} in ${formatElapsedTime(input.elapsedMilliseconds)}\n`);
+	if (input.lintFailureReason !== null) process.stdout.write(`${highlighter.warn("⚠")} Lint did not run: ${input.lintFailureReason}\n`);
+	await runPromise(printFooter({
+		diagnostics: [...input.diagnostics],
+		scoreResult: input.scoreResult,
+		projectName: input.projectName,
+		isOffline: input.isOffline
+	}));
+};
+const performTuiHandoff = async (request, rootDirectory) => {
+	try {
+		await launchCliAgent(request.agentId, request.prompt, rootDirectory);
+	} catch {
+		process.stdout.write(`${highlighter.warn("⚠")} Couldn't launch ${CLI_AGENT_BINARIES[request.agentId]}. Here's the prompt instead:\n`);
+		process.stdout.write(`${highlighter.dim("──── Agent prompt ────")}\n`);
+		process.stdout.write(`${request.prompt}\n`);
+		process.stdout.write(`${highlighter.dim("──────────────────────")}\n`);
+	}
+};
+const isCiUnconfigured = (directory) => !isReactDoctorWorkflowInstalled(findNearestPackageDirectory(directory) ?? directory);
+const performCiSetup = async (rootDirectory) => {
+	const didCreateWorkflow = await setUpGitHubActions({ rootDirectory });
+	recordCount(METRIC.agentHandoff, 1, {
+		outcome: "ci-yes",
+		source: "tui",
+		created: didCreateWorkflow
+	});
+};
+const mountScanApp = async (rootDirectory, shouldRecommendCi) => {
+	const store = createScanStore();
+	const launchableAgents = await detectLaunchableAgents();
+	const pendingActions = {
+		handoffRequest: null,
+		shouldSetUpCi: false,
+		didQuit: false
+	};
+	const instance = render(/* @__PURE__ */ jsx(ScanApp, {
+		store,
+		launchableAgents,
+		onHandoff: (request) => {
+			pendingActions.handoffRequest = request;
+		},
+		canAddToCi: shouldRecommendCi,
+		onAddToCi: () => {
+			pendingActions.shouldSetUpCi = true;
+		},
+		onQuit: () => {
+			pendingActions.didQuit = true;
+		}
+	}), { exitOnCtrlC: false });
+	const executePendingActions = async () => {
+		if (pendingActions.shouldSetUpCi) await performCiSetup(rootDirectory);
+		if (pendingActions.didQuit) return;
+		if (pendingActions.handoffRequest) await performTuiHandoff(pendingActions.handoffRequest, rootDirectory);
+	};
+	return {
+		store,
+		instance,
+		pendingActions,
+		executePendingActions
+	};
+};
+const runMountedScan = async (rootDirectory, presentation, blockingLevel, executeScan) => {
+	const { store, instance, pendingActions, executePendingActions } = await mountScanApp(rootDirectory, presentation.shouldRecommendCi);
+	const context = {
+		store,
+		...presentation
+	};
+	try {
+		const completedScan = await executeScan(context);
+		await instance.waitUntilExit();
+		if (!pendingActions.didQuit) await printExitFooter({
+			diagnostics: completedScan.diagnostics,
+			scoreResult: completedScan.scoreResult,
+			projectName: completedScan.projectName,
+			scannedFileCount: completedScan.scannedFileCount,
+			elapsedMilliseconds: completedScan.elapsedMilliseconds,
+			isOffline: context.isOffline,
+			lintFailureReason: resolveLintFailureReason(completedScan.scans.map(({ result }) => result))
+		});
+		await executePendingActions();
+		return { shouldFail: shouldFailScanGate({
+			scans: completedScan.scans,
+			blockingLevel
+		}) };
+	} catch (error) {
+		instance.unmount();
+		throw error;
+	}
+};
+const runSingleProjectScan = async (rootScanTarget, projectDirectory, input, blockingLevel, inspectProject) => {
+	const projectScan = await resolveProjectScan(rootScanTarget, projectDirectory);
+	const presentation = resolveScanPresentation(input, [projectScan]);
+	return runMountedScan(projectScan.directory, presentation, blockingLevel, async (context) => {
+		const result = await inspectProject(projectScan.directory, {
+			...resolveTuiInspectOptions(input, projectScan.config),
+			isCi: isCiEnvironment(),
+			configOverride: projectScan.config,
+			configSourceDirectory: projectScan.configSourceDirectory ?? void 0,
+			uiLayers: {
+				reporter: reporterLayerForStore(context.store),
+				progress: progressLayerForStore(context.store)
+			}
+		});
+		const reportSelection = selectReportDiagnostics({
+			scan: {
+				result,
+				config: projectScan.config
+			},
+			categoryFilters: input.options?.categoryFilters,
+			surface: input.options?.outputSurface
+		});
+		const scoreDiagnostics = filterScansForSurface([{
+			result,
+			config: projectScan.config
+		}], "score");
+		const projectedScore = result.score ? await computeProjectedScore([...reportSelection.diagnostics], scoreDiagnostics, result.score) : null;
+		context.store.setReport(toScanReport({
+			result,
+			diagnostics: reportSelection.diagnostics,
+			rootDirectory: projectScan.directory,
+			projectedScore,
+			isOffline: context.isOffline,
+			noScoreMessage: context.noScoreMessage,
+			emptyStateMessage: resolveEmptyStateMessage(input, reportSelection.demotedDiagnosticCount)
+		}));
+		return {
+			scans: [{
+				result,
+				config: projectScan.config
+			}],
+			diagnostics: reportSelection.diagnostics,
+			scoreResult: result.score,
+			projectName: result.project.projectName,
+			scannedFileCount: result.scannedFileCount ?? 0,
+			elapsedMilliseconds: result.elapsedMilliseconds
+		};
+	});
+};
+const runMultiProjectScan = async (rootScanTarget, directories, input, blockingLevel, inspectProject) => {
+	const rootDirectory = rootScanTarget.resolvedDirectory;
+	const projectScans = await mapWithConcurrency([...directories], 4, (projectDirectory) => resolveProjectScan(rootScanTarget, projectDirectory));
+	return runMountedScan(rootDirectory, resolveScanPresentation(input, projectScans), blockingLevel, async (context) => {
+		const startTime = performance.now();
+		let finishedCount = 0;
+		context.store.setProgress(`Scanning ${directories.length} projects…`);
+		const results = await mapWithConcurrency(projectScans, 4, async (projectScan) => {
+			const result = await inspectProject(projectScan.directory, {
+				...resolveTuiInspectOptions(input, projectScan.config),
+				isCi: isCiEnvironment(),
+				configOverride: projectScan.config,
+				configSourceDirectory: projectScan.configSourceDirectory ?? void 0,
+				uiLayers: { reporter: Reporter.layerNoop },
+				concurrentScan: true
+			});
+			finishedCount += 1;
+			context.store.setProgress(`Scanning ${directories.length} projects… (${finishedCount}/${directories.length})`);
+			return {
+				directory: projectScan.directory,
+				result,
+				config: projectScan.config
+			};
+		});
+		const projectEntries = results.map(({ directory, result, config }) => {
+			const reportSelection = selectReportDiagnostics({
+				scan: {
+					result,
+					config
+				},
+				categoryFilters: input.options?.categoryFilters,
+				surface: input.options?.outputSurface
+			});
+			return {
+				report: toScanReport({
+					result,
+					diagnostics: reportSelection.diagnostics,
+					rootDirectory: directory,
+					projectedScore: null,
+					isOffline: context.isOffline,
+					noScoreMessage: context.noScoreMessage,
+					emptyStateMessage: resolveEmptyStateMessage(input, reportSelection.demotedDiagnosticCount)
+				}),
+				score: result.score,
+				scoreDiagnostics: filterScansForSurface([{
+					result,
+					config
+				}], "score"),
+				demotedDiagnosticCount: reportSelection.demotedDiagnosticCount
+			};
+		});
+		const projects = projectEntries.map(({ report }) => report);
+		const combinedDiagnostics = projects.flatMap((project) => qualifyDiagnosticPaths(project.diagnostics, rootDirectory, project.rootDirectory));
+		const lowestScoredReport = findLowestScoredReport(projectEntries);
+		const projectedScore = lowestScoredReport ? await computeProjectedScore(combinedDiagnostics, [...lowestScoredReport.scoreDiagnostics], lowestScoredReport.score) : null;
+		const scannedFileCount = countUniqueScannedFiles(results.map(({ result }) => result));
+		const elapsedMilliseconds = performance.now() - startTime;
+		const lintFailureReason = resolveLintFailureReason(results.map(({ result }) => result));
+		const summary = {
+			projects,
+			aggregateScore: lowestScoredReport?.score ?? null,
+			projectedScore,
+			combinedDiagnostics,
+			scannedFileCount,
+			elapsedMilliseconds,
+			projectName: path.basename(rootDirectory),
+			rootDirectory,
+			isOffline: context.isOffline,
+			noScoreMessage: context.noScoreMessage,
+			emptyStateMessage: resolveEmptyStateMessage(input, projectEntries.reduce((total, projectEntry) => total + projectEntry.demotedDiagnosticCount, 0)),
+			...lintFailureReason ? { lintFailureReason } : {}
+		};
+		context.store.setSummary(summary);
+		return {
+			scans: results,
+			diagnostics: combinedDiagnostics,
+			scoreResult: summary.aggregateScore,
+			projectName: summary.projectName,
+			scannedFileCount,
+			elapsedMilliseconds
+		};
+	});
+};
+const runScanApp = async (input) => {
+	const scanTarget = input.scanTarget ?? await resolveScanTarget(input.directory, { allowAmbiguous: true });
+	const rootDirectory = scanTarget.resolvedDirectory;
+	const deadlineEpochMs = input.options?.deadlineEpochMs ?? (input.options?.maxDurationMs != null ? Date.now() + input.options.maxDurationMs : void 0);
+	const resolvedInput = {
+		...input,
+		options: {
+			...input.options,
+			deadlineEpochMs
+		},
+		configProjects: input.configProjects ?? scanTarget.userConfig?.projects,
+		share: input.share ?? scanTarget.userConfig?.share ?? true
+	};
+	const selectedDirectories = await resolveSelectedDirectories(rootDirectory, resolvedInput);
+	const inspectProject = createInvocationInspect(input.options?.concurrency);
+	const blockingLevel = resolveBlockingLevel({ blocking: resolvedInput.blocking }, scanTarget.userConfig);
+	if (selectedDirectories.length === 0) return { shouldFail: false };
+	if (selectedDirectories.length === 1) return runSingleProjectScan(scanTarget, selectedDirectories[0], resolvedInput, blockingLevel, inspectProject);
+	return runMultiProjectScan(scanTarget, selectedDirectories, resolvedInput, blockingLevel, inspectProject);
+};
+//#endregion
+export { runScanApp };
+
+//# sourceMappingURL=run-scan-app-DtYeufgr.js.map
+//# debugId=e34d02bb-f20a-5479-99b2-18946ed44afb