magus-cli 7.5.2 → 7.5.3

package/src/services/profile-state.ts

@@ -41,10 +41,6 @@ import {
 	type ProfileChoice,
 	activateProfile,
 	activationNotes,
-	activeWritableSkillFolders,
-	assertNoTrackedWriteTargets,
-	writableSkillFolders,
-	writeRefusal,
 } from "./profile-activate.js";
 import { adoptCurrentProject } from "./profile-adopt.js";
 import {
@@ -73,7 +69,6 @@ import {
 	skillFolder,
 } from "./profile-skills.js";
 import type { SettingsParseError } from "./settings-file.js";
-import type { LiveFileRefusal } from "./tracked-live-files.js";
 
 export type ActiveProfileCheck =
 	| { state: "no-profiles" }
@@ -304,11 +299,6 @@ export interface ProfileStatePrep {
 	problems: string[];
 	/** The files behind `problems` that could not be parsed. */
 	unreadable: SettingsParseError[];
-	/**
-	 * Set when a file magus would write is tracked by git, or git could not
-	 * say: nothing ran, and `problems` holds its message.
-	 */
-	refusal?: LiveFileRefusal;
 }
 
 /**
@@ -322,27 +312,6 @@ export async function prepareProfileState(
 	projectPath: string,
 	opts: Pick<ActivateOptions, "installSkill"> = {},
 ): Promise<ProfileStatePrep> {
-	// A project with profiles whose live files — or the active profile's
-	// magus-installed skill folders — git tracks: every path below would write
-	// one of them (or the marker, or the manifest on the way), so nothing runs,
-	// not even the marker a unique match would restore.
-	const manifest = await readManifest(projectPath);
-	if (Object.keys(manifest.profiles).length > 0) {
-		const refusal = await writeRefusal(
-			projectPath,
-			await activeWritableSkillFolders(projectPath, manifest),
-		);
-		if (refusal) {
-			return {
-				check: await checkActiveProfile(projectPath, { restore: false }),
-				reconcile: null,
-				lines: [],
-				problems: [refusal.message],
-				unreadable: [],
-				refusal,
-			};
-		}
-	}
 	const check = await checkActiveProfile(projectPath);
 	const out: ProfileStatePrep = {
 		check,
@@ -524,22 +493,6 @@ export async function switchToProfile(
 		);
 		return result;
 	}
-	// Before the absorbs below write profiles.json: nothing at all is written
-	// when a live file this switch would write is tracked by git.
-	const marker = await readActiveMarker(projectPath);
-	const refusal = await writeRefusal(projectPath, [
-		...(await writableSkillFolders(
-			projectPath,
-			target.skills ?? [],
-			marker?.skills,
-		)),
-		...(await activeWritableSkillFolders(projectPath, before)),
-	]);
-	if (refusal) {
-		result.problems.push(refusal.message);
-		return result;
-	}
-
 	if (!take(await absorbBeforeConversion(projectPath, name))) return result;
 	const installSkill = { installSkill: opts.installSkill };
 	if (!take(await reconcileActiveProfile(projectPath, installSkill))) {
@@ -580,20 +533,6 @@ export async function applyProfileChoice(
 	projectPath: string,
 	opts: ActivateOptions = {},
 ): Promise<ActivationResult> {
-	// Nothing is written — not the adopted manifest, not an absorbed edit —
-	// when a live file this choice would write is tracked by git.
-	const skills =
-		choice.kind === "activate"
-			? (manifest.profiles[choice.id]?.skills ?? [])
-			: [];
-	await assertNoTrackedWriteTargets(
-		projectPath,
-		await writableSkillFolders(
-			projectPath,
-			skills,
-			(await readActiveMarker(projectPath))?.skills,
-		),
-	);
 	if (choice.kind === "activate") {
 		const absorbed: string[] = [];
 		let changed = false;
@@ -635,7 +574,6 @@ export async function prepareProfileWrite(
 	projectPath: string,
 ): Promise<ProfileStatePrep> {
 	const prep = await prepareProfileState(projectPath);
-	if (prep.refusal) throw prep.refusal;
 	refuseOnProblems(prep);
 	return prep;
 }

package/src/services/tracked-live-files.ts

@@ -1,76 +1,54 @@
 /**
- * magus never writes a generated file that git tracks.
+ * Generated files that git tracks: reported, never refused.
  *
- * In a project with profiles, `.claude/settings.json`, `.mcp.json` and
- * `.claude/models.json` are generated per developer from `.claude/profiles.json`.
- * A committed copy is the team's hand-kept file: writing it leaves git
- * tracking a file that now differs per developer, so every write shows as a
- * modified tracked file and one developer's plugin set gets committed for
- * everyone. `.gitignore` cannot fix that — it does not untrack a file already
- * committed. So every writer refuses, having written nothing, and says how to
- * stop tracking it; the user decides.
+ * In a project with profiles, `.claude/settings.json`, `.mcp.json`,
+ * `.claude/models.json` and the magus-installed skill folders are generated
+ * per developer from `.claude/profiles.json`, and are expected to be
+ * gitignored. A repository that committed one before adopting profiles keeps
+ * tracking it — `.gitignore` does not untrack a committed file.
  *
- * Activation checks every path it would write up front (`profile-activate.ts`).
- * This module holds the refusal itself, and the check for the writers outside
- * activation: the TUI's direct settings edits, `.mcp.json` edits, and the
- * Claude CLI's project-scope installs, which write `.claude/settings.json`.
+ * magus writes those files anyway: every command that writes them proceeds
+ * exactly as for an untracked file. What changes is what it says. The CLI
+ * prints one warning per tracked file with the fix (`git rm --cached <path>`,
+ * then commit) and never runs git itself; `magus doctor` reports it as a note;
+ * the TUI asks on every open and, when told to, untracks them in place
+ * (`gitignore-check.ts`, `profileGitignoreManifest`).
  */
 
 import path from "node:path";
+import type { GitignoreManifest } from "../types/gitignore.js";
 import { GitQueryError, trackedByGit } from "./git-worktree.js";
 import { getManifestPath, readProfilesFile } from "./manifest.js";
-
-/** magus refused to write a live file, and changed nothing. */
-export class LiveFileRefusal extends Error {}
-
-/** A live file magus would write is tracked by git. */
-export class TrackedLiveFileError extends LiveFileRefusal {
-	constructor(readonly paths: readonly string[]) {
-		const one = paths.length === 1;
-		super(
-			[
-				`magus will not write ${one ? "a file" : "files"} git tracks in this project — ${
-					one ? "it is" : "they are"
-				} generated from .claude/profiles.json and ${one ? "differs" : "differ"} per developer:`,
-				...paths.map((p) => `  ${p}`),
-				`Stop tracking ${one ? "it" : "them"}, commit, then run the command again:`,
-				...paths.map((p) => `  ${untrackCommand(p)}`),
-				'  git commit -m "Stop tracking generated Claude Code config"',
-				"Nothing was changed.",
-			].join("\n"),
-		);
-		this.name = "TrackedLiveFileError";
-	}
-}
+import {
+	LIVE_FILE_KEYS,
+	livePath,
+	readActiveMarker,
+	skillsRoot,
+} from "./profile-live.js";
 
 /**
  * The project is a git work tree, but git could not say what it tracks — it
  * timed out, is missing, or refused the repository (`detected dubious
- * ownership`). Answering "nothing is tracked" would let magus write a tracked
- * file, so it refuses instead and passes on git's own words.
+ * ownership`). Reported with git's own words wherever the check is made; it
+ * never stops a write.
  */
-export class GitCheckError extends LiveFileRefusal {
+export class GitCheckError extends Error {
 	constructor(readonly detail: string) {
 		super(
-			[
-				"magus could not check which files git tracks in this project, so it wrote nothing. git said:",
-				...detail
-					.trim()
-					.split("\n")
-					.map((line) => `  ${line}`),
-				"Fix that, then run the command again. Nothing was changed.",
-			].join("\n"),
+			`magus could not check which files git tracks in this project. git said: ${detail.trim()}`,
 		);
 		this.name = "GitCheckError";
 	}
 }
 
-/** How to untrack one generated path — `-r` for a skill folder. */
+/** How to untrack one generated path. */
 export function untrackCommand(rel: string): string {
-	const isDir =
-		rel.split(path.sep).length > 2 &&
-		rel.startsWith(path.join(".claude", "skills") + path.sep);
-	return isDir ? `git rm --cached -r ${rel}` : `git rm --cached ${rel}`;
+	return `git rm --cached ${rel}`;
+}
+
+/** The warning the CLI prints for one tracked generated path. */
+export function trackedWarning(rel: string): string {
+	return `${rel} is generated from .claude/profiles.json but tracked by git — run \`${untrackCommand(rel)}\`, then commit`;
 }
 
 /**
@@ -92,34 +70,70 @@ export async function trackedPaths(
 }
 
 /**
- * Does magus generate this project's live files — does its profiles.json
- * define a profile? A profiles.json that cannot be read counts as yes: the
- * check that follows only ever stops a write.
+ * Of `folders` under `.claude/skills/`, the ones git tracks — the team's own
+ * copies. A skill folder git tracks is the team's, never magus's: magus does
+ * not install over it, manage it, flag it or untrack it. Empty when git cannot
+ * say, so a failed git call never turns a team skill into one magus removes —
+ * it only leaves a folder magus recorded as its own until git answers.
  */
-async function hasProfiles(projectPath: string): Promise<boolean> {
+export async function trackedSkillFolders(
+	projectPath: string,
+	folders: readonly string[],
+): Promise<Set<string>> {
+	if (folders.length === 0) return new Set();
+	const root = path.relative(projectPath, skillsRoot(projectPath));
+	let tracked: Set<string>;
 	try {
-		const file = await readProfilesFile(getManifestPath(projectPath));
-		return Object.keys(file.profiles).length > 0;
-	} catch {
-		return true;
+		tracked = await trackedPaths(
+			projectPath,
+			[],
+			folders.map((folder) => path.join(root, folder)),
+		);
+	} catch (error) {
+		if (error instanceof GitCheckError) return new Set();
+		throw error;
 	}
+	return new Set(folders.filter((f) => tracked.has(path.join(root, f))));
 }
 
 /**
- * Throw {@link TrackedLiveFileError} — before anything is written — when
- * `projectPath` has profiles and git tracks any of `files` (absolute, or
- * relative to the project). A project without profiles owns its files by
- * hand, and writing them is not magus's to refuse.
+ * The gitignore rules the profile model implies, for the gitignore manager's
+ * `profile` tier — or null in a project without profiles.
+ *
+ * In a project with profiles — profiles.json defines at least one — the three
+ * live files and the magus-installed skill folders are generated per
+ * developer, so they must be ignored. The built-in defaults say to TRACK
+ * `.claude/settings.json` and `.mcp.json`, which is right for a project that
+ * writes them by hand; this tier overrides that for a profiled one, so a
+ * committed copy is reported as "tracked but should be ignored". A left-over
+ * marker in a repo that dropped profiles.json does not make it profiled.
+ *
+ * A skill folder git tracks is left out even when the marker records it:
+ * markers written by 7.5.0's conversion recorded committed skills as
+ * magus-installed, and the team's copy must never be flagged or untracked.
  */
-export async function refuseTrackedLiveFiles(
+export async function profileGitignoreManifest(
 	projectPath: string,
-	files: readonly string[],
-): Promise<void> {
-	if (!(await hasProfiles(projectPath))) return;
-	const rel = files.map((f) =>
-		path.isAbsolute(f) ? path.relative(projectPath, f) : f,
-	);
-	const tracked = await trackedPaths(projectPath, rel);
-	const hit = rel.filter((r) => tracked.has(r));
-	if (hit.length > 0) throw new TrackedLiveFileError(hit);
+): Promise<GitignoreManifest | null> {
+	try {
+		const file = await readProfilesFile(getManifestPath(projectPath));
+		if (Object.keys(file.profiles).length === 0) return null;
+	} catch {
+		return null; // An unreadable profiles.json is reported by every profile command.
+	}
+	const marker = await readActiveMarker(projectPath);
+	const managed = Object.keys(marker?.skills ?? {});
+	const committed = await trackedSkillFolders(projectPath, managed);
+	const posix = (abs: string) =>
+		path.relative(projectPath, abs).split(path.sep).join("/");
+	const skills = posix(skillsRoot(projectPath));
+	return {
+		ignore: [
+			...LIVE_FILE_KEYS.map((key) => posix(livePath(key, projectPath))),
+			...managed
+				.filter((folder) => !committed.has(folder))
+				.map((folder) => `${skills}/${folder}/`),
+		],
+		track: [],
+	};
 }

package/src/ui/App.tsx

@@ -7,10 +7,13 @@ import {
 	recoverMarketplaceSettings,
 	repairAllStaleLoads,
 } from "../services/claude-settings.js";
-import { checkGitignore } from "../services/gitignore-check.js";
 import {
-	applyAllSafeFixes,
-	loadGitignoreState,
+	type StartupGitignoreNeed,
+	startupGitignoreNeed,
+} from "../services/gitignore-check.js";
+import {
+	applyStartupFixes,
+	describeStartupFix,
 } from "../services/gitignore-service.js";
 import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
@@ -261,10 +264,8 @@ function AppContent({ onExit }: AppContentProps) {
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
 	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
 	const [profileNotices, setProfileNotices] = useState<string[]>([]);
-	const [gitignoreData, setGitignoreData] = useState<{
-		violationCount: number;
-		safeCount: number;
-	} | null>(null);
+	const [gitignoreData, setGitignoreData] =
+		useState<StartupGitignoreNeed | null>(null);
 	const [profileNeed, setProfileNeed] = useState<ProfileStartupNeed | null>(
 		null,
 	);
@@ -273,9 +274,22 @@ 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
+			});
+	}, []);
 	// 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);
+	const profileModal = useProfileStartupModal(onExit, checkGitignoreNow);
 
 	// Check for updates on startup, then re-check periodically (force-bypassing
 	// the session cache) so the banner reflects a release that lands while
@@ -318,10 +332,11 @@ function AppContent({ onExit }: AppContentProps) {
 		gitignoreModal.show({
 			violationCount: gitignoreData.violationCount,
 			safeCount: gitignoreData.safeCount,
-			onFixSafe: async () => {
-				const s = await loadGitignoreState(state.projectPath);
-				await applyAllSafeFixes(state.projectPath, s.violations);
-			},
+			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]);
@@ -389,6 +404,13 @@ function AppContent({ onExit }: AppContentProps) {
 		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.
+	useEffect(() => {
+		checkGitignoreNow();
+	}, [checkGitignoreNow]);
+
 	// Is this project actually running a profile? Detection only — nothing is
 	// written until the user picks something in the modal. The Profiles tab could
 	// list two profiles while the project ran neither, and nothing anywhere said
@@ -470,27 +492,6 @@ function AppContent({ onExit }: AppContentProps) {
 			})
 			.catch(() => {}); // non-fatal
 
-		// Check for gitignore manifest violations and surface a popup if any.
-		// Loads twice (once for count, once when user picks "fix safe") because
-		// the second load happens after edits — keeps detection cheap on startup.
-		(async () => {
-			try {
-				const result = await checkGitignore(process.cwd());
-				if (result.violationCount > 0) {
-					const s = await loadGitignoreState(process.cwd());
-					const safeCount = s.violations.filter(
-						(v) => v.severity === "safe",
-					).length;
-					setGitignoreData({
-						violationCount: result.violationCount,
-						safeCount,
-					});
-				}
-			} catch {
-				// non-fatal
-			}
-		})();
-
 		repairAllMarketplaces()
 			.then(async () => {
 				dispatch({ type: "HIDE_PROGRESS" });

package/src/ui/hooks/useGitignoreModal.ts

@@ -12,19 +12,38 @@ import type { ModalState } from "../state/types.js";
 export interface BuildModalArgs {
 	violationCount: number;
 	safeCount: number;
+	/**
+	 * Files magus generates from `.claude/profiles.json` that git tracks. The
+	 * fix untracks these in place; every other destructive fix stays in the tab.
+	 */
+	generated?: readonly string[];
 	onFixSafe: () => void;
 	onOpenTab: () => void;
 	onDismiss: () => void;
 }
 
+function entries(n: number): string {
+	return `${n} missing .gitignore entr${n === 1 ? "y" : "ies"}`;
+}
+
+function fixLabel(safeCount: number, generated: number): string {
+	if (generated > 0) {
+		const files = `${generated} generated file${generated === 1 ? "" : "s"}`;
+		return safeCount > 0
+			? `Stop tracking ${files} and add ${entries(safeCount)}`
+			: `Stop tracking ${files}`;
+	}
+	return safeCount > 0
+		? `Add ${entries(safeCount)}`
+		: "(no missing .gitignore entries)";
+}
+
 export function buildGitignoreModal(args: BuildModalArgs): ModalState {
 	const { violationCount, safeCount, onFixSafe, onOpenTab, onDismiss } = args;
+	const generated = args.generated ?? [];
 	const options = [
 		{
-			label:
-				safeCount > 0
-					? `Add ${safeCount} missing .gitignore entr${safeCount === 1 ? "y" : "ies"}`
-					: "(no missing .gitignore entries)",
+			label: fixLabel(safeCount, generated.length),
 			value: "fix-safe",
 		},
 		{
@@ -36,10 +55,20 @@ export function buildGitignoreModal(args: BuildModalArgs): ModalState {
 			value: "dismiss",
 		},
 	];
+	const generatedNote =
+		generated.length > 0
+			? `magus generates ${generated.length === 1 ? "this file" : "these files"} from .claude/profiles.json for each developer, so ${
+					generated.length === 1 ? "it is" : "they are"
+				} expected to be gitignored — but git tracks ${generated.length === 1 ? "it" : "them"}:\n${generated
+					.map((p) => `  ${p}`)
+					.join(
+						"\n",
+					)}\n\nThe first choice stops tracking ${generated.length === 1 ? "it" : "them"} (git rm --cached, staged for you to commit) and adds the .gitignore entries.\n\n`
+			: "";
 	return {
 		type: "select",
 		title: "Gitignore violations detected",
-		message: `Found ${violationCount} managed gitignore item(s) that do not match the current repo state.\n\nMissing .gitignore entries can be added now. Items that change git tracking are reviewed and fixed from the Gitignore tab.`,
+		message: `${generatedNote}Found ${violationCount} managed gitignore item(s) that do not match the current repo state.\n\nMissing .gitignore entries can be added now. Other items that change git tracking are reviewed and fixed from the Gitignore tab.`,
 		options,
 		onSelect: (value: string) => {
 			if (value === "fix-safe") onFixSafe();
@@ -58,27 +87,44 @@ export function useGitignoreModal() {
 		(args: {
 			violationCount: number;
 			safeCount: number;
-			onFixSafe: () => Promise<void> | void;
+			generated?: readonly string[];
+			/** Returns what it did, shown before returning to the app. */
+			onFixSafe: () => Promise<string | undefined> | string | undefined;
 		}) => {
 			if (args.violationCount === 0) return;
 			const dismiss = () => dispatch({ type: "HIDE_MODAL" });
 			const modal = buildGitignoreModal({
 				violationCount: args.violationCount,
 				safeCount: args.safeCount,
+				generated: args.generated,
 				onFixSafe: () => {
 					dispatch({ type: "HIDE_MODAL" });
-					void Promise.resolve(args.onFixSafe()).catch((err) => {
-						dispatch({
-							type: "SHOW_MODAL",
-							modal: {
-								type: "message",
-								title: "Safe fixes failed",
-								message: err instanceof Error ? err.message : String(err),
-								variant: "error",
-								onDismiss: dismiss,
-							},
+					void Promise.resolve(args.onFixSafe())
+						.then((report) => {
+							if (!report) return;
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: "Gitignore fixed",
+									message: report,
+									variant: "success",
+									onDismiss: dismiss,
+								},
+							});
+						})
+						.catch((err) => {
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: "Safe fixes failed",
+									message: err instanceof Error ? err.message : String(err),
+									variant: "error",
+									onDismiss: dismiss,
+								},
+							});
 						});
-					});
 				},
 				onOpenTab: () => {
 					dispatch({ type: "HIDE_MODAL" });

package/src/ui/hooks/useProfileStartupModal.ts

@@ -157,7 +157,11 @@ export function describeFailure(
 	].join("\n");
 }
 
-export function useProfileStartupModal(onQuit: () => void) {
+export function useProfileStartupModal(
+	onQuit: () => void,
+	/** Called once a choice has activated a profile — see App's gitignore re-check. */
+	onActivated?: () => void,
+) {
 	const { state, dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
 	const projectPath = state.projectPath;
@@ -191,6 +195,7 @@ export function useProfileStartupModal(onQuit: () => void) {
 					onDisplace: (artifact) => moved.push(artifact),
 				})
 					.then((result: ActivationResult) => {
+						onActivated?.();
 						const { profileId, displaced } = result;
 						dispatch({
 							type: "SHOW_MODAL",
@@ -270,7 +275,7 @@ export function useProfileStartupModal(onQuit: () => void) {
 			}
 			ask();
 		},
-		[dispatch, navigateToScreen, projectPath, onQuit],
+		[dispatch, navigateToScreen, projectPath, onQuit, onActivated],
 	);
 
 	return { show };

package/src/ui/screens/PluginsScreen.tsx

@@ -44,7 +44,6 @@ import {
 	fetchPluginContents,
 	fetchPluginSkillDetail,
 } from "../../services/skills-manager.js";
-import { LiveFileRefusal } from "../../services/tracked-live-files.js";
 // The one update implementation, shared with `magus update`. See the header
 // of update-engine.ts for what drifted while the TUI had its own loop.
 import {
@@ -983,11 +982,7 @@ export function PluginsScreen() {
 				fetchData();
 			} catch (error) {
 				modal.hideModal();
-				await modal.message(
-					"Error",
-					error instanceof LiveFileRefusal ? error.message : `Failed: ${error}`,
-					"error",
-				);
+				await modal.message("Error", `Failed: ${error}`, "error");
 			}
 		}
 	};
@@ -1207,11 +1202,7 @@ export function PluginsScreen() {
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
-			await modal.message(
-				"Error",
-				error instanceof LiveFileRefusal ? error.message : `Failed: ${error}`,
-				"error",
-			);
+			await modal.message("Error", `Failed: ${error}`, "error");
 		}
 	};
 

package/src/ui/screens/ProfilesScreen.tsx

@@ -26,7 +26,6 @@ import {
 	renameProfile,
 } from "../../services/profiles.js";
 import { writableMap } from "../../services/settings-file.js";
-import { LiveFileRefusal } from "../../services/tracked-live-files.js";
 import {
 	ClipboardUnavailableError,
 	readClipboard,
@@ -178,9 +177,7 @@ export function ProfilesScreen() {
 			modal.hideModal();
 			await modal.message(
 				"Error",
-				error instanceof LiveFileRefusal
-					? error.message
-					: `Failed to apply profile: ${error}`,
+				`Failed to apply profile: ${error}`,
 				"error",
 			);
 		}
@@ -245,9 +242,7 @@ export function ProfilesScreen() {
 				modal.hideModal();
 				await modal.message(
 					"Error",
-					error instanceof LiveFileRefusal
-						? error.message
-						: `Failed to switch profile: ${error}`,
+					`Failed to switch profile: ${error}`,
 					"error",
 				);
 			}
@@ -280,9 +275,7 @@ export function ProfilesScreen() {
 			modal.hideModal();
 			await modal.message(
 				"Error",
-				error instanceof LiveFileRefusal
-					? error.message
-					: `Failed to apply profile: ${error}`,
+				`Failed to apply profile: ${error}`,
 				"error",
 			);
 		}