magus-cli 7.5.3 → 7.5.4

package/src/services/profile-activate.ts

@@ -76,9 +76,10 @@ import {
 } from "./profile-skills.js";
 import {
 	GitCheckError,
+	type TrackedNotice,
+	trackedNotice,
 	trackedPaths,
 	trackedSkillFolders,
-	trackedWarning,
 } from "./tracked-live-files.js";
 import type { ApplyReporter } from "./update-engine.js";
 
@@ -127,8 +128,11 @@ export function reportDisplaced(
 	projectPath: string,
 ): (artifact: DisplacedArtifact) => void {
 	const rel = (p: string) => path.relative(projectPath, p);
-	return ({ link, savedTo }) =>
-		console.log(`  ${rel(link)} → kept at ${rel(savedTo)}`);
+	return ({ link }) =>
+		// The user's file, never where the backup went: that is magus's own
+		// storage, and the owner wants only what the user uses on screen.
+		// `savedTo` stays in the result for anything that needs to find it.
+		console.log(`     Backed up your previous ${rel(link)}`);
 }
 
 /**
@@ -157,20 +161,31 @@ export async function trackedGeneratedFiles(
 }
 
 /**
- * {@link trackedGeneratedFiles} as the warning lines the CLI prints: one per
- * tracked path, or one saying git could not be asked.
+ * {@link trackedGeneratedFiles} as the notices the CLI prints: one per tracked
+ * path, or one saying git could not be asked.
  */
