magus-cli 7.6.0 → 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,26 +359,21 @@ 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({
 		onQuit: onExit,
-		onActivated: checkGitignoreNow,
+		onActivated: profileActivated,
 		onAnswered: profileAnswered,
 	});
 
@@ -315,21 +395,6 @@ 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]);
-
 	// 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.
 	//
@@ -339,12 +404,13 @@ function AppContent({ onExit }: AppContentProps) {
 	// 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 last modal is dismissed and the slot is empty
-	// again.
+	// 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. That does not stop a SCREEN from emptying
+	// 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
@@ -363,17 +429,26 @@ function AppContent({ onExit }: AppContentProps) {
 	//   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 (state.modal) return;
-		if (gitignoreData) {
+		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: gitignoreData.violationCount,
-				safeCount: gitignoreData.safeCount,
-				generated: gitignoreData.generated,
+				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 () =>
-					describeStartupFix(await applyStartupFixes(state.projectPath)),
+					startupFixNotices(await applyStartupFixes(state.projectPath)),
 			});
 			setGitignoreData(null);
 			return;
@@ -391,7 +466,7 @@ function AppContent({ onExit }: AppContentProps) {
 				// repair that capped at a different ceiling than the offer was counted
 				// against would move rows the dialog never mentioned.
 				onFix: async () =>
-					staleLoadRepairSummary(
+					staleLoadRepairNotices(
 						await repairAllStaleLoads(
 							state.projectPath,
 							undefined,
@@ -409,6 +484,7 @@ function AppContent({ onExit }: AppContentProps) {
 		state.modal,
 		state.projectPath,
 		gitignoreData,
+		gitignorePending,
 		gitignoreModal,
 		brokenPluginCount,
 		staleLoadModal,
@@ -439,12 +515,46 @@ function AppContent({ onExit }: AppContentProps) {
 		})();
 	}, []);
 
-	// 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
@@ -462,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(() => {
@@ -498,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
@@ -509,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(
@@ -519,7 +638,7 @@ function AppContent({ onExit }: AppContentProps) {
 							await updateMarketplace(mp);
 							parts.push(`${mp} refreshed`);
 						} catch {
-							parts.push(`${mp} (update failed)`);
+							failed.push(mp);
 						}
 					}
 				}
@@ -527,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
@@ -540,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/hooks/useGitignoreModal.ts

@@ -1,6 +1,7 @@
 import { useCallback } from "react";
-import { useApp, useNavigation } from "../state/AppContext.js";
-import type { ModalState } from "../state/types.js";
+import type { StartupFixResult } from "../../services/gitignore-service.js";
+import { useApp, useNavigation, useNotify } from "../state/AppContext.js";
+import type { ModalState, NoticeLine } from "../state/types.js";
 
 /**
  * Startup gitignore-violation modal: magus launches, detects a problem, and
@@ -79,17 +80,49 @@ export function buildGitignoreModal(args: BuildModalArgs): ModalState {
 	};
 }
 
+/**
+ * What the startup fix did, as notices. Untracking is a warning because it is
+ * not finished until the user commits the staged removal — the one thing here
+ * they must still do. The files are named only there, and in a failure, which
+ * the user has to deal with by hand.
+ */
+export function startupFixNotices(result: StartupFixResult): NoticeLine[] {
+	const lines: NoticeLine[] = [];
+	if (result.untracked.length > 0) {
+		lines.push({
+			text: `Stopped tracking ${result.untracked.join(", ")} — commit the staged removal`,
+			tone: "warning",
+		});
+	}
+	if (result.appended.length > 0) {
+		lines.push({
+			text: `Added ${entries(result.appended.length)}`,
+			tone: "success",
+		});
+	}
+	for (const f of result.failed) {
+		lines.push({
+			text: `Could not stop tracking ${f.path}: ${f.reason}`,
+			tone: "warning",
+		});
+	}
+	return lines.length > 0
+		? lines
+		: [{ text: "Gitignore already up to date", tone: "success" }];
+}
+
 export function useGitignoreModal() {
 	const { dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
+	const notify = useNotify();
 
 	const show = useCallback(
 		(args: {
 			violationCount: number;
 			safeCount: number;
 			generated?: readonly string[];
-			/** Returns what it did, shown before returning to the app. */
-			onFixSafe: () => Promise<string | undefined> | string | undefined;
+			/** Returns what it did, reported as notices once the fix settles. */
+			onFixSafe: () => Promise<readonly NoticeLine[]> | readonly NoticeLine[];
 		}) => {
 			if (args.violationCount === 0) return;
 			const dismiss = () => dispatch({ type: "HIDE_MODAL" });
@@ -101,9 +134,9 @@ export function useGitignoreModal() {
 					// A loading modal, NOT HIDE_MODAL. The fix is async, and an empty
 					// modal slot is App's signal that the next startup question may be
 					// asked: hiding here let the profile question show during the await,
-					// be marked as asked, and then be replaced by "Gitignore fixed" —
+					// be marked as asked, and then be replaced by the fix's result —
 					// lost for the whole session. The slot stays occupied until the
-					// result below is dismissed.
+					// fix settles.
 					dispatch({
 						type: "SHOW_MODAL",
 						modal: { type: "loading", message: "Fixing gitignore…" },
@@ -114,22 +147,11 @@ export function useGitignoreModal() {
 					void Promise.resolve()
 						.then(() => args.onFixSafe())
 						.then((report) => {
-							// Nothing to report still has to clear the loading modal: it
-							// swallows every key, so leaving it would hang the app.
-							if (!report) {
-								dispatch({ type: "HIDE_MODAL" });
-								return;
-							}
-							dispatch({
-								type: "SHOW_MODAL",
-								modal: {
-									type: "message",
-									title: "Gitignore fixed",
-									message: report,
-									variant: "success",
-									onDismiss: dismiss,
-								},
-							});
+							// The loading modal must go — it swallows every key — and the
+							// result goes to the notice banner, which is outside the modal
+							// slot, so the next startup question can take the slot now.
+							dispatch({ type: "HIDE_MODAL" });
+							for (const line of report) notify(line.text, line.tone);
 						})
 						.catch((err) => {
 							dispatch({
@@ -152,7 +174,7 @@ export function useGitignoreModal() {
 			});
 			dispatch({ type: "SHOW_MODAL", modal });
 		},
-		[dispatch, navigateToScreen],
+		[dispatch, navigateToScreen, notify],
 	);
 
 	return { show };