magus-cli 7.5.4 → 7.7.0

package/src/ui/App.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 import { activePluginPins } from "../services/active-closure.js";
 import { isClaudeAvailable } from "../services/claude-cli.js";
 import {
@@ -11,10 +11,7 @@ import {
 	type StartupGitignoreNeed,
 	startupGitignoreNeed,
 } from "../services/gitignore-check.js";
-import {
-	applyStartupFixes,
-	describeStartupFix,
-} from "../services/gitignore-service.js";
+import { applyStartupFixes } from "../services/gitignore-service.js";
 import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
 import {
@@ -31,10 +28,16 @@ import { ScreenErrorBoundary } from "./components/ScreenErrorBoundary.js";
 import { TABS } from "./components/TabBar.js";
 import { ProgressBar } from "./components/layout/ProgressBar.js";
 import { ModalContainer } from "./components/modals/index.js";
-import { useGitignoreModal } from "./hooks/useGitignoreModal.js";
-import { useProfileStartupModal } from "./hooks/useProfileStartupModal.js";
 import {
-	staleLoadRepairSummary,
+	startupFixNotices,
+	useGitignoreModal,
+} from "./hooks/useGitignoreModal.js";
+import {
+	activationWarnings,
+	useProfileStartupModal,
+} from "./hooks/useProfileStartupModal.js";
+import {
+	staleLoadRepairNotices,
 	useStaleLoadModal,
 } from "./hooks/useStaleLoadModal.js";
 import { KeyRouter, useKeyLayer } from "./input/KeyRouter.js";
@@ -57,12 +60,14 @@ import {
 	useApp,
 	useModal,
 	useNavigation,
+	useNotify,
 } from "./state/AppContext.js";
 import {
 	DimensionsProvider,
 	useDimensions,
 } from "./state/DimensionsContext.js";
-import type { Screen } from "./state/types.js";
+import type { Notice, Screen } from "./state/types.js";
+import { truncate } from "./text-width.js";
 import { theme } from "./theme.js";
 
 export const VERSION = getCurrentVersion();
@@ -180,6 +185,72 @@ function UpdateBanner({ result }: { result: VersionCheckResult }) {
 	);
 }
 
+/**
+ * NoticeBanner Component
+ * The app's one notice line (or a few): what an action did, from `useNotify`.
+ * It sits above the screen and outside the modal slot, so it never takes a key
+ * and never stands in the way of a startup question. Each line clears itself
+ * at its `expiresAt` — counting only time with no modal open.
+ *
+ * One notice is exactly ONE row: the layout reserves one row per notice
+ * (`transientBannerCount`), so a line that wrapped would push the screen's
+ * last rows off the terminal. Hence no wrapping, and the text clipped to the
+ * width — the start of a line says what happened, and that is what survives.
+ */
+function NoticeBanner({ notices }: { notices: readonly Notice[] }) {
+	const { state, dispatch } = useApp();
+	const { terminalWidth } = useDimensions();
+	const modalOpen = state.modal !== null;
+	const paused = state.noticesPausedAt !== null;
+
+	// Hold the notices while a modal is open. A warning posted just before a
+	// startup question, or under it, would otherwise run down behind it and be
+	// gone by the time the user has answered.
+	useEffect(() => {
+		dispatch({
+			type: modalOpen ? "PAUSE_NOTICES" : "RESUME_NOTICES",
+			now: Date.now(),
+		});
+	}, [modalOpen, dispatch]);
+
+	// One timer, for the line that expires first; the reducer then drops every
+	// line past its time, and the next render schedules the one after. None
+	// while paused: RESUME_NOTICES moves every `expiresAt` on first.
+	useEffect(() => {
+		if (notices.length === 0 || paused) return;
+		const next = Math.min(...notices.map((n) => n.expiresAt));
+		const timer = setTimeout(
+			() => dispatch({ type: "EXPIRE_NOTICES", now: Date.now() }),
+			Math.max(0, next - Date.now()),
+		);
+		return () => clearTimeout(timer);
+	}, [notices, paused, dispatch]);
+
+	// The box's left and right padding.
+	const width = Math.max(0, terminalWidth - 2);
+	return (
+		<>
+			{notices.map((notice) => (
+				<box key={notice.id} paddingLeft={1} paddingRight={1} height={1}>
+					<text
+						wrapMode="none"
+						fg={
+							notice.tone === "warning"
+								? theme.colors.warning
+								: theme.colors.success
+						}
+					>
+						{truncate(
+							`${notice.tone === "warning" ? "⚠" : "✓"} ${notice.text}`,
+							width,
+						)}
+					</text>
+				</box>
+			))}
+		</>
+	);
+}
+
 /**
  * ProgressIndicator Component
  * Shows progress bar when operations are running
@@ -207,34 +278,17 @@ function ProgressIndicator({
 interface AppContentInnerProps {
 	updateInfo: VersionCheckResult | null;
 	onExit: () => void;
-	recoveryReport: string | null;
-	/** What the startup profile gate did: absorbed edits, regeneration, repairs. */
-	profileNotices: string[];
 }
 
