magus-cli 7.4.0 → 7.5.0

package/src/cli/profile.ts

@@ -1,29 +1,31 @@
 /**
- * `magus profile <list|show|switch|sync> [name]`
+ * `magus profile <list|show|switch|init> [name]`
  *
- * Inspect and switch between team profiles materialized under
- * `.claude/_profiles/`. Switching is cheap and offline — it just repoints the
- * shared-config symlinks. `sync` (Phase 5) promotes local drift back into the
- * committed manifest.
+ * Inspect and switch between the team profiles in `.claude/profiles.json`.
+ * Switching renders the chosen profile's settings.json, .mcp.json and
+ * models.json and installs its skills; anything Claude Code wrote into the
+ * live config first goes into the profile being left.
  */
 
-import path from "node:path";
-import fs from "fs-extra";
-import { ensureGitignoreEntries } from "../services/conventions-manager.js";
 import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
 import { summarizeClosure } from "../services/install-plan.js";
 import { getManifestPath, readManifest } from "../services/manifest.js";
 import { reportDisplaced } from "../services/profile-activate.js";
-import { syncProfile } from "../services/profile-sync.js";
+import { activeProfile, namedActiveProfile } from "../services/profile-live.js";
+import type { SkillInstaller } from "../services/profile-skills.js";
+import {
+	suggestedProfile,
+	switchHint,
+	switchToProfile,
+} from "../services/profile-state.js";
 import { resolveProfile } from "../services/resolver.js";
 import { SettingsParseError } from "../services/settings-file.js";
 import {
-	PROFILE_GITIGNORE_ENTRIES,
-	activateProfile,
-	activeProfile,
-	profileDir,
-} from "../services/symlink-manager.js";
-import { ensureManifest, reportUnparseable } from "./bootstrap.js";
+	ensureManifest,
+	printActivationNotes,
+	reportUnparseable,
+} from "./bootstrap.js";
+import { note as noteLine } from "./update-view.js";
 
 /**
  * Every subcommand reads `.claude/profiles.json`, and one that does not parse
@@ -58,11 +60,9 @@ async function dispatchProfileCommand(args: string[]): Promise<number> {
 				args.includes("--yes") || args.includes("-y"),
 				projectPath,
 			);
-		case "sync":
-			return syncActiveProfile(rest[0], projectPath);
 		default:
 			console.error(
-				`Unknown profile command "${sub}". Use: list | show <name> | switch <name> | init | sync`,
+				`Unknown profile command "${sub}". Use: list | show <name> | switch <name> | init`,
 			);
 			return 1;
 	}
@@ -83,7 +83,9 @@ export async function initProfile(
 		console.error(
 			`${getManifestPath(projectPath)} already defines: ${Object.keys(existing.profiles).join(", ")}`,
 		);
-		console.error("Use `magus profile sync` to promote local edits into it.");
+		console.error(
+			"Changes to the live config are recorded in the active profile automatically.",
+		);
 		return 1;
 	}
 	// `profile init` exists to create the manifest, so it is the one caller that
@@ -103,12 +105,18 @@ export async function listProfiles(projectPath: string): Promise<number> {
 	for (const id of ids) {
 		const entry = manifest.profiles[id];
 		const marker = id === active ? "●" : " ";
-		const materialized = (await fs.pathExists(profileDir(id, projectPath)))
-			? ""
-			: "  (not installed)";
-		console.log(`  ${marker} ${id} — ${entry.name}${materialized}`);
+		console.log(`  ${marker} ${id} — ${entry.name}`);
+	}
+	if (active) {
+		console.log(`\nActive: ${active}`);
+	} else {
+		const named = await namedActiveProfile(projectPath);
+		if (named) {
+			console.log(
+				`\nThe active profile is recorded as "${named.profile}", which is not defined above. Run: ${switchHint(ids, suggestedProfile(manifest))}`,
+			);
+		}
 	}
-	if (active) console.log(`\nActive: ${active}`);
 	return 0;
 }
 
@@ -137,42 +145,32 @@ export async function showProfile(
 export async function switchProfile(
 	name: string | undefined,
 	projectPath: string,
+	/** Skill installer seam; the real one fetches from GitHub. */
+	opts: { installSkill?: SkillInstaller } = {},
 ): Promise<number> {
 	if (!name) {
 		console.error("Usage: magus profile switch <name>");
 		return 1;
 	}
-	const manifest = await readManifest(projectPath);
-	if (!manifest.profiles[name]) {
-		console.error(
-			`Profile "${name}" not found. Available: ${Object.keys(manifest.profiles).join(", ")}`,
-		);
-		return 1;
-	}
-	if (!(await fs.pathExists(profileDir(name, projectPath)))) {
-		console.error(
-			`Profile "${name}" isn't installed yet. Run: magus install ${name}`,
-		);
+
+	// The one switch path, shared with the TUI's Profiles tab: edits go into
+	// the profile being LEFT (or, if it no longer exists, into this one), then
+	// this profile is rendered. A no-op absorb when the router's gate ran first.
+	const result = await switchToProfile(projectPath, name, {
+		onDisplace: reportDisplaced(projectPath),
+		installSkill: opts.installSkill,
+	});
+	for (const line of result.lines) console.log(noteLine(line));
+	if (result.problems.length > 0 || !result.activation) {
+		for (const problem of result.problems) console.error(problem);
 		return 1;
 	}
-
-	// In profile mode the source of truth is .claude/profiles.json; the
-	// generated dir AND the per-developer symlinks must stay out of git so
-	// switching profiles causes no churn.
-	await ensureGitignoreEntries(
-		path.join(projectPath, ".gitignore"),
-		PROFILE_GITIGNORE_ENTRIES,
-		"# magus: generated profile build output + active-profile symlinks",
-	);
-
-	// Switching between two already-active profiles displaces nothing — the paths
-	// are links magus owns. The FIRST switch in an unmanaged project displaces
-	// real files, and that is the run that must say so.
-	await activateProfile(name, projectPath, reportDisplaced(projectPath));
 	console.log(`✓ Switched to profile: ${name}`);
+	printActivationNotes(result.activation);
+	const manifest = await readManifest(projectPath);
 
 	// Verify the profile's binary deps are actually usable — the switch itself
-	// succeeds (symlinks are valid), but warn so "switched" isn't misleading.
+	// succeeds (the config is in place), but warn so "switched" is not misleading.
 	try {
 		const closure = await resolveProfile(manifest, name);
 		const missing = missingBinaries(await checkBinaries(closure.bins));
@@ -189,30 +187,3 @@ export async function switchProfile(
 	}
 	return 0;
 }
-
-export async function syncActiveProfile(
-	nameArg: string | undefined,
-	projectPath: string,
-): Promise<number> {
-	const name = nameArg ?? (await activeProfile(projectPath));
-	if (!name) {
-		console.error(
-			"No active profile to sync. Pass a name: magus profile sync <name>",
-		);
-		return 1;
-	}
-	try {
-		const { changes, wrote } = await syncProfile(name, projectPath);
-		if (!wrote) {
-			console.log(`Profile "${name}" is already in sync with the manifest.`);
-			return 0;
-		}
-		console.log(`Synced "${name}" → .claude/profiles.json:`);
-		for (const c of changes) console.log(`  ${c.kind}: ${c.detail}`);
-		console.log("\nReview the diff and commit .claude/profiles.json.");
-		return 0;
-	} catch (e) {
-		console.error((e as Error).message);
-		return 1;
-	}
-}

package/src/cli/router.ts

@@ -10,7 +10,7 @@ import type { ThemeMode } from "@opentui/core";
 import { SettingsParseError } from "../services/settings-file.js";
 import { checkForUpdates } from "../services/version-check.js";
 import { type ThemeEnv, parseThemeWord } from "../ui/theme-resolve.js";
-import { reportUnparseable } from "./bootstrap.js";
+import { profileGate, reportUnparseable } from "./bootstrap.js";
 import { runDoctorCommand } from "./doctor.js";
 import { runInstallCommand } from "./install.js";
 import { runModelsCommand } from "./models.js";
@@ -102,6 +102,9 @@ const SUBCOMMANDS = new Set([
 	"doctor",
 ]);
 
+/** Subcommands that read or write profile state, and so pass the gate first. */
+const PROFILE_GATED = new Set(["install", "update", "profile", "models"]);
+
 export async function route(
 	argv: string[],
 	version: string,
@@ -173,6 +176,25 @@ export async function route(
 		setThemeMode(mode);
 	}
 
+	// Every command that reads or writes profile state passes the same gate
+	// first: restore a lost marker, convert an older layout, absorb what Claude
+	// Code wrote into the live config, regenerate from a changed profiles.json.
+	// Read-only runs (`--check`, `--dry-run`) promise to write nothing, so they
+	// skip it. `doctor` runs it itself, to report what it did.
+	if (
+		command !== undefined &&
+		PROFILE_GATED.has(command) &&
+		!rest.includes("--check") &&
+		!rest.includes("--dry-run")
+	) {
+		const ok = await profileGate(process.cwd(), {
+			// Both of these fix a marker naming a missing profile by activating
+			// one that exists.
+			allowUnknown: command === "install" || command === "profile",
+		});
+		if (!ok) return HANDLED(1);
+	}
+
 	try {
 		switch (command) {
 			case "update":
@@ -227,9 +249,9 @@ without one is offered adoption on first run. See docs/team-configuration.md.
   install [profile]  Install the profile's plugins, binaries, skills and env at
                      the manifest's PINNED versions, then activate it.
                      No argument installs every profile.
-    --check          Report drift only, write nothing (exits 1 in strict mode)
+    --check          Report version mismatches only, write nothing
+                     (exits 1 in strict mode)
     --yes, -y        Skip the confirmation prompt
-    --force          Discard unsynced local edits instead of refusing
   update [profile]   Keep the ACTIVE profile current: install whatever it
                      declares but this machine lacks, and advance anything
                      behind the version its marketplace publishes. Only the
@@ -244,10 +266,14 @@ without one is offered adoption on first run. See docs/team-configuration.md.
                      missing or known to be behind — the CI gate.
   profile list       Show every profile; ● marks the active one
   profile show <n>   Print a profile's fully resolved closure
-  profile switch <n> Repoint the active profile — offline, no reinstall
+  profile switch <n> Make <n> the active profile: render its settings.json,
+                     .mcp.json and models.json, install its skills
   profile init       Write .claude/profiles.json from this project's setup
-  profile sync       Promote local edits back into .claude/profiles.json
-  doctor             Check binary deps, profile symlinks, and conventions
+
+Changes Claude Code makes to .claude/settings.json or .mcp.json (a plugin
+installed, a setting changed) are changes to the active profile: every command
+above records them in .claude/profiles.json before it acts.
+  doctor             Check binary deps, the active profile, and conventions
     --fix            Apply the repairs it can make itself
 
 Per-subagent model routing — give each subagent its own model and effort. The

package/src/cli/update.ts

@@ -48,9 +48,20 @@ import {
 	clearMarketplaceCache,
 	getAvailablePlugins,
 } from "../services/plugin-manager.js";
+import {
+	recordRefetchedSkills,
+	trackFetchedSkills,
+	updatableSkills,
+} from "../services/profile-activate.js";
+import { activeProfile } from "../services/profile-live.js";
+import { skillFolder } from "../services/profile-skills.js";
+import {
+	suggestedProfile,
+	switchHint,
+	withCliBookkeeping,
+} from "../services/profile-state.js";
 import { resolveProfile } from "../services/resolver.js";
 import { getInstalledSkillNames } from "../services/skills-manager.js";
-import { activeProfile } from "../services/symlink-manager.js";
 import { REAL_TOOL_PROBE_IO, probeTools } from "../services/tool-probe.js";
 // The apply half lives in services/ so the TUI runs the SAME code — see the
 // header of update-engine.ts for what drifted while it did not.
@@ -197,7 +208,7 @@ export async function runUpdateCommand(
 	//
 	// BOTH `--check` and `--dry-run` are read-only here. An earlier version let
 	// `--dry-run` activate, reasoning that a preview needs a real profile to
-	// report against — but activating writes symlinks and edits a TRACKED
+	// report against — but activating writes config files and edits a TRACKED
 	// `.gitignore`, and `--dry-run` promises to write nothing and exit 0. A
 	// preview that mutates the repo is not a preview.
 	//
@@ -207,7 +218,7 @@ export async function runUpdateCommand(
 	// preview result rather than an error.
 	//
 	// NAMING A PROFILE SKIPS THE GATE. `magus update lean` says which profile to
-	// update, and updating it needs the manifest, not the symlink — installs go
+	// update, and updating it needs the manifest, not the marker — installs go
 	// to project scope either way. Gating it would refuse a question the user
 	// already answered on the command line, and would break `magus update lean`
 	// and `--check lean` in CI, both of which worked before this gate existed.
@@ -254,7 +265,7 @@ export async function runUpdateCommand(
 	if (!resolvedId) {
 		console.error(
 			failLine(
-				`No active profile. Run \`magus profile switch <${profileIds.join("|")}>\`.`,
+				`No active profile. Run ${switchHint(profileIds, suggestedProfile(current))}.`,
 			),
 		);
 		return 1;
@@ -414,11 +425,18 @@ export async function runUpdateCommand(
 
 	// ---- plan ----------------------------------------------------------------
 
+	// Skills go into the live `.claude/skills/`, so only the ACTIVE profile's,
+	// and never over a custom skill folder.
+	const skillRefs = await updatableSkills(
+		projectPath,
+		targetId,
+		closure.skills,
+	);
 	const plan: UpdatePlan = {
 		profileId: targetId,
 		plugins: planPluginUpdates(closure.plugins, catalog),
 		bins: planBinUpdates(closure.bins, toolFacts),
-		skills: planSkillUpdates(closure.skills, installedSkills),
+		skills: planSkillUpdates(skillRefs, installedSkills),
 		binSpecs: new Map(closure.bins.map((b) => [b.name, b])),
 	};
 
@@ -575,9 +593,28 @@ export async function runUpdateCommand(
 	console.log("");
 	applyLive.start((tick) => applyFrame(state, tick, Date.now()));
 
-	const outcome = await applyPlan(plan, projectPath, { report: reporter });
+	// `claude plugin install --scope project` records each install in the live
+	// settings.json — for a profile that may not be the active one. The marker
+	// is flagged while that runs; in `finally` the re-fetched skill folders are
+	// recorded with their new contents, then the live config is reconciled:
+	// the user's own edits in the meantime are kept, the install's records are
+	// discarded, and an interrupted run leaves the flag for the next command.
+	const reconciledLines: string[] = [];
+	// Only the skills this run actually fetched get new hashes: one it did
+	// not fetch and someone edited meanwhile must still read as edited.
+	const skills = trackFetchedSkills(skillRefs, reporter);
+	const outcome = await withCliBookkeeping(
+		projectPath,
+		() => applyPlan(plan, projectPath, { report: skills.report }),
+		{
+			beforeReconcile: () =>
+				recordRefetchedSkills(projectPath, skills.fetched()),
+			report: (line) => reconciledLines.push(line),
+		},
+	);
 
 	applyLive.stop();
+	for (const line of reconciledLines) console.log(noteLine(line));
 
 	const { failed } = outcome;
 

package/src/data/gitignore-defaults.ts

@@ -12,9 +12,9 @@ export const BUILTIN_DEFAULTS: GitignoreManifest = {
 		".claude/scheduled_tasks.lock",
 		".claude/cache/",
 		".claude/.statusline-worktree-*",
-		// Generated, per-developer profile build output (like node_modules).
-		".claude/_profiles/",
-		// Generated from profiles.json (a symlink into _profiles/ when a profile
+		// The per-developer active-profile marker.
+		".claude/profiles/",
+		// Generated from profiles.json (rendered from the active profile when one
 		// is active). The routing itself IS committed — in profiles.json, under
 		// the profile that declares it.
 		".claude/models.json",

package/src/services/active-closure.ts

@@ -6,7 +6,7 @@
  * pick the profile in different ways — the CLI inline, the TUI not at all (it
  * judged everything against "latest") — so an exact pin could never agree.
  * Both now choose through {@link selectProfileId} over the same manifest and
- * the same active-profile symlink.
+ * the same active-profile marker.
  *
  * Read-only. Unlike the CLI's `ensureManifest`, nothing here bootstraps a
  * manifest: a screen opening must never author a file a team commits.
@@ -20,14 +20,14 @@ import type {
 	ResolvedClosure,
 } from "../types/index.js";
 import { readManifest, validateManifest } from "./manifest.js";
+import { activeProfile } from "./profile-live.js";
 import { resolveProfile } from "./resolver.js";
-import { activeProfile } from "./symlink-manager.js";
 
 /**
  * The profile to use: the explicit one, else the active one, else the only one.
  *
  * Each candidate counts only if the manifest defines it. A stale active-profile
- * symlink naming a profile that was since removed would otherwise be chosen and
+ * marker naming a profile that was since removed would otherwise be chosen and
  * then fail to resolve, even when the manifest has exactly one profile and the
  * answer is unambiguous.
  */