magus-cli 7.5.2 → 7.5.4

package/src/services/profile-absorb.ts

@@ -61,8 +61,7 @@ import {
 	type ActivateOptions,
 	activateProfile,
 	activationNotes,
-	activeWritableSkillFolders,
-	writeRefusal,
+	releasedCommittedSkillNote,
 } from "./profile-activate.js";
 import {
 	type ActiveMarker,
@@ -94,6 +93,7 @@ import {
 } from "./profile-skills.js";
 import { resolveExtends, resolveProfile } from "./resolver.js";
 import { SettingsParseError } from "./settings-file.js";
+import { trackedSkillFolders } from "./tracked-live-files.js";
 
 // ─── Changes ─────────────────────────────────────────────────────────────────
 
@@ -947,7 +947,7 @@ export async function absorbOrphanedProfile(
 		);
 		if (!base && changes.length > 0) {
 			result.lines.push(
-				`There is no record of what "${orphan}" contained, so everything in the live config that "${target}" lacked was kept`,
+				`There is no record of what "${orphan}" contained, so every plugin and setting here that "${target}" lacked was kept`,
 			);
 		}
 		result.lines.push(...result.changes.map((c) => describeChange(c, target)));
@@ -1022,7 +1022,7 @@ export async function absorbOlderLayout(
 					: new SettingsParseError(livePath(key, projectPath), error);
 			result.unreadable.push(parseError);
 			result.problems.push(
-				`${rel(projectPath, key)} cannot be read (${parseError.detail}) — fix it by hand; magus left the older layout as it is and did not convert it`,
+				`${rel(projectPath, key)} cannot be read (${parseError.detail}) — fix it by hand; magus did not update the old profile format`,
 			);
 			continue;
 		}
@@ -1056,8 +1056,8 @@ export async function absorbOlderLayout(
 		result.changes.push(...changes);
 		result.lines.push(
 			exact
-				? `Changes Claude Code made under the older layout were added to profile "${into}"`
-				: `Profile "${named ?? "?"}" no longer exists in profiles.json — its unsaved changes under the older layout were added to profile "${into}"`,
+				? `Changes Claude Code made were added to profile "${into}"`
+				: `Profile "${named ?? "?"}" no longer exists in profiles.json — its unsaved changes were added to profile "${into}"`,
 		);
 		if (!exact) {
 			result.lines.push(
@@ -1072,7 +1072,7 @@ export async function absorbOlderLayout(
 	);
 	if (absorbed.keptMore) {
 		result.lines.push(
-			`profiles.json has entries the older layout's files lack; they were kept — a removal made under the older layout is not applied (the older files are in the -layout backup under .claude/.magus-backups/)`,
+			"profiles.json has entries the old profile format lacked; they were kept — a removal made in the old format is not applied (the old format is backed up)",
 		);
 	}
 	return result;
@@ -1114,7 +1114,7 @@ async function olderRenderIds(
 
 /** One line for a value the older layout's file and profiles.json disagree on. */
 export function describeLayoutConflict(at: string, profile: string): string {
-	return `Profile "${profile}": ${at} differs between the older layout and profiles.json — kept profiles.json's value; the older copy is in the -layout backup under .claude/.magus-backups/`;
+	return `Profile "${profile}": ${at} differs between the old profile format and profiles.json — kept profiles.json's value (the old one is backed up)`;
 }
 
 /**
@@ -1302,13 +1302,39 @@ export async function reconcileActiveProfile(
 	opts: ReconcileOptions = {},
 ): Promise<ReconcileResult> {
 	if (!(await hasCurrentMarker(projectPath))) return emptyResult(null);
-	const marker = await readActiveMarker(projectPath);
+	let marker = await readActiveMarker(projectPath);
 	if (!marker) return emptyResult(null);
 	const manifest = await readManifest(projectPath);
 	const current = manifest.profiles[marker.profile];
 	if (!current) return emptyResult(null);
 	const name = marker.profile;
 
+	// A recorded skill folder git tracks is the team's copy: 7.5.0's conversion
+	// recorded committed skills as magus-installed. Handed back — dropped from
+	// the marker, and from magus's ignore lines — before anything below could
+	// treat it as magus's to sync or remove, and said once.
+	const handedBackLines: string[] = [];
+	const handedBack = await trackedSkillFolders(
+		projectPath,
+		Object.keys(marker.skills),
+	);
+	if (handedBack.size > 0) {
+		const skills: Record<string, string> = {};
+		for (const [folder, hash] of Object.entries(marker.skills)) {
+			if (!handedBack.has(folder)) skills[folder] = hash;
+		}
+		await updateSkillIgnoreLines(
+			projectPath,
+			[...handedBack],
+			Object.keys(skills),
+		);
+		marker = { ...marker, skills };
+		await writeActiveMarker(marker, projectPath);
+		handedBackLines.push(
+			...[...handedBack].sort().map(releasedCommittedSkillNote),
+		);
+	}
+
 	const edited: LiveFileKey[] = [];
 	const missing: LiveFileKey[] = [];
 	for (const key of LIVE_FILE_KEYS) {
@@ -1343,23 +1369,11 @@ export async function reconcileActiveProfile(
 		!definitionChanged &&
 		!marker.cliBookkeeping
 	) {
-		return emptyResult(name);
+		return { ...emptyResult(name), lines: handedBackLines };
 	}
 
 	const result = emptyResult(name);
-
-	// Every write below lands in a live file, a skill folder the profile
-	// installs (or the manifest, on the way to one). None happens when git
-	// tracks one of them, or cannot say: see `tracked-live-files.ts`.
-	const refusal = await writeRefusal(
-		projectPath,
-		await activeWritableSkillFolders(projectPath, manifest),
-	);
-	if (refusal) {
-		result.problems.push(refusal.message);
-		result.lines.push(refusal.message);
-		return result;
-	}
+	result.lines.push(...handedBackLines);
 
 	// ── a. absorb ────────────────────────────────────────────────────────────
 	const base = marker.base ?? current;
@@ -1511,7 +1525,10 @@ export async function reconcileActiveProfile(
 					installSkill: opts.installSkill,
 				},
 			);
-			notes.push(...activationNotes(activation));
+			// A re-render in the background never reports a tracked file: the
+			// command that ran it reports that once, itself, and repeating it here
+			// printed the same warning three times in one `magus update`.
+			notes.push(...activationNotes(activation, { tracked: false }));
 		} catch (error) {
 			result.problems.push(
 				error instanceof Error ? error.message : String(error),

package/src/services/profile-activate.ts

@@ -75,10 +75,11 @@ import {
 	updateSkillIgnoreLines,
 } from "./profile-skills.js";
 import {
-	LiveFileRefusal,
-	TrackedLiveFileError,
+	GitCheckError,
+	type TrackedNotice,
+	trackedNotice,
 	trackedPaths,
-	untrackCommand,
+	trackedSkillFolders,
 } from "./tracked-live-files.js";
 import type { ApplyReporter } from "./update-engine.js";
 
@@ -91,8 +92,12 @@ export interface ActivationResult {
 	skills: SkillSyncResult;
 	/** What converting an older layout did, if there was one. */
 	conversion: LegacySkillConversion;
-	/** Generated paths git still tracks (see {@link trackedGeneratedFiles}). */
-	tracked: string[];
+	/**
+	 * Generated paths git still tracks (see {@link trackedGeneratedFiles}) —
+	 * written all the same, and each warned about. A string instead when git
+	 * could not say (`GitCheckError`).
+	 */
+	tracked: string[] | string;
 	/** Where `.claude/_profiles/` was kept, project-relative, or null. */
 	keptAt: string | null;
 	/** Unsaved changes added to a profile before activating, one line each. */
@@ -101,6 +106,11 @@ export interface ActivationResult {
 	dependencies?: DependencyReport;
 	/** Listed skills whose folder the team committed: that copy is used. */
 	committedSkills?: string[];
+	/**
+	 * Skill folders the marker recorded as magus-installed that git tracks —
+	 * handed back to the team (see `releasedCommittedSkillNote`).
+	 */
+	releasedCommitted?: string[];
 }
 
 export interface ActivateOptions {
@@ -118,25 +128,27 @@ 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)}`);
 }
 
 /**
- * Generated paths that git tracks: the three live files, a committed
- * `.claude/skills` SYMLINK (an older layout committed by mistake), and any of
- * `skillFolders` — skill folders magus would install or remove. Committed
- * custom skills under a real `.claude/skills/` directory are not generated
- * state and are never reported. Empty outside a git repository.
+ * Generated files that git tracks: the three live files, and a committed
+ * `.claude/skills` SYMLINK (an older layout committed by mistake). A skill
+ * FOLDER git tracks is never one of them — it is the team's copy (see
+ * `trackedSkillFolders`). Empty outside a git repository; throws
+ * `GitCheckError` when git cannot say. Reported only — nothing refuses to
+ * write because of it (see `tracked-live-files.ts`).
  */
-export async function trackedWriteTargets(
+export async function trackedGeneratedFiles(
 	projectPath: string,
-	skillFolders: readonly string[] = [],
 ): Promise<string[]> {
 	const rel = (abs: string) => path.relative(projectPath, abs);
 	const live = LIVE_FILE_KEYS.map((key) => rel(livePath(key, projectPath)));
 	const skills = rel(skillsRoot(projectPath));
-	const folders = skillFolders.map((folder) => path.join(skills, folder));
 	let skillsIsLink = false;
 	try {
 		skillsIsLink = (await lstat(skillsRoot(projectPath))).isSymbolicLink();
@@ -144,127 +156,75 @@ export async function trackedWriteTargets(
 		// No .claude/skills at all.
 	}
 	const files = [...live, ...(skillsIsLink ? [skills] : [])];
-	const tracked = await trackedPaths(projectPath, files, folders);
-	return [...files, ...folders].filter((c) => tracked.has(c));
+	const tracked = await trackedPaths(projectPath, files);
+	return files.filter((c) => tracked.has(c));
 }
 
 /**
- * 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
- * manages it, so it never has cause to suggest untracking it.
+ * {@link trackedGeneratedFiles} as the notices the CLI prints: one per tracked
+ * path, or one saying git could not be asked.
  */
-export async function committedSkillFolders(
+export async function trackedGeneratedNotices(
 	projectPath: string,
-	skills: readonly ProfileSkillRef[],
-): Promise<Set<string>> {
-	const root = path.relative(projectPath, skillsRoot(projectPath));
-	const folders = skills.map((ref) => skillFolder(ref));
-	const tracked = await trackedPaths(
-		projectPath,
-		[],
-		folders.map((folder) => path.join(root, folder)),
-	);
-	return new Set(folders.filter((f) => tracked.has(path.join(root, f))));
+): Promise<TrackedNotice[]> {
+	try {
+		return (await trackedGeneratedFiles(projectPath)).map(trackedNotice);
+	} catch (error) {
+		if (error instanceof GitCheckError) {
+			return [{ problem: error.message, fix: [] }];
+		}
+		throw error;
+	}
 }
 
-/** {@link trackedWriteTargets} for the live files alone — what doctor reports. */
-export async function trackedGeneratedFiles(
-	projectPath: string,
-): Promise<string[]> {
-	return trackedWriteTargets(projectPath);
+/** 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 skill folders activating a profile with `skills` could write: those
- * magus manages now (kept or removed), and the profile's that are not on disk
- * yet — unless the team committed them (see {@link committedSkillFolders}).
- * An existing folder magus does not manage is a custom skill, which
- * activation refuses as a clash rather than writing.
+ * 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
+ * manages it, so it never has cause to suggest untracking it. None when git
+ * cannot say — each existing folder is then judged as a custom skill.
  */
-export async function writableSkillFolders(
+export async function committedSkillFolders(
 	projectPath: string,
 	skills: readonly ProfileSkillRef[],
-	managed: Readonly<Record<string, string>> = {},
-): Promise<string[]> {
-	const out = new Set(Object.keys(managed));
-	const missing: ProfileSkillRef[] = [];
-	for (const ref of skills) {
-		const folder = skillFolder(ref);
-		if (out.has(folder)) continue;
-		try {
-			await lstat(path.join(skillsRoot(projectPath), folder));
-		} catch {
-			missing.push(ref);
-		}
-	}
-	const committed = await committedSkillFolders(projectPath, missing);
-	for (const ref of missing) {
-		if (!committed.has(skillFolder(ref))) out.add(skillFolder(ref));
-	}
-	return [...out];
-}
-
-/**
- * The skill folders the ACTIVE profile's next render could write — see
- * {@link writableSkillFolders}. For the checks made before a reconcile, which
- * may re-render and so install or remove them.
- */
-export async function activeWritableSkillFolders(
-	projectPath: string,
-	manifest: ProfileManifest,
-): Promise<string[]> {
-	const marker = await readActiveMarker(projectPath);
-	if (!marker) return [];
-	return writableSkillFolders(
+): Promise<Set<string>> {
+	return trackedSkillFolders(
 		projectPath,
-		manifest.profiles[marker.profile]?.skills ?? [],
-		marker.skills,
+		skills.map((ref) => skillFolder(ref)),
 	);
 }
 
-/**
- * Why magus must not write here, or null: {@link assertNoTrackedWriteTargets}
- * as a value, for callers that report a refusal instead of throwing it.
- */
-export async function writeRefusal(
-	projectPath: string,
-	skillFolders: readonly string[] = [],
-): Promise<LiveFileRefusal | null> {
-	try {
-		await assertNoTrackedWriteTargets(projectPath, skillFolders);
-		return null;
-	} catch (error) {
-		if (error instanceof LiveFileRefusal) return error;
-		throw error;
-	}
-}
-
-/**
- * Throw {@link TrackedLiveFileError} — before anything is written — when any
- * of {@link trackedWriteTargets} is tracked, or `GitCheckError` when git
- * cannot say.
- */
-export async function assertNoTrackedWriteTargets(
-	projectPath: string,
-	skillFolders: readonly string[] = [],
-): Promise<void> {
-	const tracked = await trackedWriteTargets(projectPath, skillFolders);
-	if (tracked.length > 0) throw new TrackedLiveFileError(tracked);
+/** The line for a recorded skill folder handed back to the team. */
+export function releasedCommittedSkillNote(folder: string): string {
+	return `Skill ${folder} is committed by the team — magus no longer manages it`;
 }
 
 /**
  * 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(
@@ -274,20 +234,21 @@ export function activationNotes(result: ActivationResult): string[] {
 	for (const f of result.skills.failed) {
 		lines.push(`Skill "${f.skill}" could not be installed: ${f.reason}`);
 	}
+	for (const folder of result.releasedCommitted ?? []) {
+		lines.push(releasedCommittedSkillNote(folder));
+	}
 	for (const folder of result.committedSkills ?? []) {
 		lines.push(
 			`Skill .claude/skills/${folder} is committed to git — the team's copy is used; magus does not install or manage it`,
 		);
 	}
-	for (const rel of result.tracked) {
-		lines.push(
-			`${rel} is generated but tracked by git — run \`${untrackCommand(rel)}\`, then commit`,
-		);
+	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;
 }
@@ -295,9 +256,10 @@ export function activationNotes(result: ActivationResult): string[] {
 /**
  * Render `profileId` from `manifest` and make it the active profile.
  *
- * Throws {@link TrackedLiveFileError}, having changed nothing, when a path it
- * would write is tracked by git. Throws `SettingsParseError`, having changed
- * nothing, when a live file of a managed project does not parse. Throws
+ * A generated file git tracks is written like any other, and named in
+ * `tracked` so the caller can warn about it. Throws `SettingsParseError`,
+ * having changed nothing, when a live file of a managed project does not
+ * parse. Throws
  * {@link SkillClashError} — having
  * changed nothing but moving an older layout's skills into `.claude/skills/` —
  * when a listed skill's folder is already a custom skill.
@@ -315,21 +277,27 @@ export async function activateProfile(
 	// Read before converting: the older marker lives in the directory the
 	// conversion moves away, and an older layout is recognised by its links.
 	const previous = await readActiveMarker(projectPath);
-	// Before anything else is touched — the conversion below writes too.
-	await assertNoTrackedWriteTargets(
-		projectPath,
-		await writableSkillFolders(projectPath, skillRefs, previous?.skills),
-	);
 	const wasOldLayout = (await oldLayoutProfile(projectPath)) !== null;
 	// A managed project's live files are the profile's; one that does not
 	// parse is somebody mid-edit, and replacing it would lose their work. (At
 	// first adoption a hand-written file is moved to a backup, not replaced.)
 	if (previous !== null) await assertLiveFilesParse(projectPath);
 	const conversion = await convertLegacySkills(manifest, projectPath);
-	const managedBefore: Record<string, string> = {
+	const recorded: Record<string, string> = {
 		...(previous?.skills ?? {}),
 		...conversion.managed,
 	};
+	// A recorded folder git tracks is the team's copy — 7.5.0's conversion
+	// recorded committed skills as magus-installed. Dropped from the record
+	// here, before a sync could remove it, and said once.
+	const committedRecorded = await trackedSkillFolders(
+		projectPath,
+		Object.keys(recorded),
+	);
+	const managedBefore: Record<string, string> = {};
+	for (const [folder, hash] of Object.entries(recorded)) {
+		if (!committedRecorded.has(folder)) managedBefore[folder] = hash;
+	}
 
 	// Listed skills the team committed and magus does not manage: that copy
 	// stands, and magus neither installs over it nor reports it as a clash.
@@ -397,7 +365,7 @@ export async function activateProfile(
 	);
 	await updateSkillIgnoreLines(
 		projectPath,
-		Object.keys(managedBefore),
+		Object.keys(recorded),
 		Object.keys(skills.skills),
 	);
 	await writeActiveMarker(
@@ -412,7 +380,12 @@ export async function activateProfile(
 		displaced,
 		skills,
 		conversion,
-		tracked: await trackedGeneratedFiles(projectPath),
+		tracked: await trackedGeneratedFiles(projectPath).catch(
+			(error: unknown) => {
+				if (error instanceof GitCheckError) return error.message;
+				throw error;
+			},
+		),
 		keptAt: conversion.keptAt
 			? path.relative(projectPath, conversion.keptAt)
 			: null,
@@ -420,6 +393,9 @@ export async function activateProfile(
 		...(committedSkills.size > 0
 			? { committedSkills: [...committedSkills].sort() }
 			: {}),
+		...(committedRecorded.size > 0
+			? { releasedCommitted: [...committedRecorded].sort() }
+			: {}),
 	};
 }
 
@@ -445,7 +421,6 @@ export async function regenerateLiveFiles(
 	const marker = await readActiveMarker(projectPath);
 	const manifest = await readManifest(projectPath);
 	if (!marker || !manifest.profiles[marker.profile]) return false;
-	await assertNoTrackedWriteTargets(projectPath);
 	await assertLiveFilesParse(projectPath);
 	const rendered = await renderProfile(manifest, marker.profile, projectPath);
 	const files = await writeRenderedFiles(rendered, projectPath);