magus-cli 7.4.1 → 7.5.0

package/src/services/resolver.ts

@@ -21,7 +21,7 @@ import type {
 } from "../types/index.js";
 import { readManifest } from "./manifest.js";
 import { resolvePluginBinRequirements } from "./plugin-requires.js";
-import { activeProfile } from "./symlink-manager.js";
+import { activeProfile } from "./profile-live.js";
 
 export interface ResolveOptions {
 	/**
@@ -236,9 +236,14 @@ export async function resolveProfile(
 	const plugins = normalizePlugins(entry.plugins);
 	const bins = await resolveBins(entry, Object.keys(plugins), binResolver);
 
+	const disabledPlugins = Object.entries(entry.plugins ?? {})
+		.filter(([, ver]) => ver === false)
+		.map(([id]) => id);
+
 	return {
 		marketplaces: withDerivedMarketplaces(entry.marketplaces, plugins),
 		plugins,
+		...(disabledPlugins.length > 0 ? { disabledPlugins } : {}),
 		mcpServers: { ...(entry.mcpServers ?? {}) },
 		bins,
 		skills: [...(entry.skills ?? [])],

package/src/services/settings-file.ts

@@ -3,11 +3,11 @@
  *
  * Two rules, and both exist because of damage they prevent:
  *
- *  1. **Write IN PLACE, never remove-and-recreate.** `.claude/settings.json` is
- *     a SYMLINK into `.claude/_profiles/<name>/` whenever a profile is active,
- *     and `writeFile` follows it — which is what we want. Unlinking the file
- *     first would break the link and silently detach the project from its
- *     profile, leaving the next read looking at a fresh, empty file.
+ *  1. **Write IN PLACE, never remove-and-recreate.** A settings file may be a
+ *     symlink somebody set up deliberately, and `writeFile` follows it — which
+ *     is what we want. Unlinking the file first would break the link and leave
+ *     the next read looking at a fresh, empty file. (magus's own profile files
+ *     are real files; `profile-live.ts` replaces them via a rename.)
  *  2. **Unparseable is an ERROR, not an empty object.** A settings file that
  *     fails to parse is a file we do not understand, usually because a human is
  *     mid-edit. Treating it as `{}` and writing our one key back is how a

package/src/services/skills-manager.ts

@@ -40,6 +40,18 @@ export function getProjectSkillsDir(projectPath?: string): string {
 	return path.join(projectPath ?? process.cwd(), ".claude", "skills");
 }
 
+/**
+ * The folder a skill installs into: a slug of its display name, since display
+ * names can carry slashes and spaces. One definition, because the profile code
+ * must predict exactly where `installSkill` will write.
+ */
+export function skillFolderName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
 // ─── GitHub Tree API ──────────────────────────────────────────────────────────
 
 async function fetchGitTree(repo: string): Promise<GitTreeResponse> {
@@ -1003,10 +1015,7 @@ export async function installSkill(
 	}
 
 	// Use slug for directory name — display names can have slashes/spaces
-	const dirName = skill.name
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-|-$/g, "");
+	const dirName = skillFolderName(skill.name);
 
 	const installDir =
 		scope === "user"
@@ -1090,10 +1099,7 @@ export async function uninstallSkill(
 	scope: "user" | "project",
 	projectPath?: string,
 ): Promise<void> {
-	const dirName = skillName
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-|-$/g, "");
+	const dirName = skillFolderName(skillName);
 
 	const installDir =
 		scope === "user"

package/src/services/styles-manager.ts

@@ -19,12 +19,11 @@
  *
  * ## Profile awareness
  *
- * `.claude/settings.json` is a symlink into `.claude/_profiles/<name>/` when a
- * profile is active, so writing `outputStyle` through it lands in that
- * profile. But `materializeProfile` REWRITES that file from the manifest on
- * every `magus install`, so the live write alone silently regresses. The
- * selection is therefore also recorded in `.claude/profiles.json` under
- * `profiles.<name>.settings.outputStyle`, which is the durable source.
+ * `.claude/settings.json` is rendered from the active profile when there is
+ * one, so the selection is recorded in `.claude/profiles.json` under
+ * `profiles.<name>.settings.outputStyle` — the durable source — and the live
+ * file is rendered again from it. Without a profile the live file is edited in
+ * place.
  *
  * The generated style file is named per-profile (`composed-<name>`) so two
  * profiles can hold different styles without clobbering each other's file
@@ -43,8 +42,10 @@ import {
 	readManifest,
 	writeManifest,
 } from "./manifest.js";
+import { regenerateLiveFiles } from "./profile-activate.js";
+import { activeProfile } from "./profile-live.js";
+import { prepareProfileWrite } from "./profile-state.js";
 import { updateSettingsFile } from "./settings-file.js";
-import { activeProfile } from "./symlink-manager.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -188,7 +189,7 @@ export interface StylesSnapshot {
 	settingsPath: string;
 	/** Name of the generated style, e.g. "composed" or "composed-dev". */
 	styleName: string;
-	/** Active profile name, when .claude/settings.json is a profile symlink. */
+	/** Active profile name, when a profile is active (see `activeProfile`). */
 	profile: string | null;
 	/** The value currently in settings.json, whatever set it. */
 	currentOutputStyle: string | null;
@@ -1112,6 +1113,10 @@ export async function applyStyles({
 		throw new Error("Nothing selected. Pick at least one style.");
 	}
 
+	// The gate before anything is written: whatever Claude Code wrote to the
+	// live config goes into the profile, so the render below replaces nothing
+	// unrecorded — and a live file that does not parse stops everything.
+	await prepareProfileWrite(projectPath);
 	const profile = await activeProfile(projectPath);
 	const styleName = generatedStyleName(profile);
 	const stylePath = stylePathFor(projectPath, styleName);
@@ -1122,7 +1127,19 @@ export async function applyStyles({
 
 	await fs.ensureDir(path.dirname(stylePath));
 	await fs.writeFile(stylePath, contents, "utf8");
-	await setOutputStyle(settingsPath, styleName);
+
+	// With a profile active, the manifest is where the selection lives and the
+	// live file is rendered from it.
+	let recordedInManifest = false;
+	if (profile !== null) {
+		recordedInManifest = await recordInManifest(
+			projectPath,
+			profile,
+			styleName,
+		);
+	}
+	if (recordedInManifest) await regenerateLiveFiles(projectPath);
+	else await setOutputStyle(settingsPath, styleName);
 
 	// Verify by re-reading, not by trusting the write.
 	const verify = splitFrontmatter(await fs.readFile(stylePath, "utf8"));
@@ -1144,12 +1161,6 @@ export async function applyStyles({
 		throw new Error(`Verification failed — ${problems.join("; ")}`);
 	}
 
-	const recordedInManifest = await recordInManifest(
-		projectPath,
-		profile,
-		styleName,
-	);
-
 	// Write the declaration LAST, once the artifact is verified. It is the thing
 	// that gets committed and that teammates are told to match, so it must never
 	// claim a composition that failed to produce a valid file.
@@ -1268,6 +1279,25 @@ export async function createTeamStyle(
  */
 export async function clearStyle(projectPath: string): Promise<void> {
 	const settingsPath = settingsPathFor(projectPath);
+	// The gate first; a live file that does not parse stops everything.
+	await prepareProfileWrite(projectPath);
+	const profile = await activeProfile(projectPath);
+
+	if (profile !== null && (await fs.pathExists(getManifestPath(projectPath)))) {
+		const manifest = await readManifest(projectPath);
+		const entry = manifest.profiles[profile];
+		if (entry?.settings && "outputStyle" in entry.settings) {
+			// The guard above uses `in`, so assigning undefined would make a second
+			// call a no-op that still leaves the key serialized into profiles.json.
+			// biome-ignore lint/performance/noDelete: removal is the intent, not a shortcut
+			delete entry.settings.outputStyle;
+			entry.updatedAt = new Date().toISOString();
+			await writeManifest(manifest, projectPath);
+		}
+		await regenerateLiveFiles(projectPath);
+		return;
+	}
+
 	// The guard stays: a project that never had a style must not gain a
 	// settings.json just because the style was cleared.
 	if (await fs.pathExists(settingsPath)) {
@@ -1278,17 +1308,4 @@ export async function clearStyle(projectPath: string): Promise<void> {
 			delete settings.outputStyle;
 		});
 	}
-
-	const profile = await activeProfile(projectPath);
-	if (!profile) return;
-	if (!(await fs.pathExists(getManifestPath(projectPath)))) return;
-	const manifest = await readManifest(projectPath);
-	const entry = manifest.profiles[profile];
-	if (!entry?.settings || !("outputStyle" in entry.settings)) return;
-	// The guard above uses `in`, so assigning undefined would make a second call
-	// a no-op that still leaves the key serialized into profiles.json.
-	// biome-ignore lint/performance/noDelete: removal is the intent, not a shortcut
-	delete entry.settings.outputStyle;
-	entry.updatedAt = new Date().toISOString();
-	await writeManifest(manifest, projectPath);
 }

package/src/types/index.ts

@@ -312,8 +312,8 @@ export interface ProfileEntry extends ProfileManifestEntry {
 	/**
 	 * This profile is the one the project is actually running.
 	 *
-	 * Derived from the `.claude/settings.json` symlink, not stored — see
-	 * `activeProfile`. Carried on the entry because a list of profiles with no
+	 * Derived from the per-developer marker `.claude/profiles/active.json`, not
+	 * stored in the manifest — see `activeProfile`. Carried on the entry because a list of profiles with no
 	 * mark on the live one cannot answer the first question anybody asks of it:
 	 * the Profiles tab showed two identical-looking rows straight after
 	 * activating one of them.
@@ -377,8 +377,7 @@ export interface ProfileManifestEntry {
 	settings?: Record<string, unknown>;
 	/**
 	 * Per-subagent model routing. A PROFILE property, so switching profiles
-	 * switches routing, and materialization writes it to
-	 * `_profiles/<name>/models.json` for `.claude/models.json` to link at.
+	 * switches routing; activation renders it to `.claude/models.json`.
 	 */
 	models?: ModelsConfig;
 	env?: ProfileEnvRequirements;
@@ -399,8 +398,9 @@ export interface ProfileManifest {
 	 * use, so every teammate cloning the repo is asked to choose and has nothing
 	 * to choose by — the repo knows the answer and had no way to write it down.
 	 *
-	 * It is intent, not state: the profile that is ACTUALLY active is the symlink
-	 * (see `activeProfile`), which is per-developer and gitignored. This field is
+	 * It is intent, not state: the profile that is ACTUALLY active is recorded in
+	 * the marker `.claude/profiles/active.json` (see `activeProfile`), which is
+	 * per-developer and gitignored. This field is
 	 * what a fresh clone activates so nobody is asked at all.
 	 *
 	 * Must name a profile that exists; `validateManifest` rejects it otherwise.
@@ -452,14 +452,20 @@ export interface ResolvedClosure {
 	marketplaces: Record<string, ProfileMarketplaceRef>;
 	/** pluginId -> version pin | "latest". */
 	plugins: Record<string, string>;
+	/**
+	 * Plugin ids the profile declares as `false` — explicitly off in this
+	 * project. Rendered as `false` in enabledPlugins so a plugin enabled at user
+	 * scope stays off here. Set per profile; a union carries none.
+	 */
+	disabledPlugins?: string[];
 	mcpServers: Record<string, McpServerConfig>;
 	bins: ResolvedBin[];
 	skills: ProfileSkillRef[];
 	settings: Record<string, unknown>;
 	/**
-	 * The profile's model routing, if it declares any. Absent means the
-	 * materialized profile carries no models.json — and materialization DELETES
-	 * a stale one, which is what makes `magus models off` take effect.
+	 * The profile's model routing, if it declares any. Absent means rendering
+	 * REMOVES `.claude/models.json`, which is what makes `magus models off`
+	 * take effect.
 	 */
 	models?: ModelsConfig;
 	env: { required: string[]; optional: string[] };

package/src/ui/App.tsx

@@ -16,8 +16,8 @@ import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
 import {
 	type ProfileStartupNeed,
-	detectProfileStartupNeed,
 	needsNothing,
+	prepareProfileStartup,
 } from "../services/profile-startup.js";
 import {
 	type VersionCheckResult,
@@ -205,12 +205,15 @@ 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) {
 	const { state } = useApp();
 	const { progress } = state;
@@ -224,6 +227,11 @@ function AppContentInner({
 					<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>
+			))}
 			{progress && <ProgressIndicator {...progress} />}
 			<box
 				flexDirection="column"
@@ -252,6 +260,7 @@ function AppContent({ onExit }: AppContentProps) {
 	const { progress } = state;
 	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;
@@ -286,6 +295,14 @@ 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;
@@ -384,7 +401,12 @@ function AppContent({ onExit }: AppContentProps) {
 	useEffect(() => {
 		(async () => {
 			try {
-				const need = await detectProfileStartupNeed(process.cwd());
+				// The same gate every CLI command runs — absorb Claude Code's
+				// 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);
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
@@ -492,6 +514,7 @@ function AppContent({ onExit }: AppContentProps) {
 				updateInfo={updateInfo}
 				onExit={onExit}
 				recoveryReport={recoveryReport}
+				profileNotices={profileNotices}
 			/>
 		</DimensionsProvider>
 	);

package/src/ui/hooks/useProfileStartupModal.ts

@@ -18,9 +18,11 @@
 import { useCallback } from "react";
 import { getManifestPath } from "../../services/manifest.js";
 import {
+	type ActivationResult,
 	type ProfileChoice,
-	applyProfileChoice,
+	activationNotes,
 } from "../../services/profile-activate.js";
+import type { DisplacedArtifact } from "../../services/profile-live.js";
 import {
 	type ProfileStartupNeed,
 	buildProfileOptions,
@@ -29,8 +31,8 @@ import {
 	parseProfileChoice,
 	unparseableNeed,
 } from "../../services/profile-startup.js";
+import { applyProfileChoice } from "../../services/profile-state.js";
 import { SettingsParseError } from "../../services/settings-file.js";
-import type { DisplacedArtifact } from "../../services/symlink-manager.js";
 import { useApp, useNavigation } from "../state/AppContext.js";
 import type { ModalState } from "../state/types.js";
 
@@ -80,6 +82,8 @@ export function describeOutcome(
 	projectPath: string,
 	/** True when this happened without asking, following the committed default. */
 	automatic = false,
+	/** Anything else activation reported (see `activationNotes`). */
+	notes: string[] = [],
 ): string {
 	const lines = [
 		automatic
@@ -89,7 +93,7 @@ export function describeOutcome(
 	if (displaced.length > 0) {
 		lines.push(
 			"",
-			"These were moved aside to make room for links into the profile, and are kept:",
+			"These were moved aside to make room for the profile's files, and are kept:",
 			...displaced.map((d) => {
 				const from = d.link.startsWith(projectPath)
 					? d.link.slice(projectPath.length + 1)
@@ -101,6 +105,7 @@ export function describeOutcome(
 			}),
 		);
 	}
+	if (notes.length > 0) lines.push("", ...notes);
 	return lines.join("\n");
 }
 
@@ -112,9 +117,10 @@ function rel(p: string, projectPath: string): string {
 /**
  * What to say when activation threw partway through.
  *
- * The hard part is that a failure is NOT always a no-op. Activation moves up to
- * four artifacts in sequence and `settings.json` goes first, so a throw on the
- * second leaves it already in the backup. The old message said "Nothing was
+ * The hard part is that a failure is NOT always a no-op. At first adoption
+ * activation moves up to three hand-written files in sequence and
+ * `settings.json` goes first, so a throw on the second leaves it already in
+ * the backup. The old message said "Nothing was
  * activated" unconditionally, which in exactly that case is false about the
  * user's own file — and `.magus-backups/` is gitignored, so `git status` showed
  * the deletion with no sign of the copy. It read as "magus deleted my settings".
@@ -172,8 +178,8 @@ export function useProfileStartupModal(onQuit: () => void) {
 				});
 				// Collected as they move, NOT read from the resolved result.
 				//
-				// Activation moves up to four artifacts in sequence and
-				// `settings.json` goes first, so a throw on the second leaves the
+				// First adoption moves up to three hand-written files in sequence
+				// and `settings.json` goes first, so a throw on the second leaves the
 				// user's file already in the backup — and the resolved value that
 				// would have listed it never arrives. This array is the only record
 				// the error path has, and without it the failure modal claimed
@@ -181,13 +187,11 @@ export function useProfileStartupModal(onQuit: () => void) {
 				// where they left it. `.magus-backups/` is gitignored, so git status
 				// showed the deletion and no sign of the copy.
 				const moved: DisplacedArtifact[] = [];
-				void applyProfileChoice(
-					choice,
-					need.manifest,
-					projectPath,
-					(artifact) => moved.push(artifact),
-				)
-					.then(({ profileId, displaced }) => {
+				void applyProfileChoice(choice, need.manifest, projectPath, {
+					onDisplace: (artifact) => moved.push(artifact),
+				})
+					.then((result: ActivationResult) => {
+						const { profileId, displaced } = result;
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -198,6 +202,7 @@ export function useProfileStartupModal(onQuit: () => void) {
 									displaced,
 									projectPath,
 									automatic,
+									activationNotes(result),
 								),
 								variant: "success",
 								onDismiss: () => {

package/src/ui/screens/ProfilesScreen.tsx

@@ -14,8 +14,11 @@ import {
 	readSettings,
 	writeSettings,
 } from "../../services/claude-settings.js";
+import { reconcileActiveProfile } from "../../services/profile-absorb.js";
+import { activationNotes } from "../../services/profile-activate.js";
+import { switchToProfile } from "../../services/profile-state.js";
 import {
-	applyProfile,
+	applyUserProfile,
 	deleteProfile,
 	exportProfileToJson,
 	importProfileFromJson,
@@ -29,6 +32,7 @@ import {
 	writeClipboard,
 } from "../../utils/clipboard.js";
 import { ScrollableList } from "../components/ScrollableList.js";
+import { describeOutcome } from "../hooks/useProfileStartupModal.js";
 import {
 	type ProfileListItem,
 	buildProfileListItems,
@@ -156,11 +160,17 @@ export function ProfilesScreen() {
 				}
 			}
 			await writeSettings(settings, state.projectPath);
+			// In a profiled project the merge is a change to the active profile:
+			// record it there now, rather than at the next magus command.
+			const recorded = await reconcileActiveProfile(state.projectPath);
 			modal.hideModal();
 			dispatch({ type: "DATA_REFRESH_COMPLETE" });
 			await modal.message(
 				"Applied",
-				`Profile "${profile.name}" merged into project settings.`,
+				[
+					`Profile "${profile.name}" merged into project settings.`,
+					...recorded.lines,
+				].join("\n"),
 				"success",
 			);
 		} catch (error) {
@@ -173,28 +183,71 @@ export function ProfilesScreen() {
 		}
 	};
 
+	/**
+	 * Apply a saved profile.
+	 *
+	 * A PROJECT profile is switched to, through the same path as `magus profile
+	 * switch`: what was changed in the live config goes into the profile being
+	 * left, then this one is rendered. Writing its enabledPlugins straight into
+	 * `.claude/settings.json` made the apply invisible to the profile and undone
+	 * by the next render.
+	 *
+	 * A USER-scope profile is a template in `~/.claude/profiles.json` and applies
+	 * to `~/.claude/settings.json` only — never to this project's live files,
+	 * which belong to its active profile.
+	 */
 	const handleApply = async () => {
 		if (selectedItem?.kind !== "saved") return;
 		const selectedProfile = selectedItem.entry;
 
-		const scopeChoice = await modal.select(
-			"Apply Profile",
-			`Apply "${selectedProfile.name}" to which scope?`,
-			[
-				{ label: "User — ~/.claude/settings.json (global)", value: "user" },
-				{
-					label: "Project — .claude/settings.json (this project)",
-					value: "project",
-				},
-			],
-		);
-		if (scopeChoice === null) return;
+		if (selectedProfile.scope === "project") {
+			const confirmed = await modal.confirm(
+				"Switch profile",
+				`Make "${selectedProfile.name}" this project's active profile?\n\nIts plugins, MCP servers, model routing and skills replace the current ones. Anything changed in the current config is saved into the profile you are leaving first.`,
+			);
+			if (!confirmed) return;
 
-		const targetScope = scopeChoice as "user" | "project";
-		const scopeLabel =
-			targetScope === "user"
-				? "~/.claude/settings.json"
-				: ".claude/settings.json";
+			modal.loading(`Switching to "${selectedProfile.name}"...`);
+			try {
+				const result = await switchToProfile(
+					state.projectPath,
+					selectedProfile.id,
+					{ onDisplace: () => {} },
+				);
+				modal.hideModal();
+				dispatch({ type: "DATA_REFRESH_COMPLETE" });
+				if (result.problems.length > 0 || !result.activation) {
+					await modal.message(
+						"Could not switch",
+						[...result.lines, ...result.problems].join("\n"),
+						"error",
+					);
+					return;
+				}
+				const outcome = describeOutcome(
+					result.activation.profileId,
+					result.activation.displaced,
+					state.projectPath,
+					false,
+					activationNotes(result.activation),
+				);
+				await modal.message(
+					"Profile active",
+					result.lines.length > 0
+						? `${result.lines.join("\n")}\n\n${outcome}`
+						: outcome,
+					"success",
+				);
+			} catch (error) {
+				modal.hideModal();
+				await modal.message(
+					"Error",
+					`Failed to switch profile: ${error}`,
+					"error",
+				);
+			}
+			return;
+		}
 
 		const pluginCount = Object.keys(selectedProfile.plugins ?? {}).length;
 		const emptyWarning =
@@ -204,23 +257,18 @@ export function ProfilesScreen() {
 
 		const confirmed = await modal.confirm(
 			"Confirm Apply",
-			`This will REPLACE all enabledPlugins in ${scopeLabel}.${emptyWarning}\n\nContinue?`,
+			`This will REPLACE all enabledPlugins in ~/.claude/settings.json (every project on this machine).${emptyWarning}\n\nContinue?`,
 		);
 		if (!confirmed) return;
 
 		modal.loading(`Applying "${selectedProfile.name}"...`);
 		try {
-			await applyProfile(
-				selectedProfile.id,
-				selectedProfile.scope,
-				targetScope,
-				state.projectPath,
-			);
+			await applyUserProfile(selectedProfile);
 			modal.hideModal();
 			dispatch({ type: "DATA_REFRESH_COMPLETE" });
 			await modal.message(
 				"Applied",
-				`Profile "${selectedProfile.name}" applied to ${scopeLabel}.`,
+				`Profile "${selectedProfile.name}" applied to ~/.claude/settings.json.`,
 				"success",
 			);
 		} catch (error) {

package/src/ui/screens/StylesScreen.tsx

@@ -535,7 +535,8 @@ export function StylesScreen() {
 				? `profile "${result.profile}"`
 				: "this project";
 			// Say plainly when the manifest was NOT updated: without that record a
-			// `magus install` re-materializes settings.json and drops the style.
+			// the next activation renders settings.json from the manifest and
+			// drops the style.
 			const durability =
 				result.profile && !result.recordedInManifest
 					? " — not in profiles.json, so `magus install` will drop it"

package/src/ui/state/types.ts

@@ -306,7 +306,7 @@ export interface ModelsScreenState {
 	 * True while an apply or a clear is writing.
 	 *
 	 * App state, not screen state, because the screen UNMOUNTS on a tab switch.
-	 * An apply rewrites the profile, re-materializes it and registers a hook —
+	 * An apply rewrites the profile, re-renders its live files and registers a hook —
 	 * two of those running at once would interleave writes to the same files.
 	 */
 	isApplying: boolean;