magus-cli 7.5.2 → 7.5.4

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}`

package/src/services/update-plan.ts

@@ -34,7 +34,11 @@ import type { PluginScope } from "./claude-cli.js";
 import {
 	type PluginInfo,
 	compareVersions,
+	filesMissingScopes,
+	highestInstalledVersion,
+	installedScopeVersions,
 	isBehind,
+	isInstalledAnywhere,
 	isRepairablyBehind,
 } from "./plugin-manager.js";
 import {
@@ -48,7 +52,7 @@ import {
 // ── Plugins ──────────────────────────────────────────────────────────────────
 
 export type PluginUpdateAction =
-	/** Declared by the profile, installed nowhere. */
+	/** Declared by the profile and installed nowhere, or installed with its files missing. */
 	| "install"
 	/** Installed at a version other than the one we should be on. */
 	| "update"
@@ -83,8 +87,8 @@ export type PluginUpdateAction =
 export type PluginReason =
 	/** install: declared by the profile, installed nowhere. */
 	| "absent"
-	/** install: enabled in a settings file, but no registry row in any scope. */
-	| "enabled-not-installed"
+	/** install: installed at a scope, but no version resolves at any installed scope. */
+	| "files-missing"
 	/** unknown: a marketplace we READ does not list it. */
 	| "not-offered"
 	/** unknown: installed, unlisted, and its marketplace contributed no listed ids. */
@@ -127,7 +131,11 @@ export interface PluginUpdateItem {
 	action: PluginUpdateAction;
 	/** Why it is in this state. */
 	reason: PluginReason;
-	/** Scopes holding an install this action must touch. Empty for a fresh install. */
+	/**
+	 * Scopes holding an install this action must touch — for `files-missing`, the
+	 * scopes installed with no version. Empty for an `absent` install, which the
+	 * engine puts at project scope.
+	 */
 	scopes: PluginScope[];
 	/**
 	 * The version installed in each scope BEFORE any work, so an apply can tell
@@ -141,44 +149,12 @@ export interface PluginUpdateItem {
 	note?: string;
 }
 
-/** Scope → installed version, for the three scopes a PluginInfo carries. */
-function scopeVersions(
-	info: PluginInfo | undefined,
-): Array<[PluginScope, string]> {
-	if (!info) return [];
-	const out: Array<[PluginScope, string]> = [];
-	for (const [scope, status] of [
-		["user", info.userScope],
-		["project", info.projectScope],
-		["local", info.localScope],
-	] as const) {
-		if (status?.version) out.push([scope, status.version]);
-	}
-	return out;
-}
-
-/**
- * The highest version installed across scopes, or null.
- *
- * `compareVersions` answers null for an unorderable pair, and null is not
- * `>= 0`, so the reduce keeps the right-hand side when two versions cannot be
- * ranked. "Highest" is not meaningful across commit ids; picking one
- * deterministically is, and every caller only needs *an* installed version.
- */
-function highestInstalled(info: PluginInfo | undefined): string | null {
-	const versions = scopeVersions(info).map(([, v]) => v);
-	if (versions.length === 0) return null;
-	return versions.reduce((a, b) =>
-		(compareVersions(a, b) ?? -1) >= 0 ? a : b,
-	);
-}
-
 /**
  * The highest installed version THE PIN PERMITS — the ceiling a stale-load
  * repair may aim at. Null when no installed version qualifies.
  *
- * Under "latest" that is simply {@link highestInstalled}: nothing caps it, and
- * the newest version on this machine is the one to converge on.
+ * Under "latest" that is simply {@link highestInstalledVersion}: nothing caps
+ * it, and the newest version on this machine is the one to converge on.
  *
  * Under an EXACT pin it is the highest installed version at or below the pin.
  * `installed` reaches across every scope and `scopesNeeding` never downgrades, so
@@ -196,8 +172,8 @@ function highestPermittedInstalled(
 	info: PluginInfo | undefined,
 	pin: string,
 ): string | null {
-	if (pin === "latest") return highestInstalled(info);
-	const permitted = scopeVersions(info)
+	if (pin === "latest") return highestInstalledVersion(info);
+	const permitted = installedScopeVersions(info)
 		.map(([, v]) => v)
 		// pin >= v, i.e. v is at or below the pin. Null (unorderable) fails this.
 		.filter((v) => (compareVersions(pin, v) ?? -1) >= 0);
@@ -238,7 +214,7 @@ export function scopesNeeding(
 	// A raw `compareVersions(...) > 0` reported false for that pair and the
 	// scope was silently left alone. An unknown (null) is still left alone —
 	// moving a scope we cannot rank would be a guess.
-	return scopeVersions(info)
+	return installedScopeVersions(info)
 		.filter(([, version]) => isBehind(target, version) === true)
 		.map(([scope]) => scope);
 }
@@ -255,11 +231,11 @@ function marketplaceSuffix(id: string): string | null {
  * The catalog, indexed for the questions the classifier asks of it.
  *
  * "Listed" is narrower than "present". `getAvailablePlugins` puts ORPHANS —
- * installed or enabled, but published by no marketplace we read — into the same
- * list with `isOrphaned: true`, so a plain `has(id)` is true for a plugin that
- * nothing publishes. Treating an orphan as listed is what let an orphan plan as
- * `current`: its `version` is filled in from its own installed version, so the
- * compare found them equal.
+ * in this project's settings or registry, but published by no marketplace we
+ * read — into the same list with `isOrphaned: true`, so a plain `has(id)` is
+ * true for a plugin that nothing publishes. Treating an orphan as listed is
+ * what let an orphan plan as `current`: its `version` is filled in from its own
+ * installed version, so the compare found them equal.
  */
 export interface CatalogIndex {
 	get(pluginId: string): PluginInfo | undefined;
@@ -306,15 +282,6 @@ export function indexCatalog(
 	};
 }
 
-/** True when a settings file enables the plugin in at least one scope. */
-function enabledAnywhere(info: PluginInfo | undefined): boolean {
-	return (
-		!!info?.userScope?.enabled ||
-		!!info?.projectScope?.enabled ||
-		!!info?.localScope?.enabled
-	);
-}
-
 /**
  * THE plugin classifier. Pure.
  *
@@ -332,7 +299,7 @@ export function classifyPlugin(
 ): PluginUpdateItem {
 	const info = index.get(pluginId);
 	const listed = index.isListed(pluginId);
-	const installed = highestInstalled(info);
+	const installed = highestInstalledVersion(info);
 	// An orphan's `version` is its own installed version (or a stale local
 	// clone's), not something a marketplace we read offers — so it is not
 	// "available" from anywhere.
@@ -344,7 +311,7 @@ export function classifyPlugin(
 		installed,
 		loaded: info?.loadedVersion ?? null,
 		available,
-		beforeVersions: Object.fromEntries(scopeVersions(info)) as Partial<
+		beforeVersions: Object.fromEntries(installedScopeVersions(info)) as Partial<
 			Record<PluginScope, string>
 		>,
 	};
@@ -388,24 +355,29 @@ export function classifyPlugin(
 		};
 	}
 
-	// Not installed anywhere — the "checked but not installed" case.
+	// No installed scope has a version — the "checked but not installed" case.
 	//
-	// Nothing is installed in any scope here, so "enabled somewhere" is exactly
-	// "enabled but not installed". It is tested directly rather than through
-	// `isEnabledButNotInstalled`, which excludes orphans: an orphan that is only
-	// a settings key would otherwise read as `absent`, and the TUI renders
-	// `absent` as "the profile declares it", which an undeclared orphan does not.
+	// So a scope that IS installed here has its files missing. It is tested
+	// directly rather than through `hasMissingFiles`, which excludes orphans: an
+	// orphan that is only a settings key would otherwise read as `absent`, and the
+	// TUI renders `absent` as "the profile declares it", which an undeclared
+	// orphan does not.
+	//
+	// Files missing carries the scopes to reinstall at: exactly the ones installed
+	// with no version. It used to carry none, and the engine read "install" as
+	// "project scope" — so a user-scope plugin with its files missing was
+	// reinstalled at project scope, turning it on in the team's settings.json.
+	// `absent` still carries none: the engine installs it at project scope.
 	if (!installed) {
-		const brokenEnable = enabledAnywhere(info);
+		const missingAt = filesMissingScopes(info);
+		const filesMissing = missingAt.length > 0;
 		return {
 			...base,
 			target: pin === "latest" ? available : pin,
 			action: "install",
-			reason: brokenEnable ? "enabled-not-installed" : "absent",
-			scopes: [],
-			...(brokenEnable
-				? { note: "enabled in settings, but no files on disk" }
-				: {}),
+			reason: filesMissing ? "files-missing" : "absent",
+			scopes: missingAt,
+			...(filesMissing ? { note: "files missing" } : {}),
 		};
 	}
 
@@ -622,7 +594,7 @@ export function classifyPlugin(
 			target: installed,
 			action: "repair",
 			reason: "content-stale",
-			scopes: scopeVersions(info).map(([scope]) => scope),
+			scopes: installedScopeVersions(info).map(([scope]) => scope),
 			note: "files changed without a version bump",
 		};
 	}
@@ -669,17 +641,38 @@ export function classifyPlugin(
 }
 
 /**
- * Decide what to do with every plugin the profile declares.
+ * THE plugin plan — for `magus update` and the Plugins screen alike.
+ *
+ * Every plugin the active profile declares, under its pin, and every plugin
+ * installed in any scope (user, project, local), under "latest" — the rule
+ * {@link pinForRow} states — each classified by {@link classifyPlugin}, sorted.
+ *
+ * ONE list, read by both surfaces: the screen's rows, header counts and
+ * "update all", and the CLI's report and apply. It used to be two — the CLI
+ * planned the profile's plugins only, the screen every installed plugin — so a
+ * USER-scope plugin the screen showed as "update available" was never seen by
+ * `magus update`, which then reported everything up to date. The owner asked
+ * for "absolutely the same code" on both sides; this is it.
  *
  * @param pinned  closure.plugins — pluginId -> exact version | "latest"
- * @param catalog getAvailablePlugins() output, keyed by plugin id
+ * @param catalog getAvailablePlugins() output — keyed by id, or as a list
  */
 export function planPluginUpdates(
-	pinned: Record<string, string>,
-	catalog: Map<string, PluginInfo>,
+	pinned: Readonly<Record<string, string>>,
+	catalog: ReadonlyMap<string, PluginInfo> | readonly PluginInfo[],
 ): PluginUpdateItem[] {
 	const index = indexCatalog(catalog);
-	return Object.entries(pinned)
+	const plugins =
+		catalog instanceof Map
+			? [...catalog.values()]
+			: (catalog as readonly PluginInfo[]);
+	const pins = new Map(Object.entries(pinned));
+	for (const info of plugins) {
+		if (pins.has(info.id)) continue;
+		const pin = pinForRow(info, pinned);
+		if (pin !== null) pins.set(info.id, pin);
+	}
+	return [...pins]
 		.map(([pluginId, pin]) => classifyPlugin(pluginId, pin, index))
 		.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 }
@@ -689,45 +682,36 @@ export function planPluginUpdates(
  *
  * 1. The active profile's pin, when it declares the plugin — the SAME value
  *    `magus update` plans with, which is what makes the two agree.
- * 2. Otherwise "latest", when the plugin is installed in any scope or enabled
- *    in one — what the TUI's own update actions have always planned with, so
- *    the row and the action agree.
+ * 2. Otherwise "latest", when the plugin is installed in any scope, files
+ *    missing included — what the TUI's own update actions have always planned
+ *    with, so the row and the action agree.
  * 3. Otherwise null: an undeclared catalog entry the user is only browsing. It
  *    gets no status at all. `install` means "the profile wants it", and an
  *    undeclared plugin carries no such claim.
  *
  * A consequence the renderer relies on: reason `absent` can only come from
- * rule 1, because rule 2 never assigns a pin to a row that is neither installed
- * nor enabled.
+ * rule 1, because rule 2 never assigns a pin to a row that is not installed.
  */
 export function pinForRow(
 	info: PluginInfo,
 	pins: Readonly<Record<string, string>>,
 ): string | null {
 	if (Object.hasOwn(pins, info.id)) return pins[info.id] ?? null;
-	if (scopeVersions(info).length > 0 || enabledAnywhere(info)) return "latest";
+	if (isInstalledAnywhere(info)) return "latest";
 	return null;
 }
 
 /**
- * One status per row that has a pin. Rows whose {@link pinForRow} is null are
- * absent from the map.
- *
- * Computed once per data/pins change, and the same map feeds every consumer —
- * so the row, the detail panel, the header and the scope picker cannot disagree.
+ * {@link planPluginUpdates} keyed by plugin id, for the screen's lookups — the
+ * SAME plan `magus update` runs, not a second classification. Computed once
+ * per data/pins change, and the one map feeds the row, the detail panel, the
+ * header and the scope picker, so none of them can disagree.
  */
 export function classifyPluginRows(
 	plugins: readonly PluginInfo[],
 	pins: Readonly<Record<string, string>>,
 ): Map<string, PluginUpdateItem> {
-	const index = indexCatalog(plugins);
-	const out = new Map<string, PluginUpdateItem>();
-	for (const info of plugins) {
-		const pin = pinForRow(info, pins);
-		if (pin === null) continue;
-		out.set(info.id, classifyPlugin(info.id, pin, index));
-	}
-	return out;
+	return new Map(planPluginUpdates(pins, plugins).map((i) => [i.pluginId, i]));
 }
 
 export interface PluginStateCounts {

package/src/ui/App.tsx

@@ -7,10 +7,13 @@ import {
 	recoverMarketplaceSettings,
 	repairAllStaleLoads,
 } from "../services/claude-settings.js";
-import { checkGitignore } from "../services/gitignore-check.js";
 import {
-	applyAllSafeFixes,
-	loadGitignoreState,
+	type StartupGitignoreNeed,
+	startupGitignoreNeed,
+} from "../services/gitignore-check.js";
+import {
+	applyStartupFixes,
+	describeStartupFix,
 } from "../services/gitignore-service.js";
 import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
@@ -261,10 +264,8 @@ function AppContent({ onExit }: AppContentProps) {
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
 	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
 	const [profileNotices, setProfileNotices] = useState<string[]>([]);
-	const [gitignoreData, setGitignoreData] = useState<{
-		violationCount: number;
-		safeCount: number;
-	} | null>(null);
+	const [gitignoreData, setGitignoreData] =
+		useState<StartupGitignoreNeed | null>(null);
 	const [profileNeed, setProfileNeed] = useState<ProfileStartupNeed | null>(
 		null,
 	);
@@ -273,9 +274,22 @@ function AppContent({ onExit }: AppContentProps) {
 		null,
 	);
 	const staleLoadModal = useStaleLoadModal();
+	// The gitignore question, asked fresh: on every open, and again once the
+	// profile modal has activated a profile — a first adoption is what turns a
+	// committed settings.json into a generated file git should not track.
+	// Nothing remembers an earlier answer.
+	const checkGitignoreNow = React.useCallback(() => {
+		startupGitignoreNeed(process.cwd())
+			.then((need) => {
+				if (need) setGitignoreData(need);
+			})
+			.catch(() => {
+				// non-fatal: the Git State tab still shows the same rows
+			});
+	}, []);
 	// The profile modal cannot be dismissed, so it needs the app's own exit: its
 	// only non-action is to leave.
-	const profileModal = useProfileStartupModal(onExit);
+	const profileModal = useProfileStartupModal(onExit, checkGitignoreNow);
 
 	// Check for updates on startup, then re-check periodically (force-bypassing
 	// the session cache) so the banner reflects a release that lands while
@@ -318,10 +332,11 @@ function AppContent({ onExit }: AppContentProps) {
 		gitignoreModal.show({
 			violationCount: gitignoreData.violationCount,
 			safeCount: gitignoreData.safeCount,
-			onFixSafe: async () => {
-				const s = await loadGitignoreState(state.projectPath);
-				await applyAllSafeFixes(state.projectPath, s.violations);
-			},
+			generated: gitignoreData.generated,
+			// In place, then back to the app: tracked generated files are
+			// untracked, missing entries added; other items stay for the tab.
+			onFixSafe: async () =>
+				describeStartupFix(await applyStartupFixes(state.projectPath)),
 		});
 		setGitignoreData(null);
 	}, [gitignoreData, gitignoreModal, state.modal, state.projectPath]);
@@ -389,6 +404,13 @@ function AppContent({ onExit }: AppContentProps) {
 		setProfileNeed(null);
 	}, [profileNeed, profileModal, state.modal]);
 
+	// The gitignore question on every open. Its own effect, NOT part of the
+	// marketplace block below, which returns early on `--no-refresh`: that flag
+	// is about network calls and must not silence this question.
+	useEffect(() => {
+		checkGitignoreNow();
+	}, [checkGitignoreNow]);
+
 	// Is this project actually running a profile? Detection only — nothing is
 	// written until the user picks something in the modal. The Profiles tab could
 	// list two profiles while the project ran neither, and nothing anywhere said
@@ -405,8 +427,13 @@ function AppContent({ onExit }: AppContentProps) {
 				// edits into the active profile, regenerate from a changed
 				// profiles.json, restore a lost marker — then the question, if one
 				// is left to ask.
-				const { need, notices } = await prepareProfileStartup(process.cwd());
-				if (notices.length > 0) setProfileNotices(notices);
+				const { need, notices, problems } = await prepareProfileStartup(
+					process.cwd(),
+				);
+				// A refusal never blocks the TUI at startup: it is shown beside what
+				// the gate did, and the user is still asked whatever is left.
+				const shown = [...notices, ...problems];
+				if (shown.length > 0) setProfileNotices(shown);
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
@@ -470,27 +497,6 @@ function AppContent({ onExit }: AppContentProps) {
 			})
 			.catch(() => {}); // non-fatal
 
-		// Check for gitignore manifest violations and surface a popup if any.
-		// Loads twice (once for count, once when user picks "fix safe") because
-		// the second load happens after edits — keeps detection cheap on startup.
-		(async () => {
-			try {
-				const result = await checkGitignore(process.cwd());
-				if (result.violationCount > 0) {
-					const s = await loadGitignoreState(process.cwd());
-					const safeCount = s.violations.filter(
-						(v) => v.severity === "safe",
-					).length;
-					setGitignoreData({
-						violationCount: result.violationCount,
-						safeCount,
-					});
-				}
-			} catch {
-				// non-fatal
-			}
-		})();
-
 		repairAllMarketplaces()
 			.then(async () => {
 				dispatch({ type: "HIDE_PROGRESS" });

package/src/ui/adapters/pluginsAdapter.ts

@@ -43,7 +43,7 @@ export interface PluginPluginItem {
 	/**
 	 * The classifier's answer for this plugin — the same item `magus update`
 	 * plans with. Null for a catalog entry the user is only browsing (neither
-	 * declared by the profile, installed, nor enabled): it has no state to claim.
+	 * declared by the profile nor installed): it has no state to claim.
 	 */
 	status: PluginUpdateItem | null;
 }

package/src/ui/components/primitives/ScopeSquares.tsx

@@ -8,23 +8,28 @@ interface ScopeSquaresProps {
 	selected?: boolean;
 }
 
-/** Installed at that scope. */
+/** On at that scope. */
 export const SCOPE_ON = "■";
-/** Not installed at that scope. */
+/** Not on at that scope. */
 export const SCOPE_OFF = "□";
 
 /**
  * Scope bar: three positional squares, user / project / local.
  *
  * POSITION names the scope — the first square is always user, the second
- * project, the third local — and SHAPE says the state: `■` installed, `□` not.
- * That reads with no colour at all, which the bar never used to: every square
+ * project, the third local — and SHAPE says the state: `■` on, `□` not. "On"
+ * is the caller's to decide, and for a plugin and a skill alike it is
+ * installed. For a plugin that is `isInstalledInScope` — the scope's settings
+ * file turns it on, which is what Claude Code loads by — the same function the
+ * detail panel's dot reads, so the two cannot disagree.
+ *
+ * The shape reads with no colour at all, which the bar never used to: every square
  * was the same filled block, lit in a scope hue or unlit in a fill near the
  * page, so on a monochrome terminal, to a colour-blind reader, or on a theme
  * that drew two hues alike, all three states were one shape.
  *
  * Colour now only repeats what the shape says. A filled square wears `success`
- * (installed is what it means, on every screen); a hollow one wears `muted`,
+ * (on is what it means, on every screen); a hollow one wears `muted`,
  * which a thin outline needs to stay visible — the shape, not a pale fill, is
  * what makes it recede. On a selected row the selection owns the colour
  * channel: filled squares take its ink, hollow ones its dim ink.