-function AppContentInner({
-	updateInfo,
-	onExit,
-	recoveryReport,
-	profileNotices,
-}: AppContentInnerProps) {
+function AppContentInner({ updateInfo, onExit }: AppContentInnerProps) {
 	const { state } = useApp();
-	const { progress } = state;
+	const { progress, notices } = state;
 	const dimensions = useDimensions();
 
 	return (
 		<box flexDirection="column" height={dimensions.terminalHeight}>
 			{updateInfo?.updateAvailable && <UpdateBanner result={updateInfo} />}
-			{recoveryReport && (
-				<box paddingLeft={1} paddingRight={1}>
-					<text fg={theme.colors.success}>✓ Fixed: {recoveryReport}</text>
-				</box>
-			)}
-			{profileNotices.map((line) => (
-				<box key={line} paddingLeft={1} paddingRight={1}>
-					<text fg={theme.colors.success}>• {line}</text>
-				</box>
-			))}
+			<NoticeBanner notices={notices} />
 			{progress && <ProgressIndicator {...progress} />}
 			<box
 				flexDirection="column"
@@ -250,6 +304,27 @@ function AppContentInner({
 	);
 }
 
+/** A gitignore check's answer, waiting for the modal slot. */
+interface QueuedGitignore {
+	need: StartupGitignoreNeed;
+	/** The `gitignoreCheckRequest` it answers. */
+	request: number;
+}
+
+/**
+ * The gitignore check's bookkeeping. A ref, not state: a landing check reads
+ * the latest request and what was last shown at that moment, not as of the
+ * render that started it.
+ */
+interface GitignoreCheck {
+	/** A check is running. There is never more than one. */
+	inFlight: boolean;
+	/** The newest `gitignoreCheckRequest` seen. */
+	latest: number;
+	/** The request whose answer was last shown as a question; -1 for none. */
+	shown: number;
+}
+
 /**
  * AppContent Component
  * Wraps app with DimensionsProvider and manages state for debug/updates
@@ -261,11 +336,21 @@ interface AppContentProps {
 function AppContent({ onExit }: AppContentProps) {
 	const { state, dispatch } = useApp();
 	const { progress } = state;
+	const notify = useNotify();
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
-	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
-	const [profileNotices, setProfileNotices] = useState<string[]>([]);
-	const [gitignoreData, setGitignoreData] =
-		useState<StartupGitignoreNeed | null>(null);
+	const [gitignoreData, setGitignoreData] = useState<QueuedGitignore | null>(
+		null,
+	);
+	// The last request whose check has landed. Behind the latest request, a
+	// check is pending, and `gitignoreData` — if any — is an answer to an
+	// earlier question about a project that has since changed.
+	const [gitignoreSettled, setGitignoreSettled] = useState(-1);
+	const gitignorePending = gitignoreSettled < state.gitignoreCheckRequest;
+	const gitignoreCheck = useRef<GitignoreCheck>({
+		inFlight: false,
+		latest: 0,
+		shown: -1,
+	});
 	const [profileNeed, setProfileNeed] = useState<ProfileStartupNeed | null>(
 		null,
 	);
@@ -274,22 +359,23 @@ function AppContent({ onExit }: AppContentProps) {
 		null,
 	);
 	const staleLoadModal = useStaleLoadModal();
-	// The gitignore question, asked fresh: on every open, and again once the
-	// profile modal has activated a profile — a first adoption is what turns a
-	// committed settings.json into a generated file git should not track.
-	// Nothing remembers an earlier answer.
-	const checkGitignoreNow = React.useCallback(() => {
-		startupGitignoreNeed(process.cwd())
-			.then((need) => {
-				if (need) setGitignoreData(need);
-			})
-			.catch(() => {
-				// non-fatal: the Git State tab still shows the same rows
-			});
-	}, []);
+	// Stable, so `profileModal.show` is not rebuilt for it on every render.
+	const profileAnswered = React.useCallback(() => setProfileNeed(null), []);
+	// Activating a profile changes which plugins are on, so the open screen must
+	// reload. The result modal that used to follow sent the user to the Profiles
+	// tab, which remounted it; without that modal the user stays where they are,
+	// and the screen under them would keep showing the pre-activation state.
+	// The same action re-runs the gitignore check — see the effect below.
+	const profileActivated = React.useCallback(() => {
+		dispatch({ type: "PROFILE_ACTIVATED" });
+	}, [dispatch]);
 	// The profile modal cannot be dismissed, so it needs the app's own exit: its
 	// only non-action is to leave.
-	const profileModal = useProfileStartupModal(onExit, checkGitignoreNow);
+	const profileModal = useProfileStartupModal({
+		onQuit: onExit,
+		onActivated: profileActivated,
+		onAnswered: profileAnswered,
+	});
 
 	// Check for updates on startup, then re-check periodically (force-bypassing
 	// the session cache) so the banner reflects a release that lands while
@@ -309,66 +395,102 @@ function AppContent({ onExit }: AppContentProps) {
 		return () => clearInterval(id);
 	}, []);
 
-	// Auto-dismiss the profile gate's notices after 10 seconds — long enough to
-	// read a line per absorbed change.
-	useEffect(() => {
-		if (profileNotices.length === 0) return;
-		const timer = setTimeout(() => setProfileNotices([]), 10000);
-		return () => clearTimeout(timer);
-	}, [profileNotices]);
-
-	// Auto-dismiss recovery banner after 5 seconds
-	useEffect(() => {
-		if (!recoveryReport) return;
-		const timer = setTimeout(() => setRecoveryReport(null), 5000);
-		return () => clearTimeout(timer);
-	}, [recoveryReport]);
-
-	// Show gitignore modal — wait for the modal slot to be free so we don't
-	// stomp on another modal that may have just been shown.
-	useEffect(() => {
-		if (!gitignoreData) return;
-		if (state.modal) return;
-		gitignoreModal.show({
-			violationCount: gitignoreData.violationCount,
-			safeCount: gitignoreData.safeCount,
-			generated: gitignoreData.generated,
-			// In place, then back to the app: tracked generated files are
-			// untracked, missing entries added; other items stay for the tab.
-			onFixSafe: async () =>
-				describeStartupFix(await applyStartupFixes(state.projectPath)),
-		});
-		setGitignoreData(null);
-	}, [gitignoreData, gitignoreModal, state.modal, state.projectPath]);
-
-	// Show the broken-plugin modal — same "wait for the modal slot" rule as the
-	// gitignore one above, so two startup findings queue instead of one stomping
-	// the other.
+	// The startup questions — gitignore, then broken plugins, then profile — are
+	// asked ONE at a time, from ONE effect, and only while the modal slot is free.
+	//
+	// They used to be three effects, each checking `state.modal` from the same
+	// render. Two needs arriving in one commit both saw an empty slot, both
+	// showed, and the later SHOW_MODAL replaced the earlier question after its
+	// need had already been cleared — so it never came back. The profile question
+	// was lost exactly that way, and the user updated plugins believing a profile
+	// was active. So: show at most one per run and return; the next question
+	// follows once that one's flow has ended and the slot is empty again.
+	//
+	// The hooks keep the slot occupied for their whole flow (a loading modal
+	// while their fix runs, never HIDE_MODAL mid-flow), because an empty slot is
+	// what lets the next question in. A flow that succeeds ends by hiding its
+	// loading modal and reporting through `useNotify`: a notice is not in the
+	// modal slot, so it cannot hold the next question back or be replaced by it. That does not stop a SCREEN from emptying
+	// it: `useModal().confirm` hides its modal when answered and the screen shows
+	// its loading modal a microtask later. A key pressed before the profile check
+	// resolved lands the profile question in exactly that gap, and the screen's
+	// loading modal then replaces it.
+	//
+	// So the two kinds of question are cleared at different points.
+	//
+	// - The profile need is cleared when it is ANSWERED (`profileAnswered`, from
+	//   the hook: a profile activated, or quit), never when shown. The modal
+	//   cannot be dismissed, so an empty slot while the need is still set means
+	//   it was lost, and this effect puts it back. The hook keeps what was last
+	//   asked and whether work is in flight, so a re-show re-asks the question
+	//   that was on screen and never starts a second activation.
+	// - The gitignore and broken-plugin needs are still cleared on show. Both
+	//   can be dismissed, so an empty slot does not mean they were lost —
+	//   re-showing would re-ask a question the user just declined. Losing one
+	//   costs nothing lasting: the Git State and Plugins tabs show the same rows,
+	//   and gitignore is asked again after a profile activates.
+	//
+	// The gitignore question also waits while a check is pending. An activation
+	// both empties the slot and asks for a fresh check, so the slot is free
+	// while an answer from BEFORE the activation may still be queued: showing
+	// it and then the fresh one asked the same question twice. The fresh result
+	// replaces the queued one instead (see the check effect below).
 	useEffect(() => {
-		if (brokenPluginCount === null) return;
 		if (state.modal) return;
-		staleLoadModal.show({
-			brokenCount: brokenPluginCount,
-			// Re-surveys before repairing, like the gitignore fixer: the registry may
-			// have moved between the startup scan and the user pressing Enter, and
-			// repairing from the stale count would act on rows that are no longer
-			// there. `repairAllStaleLoads` is the same `repairStaleLoad` the Plugins
-			// screen's `a` key drives through the apply engine.
-			//
-			// The pins are re-read with it, from the same helper the survey used: a
-			// repair that capped at a different ceiling than the offer was counted
-			// against would move rows the dialog never mentioned.
-			onFix: async () =>
-				staleLoadRepairSummary(
-					await repairAllStaleLoads(
-						state.projectPath,
-						undefined,
-						await activePluginPins(state.projectPath),
+		if (gitignoreData && !gitignorePending) {
+			// Anything older than what is now on screen is dropped on arrival.
+			gitignoreCheck.current.shown = gitignoreData.request;
+			const need = gitignoreData.need;
+			gitignoreModal.show({
+				violationCount: need.violationCount,
+				safeCount: need.safeCount,
+				generated: need.generated,
+				// In place, then back to the app: tracked generated files are
+				// untracked, missing entries added; other items stay for the tab.
+				onFixSafe: async () =>
+					startupFixNotices(await applyStartupFixes(state.projectPath)),
+			});
+			setGitignoreData(null);
+			return;
+		}
+		if (brokenPluginCount !== null) {
+			staleLoadModal.show({
+				brokenCount: brokenPluginCount,
+				// Re-surveys before repairing, like the gitignore fixer: the registry
+				// may have moved between the startup scan and the user pressing Enter,
+				// and repairing from the stale count would act on rows that are no
+				// longer there. `repairAllStaleLoads` is the same `repairStaleLoad` the
+				// Plugins screen's `a` key drives through the apply engine.
+				//
+				// The pins are re-read with it, from the same helper the survey used: a
+				// repair that capped at a different ceiling than the offer was counted
+				// against would move rows the dialog never mentioned.
+				onFix: async () =>
+					staleLoadRepairNotices(
+						await repairAllStaleLoads(
+							state.projectPath,
+							undefined,
+							await activePluginPins(state.projectPath),
+						),
 					),
-				),
-		});
-		setBrokenPluginCount(null);
-	}, [brokenPluginCount, staleLoadModal, state.modal, state.projectPath]);
+			});
+			setBrokenPluginCount(null);
+			return;
+		}
+		// Not cleared here — see above. Re-called on every empty slot until the
+		// hook reports it answered.
+		if (profileNeed) profileModal.show(profileNeed);
+	}, [
+		state.modal,
+		state.projectPath,
+		gitignoreData,
+		gitignorePending,
+		gitignoreModal,
+		brokenPluginCount,
+		staleLoadModal,
+		profileNeed,
+		profileModal,
+	]);
 
 	// Does this project load an older plugin than it installed? Detection only;
 	// nothing is written until the user chooses Fix.
@@ -393,23 +515,46 @@ function AppContent({ onExit }: AppContentProps) {
 		})();
 	}, []);
 
-	// Show the profile modal on the same terms as the gitignore one: only once
-	// the modal slot is free, so two startup checks that both found something do
-	// not stomp on each other. Gitignore is asked first simply because its
-	// effect is declared first; whichever the user dismisses, the other follows.
-	useEffect(() => {
-		if (!profileNeed) return;
-		if (state.modal) return;
-		profileModal.show(profileNeed);
-		setProfileNeed(null);
-	}, [profileNeed, profileModal, state.modal]);
-
-	// The gitignore question on every open. Its own effect, NOT part of the
-	// marketplace block below, which returns early on `--no-refresh`: that flag
-	// is about network calls and must not silence this question.
+	// The gitignore question, asked fresh: on every open (request 0), and again
+	// on each PROFILE_ACTIVATED — a first adoption is what turns a committed
+	// settings.json into a generated file git should not track, and a
+	// Profiles-tab switch can do the same. Nothing remembers an earlier answer.
+	//
+	// At most ONE check runs at a time. A request that arrives while one runs
+	// is not started beside it: the running check, on landing, sees that it is
+	// no longer the latest, throws its answer away — it describes the project
+	// before whatever prompted the request — and runs again. Only the latest
+	// request's answer is kept, and it REPLACES anything still queued, including
+	// with nothing when the project no longer needs the question.
+	//
+	// Its own effect, NOT part of the marketplace block below, which returns
+	// early on `--no-refresh`: that flag is about network calls and must not
+	// silence this question.
 	useEffect(() => {
-		checkGitignoreNow();
-	}, [checkGitignoreNow]);
+		const check = gitignoreCheck.current;
+		check.latest = state.gitignoreCheckRequest;
+		if (check.inFlight) return;
+		const run = (request: number): void => {
+			check.inFlight = true;
+			startupGitignoreNeed(process.cwd())
+				// non-fatal: the Git State tab still shows the same rows
+				.catch(() => null)
+				.then((need) => {
+					if (request !== check.latest) {
+						run(check.latest);
+						return;
+					}
+					check.inFlight = false;
+					setGitignoreSettled(request);
+					// Defence in depth: an answer to a request no newer than the
+					// question last shown predates the user's reply to it.
+					setGitignoreData(
+						need && request > check.shown ? { need, request } : null,
+					);
+				});
+		};
+		run(check.latest);
+	}, [state.gitignoreCheckRequest]);
 
 	// Is this project actually running a profile? Detection only — nothing is
 	// written until the user picks something in the modal. The Profiles tab could
@@ -427,19 +572,25 @@ function AppContent({ onExit }: AppContentProps) {
 				// edits into the active profile, regenerate from a changed
 				// profiles.json, restore a lost marker — then the question, if one
 				// is left to ask.
-				const { need, notices, problems } = await prepareProfileStartup(
-					process.cwd(),
-				);
+				const { need, notices, problems, activations } =
+					await prepareProfileStartup(process.cwd());
 				// A refusal never blocks the TUI at startup: it is shown beside what
-				// the gate did, and the user is still asked whatever is left.
-				const shown = [...notices, ...problems];
-				if (shown.length > 0) setProfileNotices(shown);
+				// the gate did, as a warning, and the user is still asked whatever
+				// is left. What a re-render left to act on — a plugin that will not
+				// load, one not downloaded yet — is a warning too, in user terms.
+				for (const line of notices) notify(line);
+				for (const activation of activations) {
+					for (const line of activationWarnings(activation)) {
+						notify(line.text, line.tone);
+					}
+				}
+				for (const line of problems) notify(line, "warning");
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
 			}
 		})();
-	}, []);
+	}, [notify]);
 
 	// Auto-refresh marketplaces on startup
 	useEffect(() => {
@@ -463,7 +614,7 @@ function AppContent({ onExit }: AppContentProps) {
 				if (!(await isClaudeAvailable())) return;
 				const added = await autoAddMissingMarketplaces(process.cwd());
 				if (added.length > 0) {
-					setRecoveryReport(`added marketplace(s): ${added.join(", ")}`);
+					notify(`Fixed: added marketplace(s): ${added.join(", ")}`);
 				}
 			} catch {
 				// non-fatal: user can still install marketplaces manually
@@ -474,6 +625,9 @@ function AppContent({ onExit }: AppContentProps) {
 		recoverMarketplaceSettings()
 			.then(async (recovery) => {
 				const parts: string[] = [];
+				// Apart from `parts`: a success line would carry them in green,
+				// and a marketplace left stale is something the user may act on.
+				const failed: string[] = [];
 				if (recovery.reregistered.length > 0) {
 					// Update the marketplace clone now that the source is fixed
 					const { updateMarketplace } = await import(
@@ -484,7 +638,7 @@ function AppContent({ onExit }: AppContentProps) {
 							await updateMarketplace(mp);
 							parts.push(`${mp} refreshed`);
 						} catch {
-							parts.push(`${mp} (update failed)`);
+							failed.push(mp);
 						}
 					}
 				}
@@ -492,7 +646,13 @@ function AppContent({ onExit }: AppContentProps) {
 					parts.push(`removed: ${recovery.removed.join(", ")}`);
 				}
 				if (parts.length > 0) {
-					setRecoveryReport(parts.join(" | "));
+					notify(`Fixed: ${parts.join(" | ")}`);
+				}
+				if (failed.length > 0) {
+					notify(
+						`Could not refresh marketplace(s): ${failed.join(", ")}`,
+						"warning",
+					);
 				}
 			})
 			.catch(() => {}); // non-fatal
@@ -505,23 +665,17 @@ function AppContent({ onExit }: AppContentProps) {
 			.catch(() => {
 				dispatch({ type: "HIDE_PROGRESS" });
 			});
-	}, [dispatch]);
-
-	// Count transient banners for dimension calculation
-	const transientBannerCount = recoveryReport ? 1 : 0;
+	}, [dispatch, notify]);
 
 	return (
 		<DimensionsProvider
 			showProgress={!!progress}
 			showUpdateBanner={!!updateInfo?.updateAvailable}
-			transientBannerCount={transientBannerCount}
+			// One row per notice line, so the screen below shrinks rather than
+			// being pushed off the bottom of the terminal.
+			transientBannerCount={state.notices.length}
 		>
-			<AppContentInner
-				updateInfo={updateInfo}
-				onExit={onExit}
-				recoveryReport={recoveryReport}
-				profileNotices={profileNotices}
-			/>
+			<AppContentInner updateInfo={updateInfo} onExit={onExit} />
 		</DimensionsProvider>
 	);
 }

package/src/ui/adapters/pluginsAdapter.ts

@@ -247,10 +247,27 @@ function isMadAppGang(mp: Marketplace): boolean {
  */
 export function noMoveReasons(): {
 	reporter: ApplyReporter;
-	/** One line per unchanged item, with its cause when one was reported. */
-	lines(unchanged: readonly string[]): string;
+	/**
+	 * One line per unchanged item, with its cause when one was reported, so one
+	 * plugin's reason never runs into the next. The screen posts
+	 * {@link notice} instead; this is the per-item form it is built from.
+	 */
+	lines(unchanged: readonly string[]): string[];
+	/**
+	 * The same, as ONE notice line, or null when nothing was unchanged. "Update
+	 * all" can leave many plugins where they were, and a line each would fill
+	 * the banner and push out whatever else it had to say. So several become
+	 * `3 plugins unchanged — a, b, c`, with the cause only when they all share
+	 * it; one keeps its own cause.
+	 */
+	notice(unchanged: readonly string[]): string | null;
 } {
 	const why = new Map<string, string>();
+	const lines = (unchanged: readonly string[]): string[] =>
+		unchanged.map((name) => {
+			const reason = why.get(name);
+			return reason ? `${name}: ${reason}` : name;
+		});
 	return {
 		reporter: {
 			begin: () => {},
@@ -260,13 +277,15 @@ export function noMoveReasons(): {
 			},
 			detach: (work) => work(),
 		},
-		lines: (unchanged) =>
-			unchanged
-				.map((name) => {
-					const reason = why.get(name);
-					return reason ? `${name}: ${reason}` : name;
-				})
-				.join("\n"),
+		lines,
+		notice: (unchanged) => {
+			if (unchanged.length === 0) return null;
+			if (unchanged.length === 1) return `No change: ${lines(unchanged)[0]}`;
+			const reasons = new Set(unchanged.map((name) => why.get(name)));
+			const [shared] = reasons;
+			const cause = reasons.size === 1 && shared ? `: ${shared}` : "";
+			return `${unchanged.length} plugins unchanged — ${unchanged.join(", ")}${cause}`;
+		},
 	};
 }
 

package/src/ui/components/modals/MessageModal.tsx

@@ -7,12 +7,11 @@ interface MessageModalProps {
 	/** Modal message */
 	message: string;
 	/** Message variant */
-	variant: "info" | "success" | "error";
+	variant: "info" | "error";
 }
 
 const variantConfig = {
 	info: { icon: "ℹ", color: theme.colors.info },
-	success: { icon: "✓", color: theme.colors.success },
 	error: { icon: "✗", color: theme.colors.danger },
 } as const;
 

package/src/ui/components/modals/ModalContainer.tsx

@@ -34,6 +34,9 @@ const isPlain = (key: KeyPress) => !key.ctrl && !key.meta;
  *            question that must be answered).
  * - input:   Esc cancels; everything else goes to the focused <input>, which
  *            OpenTUI delivers after this layer and which submits on Enter.
+ *            Only an <input> that was ALREADY focused when the key arrived:
+ *            the Enter that opens an input modal from a select never reaches
+ *            it (KeyRouter's `dispatchThenGuardFocus`).
  * - message: any key dismisses.
  * - loading: keys are swallowed until the work finishes.
  * - help:    ↑↓ / PgUp / PgDn / Ctrl+U / Ctrl+D scroll; Esc or `?` close.