magus-cli 7.4.0 → 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
@@ -135,16 +135,22 @@ type CheckedMap<V> = unknown extends V
 
 /**
  * {@link writableMap} for a list the caller pushes into or filters —
- * `enabledMcpjsonServers`. Present but not an array throws the same way.
+ * `enabledMcpjsonServers`, a gitignore manifest's `ignore` and `track`. Present
+ * but not an array throws the same way.
  */
 export function writableList<S extends object, K extends keyof S & string>(
 	settings: S,
 	key: K,
 	settingsPath: string,
-): S[K] {
-	return checkedEntry(settings, key, settingsPath, key, "array");
+): CheckedList<S[K]> {
+	return checkedEntry(settings, key, settingsPath, key, "array") as CheckedList<
+		S[K]
+	>;
 }
 
+/** {@link CheckedMap} for a list: an untyped key comes back as the array it is. */
+type CheckedList<V> = unknown extends V ? unknown[] | undefined : V;
+
 function checkedEntry<S extends object, K extends keyof S & string>(
 	settings: S,
 	key: K,

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/services/tool-probe.ts

@@ -1439,6 +1439,36 @@ async function isNpmDefaultPrefix(
 	return real !== null && path.resolve(real) === root;
 }
 
+/**
+ * Is `onPath` — the entry PATH actually runs, before any link is followed —
+ * the launcher the native installer maintains beside `dataHome`?
+ *
+ * The launcher lives one level up from the data home, in `bin`:
+ * `~/.local/share` → `~/.local/bin/claude`. The comparison is on the
+ * DIRECTORIES, never on the files: both the launcher and a hand-made link
+ * resolve into `versions/<version>`, which is precisely what has to be told
+ * apart. Their real paths are compared too, so a symlinked `~/.local` still
+ * matches.
+ */
+async function isNativeLauncher(
+	s: ProbeSession,
+	onPath: string,
+	dataHome: string,
+): Promise<boolean> {
+	const launcherDir = path.resolve(dataHome, "..", "bin");
+	const entryDir = path.resolve(path.dirname(onPath));
+	if (launcherDir === entryDir) return true;
+	const [launcherReal, entryReal] = await Promise.all([
+		s.io.realpath(launcherDir),
+		s.io.realpath(entryDir),
+	]);
+	return (
+		launcherReal !== null &&
+		entryReal !== null &&
+		path.resolve(launcherReal) === path.resolve(entryReal)
+	);
+}
+
 /**
  * Claude Code's native installer keeps every release side by side under
  * `<data>/claude/versions/<version>` and points PATH (`~/.local/bin/claude`) at
@@ -1451,12 +1481,23 @@ async function isNpmDefaultPrefix(
  * number. The version is that name; the latest is npm's `latest` dist-tag for
  * Claude Code, the channel the native installer tracks by default.
  *
+ * **Resolving into `versions/` is not enough: the entry PATH runs has to BE the
+ * native launcher.** A hand-made link earlier on PATH — `/usr/local/bin/claude`
+ * pointed at a release directory by hand, a wrapper someone wrote — resolves
+ * into exactly the same place, and planning `claude update` for it would be a
+ * plan that changes nothing: the updater rewrites the launcher, and PATH goes
+ * on running the other file at the old version. Every run would find it behind
+ * and plan the same no-op again. So the check is on `onPath`, the unresolved
+ * entry, and a copy that is not the launcher falls through to the spec's own
+ * installer — which reports it as a second copy it does not own.
+ *
  * True when it recognised the layout; `f` then holds the whole answer.
  */
 async function probeClaudeNative(
 	s: ProbeSession,
 	spec: BinRequirement,
 	f: ToolFacts,
+	onPath: string,
 	resolvedPath: string,
 ): Promise<boolean> {
 	// The cheap, pure shape test first, so no other tool pays for the IO below.
@@ -1471,7 +1512,10 @@ async function probeClaudeNative(
 	let owned = false;
 	for (const home of dataHomes) {
 		const versions = path.resolve(home, "claude", "versions");
-		owned = versions === dir || (await s.io.realpath(versions)) === dir;
+		if (versions !== dir && (await s.io.realpath(versions)) !== dir) continue;
+		// The directory is the installer's. Only the launcher it maintains
+		// there speaks for it.
+		owned = await isNativeLauncher(s, onPath, home);
 		if (owned) break;
 	}
 	if (!owned) return false;
@@ -1561,8 +1605,9 @@ async function probeInto(
 	f.resolvedPath = resolvedPath;
 
 	// A file Claude Code's native installer owns answers for itself, whatever
-	// installer the spec names.
-	if (await probeClaudeNative(s, spec, f, resolvedPath)) return;
+	// installer the spec names. `onPath` as well as `resolvedPath`: ownership
+	// turns on which file PATH runs, not only on where it points.
+	if (await probeClaudeNative(s, spec, f, onPath, resolvedPath)) return;
 
 	const pinned = pinOf(spec) !== undefined;
 	const via: BinInstaller = spec.via;

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/components/modals/ModalContainer.tsx

@@ -1,6 +1,6 @@
 import type { ScrollBoxRenderable } from "@opentui/core";
 import React, { useRef, useState } from "react";
-import { useKeyLayer } from "../../input/KeyRouter.js";
+import { useKeyLayer, usePasteLayer } from "../../input/KeyRouter.js";
 import { type KeyPress, isScrollKey } from "../../input/key-dispatch.js";
 import { useApp, useModal } from "../../state/AppContext.js";
 import { useDimensions } from "../../state/DimensionsContext.js";
@@ -23,6 +23,12 @@ const isPlain = (key: KeyPress) => !key.ctrl && !key.meta;
  * Enter that confirms a dialog confirms only the dialog. Ctrl+C still quits: it
  * is taken above every layer, in src/tui.tsx.
  *
+ * It takes every PASTE for the same reason, and does nothing with it: a search
+ * box on the screen behind still has focus, and without this its query would
+ * grow from a paste aimed at the dialog in front of it. The event itself is not
+ * stopped, so the input modal's focused `<input>` still receives it — the
+ * arrangement the `input` case below already relies on for keys.
+ *
  * - confirm: y / Enter confirm; n / Esc / q cancel.
  * - select:  ↑↓ (j/k) move, Enter picks, Esc / q cancel (a no-op for a
  *            question that must be answered).
@@ -79,6 +85,8 @@ export function ModalContainer() {
 		}
 	};
 
+	usePasteLayer("modal", modal !== null, () => true);
+
 	useKeyLayer("modal", modal !== null, (key) => {
 		if (!modal) return false;
 

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: () => {