magus-cli 7.5.1 → 7.5.3

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 ─────────────────────────────────────────────────────────────────
 
@@ -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;

package/src/services/profile-activate.ts

@@ -75,10 +75,10 @@ import {
 	updateSkillIgnoreLines,
 } from "./profile-skills.js";
 import {
-	LiveFileRefusal,
-	TrackedLiveFileError,
+	GitCheckError,
 	trackedPaths,
-	untrackCommand,
+	trackedSkillFolders,
+	trackedWarning,
 } from "./tracked-live-files.js";
 import type { ApplyReporter } from "./update-engine.js";
 
@@ -91,8 +91,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 +105,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 {
@@ -123,20 +132,19 @@ export function reportDisplaced(
 }
 
 /**
- * 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,112 +152,44 @@ 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));
-}
-
-/**
- * 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.
- */
-export async function committedSkillFolders(
-	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))));
-}
-
-/** {@link trackedWriteTargets} for the live files alone — what doctor reports. */
-export async function trackedGeneratedFiles(
-	projectPath: string,
-): Promise<string[]> {
-	return trackedWriteTargets(projectPath);
+	const tracked = await trackedPaths(projectPath, files);
+	return files.filter((c) => tracked.has(c));
 }
 
 /**
- * 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.
+ * {@link trackedGeneratedFiles} as the warning lines the CLI prints: one per
+ * tracked path, or one saying git could not be asked.
  */
-export async function writableSkillFolders(
+export async function trackedGeneratedWarnings(
 	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));
+	try {
+		return (await trackedGeneratedFiles(projectPath)).map(trackedWarning);
+	} catch (error) {
+		if (error instanceof GitCheckError) return [error.message];
+		throw error;
 	}
-	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.
+ * 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 activeWritableSkillFolders(
+export async function committedSkillFolders(
 	projectPath: string,
-	manifest: ProfileManifest,
-): Promise<string[]> {
-	const marker = await readActiveMarker(projectPath);
-	if (!marker) return [];
-	return writableSkillFolders(
+	skills: readonly ProfileSkillRef[],
+): 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`;
 }
 
 /**
@@ -274,16 +214,16 @@ 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 (typeof result.tracked === "string") lines.push(result.tracked);
+	else lines.push(...result.tracked.map(trackedWarning));
 	if (result.keptAt) {
 		lines.push(
 			`The older layout's .claude/_profiles/ was kept at ${result.keptAt}/`,
@@ -295,9 +235,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 +256,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 +344,7 @@ export async function activateProfile(
 	);
 	await updateSkillIgnoreLines(
 		projectPath,
-		Object.keys(managedBefore),
+		Object.keys(recorded),
 		Object.keys(skills.skills),
 	);
 	await writeActiveMarker(
@@ -412,7 +359,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 +372,9 @@ export async function activateProfile(
 		...(committedSkills.size > 0
 			? { committedSkills: [...committedSkills].sort() }
 			: {}),
+		...(committedRecorded.size > 0
+			? { releasedCommitted: [...committedRecorded].sort() }
+			: {}),
 	};
 }
 
@@ -445,7 +400,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);

package/src/services/profile-state.ts

@@ -41,10 +41,6 @@ import {
 	type ProfileChoice,
 	activateProfile,
 	activationNotes,
-	activeWritableSkillFolders,
-	assertNoTrackedWriteTargets,
-	writableSkillFolders,
-	writeRefusal,
 } from "./profile-activate.js";
 import { adoptCurrentProject } from "./profile-adopt.js";
 import {
@@ -73,7 +69,6 @@ import {
 	skillFolder,
 } from "./profile-skills.js";
 import type { SettingsParseError } from "./settings-file.js";
-import type { LiveFileRefusal } from "./tracked-live-files.js";
 
 export type ActiveProfileCheck =
 	| { state: "no-profiles" }
@@ -304,11 +299,6 @@ export interface ProfileStatePrep {
 	problems: string[];
 	/** The files behind `problems` that could not be parsed. */
 	unreadable: SettingsParseError[];
-	/**
-	 * Set when a file magus would write is tracked by git, or git could not
-	 * say: nothing ran, and `problems` holds its message.
-	 */
-	refusal?: LiveFileRefusal;
 }
 
 /**
@@ -322,27 +312,6 @@ export async function prepareProfileState(
 	projectPath: string,
 	opts: Pick<ActivateOptions, "installSkill"> = {},
 ): Promise<ProfileStatePrep> {
-	// A project with profiles whose live files — or the active profile's
-	// magus-installed skill folders — git tracks: every path below would write
-	// one of them (or the marker, or the manifest on the way), so nothing runs,
-	// not even the marker a unique match would restore.
-	const manifest = await readManifest(projectPath);
-	if (Object.keys(manifest.profiles).length > 0) {
-		const refusal = await writeRefusal(
-			projectPath,
-			await activeWritableSkillFolders(projectPath, manifest),
-		);
-		if (refusal) {
-			return {
-				check: await checkActiveProfile(projectPath, { restore: false }),
-				reconcile: null,
-				lines: [],
-				problems: [refusal.message],
-				unreadable: [],
-				refusal,
-			};
-		}
-	}
 	const check = await checkActiveProfile(projectPath);
 	const out: ProfileStatePrep = {
 		check,
@@ -524,22 +493,6 @@ export async function switchToProfile(
 		);
 		return result;
 	}
-	// Before the absorbs below write profiles.json: nothing at all is written
-	// when a live file this switch would write is tracked by git.
-	const marker = await readActiveMarker(projectPath);
-	const refusal = await writeRefusal(projectPath, [
-		...(await writableSkillFolders(
-			projectPath,
-			target.skills ?? [],
-			marker?.skills,
-		)),
-		...(await activeWritableSkillFolders(projectPath, before)),
-	]);
-	if (refusal) {
-		result.problems.push(refusal.message);
-		return result;
-	}
-
 	if (!take(await absorbBeforeConversion(projectPath, name))) return result;
 	const installSkill = { installSkill: opts.installSkill };
 	if (!take(await reconcileActiveProfile(projectPath, installSkill))) {
@@ -580,20 +533,6 @@ export async function applyProfileChoice(
 	projectPath: string,
 	opts: ActivateOptions = {},
 ): Promise<ActivationResult> {
-	// Nothing is written — not the adopted manifest, not an absorbed edit —
-	// when a live file this choice would write is tracked by git.
-	const skills =
-		choice.kind === "activate"
-			? (manifest.profiles[choice.id]?.skills ?? [])
-			: [];
-	await assertNoTrackedWriteTargets(
-		projectPath,
-		await writableSkillFolders(
-			projectPath,
-			skills,
-			(await readActiveMarker(projectPath))?.skills,
-		),
-	);
 	if (choice.kind === "activate") {
 		const absorbed: string[] = [];
 		let changed = false;
@@ -635,7 +574,6 @@ export async function prepareProfileWrite(
 	projectPath: string,
 ): Promise<ProfileStatePrep> {
 	const prep = await prepareProfileState(projectPath);
-	if (prep.refusal) throw prep.refusal;
 	refuseOnProblems(prep);
 	return prep;
 }