magus-cli 7.5.3 → 7.6.0

package/src/services/update-plan.ts

@@ -34,7 +34,11 @@ import type { PluginScope } from "./claude-cli.js";
 import {
 	type PluginInfo,
 	compareVersions,
+	filesMissingScopes,
+	highestInstalledVersion,
+	installedScopeVersions,
 	isBehind,
+	isInstalledAnywhere,
 	isRepairablyBehind,
 } from "./plugin-manager.js";
 import {
@@ -48,7 +52,7 @@ import {
 // ── Plugins ──────────────────────────────────────────────────────────────────
 
 export type PluginUpdateAction =
-	/** Declared by the profile, installed nowhere. */
+	/** Declared by the profile and installed nowhere, or installed with its files missing. */
 	| "install"
 	/** Installed at a version other than the one we should be on. */
 	| "update"
@@ -83,8 +87,8 @@ export type PluginUpdateAction =
 export type PluginReason =
 	/** install: declared by the profile, installed nowhere. */
 	| "absent"
-	/** install: enabled in a settings file, but no registry row in any scope. */
-	| "enabled-not-installed"
+	/** install: installed at a scope, but no version resolves at any installed scope. */
+	| "files-missing"
 	/** unknown: a marketplace we READ does not list it. */
 	| "not-offered"
 	/** unknown: installed, unlisted, and its marketplace contributed no listed ids. */
@@ -127,7 +131,11 @@ export interface PluginUpdateItem {
 	action: PluginUpdateAction;
 	/** Why it is in this state. */
 	reason: PluginReason;
-	/** Scopes holding an install this action must touch. Empty for a fresh install. */
+	/**
+	 * Scopes holding an install this action must touch — for `files-missing`, the
+	 * scopes installed with no version. Empty for an `absent` install, which the
+	 * engine puts at project scope.
+	 */
 	scopes: PluginScope[];
 	/**
 	 * The version installed in each scope BEFORE any work, so an apply can tell
@@ -141,44 +149,12 @@ export interface PluginUpdateItem {
 	note?: string;
 }
 
-/** Scope → installed version, for the three scopes a PluginInfo carries. */
-function scopeVersions(
-	info: PluginInfo | undefined,
-): Array<[PluginScope, string]> {
-	if (!info) return [];
-	const out: Array<[PluginScope, string]> = [];
-	for (const [scope, status] of [
-		["user", info.userScope],
-		["project", info.projectScope],
-		["local", info.localScope],
-	] as const) {
-		if (status?.version) out.push([scope, status.version]);
-	}
-	return out;
-}
-
-/**
- * The highest version installed across scopes, or null.
- *
- * `compareVersions` answers null for an unorderable pair, and null is not
- * `>= 0`, so the reduce keeps the right-hand side when two versions cannot be
- * ranked. "Highest" is not meaningful across commit ids; picking one
- * deterministically is, and every caller only needs *an* installed version.
- */
-function highestInstalled(info: PluginInfo | undefined): string | null {
-	const versions = scopeVersions(info).map(([, v]) => v);
-	if (versions.length === 0) return null;
-	return versions.reduce((a, b) =>
-		(compareVersions(a, b) ?? -1) >= 0 ? a : b,
-	);
-}
-
 /**
  * The highest installed version THE PIN PERMITS — the ceiling a stale-load
  * repair may aim at. Null when no installed version qualifies.
  *
- * Under "latest" that is simply {@link highestInstalled}: nothing caps it, and
- * the newest version on this machine is the one to converge on.
+ * Under "latest" that is simply {@link highestInstalledVersion}: nothing caps
+ * it, and the newest version on this machine is the one to converge on.
  *
  * Under an EXACT pin it is the highest installed version at or below the pin.
  * `installed` reaches across every scope and `scopesNeeding` never downgrades, so
@@ -196,8 +172,8 @@ function highestPermittedInstalled(
 	info: PluginInfo | undefined,
 	pin: string,
 ): string | null {
-	if (pin === "latest") return highestInstalled(info);
-	const permitted = scopeVersions(info)
+	if (pin === "latest") return highestInstalledVersion(info);
+	const permitted = installedScopeVersions(info)
 		.map(([, v]) => v)
 		// pin >= v, i.e. v is at or below the pin. Null (unorderable) fails this.
 		.filter((v) => (compareVersions(pin, v) ?? -1) >= 0);
@@ -238,7 +214,7 @@ export function scopesNeeding(
 	// A raw `compareVersions(...) > 0` reported false for that pair and the
 	// scope was silently left alone. An unknown (null) is still left alone —
 	// moving a scope we cannot rank would be a guess.
-	return scopeVersions(info)
+	return installedScopeVersions(info)
 		.filter(([, version]) => isBehind(target, version) === true)
 		.map(([scope]) => scope);
 }
@@ -255,11 +231,11 @@ function marketplaceSuffix(id: string): string | null {
  * The catalog, indexed for the questions the classifier asks of it.
  *
  * "Listed" is narrower than "present". `getAvailablePlugins` puts ORPHANS —
- * installed or enabled, but published by no marketplace we read — into the same
- * list with `isOrphaned: true`, so a plain `has(id)` is true for a plugin that
- * nothing publishes. Treating an orphan as listed is what let an orphan plan as
- * `current`: its `version` is filled in from its own installed version, so the
- * compare found them equal.
+ * in this project's settings or registry, but published by no marketplace we
+ * read — into the same list with `isOrphaned: true`, so a plain `has(id)` is
+ * true for a plugin that nothing publishes. Treating an orphan as listed is
+ * what let an orphan plan as `current`: its `version` is filled in from its own
+ * installed version, so the compare found them equal.
  */
 export interface CatalogIndex {
 	get(pluginId: string): PluginInfo | undefined;
@@ -306,15 +282,6 @@ export function indexCatalog(
 	};
 }
 
-/** True when a settings file enables the plugin in at least one scope. */
-function enabledAnywhere(info: PluginInfo | undefined): boolean {
-	return (
-		!!info?.userScope?.enabled ||
-		!!info?.projectScope?.enabled ||
-		!!info?.localScope?.enabled
-	);
-}
-
 /**
  * THE plugin classifier. Pure.
  *
@@ -332,7 +299,7 @@ export function classifyPlugin(
 ): PluginUpdateItem {
 	const info = index.get(pluginId);
 	const listed = index.isListed(pluginId);
-	const installed = highestInstalled(info);
+	const installed = highestInstalledVersion(info);
 	// An orphan's `version` is its own installed version (or a stale local
 	// clone's), not something a marketplace we read offers — so it is not
 	// "available" from anywhere.
@@ -344,7 +311,7 @@ export function classifyPlugin(
 		installed,
 		loaded: info?.loadedVersion ?? null,
 		available,
-		beforeVersions: Object.fromEntries(scopeVersions(info)) as Partial<
+		beforeVersions: Object.fromEntries(installedScopeVersions(info)) as Partial<
 			Record<PluginScope, string>
 		>,
 	};
@@ -388,24 +355,29 @@ export function classifyPlugin(
 		};
 	}
 
-	// Not installed anywhere — the "checked but not installed" case.
+	// No installed scope has a version — the "checked but not installed" case.
 	//
-	// Nothing is installed in any scope here, so "enabled somewhere" is exactly
-	// "enabled but not installed". It is tested directly rather than through
-	// `isEnabledButNotInstalled`, which excludes orphans: an orphan that is only
-	// a settings key would otherwise read as `absent`, and the TUI renders
-	// `absent` as "the profile declares it", which an undeclared orphan does not.
+	// So a scope that IS installed here has its files missing. It is tested
+	// directly rather than through `hasMissingFiles`, which excludes orphans: an
+	// orphan that is only a settings key would otherwise read as `absent`, and the
+	// TUI renders `absent` as "the profile declares it", which an undeclared
+	// orphan does not.
+	//
+	// Files missing carries the scopes to reinstall at: exactly the ones installed
+	// with no version. It used to carry none, and the engine read "install" as
+	// "project scope" — so a user-scope plugin with its files missing was
+	// reinstalled at project scope, turning it on in the team's settings.json.
+	// `absent` still carries none: the engine installs it at project scope.
 	if (!installed) {
-		const brokenEnable = enabledAnywhere(info);
+		const missingAt = filesMissingScopes(info);
+		const filesMissing = missingAt.length > 0;
 		return {
 			...base,
 			target: pin === "latest" ? available : pin,
 			action: "install",
-			reason: brokenEnable ? "enabled-not-installed" : "absent",
-			scopes: [],
-			...(brokenEnable
-				? { note: "enabled in settings, but no files on disk" }
-				: {}),
+			reason: filesMissing ? "files-missing" : "absent",
+			scopes: missingAt,
+			...(filesMissing ? { note: "files missing" } : {}),
 		};
 	}
 
@@ -622,7 +594,7 @@ export function classifyPlugin(
 			target: installed,
 			action: "repair",
 			reason: "content-stale",
-			scopes: scopeVersions(info).map(([scope]) => scope),
+			scopes: installedScopeVersions(info).map(([scope]) => scope),
 			note: "files changed without a version bump",
 		};
 	}
@@ -669,17 +641,38 @@ export function classifyPlugin(
 }
 
 /**
- * Decide what to do with every plugin the profile declares.
+ * THE plugin plan — for `magus update` and the Plugins screen alike.
+ *
+ * Every plugin the active profile declares, under its pin, and every plugin
+ * installed in any scope (user, project, local), under "latest" — the rule
+ * {@link pinForRow} states — each classified by {@link classifyPlugin}, sorted.
+ *
+ * ONE list, read by both surfaces: the screen's rows, header counts and
+ * "update all", and the CLI's report and apply. It used to be two — the CLI
+ * planned the profile's plugins only, the screen every installed plugin — so a
+ * USER-scope plugin the screen showed as "update available" was never seen by
+ * `magus update`, which then reported everything up to date. The owner asked
+ * for "absolutely the same code" on both sides; this is it.
  *
  * @param pinned  closure.plugins — pluginId -> exact version | "latest"
- * @param catalog getAvailablePlugins() output, keyed by plugin id
+ * @param catalog getAvailablePlugins() output — keyed by id, or as a list
  */
 export function planPluginUpdates(
-	pinned: Record<string, string>,
-	catalog: Map<string, PluginInfo>,
+	pinned: Readonly<Record<string, string>>,
+	catalog: ReadonlyMap<string, PluginInfo> | readonly PluginInfo[],
 ): PluginUpdateItem[] {
 	const index = indexCatalog(catalog);
-	return Object.entries(pinned)
+	const plugins =
+		catalog instanceof Map
+			? [...catalog.values()]
+			: (catalog as readonly PluginInfo[]);
+	const pins = new Map(Object.entries(pinned));
+	for (const info of plugins) {
+		if (pins.has(info.id)) continue;
+		const pin = pinForRow(info, pinned);
+		if (pin !== null) pins.set(info.id, pin);
+	}
+	return [...pins]
 		.map(([pluginId, pin]) => classifyPlugin(pluginId, pin, index))
 		.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 }
@@ -689,45 +682,36 @@ export function planPluginUpdates(
  *
  * 1. The active profile's pin, when it declares the plugin — the SAME value
  *    `magus update` plans with, which is what makes the two agree.
- * 2. Otherwise "latest", when the plugin is installed in any scope or enabled
- *    in one — what the TUI's own update actions have always planned with, so
- *    the row and the action agree.
+ * 2. Otherwise "latest", when the plugin is installed in any scope, files
+ *    missing included — what the TUI's own update actions have always planned
+ *    with, so the row and the action agree.
  * 3. Otherwise null: an undeclared catalog entry the user is only browsing. It
  *    gets no status at all. `install` means "the profile wants it", and an
  *    undeclared plugin carries no such claim.
  *
  * A consequence the renderer relies on: reason `absent` can only come from
- * rule 1, because rule 2 never assigns a pin to a row that is neither installed
- * nor enabled.
+ * rule 1, because rule 2 never assigns a pin to a row that is not installed.
  */
 export function pinForRow(
 	info: PluginInfo,
 	pins: Readonly<Record<string, string>>,
 ): string | null {
 	if (Object.hasOwn(pins, info.id)) return pins[info.id] ?? null;
-	if (scopeVersions(info).length > 0 || enabledAnywhere(info)) return "latest";
+	if (isInstalledAnywhere(info)) return "latest";
 	return null;
 }
 
 /**
- * One status per row that has a pin. Rows whose {@link pinForRow} is null are
- * absent from the map.
- *
- * Computed once per data/pins change, and the same map feeds every consumer —
- * so the row, the detail panel, the header and the scope picker cannot disagree.
+ * {@link planPluginUpdates} keyed by plugin id, for the screen's lookups — the
+ * SAME plan `magus update` runs, not a second classification. Computed once
+ * per data/pins change, and the one map feeds the row, the detail panel, the
+ * header and the scope picker, so none of them can disagree.
  */
 export function classifyPluginRows(
 	plugins: readonly PluginInfo[],
 	pins: Readonly<Record<string, string>>,
 ): Map<string, PluginUpdateItem> {
-	const index = indexCatalog(plugins);
-	const out = new Map<string, PluginUpdateItem>();
-	for (const info of plugins) {
-		const pin = pinForRow(info, pins);
-		if (pin === null) continue;
-		out.set(info.id, classifyPlugin(info.id, pin, index));
-	}
-	return out;
+	return new Map(planPluginUpdates(pins, plugins).map((i) => [i.pluginId, i]));
 }
 
 export interface PluginStateCounts {

package/src/ui/App.tsx

@@ -287,9 +287,15 @@ function AppContent({ onExit }: AppContentProps) {
 				// 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), []);
 	// 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: checkGitignoreNow,
+		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
@@ -324,51 +330,91 @@ function AppContent({ onExit }: AppContentProps) {
 		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 last modal is dismissed 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
+	// 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.
 	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) {
+			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);
+			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 () =>
+					staleLoadRepairSummary(
+						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,
+		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,17 +439,6 @@ 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.
@@ -427,8 +462,13 @@ 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 } = await prepareProfileStartup(process.cwd());
-				if (notices.length > 0) setProfileNotices(notices);
+				const { need, notices, problems } = 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);
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand

package/src/ui/adapters/pluginsAdapter.ts

@@ -43,7 +43,7 @@ export interface PluginPluginItem {
 	/**
 	 * The classifier's answer for this plugin — the same item `magus update`
 	 * plans with. Null for a catalog entry the user is only browsing (neither
-	 * declared by the profile, installed, nor enabled): it has no state to claim.
+	 * declared by the profile nor installed): it has no state to claim.
 	 */
 	status: PluginUpdateItem | null;
 }

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.

package/src/ui/components/primitives/ScopeSquares.tsx

@@ -8,23 +8,28 @@ interface ScopeSquaresProps {
 	selected?: boolean;
 }
 
-/** Installed at that scope. */
+/** On at that scope. */
 export const SCOPE_ON = "■";
-/** Not installed at that scope. */
+/** Not on at that scope. */
 export const SCOPE_OFF = "□";
 
 /**
  * Scope bar: three positional squares, user / project / local.
  *
  * POSITION names the scope — the first square is always user, the second
- * project, the third local — and SHAPE says the state: `■` installed, `□` not.
- * That reads with no colour at all, which the bar never used to: every square
+ * project, the third local — and SHAPE says the state: `■` on, `□` not. "On"
+ * is the caller's to decide, and for a plugin and a skill alike it is
+ * installed. For a plugin that is `isInstalledInScope` — the scope's settings
+ * file turns it on, which is what Claude Code loads by — the same function the
+ * detail panel's dot reads, so the two cannot disagree.
+ *
+ * The shape reads with no colour at all, which the bar never used to: every square
  * was the same filled block, lit in a scope hue or unlit in a fill near the
  * page, so on a monochrome terminal, to a colour-blind reader, or on a theme
  * that drew two hues alike, all three states were one shape.
  *
  * Colour now only repeats what the shape says. A filled square wears `success`
- * (installed is what it means, on every screen); a hollow one wears `muted`,
+ * (on is what it means, on every screen); a hollow one wears `muted`,
  * which a thin outline needs to stay visible — the shape, not a pale fill, is
  * what makes it recede. On a selected row the selection owns the colour
  * channel: filled squares take its ink, hollow ones its dim ink.

package/src/ui/hooks/useGitignoreModal.ts

@@ -98,10 +98,28 @@ export function useGitignoreModal() {
 				safeCount: args.safeCount,
 				generated: args.generated,
 				onFixSafe: () => {
-					dispatch({ type: "HIDE_MODAL" });
-					void Promise.resolve(args.onFixSafe())
+					// 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" —
+					// lost for the whole session. The slot stays occupied until the
+					// result below is dismissed.
+					dispatch({
+						type: "SHOW_MODAL",
+						modal: { type: "loading", message: "Fixing gitignore…" },
+					});
+					// Called inside `.then`, not passed to `Promise.resolve`: a fixer
+					// that throws synchronously must land in `.catch` below too, or
+					// the loading modal above stays up and swallows every key.
+					void Promise.resolve()
+						.then(() => args.onFixSafe())
 						.then((report) => {
-							if (!report) return;
+							// 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: {