magus-cli 7.4.1 → 7.5.1

package/src/services/update-engine.ts

@@ -42,9 +42,11 @@ import type { PluginScope } from "./claude-cli.js";
 import { installPlugin, repairPlugin, updatePlugin } from "./claude-cli.js";
 import {
 	type StaleLoadRepairResult,
+	loadedVersionHere,
 	repairStaleLoad,
 } from "./claude-settings.js";
 import {
+	isRepairablyBehind,
 	readInstalledVersionForScope,
 	saveInstalledPluginVersionForScope,
 } from "./plugin-manager.js";
@@ -181,6 +183,15 @@ export interface PluginApplyDeps {
 		target: string,
 		projectPath: string,
 	) => Promise<StaleLoadRepairResult>;
+	/**
+	 * The version Claude Code's loader resolves for a plugin in a project — the
+	 * question an install must ask afterwards (see {@link bringLoadForward}).
+	 * Optional so a test double that does not model the loader skips the check.
+	 */
+	loadedVersion?: (
+		pluginId: string,
+		projectPath: string,
+	) => Promise<string | null>;
 }
 
 export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
@@ -190,8 +201,47 @@ export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
 	readInstalled: readInstalledVersionForScope,
 	saveInstalled: saveInstalledPluginVersionForScope,
 	repairStaleLoad,
+	loadedVersion: loadedVersionHere,
 };
 
+/**
+ * After a plugin landed at `target` for `projectPath`: make sure that is the
+ * version Claude Code actually loads there, and bring the loader forward when
+ * it is not.
+ *
+ * The loader takes the FIRST registry row relevant to the repository, and rows
+ * from this repository's other checkouts — deleted worktrees included — often
+ * precede this project's own row. `claude plugin install|update` writes only
+ * this project's row, so a successful update could leave the plugin showing
+ * "updated" and loading the old version at once (measured: an update wrote
+ * 2.0.5 to this project's row while eight earlier rows held 2.0.4, and
+ * `--debug-file` showed 2.0.4 loading). So the update runs the stale-load
+ * repair as its own last step — the same `repairStaleLoad` the `stale-load`
+ * state uses, moving this repository's older rows forward to `target`.
+ *
+ * Null when nothing needed doing (the loader already resolves `target`, or the
+ * dep that asks it is absent); otherwise the repair's result, which the caller
+ * reports — `ok: false` means the plugin still does not load `target`.
+ */
+export async function bringLoadForward(
+	pluginId: string,
+	target: string,
+	projectPath: string,
+	deps: PluginApplyDeps = REAL_PLUGIN_DEPS,
+): Promise<StaleLoadRepairResult | null> {
+	if (!deps.loadedVersion) return null;
+	const loaded = await deps.loadedVersion(pluginId, projectPath);
+	if (!isRepairablyBehind(target, loaded)) return null;
+	return deps.repairStaleLoad(pluginId, target, projectPath);
+}
+
+/** The words for a load brought forward, appended to an item's detail. */
+function describeLoadForward(outcome: StaleLoadRepairResult): string {
+	return `Claude Code now loads v${outcome.target} here (${outcome.rewritten} older record${
+		outcome.rewritten === 1 ? "" : "s"
+	} moved forward)`;
+}
+
 // -- selection ---------------------------------------------------------------
 
 /**
@@ -448,7 +498,28 @@ export async function applyPlugins(
 				}
 			}
 			const noMove = pluginNoMove(item, landed);
-			if (noMove) {
+			// What landed here — the project row when there is one, since that is
+			// the row the loader must end up agreeing with.
+			const here =
+				landed.find(([scope]) => scope === "project")?.[1] ??
+				landed.find(([, actual]) => actual)?.[1] ??
+				null;
+			const forward = here
+				? await bringLoadForward(item.pluginId, here, projectPath, deps)
+				: null;
+			if (forward && !forward.ok) {
+				// Installed, but not what loads: that is not "updated". Reported as
+				// a failure with the repair's own reason, so nothing says current.
+				report.finish(
+					false,
+					item.pluginId,
+					`installed v${here}, but Claude Code still loads v${
+						forward.loaded ?? "an older version"
+					} here — ${forward.error ?? "the older records could not be moved forward"}`,
+					Date.now() - startedAt,
+				);
+				result.failed.push(item.pluginId);
+			} else if (noMove && !forward) {
 				report.finish(
 					true,
 					item.pluginId,
@@ -457,10 +528,11 @@ export async function applyPlugins(
 				);
 				result.unchanged.push(item.pluginId);
 			} else {
+				const moved = `${scopes.join(", ")}${item.target ? ` → ${item.target}` : ""}`;
 				report.finish(
 					true,
 					item.pluginId,
-					`${scopes.join(", ")}${item.target ? ` → ${item.target}` : ""}`,
+					forward ? `${moved} · ${describeLoadForward(forward)}` : moved,
 					Date.now() - startedAt,
 				);
 				result.ok++;
@@ -499,6 +571,19 @@ async function applyOneInScope(
 	await run(pluginId, scope);
 	const actual = await deps.readInstalled(pluginId, scope, projectPath);
 	if (actual) await deps.saveInstalled(pluginId, actual, scope, projectPath);
+	// The same last step as the apply loop, at every scope: installed must mean
+	// loaded here. `repairStaleLoad` itself refuses — and says why — when the
+	// winning record is not one this repository's rows can move.
+	if (actual) {
+		const forward = await bringLoadForward(pluginId, actual, projectPath, deps);
+		if (forward && !forward.ok) {
+			throw new Error(
+				`installed v${actual}, but Claude Code still loads v${
+					forward.loaded ?? "an older version"
+				} here — ${forward.error ?? "the older records could not be moved forward"}`,
+			);
+		}
+	}
 	return actual;
 }
 

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,17 +452,42 @@ 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[] };
 	/** Cross-profile version conflicts detected while unioning profiles. */
 	conflicts?: string[];
