magus-cli 7.5.0 → 7.5.2

package/src/services/profile-absorb.ts

@@ -61,6 +61,8 @@ import {
 	type ActivateOptions,
 	activateProfile,
 	activationNotes,
+	activeWritableSkillFolders,
+	writeRefusal,
 } from "./profile-activate.js";
 import {
 	type ActiveMarker,
@@ -169,12 +171,22 @@ function setOrDelete<K extends "plugins" | "settings" | "mcpServers">(
  * `otherPluginIds` are the plugins other profiles enable — rendering writes
  * those as `false` in this profile on its own, so a `false` for one of them
  * says nothing new.
+ *
+ * `derived` are the plugins the render enables because one of the entry's
+ * plugins depends on them. A `true` for one equals the render, so it is not
+ * an edit and never becomes a member: dependencies are derived, not recorded.
+ * Only a `false` the render could not have written — for a dependency no
+ * other profile names — is the user turning it off, and is kept as `false`.
+ *
+ * `updatedAt` is not touched here or anywhere absorption writes: the file is
+ * committed, and a timestamp that changes with every absorbed edit is a line
+ * in every diff and a conflict between every two teammates.
  */
 export function computeAbsorb(
 	entry: ProfileManifestEntry,
 	live: LiveView,
 	otherPluginIds: ReadonlySet<string>,
-	now: string = new Date().toISOString(),
+	derived: ReadonlySet<string> = new Set(),
 ): { entry: ProfileManifestEntry; changes: AbsorbChange[] } {
 	const changes: AbsorbChange[] = [];
 	const next: ProfileManifestEntry = { ...entry };
@@ -195,6 +207,13 @@ export function computeAbsorb(
 		const liveValue = enabled[id];
 		const on = isOn(resolved.plugins?.[id]);
 		const inheritedOn = isOn(inherited.plugins?.[id]);
+		if (derived.has(id) && !on) {
+			if (liveValue === false && !otherPluginIds.has(id)) {
+				own[id] = false;
+				changes.push({ kind: "plugin-disabled", plugin: id });
+			}
+			continue;
+		}
 		if (liveValue === true && !on) {
 			// An own `false` over an inherited plugin is what kept it off.
 			if (own[id] === false && inheritedOn) delete own[id];
@@ -259,7 +278,6 @@ export function computeAbsorb(
 		changes.push({ kind: "models-changed" });
 	}
 
-	if (changes.length > 0) next.updatedAt = now;
 	return { entry: next, changes };
 }
 
@@ -539,9 +557,6 @@ export function merge3(
 		);
 		put("skills", kept.length > 0 ? kept : undefined);
 	}
-	if (!jsonEqual(local, base) && local.updatedAt) {
-		out.updatedAt = local.updatedAt;
-	}
 	return { entry: out, conflicts };
 }
 
@@ -609,17 +624,22 @@ export function refuseOnProblems(result: {
  * rendered (`marker.allPluginIds`) that `base` does not enable. The recorded
  * ids matter when a teammate removes a plugin from every profile — the live
  * `false` for it is left over from the old render, not a deliberate disable.
+ * A dependency the last render enabled (`renderedTrue`) is never one: it was
+ * written `true`, so a `false` for it is the user's, whoever else uses it.
  */
 function renderedFalseIds(
 	others: ReadonlySet<string>,
 	recorded: readonly string[] | undefined,
 	base: ProfileManifestEntry,
+	/** Dependencies the last render wrote `true` (`marker.derived`). */
+	renderedTrue: readonly string[] = [],
 ): Set<string> {
 	const out = new Set(others);
 	const enabled = resolveExtends(base).plugins ?? {};
 	for (const id of recorded ?? []) {
 		if (!isOn(enabled[id])) out.add(id);
 	}
+	for (const id of renderedTrue) out.delete(id);
 	return out;
 }
 
@@ -829,6 +849,7 @@ export async function absorbOrphanedProfile(
 		? await renderProfile(
 				{ ...manifest, profiles: { ...manifest.profiles, [orphan]: base } },
 				orphan,
+				projectPath,
 			)
 		: null;
 	const live: Record<LiveFileKey, Record<string, unknown> | null> = {
@@ -872,7 +893,12 @@ export async function absorbOrphanedProfile(
 
 	let merged: ProfileManifestEntry;
 	if (base) {
-		const local = computeAbsorb(base, view, union).entry;
+		const local = computeAbsorb(
+			base,
+			view,
+			union,
+			new Set(renderedBase?.dependencies?.derived ?? []),
+		).entry;
 		const merge = merge3(base, local, targetEntry);
 		merged = merge.entry;
 		result.conflicts.push(...merge.conflicts);
@@ -889,7 +915,6 @@ export async function absorbOrphanedProfile(
 
 	const changes = diffEntries(targetEntry, merged);
 	if (changes.length > 0) {
-		merged.updatedAt = new Date().toISOString();
 		await writeManifest(
 			{ ...manifest, profiles: { ...manifest.profiles, [target]: merged } },
 			projectPath,
@@ -970,7 +995,7 @@ export async function absorbOlderLayout(
 	if (!entry) return emptyResult(null);
 	const result = emptyResult(into);
 	const legacyHashes = await readLegacyMarkerHashes(projectPath);
-	const rendered = await renderProfile(manifest, into);
+	const rendered = await renderProfile(manifest, into, projectPath);
 	const view: Record<LiveFileKey, Record<string, unknown> | null> = {
 		settings: rendered.settings,
 		mcp: rendered.mcp,
@@ -1019,11 +1044,11 @@ export async function absorbOlderLayout(
 			models: view.models,
 		},
 		await olderRenderIds(projectPath, named, rendered.allPluginIds),
+		new Set(rendered.dependencies?.derived ?? []),
 	);
 	const next = absorbed.entry;
 	const changes = diffEntries(entry, next);
 	if (changes.length > 0) {
-		next.updatedAt = new Date().toISOString();
 		await writeManifest(
 			{ ...manifest, profiles: { ...manifest.profiles, [into]: next } },
 			projectPath,
@@ -1150,7 +1175,8 @@ function addMissing(
  * {@link absorbOlderLayout} for why nothing is removed.
  *
  *   plugins      a plugin the old file enables and the entry does not name is
- *                added ("latest"); a `false` for a plugin the entry does not
+ *                added ("latest") — unless it is in `derived`, a dependency
+ *                the render enables anyway; a `false` for a plugin the entry does not
  *                name is skipped when `renderIds` holds it (the render wrote
  *                it) and added as `false` when it does not (the user wrote
  *                it); where the old file and the entry disagree — one
@@ -1166,6 +1192,7 @@ export function absorbAdditively(
 	entry: ProfileManifestEntry,
 	old: LiveView,
 	renderIds: ReadonlySet<string>,
+	derived: ReadonlySet<string> = new Set(),
 ): { entry: ProfileManifestEntry; conflicts: string[]; keptMore: boolean } {
 	const conflicts: string[] = [];
 	const flags = { keptMore: false };
@@ -1180,7 +1207,9 @@ export function absorbAdditively(
 	for (const [id, value] of Object.entries(enabled)) {
 		const declared = resolved.plugins?.[id];
 		if (value === true) {
-			if (isOn(declared)) continue;
+			if (isOn(declared) || (derived.has(id) && declared === undefined)) {
+				continue;
+			}
 			if (declared === false) conflicts.push(`plugins.${id}`);
 			else own[id] = "latest";
 		} else if (value === false && isOn(declared)) {
@@ -1300,7 +1329,8 @@ export async function reconcileActiveProfile(
 	// teammate's change to ANOTHER profile's plugins changes which `false`
 	// entries this profile writes.
 	const definitionChanged =
-		(await renderProfile(manifest, name)).definition !== marker.definition;
+		(await renderProfile(manifest, name, projectPath)).definition !==
+		marker.definition;
 	// Whether THIS entry changed underneath the live files — the case that
 	// needs merging against `base`, and the one the message names.
 	const entryChanged =
@@ -1318,11 +1348,25 @@ export async function reconcileActiveProfile(
 
 	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;
+	}
+
 	// ── a. absorb ────────────────────────────────────────────────────────────
 	const base = marker.base ?? current;
 	const renderedBase = await renderProfile(
 		{ ...manifest, profiles: { ...manifest.profiles, [name]: base } },
 		name,
+		projectPath,
 	);
 	const live: Record<LiveFileKey, Record<string, unknown> | null> = {
 		settings: renderedBase.settings,
@@ -1345,7 +1389,11 @@ export async function reconcileActiveProfile(
 			if (key === "settings" && marker.cliBookkeeping) {
 				value = withoutCliRecords(
 					value,
-					new Set(marker.allPluginIds ?? (await allPluginIdsOf(manifest))),
+					new Set(
+						marker.cliInstallable ??
+							marker.allPluginIds ??
+							(await allPluginIdsOf(manifest)),
+					),
 					base,
 					renderedBase,
 					discarded,
@@ -1390,7 +1438,9 @@ export async function reconcileActiveProfile(
 				await otherProfilesPlugins(manifest, name),
 				marker.allPluginIds,
 				base,
+				marker.derived,
 			),
+			new Set(renderedBase.dependencies?.derived ?? []),
 		);
 		local = absorbed.entry;
 		result.changes.push(...absorbed.changes);
@@ -1408,7 +1458,7 @@ export async function reconcileActiveProfile(
 			});
 		}
 		const kept = refs.filter((r) => !released.has(skillFolder(r)));
-		local = { ...local, updatedAt: new Date().toISOString() };
+		local = { ...local };
 		if (kept.length > 0) local.skills = kept;
 		// biome-ignore lint/performance/noDelete: absent, not undefined, in profiles.json
 		else delete local.skills;
@@ -1473,7 +1523,11 @@ export async function reconcileActiveProfile(
 			}
 		}
 	} else {
-		const rendered: RenderedProfile = await renderProfile(nextManifest, name);
+		const rendered: RenderedProfile = await renderProfile(
+			nextManifest,
+			name,
+			projectPath,
+		);
 		const files: ActiveMarker["files"] = { ...marker.files };
 		for (const key of LIVE_FILE_KEYS) {
 			if (missing.includes(key)) {

package/src/services/profile-activate.ts

@@ -28,9 +28,12 @@
 
 import { lstat } from "node:fs/promises";
 import path from "node:path";
-import type { ProfileManifest, ProfileSkillRef } from "../types/index.js";
+import type {
+	DependencyReport,
+	ProfileManifest,
+	ProfileSkillRef,
+} from "../types/index.js";
 import { updateManagedGitignoreBlock } from "./conventions-manager.js";
-import { isTrackedByGit } from "./git-worktree.js";
 import { readManifest } from "./manifest.js";
 import {
 	type ActiveMarker,
@@ -48,6 +51,7 @@ import {
 	hasCurrentMarker,
 	liveKind,
 	livePath,
+	machineLocalSettings,
 	markerFor,
 	oldLayoutProfile,
 	readActiveMarker,
@@ -56,7 +60,7 @@ import {
 	writeLiveFile,
 	writeRenderedFiles,
 } from "./profile-live.js";
-import { renderProfile } from "./profile-render.js";
+import { describeDependencies, renderProfile } from "./profile-render.js";
 import {
 	type LegacySkillConversion,
 	SkillClashError,
@@ -70,6 +74,12 @@ import {
 	syncSkills,
 	updateSkillIgnoreLines,
 } from "./profile-skills.js";
+import {
+	LiveFileRefusal,
+	TrackedLiveFileError,
+	trackedPaths,
+	untrackCommand,
+} from "./tracked-live-files.js";
 import type { ApplyReporter } from "./update-engine.js";
 
 export interface ActivationResult {
@@ -87,6 +97,10 @@ export interface ActivationResult {
 	keptAt: string | null;
 	/** Unsaved changes added to a profile before activating, one line each. */
 	absorbed?: string[];
+	/** What the profile's plugins depend on — see `describeDependencies`. */
+	dependencies?: DependencyReport;
+	/** Listed skills whose folder the team committed: that copy is used. */
+	committedSkills?: string[];
 }
 
 export interface ActivateOptions {
@@ -109,37 +123,133 @@ export function reportDisplaced(
 }
 
 /**
- * Generated paths that git tracks. A .gitignore entry does not untrack a file
- * that was committed before it, so each one is reported with the fix. magus
- * never runs `git rm` itself.
+ * 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.
+ */
+export async function trackedWriteTargets(
+	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();
+	} catch {
+		// 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[]> {
-	const out: string[] = [];
-	for (const abs of generatedPaths(projectPath)) {
-		const rel = path.relative(projectPath, abs);
-		// `.claude/skills` holds committed custom skills by design; only a
-		// tracked symlink there is generated state.
-		if (rel === path.join(".claude", "skills")) {
-			if (await isTrackedByGit(projectPath, rel)) {
-				try {
-					if ((await lstat(abs)).isSymbolicLink()) out.push(rel);
-				} catch {
-					// Deleted in the working tree but still tracked as a link.
-					out.push(rel);
-				}
-			}
-			continue;
+	return trackedWriteTargets(projectPath);
+}
+
+/**
+ * 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.
+ */
+export async function writableSkillFolders(
+	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);
 		}
-		if (await isTrackedByGit(projectPath, rel)) out.push(rel);
 	}
-	return out;
+	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(
+		projectPath,
+		manifest.profiles[marker.profile]?.skills ?? [],
+		marker.skills,
+	);
 }
 
-/** How to untrack one generated path. */
-export function untrackCommand(rel: string): string {
-	return `git rm --cached ${rel}`;
+/**
+ * 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);
 }
 
 /**
@@ -147,7 +257,10 @@ export function untrackCommand(rel: string): string {
  * both the terminal and the TUI's outcome modal.
  */
 export function activationNotes(result: ActivationResult): string[] {
-	const lines: string[] = [...(result.absorbed ?? [])];
+	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)`,
@@ -161,6 +274,11 @@ 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.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`,
@@ -177,8 +295,10 @@ export function activationNotes(result: ActivationResult): string[] {
 /**
  * Render `profileId` from `manifest` and make it the active profile.
  *
- * Throws `SettingsParseError`, having changed nothing, when a live file of a
- * managed project does not parse. Throws {@link SkillClashError} — having
+ * 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
+ * {@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.
  */
@@ -189,12 +309,17 @@ export async function activateProfile(
 	opts: ActivateOptions = {},
 ): Promise<ActivationResult> {
 	const onDisplace = opts.onDisplace ?? reportDisplaced(projectPath);
-	const rendered = await renderProfile(manifest, profileId);
+	const rendered = await renderProfile(manifest, profileId, projectPath);
 	const skillRefs = rendered.entry.skills ?? [];
 
 	// 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
@@ -206,7 +331,18 @@ export async function activateProfile(
 		...conversion.managed,
 	};
 
-	const clashes = await findSkillClashes(skillRefs, managedBefore, projectPath);
+	// 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.
+	const committedSkills = await committedSkillFolders(
+		projectPath,
+		skillRefs.filter((ref) => !(skillFolder(ref) in managedBefore)),
+	);
+	const clashes = await findSkillClashes(
+		skillRefs,
+		managedBefore,
+		projectPath,
+		committedSkills,
+	);
 	if (clashes.length > 0) throw new SkillClashError(profileId, clashes);
 
 	await updateManagedGitignoreBlock(
@@ -224,6 +360,10 @@ export async function activateProfile(
 	const backupDir = path.join(backupRoot(projectPath), backupStamp());
 	const displaced: DisplacedArtifact[] = [];
 	const files: ActiveMarker["files"] = {};
+	// Read BEFORE a first adoption moves the file to a backup: this machine's
+	// `installedPluginVersions` must reach the new settings.json, and after the
+	// move there is nothing at the live path to read it from.
+	const carried = await machineLocalSettings(projectPath);
 	for (const key of LIVE_FILE_KEYS) {
 		// First adoption only: nothing marks this project as magus's and it is
 		// not an older magus layout, so a real file here is somebody's.
@@ -238,7 +378,7 @@ export async function activateProfile(
 				onDisplace(moved);
 			}
 		}
-		const hash = await writeLiveFile(key, rendered[key], projectPath);
+		const hash = await writeLiveFile(key, rendered[key], projectPath, carried);
 		if (hash) files[key] = hash;
 		// Recorded after EACH file, so a throw on the next cannot leave a file
 		// magus just wrote looking like an edit to absorb.
@@ -253,6 +393,7 @@ export async function activateProfile(
 		managedBefore,
 		projectPath,
 		opts.installSkill ?? installProfileSkill,
+		committedSkills,
 	);
 	await updateSkillIgnoreLines(
 		projectPath,
@@ -275,6 +416,10 @@ export async function activateProfile(
 		keptAt: conversion.keptAt
 			? path.relative(projectPath, conversion.keptAt)
 			: null,
+		...(rendered.dependencies ? { dependencies: rendered.dependencies } : {}),
+		...(committedSkills.size > 0
+			? { committedSkills: [...committedSkills].sort() }
+			: {}),
 	};
 }
 
@@ -300,8 +445,9 @@ 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);
+	const rendered = await renderProfile(manifest, marker.profile, projectPath);
 	const files = await writeRenderedFiles(rendered, projectPath);
 	await writeActiveMarker(
 		markerFor(marker.profile, rendered, files, marker.skills),