-export async function trackedGeneratedWarnings(
+export async function trackedGeneratedNotices(
 	projectPath: string,
-): Promise<string[]> {
+): Promise<TrackedNotice[]> {
 	try {
-		return (await trackedGeneratedFiles(projectPath)).map(trackedWarning);
+		return (await trackedGeneratedFiles(projectPath)).map(trackedNotice);
 	} catch (error) {
-		if (error instanceof GitCheckError) return [error.message];
+		if (error instanceof GitCheckError) {
+			return [{ problem: error.message, fix: [] }];
+		}
 		throw error;
 	}
 }
 
+/** The tracked-path notices an activation result carries. */
+export function activationTrackedNotices(
+	result: ActivationResult,
+): TrackedNotice[] {
+	return typeof result.tracked === "string"
+		? [{ problem: result.tracked, fix: [] }]
+		: result.tracked.map(trackedNotice);
+}
+
 /**
  * The folders of `skills` the team committed under `.claude/skills/`. Such a
  * folder is the team's copy of the skill: magus neither installs over it nor
@@ -195,16 +210,21 @@ export function releasedCommittedSkillNote(folder: string): string {
 /**
  * Lines describing what activation did beyond the switch itself, phrased for
  * both the terminal and the TUI's outcome modal.
+ *
+ * `tracked: false` leaves the tracked-path notices out, for the CLI, which
+ * prints them itself as a warning with the fix beneath it
+ * ({@link activationTrackedNotices}).
  */
-export function activationNotes(result: ActivationResult): string[] {
+export function activationNotes(
+	result: ActivationResult,
+	opts: { tracked?: boolean } = {},
+): string[] {
 	const lines: string[] = [
 		...(result.absorbed ?? []),
 		...describeDependencies(result.dependencies, result.profileId),
 	];
 	for (const folder of result.conversion.restored) {
-		lines.push(
-			`Restored custom skill .claude/skills/${folder} (the older profile layout had moved it)`,
-		);
+		lines.push(`Restored your custom skill "${folder}"`);
 	}
 	for (const c of result.conversion.conflicts) {
 		lines.push(
@@ -222,12 +242,13 @@ export function activationNotes(result: ActivationResult): string[] {
 			`Skill .claude/skills/${folder} is committed to git — the team's copy is used; magus does not install or manage it`,
 		);
 	}
-	if (typeof result.tracked === "string") lines.push(result.tracked);
-	else lines.push(...result.tracked.map(trackedWarning));
+	if (opts.tracked !== false) {
+		for (const n of activationTrackedNotices(result)) {
+			lines.push(n.problem, ...n.fix);
+		}
+	}
 	if (result.keptAt) {
-		lines.push(
-			`The older layout's .claude/_profiles/ was kept at ${result.keptAt}/`,
-		);
+		lines.push("A backup of the old profile format was kept");
 	}
 	return lines;
 }

package/src/services/profile-startup.ts

@@ -26,6 +26,12 @@
  *
  *   ok           a profile is active; the manifest is in effect; ask nothing
  *   unmigrated   no manifest — the project is not using profiles at all
+ *   old-format   the project is on an older magus profile format; asked about
+ *                before it is updated, in the CLI and the TUI alike
+ *   nested       no manifest here, but this folder is inside a project that
+ *                has one — Claude Code started here would read this folder's
+ *                settings, not that project's, so nothing is offered: the way
+ *                on is running magus in that project, or `magus profile init`
  *   inactive     a manifest with profiles, none of them activated
  *   unknown      the active-profile marker names a profile the manifest does
  *                not define; the only way on is activating one that exists
@@ -50,18 +56,25 @@
  * detects.
  */
 
+import path from "node:path";
 import type { ProfileManifest } from "../types/index.js";
 // Type-only, so it is erased: this module stays free of the UI and of React,
 // which is what lets `magus hook` and the CLI import it. The shape of a
 // selectable option is presentation-neutral data, and both surfaces render the
 // same list from these builders rather than each composing its own.
 import type { SelectOption } from "../ui/state/types.js";
-import { MANIFEST_FILE, emptyManifest, readManifest } from "./manifest.js";
+import {
+	MANIFEST_FILE,
+	emptyManifest,
+	findEnclosingManifest,
+	readManifest,
+} from "./manifest.js";
 import type { ProfileChoice } from "./profile-activate.js";
 import { freeProfileId } from "./profile-adopt.js";
 import {
 	activeProfile,
 	displaceableArtifacts,
+	hasOlderLayout,
 	namedActiveProfile,
 } from "./profile-live.js";
 import { prepareProfileState } from "./profile-state.js";
@@ -71,6 +84,8 @@ import { SettingsParseError } from "./settings-file.js";
 export type ProfileStartupState =
 	| "ok"
 	| "unmigrated"
+	| "old-format"
+	| "nested"
 	| "inactive"
 	| "unknown"
 	| "unparseable";
@@ -102,6 +117,11 @@ export interface ProfileStartupNeed {
 	activate: ActivatableProfile[];
 	/** For `unknown`: the profile the marker names. */
 	unknownProfile?: string;
+	/**
+	 * For `nested`: the enclosing project — its path relative to this folder
+	 * and its folder name, which is how the user knows it.
+	 */
+	enclosing?: { rel: string; name: string };
 	/**
 	 * The profile this project declares it wants, if the manifest names one that
 	 * exists. Used to preselect the row so Enter does the intended thing.
@@ -167,6 +187,24 @@ export async function detectProfileStartupNeed(
 	const ids = Object.keys(manifest.profiles);
 
 	if (ids.length === 0) {
+		// One decision for the CLI and the TUI alike. It lived in the CLI alone,
+		// so `magus update` in a subfolder explained and stopped while the TUI in
+		// the same folder offered to save a second, separate profile.
+		const enclosing = await findEnclosingManifest(projectPath);
+		if (enclosing !== null) {
+			return {
+				state: "nested",
+				adopt: null,
+				activate: [],
+				declaredDefault: null,
+				autoActivate: false,
+				manifest,
+				enclosing: {
+					rel: path.relative(projectPath, enclosing),
+					name: path.basename(enclosing),
+				},
+			};
+		}
 		return {
 			state: "unmigrated",
 			adopt: freeProfileId(manifest),
@@ -242,11 +280,45 @@ export async function detectProfileStartupNeed(
 	};
 }
 
+/**
+ * The `old-format` question, or null when the project is not on an older
+ * magus profile format. One source for the CLI's gate and the TUI's startup,
+ * so both ask the same thing — the TUI used to convert without asking while
+ * the CLI asked.
+ */
+export async function oldFormatNeed(
+	projectPath: string,
+): Promise<ProfileStartupNeed | null> {
+	if (!(await hasOlderLayout(projectPath))) return null;
+	let manifest: ProfileManifest;
+	try {
+		manifest = await readManifest(projectPath);
+	} catch (error) {
+		if (!(error instanceof SettingsParseError)) throw error;
+		return unparseableNeed(error);
+	}
+	return {
+		state: "old-format",
+		adopt: null,
+		activate: [],
+		declaredDefault: null,
+		autoActivate: false,
+		manifest,
+	};
+}
+
 /** What the TUI shows at startup, beyond the question (if any). */
 export interface ProfileStartup {
 	need: ProfileStartupNeed;
 	/** One line per thing the gate did: absorbed edits, regeneration, repairs. */
 	notices: string[];
+	/**
+	 * One line per thing the gate REFUSED — the lines the CLI stops on. Kept
+	 * apart from `notices` because a refusal can leave detection reading `ok`:
+	 * an old layout whose settings file does not parse is not converted, yet
+	 * still names its profile, so only this says the update did not happen.
+	 */
+	problems: string[];
 }
 
 /**
@@ -257,17 +329,66 @@ export interface ProfileStartup {
  */
 export async function prepareProfileStartup(
 	projectPath: string,
+	/**
+	 * Update an older profile format. Without it, a project on one is answered
+	 * with the `old-format` question and NOTHING is converted — the TUI asks
+	 * first, as the CLI does; the modal's "Update it now" calls back with this.
+	 */
+	opts: { convert?: boolean } = {},
 ): Promise<ProfileStartup> {
+	if (!opts.convert) {
+		const format = await oldFormatNeed(projectPath);
+		if (format !== null) return { need: format, notices: [], problems: [] };
+	}
 	const notices: string[] = [];
+	const problems: string[] = [];
 	try {
 		const prep = await prepareProfileState(projectPath);
-		notices.push(...prep.lines, ...prep.problems);
+		notices.push(...prep.lines);
+		problems.push(...prep.problems);
 	} catch (error) {
 		if (!(error instanceof SettingsParseError)) {
-			notices.push(error instanceof Error ? error.message : String(error));
+			problems.push(error instanceof Error ? error.message : String(error));
 		}
 	}
-	return { need: await detectProfileStartupNeed(projectPath), notices };
+	return {
+		need: await detectProfileStartupNeed(projectPath),
+		notices,
+		problems,
+	};
+}
+
+/** What the TUI shows once "Update it now" has run. */
+export type FormatUpdateOutcome =
+	| { kind: "ask"; need: ProfileStartupNeed }
+	| { kind: "updated"; title: string; message: string }
+	| { kind: "failed"; title: string; message: string };
+
+/**
+ * The verdict on an old-format update, from {@link prepareProfileStartup}'s
+ * result. A refusal is a failure even when detection reads `ok` — the CLI
+ * stops on the same lines, and the TUI used to show "Profile format updated"
+ * over a message saying magus had not updated it.
+ */
+export function formatUpdateOutcome(
+	result: ProfileStartup,
+): FormatUpdateOutcome {
+	if (result.problems.length > 0) {
+		return {
+			kind: "failed",
+			title: "Could not update the profile format",
+			message: [...result.problems, "", "Your profiles are kept."].join("\n"),
+		};
+	}
+	if (!needsNothing(result.need)) return { kind: "ask", need: result.need };
+	return {
+		kind: "updated",
+		title: "Profile format updated",
+		message:
+			result.notices.length > 0
+				? result.notices.join("\n")
+				: "This project now uses the current profile format.",
+	};
 }
 
 // ─── What to offer, as data both surfaces render ─────────────────────────────
@@ -276,6 +397,8 @@ export async function prepareProfileStartup(
 export const ADOPT_VALUE = "adopt";
 export const QUIT_VALUE = "quit";
 export const ACTIVATE_PREFIX = "activate:";
+/** The `old-format` question's "Update it now" row. Not a profile choice. */
+export const UPDATE_FORMAT_VALUE = "update-format";
 
 /**
  * Title and message for the state we are in.
@@ -349,6 +472,35 @@ export function describeNeed(need: ProfileStartupNeed): {
 		};
 	}
 
+	if (need.state === "old-format") {
+		return {
+			title: "This project uses an old magus profile format",
+			message:
+				"magus has to update it before it can manage this project.\n\nYour profiles, plugins and custom skills are kept.",
+		};
+	}
+
+	if (need.state === "nested") {
+		// The one other place a path appears, and for the same reason as
+		// `unparseable`: the folder IS the message. It sits on a line of its own,
+		// short, so the modal never wraps it at a `.`. The reason is stated as
+		// Claude Code's behaviour, which it is — magus follows it.
+		const at = need.enclosing;
+		return {
+			title: "Inside another Claude Code project",
+			message: [
+				"This folder is inside a Claude Code project that already has profiles:",
+				"",
+				`  ${at?.rel ?? ".."}  (${at?.name ?? "?"})`,
+				"",
+				"Claude Code treats each folder you start it in as a separate project, with its own plugins and settings, and magus follows it.",
+				"",
+				"To manage plugins for the whole project, run magus there.",
+				"To give this folder a setup of its own, run magus profile init here.",
+			].join("\n"),
+		};
+	}
+
 	if (need.state === "unknown") {
 		return {
 			title: "Active profile no longer exists",
@@ -390,6 +542,10 @@ export function describeNeed(need: ProfileStartupNeed): {
 export function buildProfileOptions(need: ProfileStartupNeed): SelectOption[] {
 	const options: SelectOption[] = [];
 
+	if (need.state === "old-format") {
+		options.push({ label: "Update it now", value: UPDATE_FORMAT_VALUE });
+	}
+
 	if (need.adopt !== null) {
 		options.push({
 			// Says what it PRESERVES, not what it creates. "Create <id> from this

package/src/services/profile-state.ts

@@ -261,7 +261,7 @@ export function describeUnknownProfile(
 export function describeUnmarked(
 	check: Extract<ActiveProfileCheck, { state: "unmarked" }>,
 ): string {
-	return `No profile is active in this project, and its live config matches no single profile. Run ${switchHint(check.available, check.suggested)}.`;
+	return `No profile is active in this project, and its plugins match none of the profiles. Run ${switchHint(check.available, check.suggested)}.`;
 }
 
 /**
@@ -328,7 +328,7 @@ export async function prepareProfileState(
 
 	if (check.state === "active" && check.restored) {
 		out.lines.push(
-			`No active-profile marker, but the live config matches profile "${check.profile}" exactly — restored it`,
+			`Using profile "${check.profile}" — this project's plugins match it`,
 		);
 	}
 
@@ -353,10 +353,11 @@ export async function prepareProfileState(
 			);
 			if (check.state === "old-layout") {
 				out.lines.push(
-					`Converted profile "${profile}" from the older layout to real files`,
+					`Updated profile "${profile}" to the current profile format`,
 				);
 			}
-			out.lines.push(...activationNotes(result));
+			// Tracked files are the command's to report, once (see profile-absorb).
+			out.lines.push(...activationNotes(result, { tracked: false }));
 		}
 		out.check = { state: "active", profile, restored: false };
 	}
@@ -386,11 +387,11 @@ export async function inspectProfileState(
 
 	if (check.state === "old-layout") {
 		pending.push(
-			`Profile "${check.profile}" is on an older magus layout (links into .claude/_profiles/). The next magus command, or \`magus doctor --fix\`, adds any changes Claude Code made under it to profiles.json, converts it to real files, and keeps .claude/_profiles/ in .claude/.magus-backups/.`,
+			`Profile "${check.profile}" uses an old magus profile format. The next magus command, or \`magus doctor --fix\`, updates it — keeping any changes Claude Code made, and a backup of the old format.`,
 		);
 	} else if (check.state === "unmarked" && check.match !== null) {
 		pending.push(
-			`No active-profile marker, but the live config matches profile "${check.match}" exactly — the next magus command, or \`magus doctor --fix\`, restores it.`,
+			`This project's plugins match profile "${check.match}" — the next magus command, or \`magus doctor --fix\`, switches to it.`,
 		);
 	} else if (
 		check.state === "active" &&

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

@@ -46,9 +46,30 @@ export function untrackCommand(rel: string): string {
 	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`;
+/** A tracked generated path, as reported: the problem, then the fix beneath. */
+export interface TrackedNotice {
+	problem: string;
+	/** Lines under the problem. Empty when git itself could not be asked. */
+	fix: string[];
+}
+
+/**
+ * The notice for one tracked generated path.
+ *
+ * Short lines, not one long one. The single line this replaced ran the
+ * problem, the cause and the command together and wrapped mid-command at 80
+ * columns; the owner read it as confusing. Now: what is wrong, what the user
+ * will see because of it, and the command alone on its line to be copied —
+ * each under 80 columns with the report's indent.
+ */
+export function trackedNotice(rel: string): TrackedNotice {
+	return {
+		problem: `git tracks ${rel}, but magus rewrites it`,
+		fix: [
+			"It will keep showing as changed. Untrack it — the file stays on disk:",
+			`${untrackCommand(rel)}, then commit`,
+		],
+	};
 }
 
 /**

package/src/services/update-engine.ts

@@ -387,9 +387,16 @@ function describeLoadForward(outcome: StaleLoadRepairResult): string {
 /**
  * Scopes the apply loop would touch for `item`. Empty means it is skipped.
  *
- * A plugin the profile declares but nothing has installed goes in at PROJECT
- * scope, matching `install`: a profile is a property of one repo, so its
- * plugins must not be enabled machine-wide.
+ * A plugin the profile declares but nothing has installed (reason `absent`)
+ * goes in at PROJECT scope, matching `install`: a profile is a property of one
+ * repo, so its plugins must not be enabled machine-wide.
+ *
+ * A plugin whose files are missing is reinstalled exactly where it is
+ * installed — the plan's `scopes`. Every install used to go to project scope,
+ * so a user-scope plugin with its files missing was installed with `--scope
+ * project`, which turns it on in the project's settings.json; for a plugin the
+ * profile does not declare, the reconcile after the run then absorbed that
+ * record into the team's committed profiles.json.
  *
  * Every scope holding an outdated install is returned, not just one. Fixing a
  * single hardcoded scope does not converge: it reports success while the
@@ -408,7 +415,9 @@ function scopesToApply(item: PluginUpdateItem): PluginScope[] {
 		item.action === "stale-load"
 	)
 		return [];
-	return item.action === "install" ? ["project"] : item.scopes;
+	return item.action === "install" && item.reason === "absent"
+		? ["project"]
+		: item.scopes;
 }
 
 /**
@@ -451,8 +460,11 @@ export function pluginNeedsWork(item: PluginUpdateItem): boolean {
  * report "0.2.4 installed, 0.3.0 available" while owning no row of its own.
  * That is exactly the shape that used to reach `update`.
  *
- * `readInstalled` matches the project path EXACTLY (no worktree inheritance),
- * which is what makes it the right question to ask here.
+ * `readInstalled` reads this project's own row at `scope` by exact path — no
+ * worktree inheritance and no user-row fallback — which is what makes it the
+ * right question to ask here. It used to fall back to the user row, so a plugin
+ * installed only at user scope and turned on in project settings passed this
+ * check and reached `update --scope project` from a folder with no project row.
  */
 async function advanceInScope(
 	deps: PluginApplyDeps,
@@ -487,9 +499,14 @@ async function advanceInScope(
  * No installer output is parsed — "already at the latest version" is
  * locale- and version-fragile. The registry row the apply loop already reads
  * back is compared with the before-version the plan carries:
- *  - update: every touched scope reads back exactly what it held before;
+ *  - update: no touched scope recorded a version it did not hold before;
  *  - install: no touched scope reads back any version at all;
  *  - repair: never — same version is its definition; the files moved.
+ *
+ * A null read-back is nothing recorded, so it is never a move. It used to
+ * count as one — null differs from any before-version — and since the
+ * read-back matches this project's own row exactly, an update that recorded
+ * nothing reported "project → <target>" on every run while nothing changed.
  */
 function pluginNoMove(
 	item: PluginUpdateItem,
@@ -497,10 +514,11 @@ function pluginNoMove(
 ): string | null {
 	if (landed.length === 0) return null;
 	if (item.action === "update") {
-		const same = landed.every(
-			([scope, actual]) => (actual ?? undefined) === item.beforeVersions[scope],
+		const moved = landed.some(
+			([scope, actual]) =>
+				actual !== null && actual !== item.beforeVersions[scope],
 		);
-		if (!same) return null;
+		if (moved) return null;
 		const v = landed.find(([, a]) => a)?.[1];
 		return v
 			? `the installer exited 0 but ${item.pluginId} is still ${v}`