+	/**
+	 * What the enabled plugins' own plugin.json files require — present when
+	 * anything was derived or could not be read. The derived ids are already
+	 * in `plugins`.
+	 */
+	dependencies?: DependencyReport;
+}
+
+/**
+ * The dependencies a profile's enabled plugins declare, resolved transitively.
+ * Derived, never recorded: profiles.json names none of them.
+ */
+export interface DependencyReport {
+	/** Enabled only because an enabled plugin depends on them. Sorted. */
+	derived: string[];
+	/** Enabled plugins whose plugin.json could not be read here. Sorted. */
+	unreadable: string[];
+	/** A dependency the profile itself turns off: `plugin` will not load. */
+	blocked: Array<{ plugin: string; dependency: 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/PluginsScreen.tsx

@@ -44,6 +44,7 @@ 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 {
@@ -982,7 +983,11 @@ export function PluginsScreen() {
 				fetchData();
 			} catch (error) {
 				modal.hideModal();
-				await modal.message("Error", `Failed: ${error}`, "error");
+				await modal.message(
+					"Error",
+					error instanceof LiveFileRefusal ? error.message : `Failed: ${error}`,
+					"error",
+				);
 			}
 		}
 	};
@@ -1202,7 +1207,11 @@ export function PluginsScreen() {
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
-			await modal.message("Error", `Failed: ${error}`, "error");
+			await modal.message(
+				"Error",
+				error instanceof LiveFileRefusal ? error.message : `Failed: ${error}`,
+				"error",
+			);
 		}
 	};
 

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,
@@ -23,12 +26,14 @@ import {
 	renameProfile,
 } from "../../services/profiles.js";
 import { writableMap } from "../../services/settings-file.js";
+import { LiveFileRefusal } from "../../services/tracked-live-files.js";
 import {
 	ClipboardUnavailableError,
 	readClipboard,
 	writeClipboard,
 } from "../../utils/clipboard.js";
 import { ScrollableList } from "../components/ScrollableList.js";
+import { describeOutcome } from "../hooks/useProfileStartupModal.js";
 import {
 	type ProfileListItem,
 	buildProfileListItems,
@@ -156,45 +161,98 @@ 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) {
 			modal.hideModal();
 			await modal.message(
 				"Error",
-				`Failed to apply profile: ${error}`,
+				error instanceof LiveFileRefusal
+					? error.message
+					: `Failed to apply profile: ${error}`,
 				"error",
 			);
 		}
 	};
 
+	/**
+	 * 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",
+					error instanceof LiveFileRefusal
+						? error.message
+						: `Failed to switch profile: ${error}`,
+					"error",
+				);
+			}
+			return;
+		}
 
 		const pluginCount = Object.keys(selectedProfile.plugins ?? {}).length;
 		const emptyWarning =
@@ -204,30 +262,27 @@ 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) {
 			modal.hideModal();
 			await modal.message(
 				"Error",
-				`Failed to apply profile: ${error}`,
+				error instanceof LiveFileRefusal
+					? error.message
+					: `Failed to apply profile: ${error}`,
 				"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;