magus-cli 7.5.1 → 7.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.5.1",
+  "version": "7.5.2",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.5.1",
-    "magus-cli-darwin-x64": "7.5.1",
-    "magus-cli-linux-x64": "7.5.1"
+    "magus-cli-darwin-arm64": "7.5.2",
+    "magus-cli-darwin-x64": "7.5.2",
+    "magus-cli-linux-x64": "7.5.2"
   }
 }

package/src/__tests__/stale-load-repair.test.ts

@@ -1180,3 +1180,163 @@ describe("B4: an update brings the loader forward in the same run", () => {
 		expect(await backups()).toEqual([]);
 	});
 });
+
+describe("7.5.2: Claude Code 2.1.281 updates another project's row of the repository", () => {
+	/**
+	 * `claude plugin update --scope project` as 2.1.281 does it: the FIRST row
+	 * relevant to the repository moves to `version` — here, the main tree's —
+	 * and this worktree's own row stays where it was.
+	 */
+	async function cli281(version: string): Promise<void> {
+		const registry = await readRegistry();
+		const rows = registry.plugins[PLUGIN];
+		const first = pickLoadedEntry(rows, here) as InstalledPluginEntry;
+		first.version = version;
+		first.installPath = cacheFor(version);
+		await fs.outputJson(registryFile, registry, { spaces: 2 });
+	}
+
+	/** The real registry, rewrite and loader question, against this root. */
+	function deps(version: string): PluginApplyDeps {
+		return {
+			install: async () => {},
+			update: async () => cli281(version),
+			repair: async () => {},
+			readInstalled: async () =>
+				(await readRegistry()).plugins[PLUGIN].find(
+					(e) => e.projectPath === here,
+				)?.version ?? null,
+			saveInstalled: async () => {},
+			registryRows: async () => (await readRegistry()).plugins[PLUGIN],
+			repairStaleLoad: (id, target, projectPath) =>
+				repairStaleLoad(id, target, projectPath, root),
+			loadedVersion: (id, projectPath) =>
+				loadedVersionHere(id, projectPath, root),
+		};
+	}
+
+	const item = (target: string) => ({
+		pluginId: PLUGIN,
+		pinned: "latest",
+		installed: "0.4.0",
+		available: target,
+		target,
+		action: "update" as const,
+		reason: "behind" as const,
+		scopes: ["project" as const],
+		beforeVersions: { project: "0.4.0" },
+	});
+
+	function collect() {
+		const details: string[] = [];
+		return {
+			details,
+			reporter: {
+				begin: () => {},
+				finish: (_ok: boolean, _name: string, detail: string) =>
+					details.push(detail),
+				detach: <T>(work: () => T) => work(),
+			},
+		};
+	}
+
+	test("7.5.2: this worktree's row follows to the version the CLI fetched, and the update says where it wrote", async () => {
+		await writeRegistry([
+			row({ version: "0.4.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins(
+			[item("0.5.0")],
+			here,
+			deps("0.5.0"),
+			reporter,
+		);
+
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+		expect(
+			(await readRegistry()).plugins[PLUGIN].map((e) => [
+				e.projectPath,
+				e.version,
+			]),
+		).toEqual([
+			[mainTree, "0.5.0"],
+			[here, "0.5.0"],
+		]);
+		expect(details).toEqual([
+			`project → 0.5.0 · Claude Code updated ${mainTree} instead of this project — moved this project's record to v0.5.0 too`,
+		]);
+		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.5.0");
+	});
+
+	test("7.5.2 review: a row of an UNRELATED repository moving during the update is not followed", async () => {
+		const other = path.join(base, "unrelated-752");
+		await fs.ensureDir(other);
+		git(other, "init", "-q");
+		await writeRegistry([
+			row({ version: "0.4.0", projectPath: other }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+		const unrelated: PluginApplyDeps = {
+			...deps("0.5.0"),
+			// Another repository's session updates its own row meanwhile.
+			update: async () => {
+				const registry = await readRegistry();
+				const moved = registry.plugins[PLUGIN].find(
+					(e) => e.projectPath === other,
+				) as InstalledPluginEntry;
+				moved.version = "0.5.0";
+				moved.installPath = cacheFor("0.5.0");
+				await fs.outputJson(registryFile, registry, { spaces: 2 });
+			},
+		};
+
+		const result = await applyPlugins(
+			[item("0.5.0")],
+			here,
+			unrelated,
+			reporter,
+		);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(
+			(await readRegistry()).plugins[PLUGIN].map((e) => [
+				e.projectPath,
+				e.version,
+			]),
+		).toEqual([
+			[other, "0.5.0"],
+			[here, "0.4.0"],
+		]);
+		expect(details).toEqual([
+			`no change — the installer exited 0 but ${PLUGIN} is still 0.4.0`,
+		]);
+	});
+
+	test("7.5.2: a version with no cache directory is not followed — no change, and why", async () => {
+		await writeRegistry([
+			row({ version: "0.4.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins(
+			[item("0.6.0")],
+			here,
+			deps("0.6.0"),
+			reporter,
+		);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(
+			(await readRegistry()).plugins[PLUGIN].find((e) => e.projectPath === here)
+				?.version,
+		).toBe("0.4.0");
+		expect(details[0]).toContain(
+			`no change — the installer exited 0 but ${PLUGIN} is still 0.4.0 (Claude Code updated ${mainTree} instead of this project, and this project's record could not follow: no cache directory for v0.6.0`,
+		);
+	});
+});

package/src/__tests__/update-apply.test.ts

@@ -25,7 +25,7 @@ import type {
 	PluginUpdateItem,
 	UpdatePlan,
 } from "../services/update-plan.js";
-import type { ResolvedBin } from "../types/index.js";
+import type { InstalledPluginEntry, ResolvedBin } from "../types/index.js";
 import { noMoveReasons } from "../ui/adapters/pluginsAdapter.js";
 
 const PROJECT = "/tmp/project";
@@ -925,3 +925,199 @@ describe("B4: an install or update ends with the loader on the new version", ()
 		).rejects.toThrow("the loader still resolves v1.0.0 here, not v2.0.0");
 	});
 });
+
+// ── 7.5.2: Claude Code 2.1.281 updates ANOTHER project's row ─────────────────
+//
+// `claude plugin update P --scope project` under 2.1.281 moves the repository's
+// FIRST relevant registry row — the one its loader would pick — not this
+// project's. Measured 2026-09-24, same registry, cwd = the project:
+//   2.1.280  updated from 8.0.0 to 8.1.3 for scope project (<sandbox>/magus-src)
+//   2.1.281  updated from 8.0.0 to 8.1.3 for scope project (<sandbox>/magus-src/tools/claudeup)
+// This project's row stayed at 8.0.0, and `magus update` said "no change".
+
+describe("7.5.2: an update Claude Code applied to another project's row", () => {
+	const HERE = "/tmp/project";
+	const OTHER = "/tmp/project/tools/claudeup";
+	const UNRELATED = "/tmp/another-repository";
+
+	/**
+	 * A registry for dev@magus — another project's row of the same repository
+	 * first, this project's second — and a fake Claude CLI that updates either
+	 * the first relevant row (`"2.1.281"`) or this project's (`"2.1.280"`).
+	 */
+	function registry(
+		cli: "2.1.280" | "2.1.281" | "unrelated" | "other-version",
+		cached: string[] = ["8.1.3", "8.5.0"],
+	) {
+		const rows: InstalledPluginEntry[] = [
+			{
+				scope: "project",
+				projectPath: OTHER,
+				version: "8.0.0",
+			} as InstalledPluginEntry,
+			{
+				scope: "project",
+				projectPath: HERE,
+				version: "8.0.0",
+			} as InstalledPluginEntry,
+			{
+				scope: "project",
+				projectPath: UNRELATED,
+				version: "8.0.0",
+			} as InstalledPluginEntry,
+		];
+		const repaired: string[] = [];
+		const saved: string[] = [];
+		const row = (projectPath: string) =>
+			rows.find((r) => r.projectPath === projectPath) as InstalledPluginEntry;
+		const deps: PluginApplyDeps = {
+			install: async () => {},
+			update: async () => {
+				if (cli === "2.1.280") row(HERE).version = "8.1.3";
+				if (cli === "2.1.281") row(OTHER).version = "8.1.3";
+				// Another repository's row moving while the CLI runs.
+				if (cli === "unrelated") row(UNRELATED).version = "8.1.3";
+				// This repository's row, but not to the version this update targets.
+				if (cli === "other-version") row(OTHER).version = "8.5.0";
+			},
+			repair: async () => {},
+			readInstalled: async (_id, scope, projectPath) =>
+				scope === "project" ? (row(projectPath)?.version ?? null) : null,
+			saveInstalled: async (_id, version) => {
+				saved.push(version);
+			},
+			registryRows: async () => rows.map((r) => ({ ...r })),
+			// Same repository = this project's tree, as git would answer.
+			inThisRepository: (r, projectPath) =>
+				(r.projectPath ?? "").startsWith(projectPath),
+			// What repairStaleLoad does: refuse an uncached target, else move every
+			// row of this repository that is behind it.
+			repairStaleLoad: async (pluginId, target) => {
+				repaired.push(target);
+				if (!cached.includes(target)) {
+					return {
+						pluginId,
+						target,
+						rewritten: 0,
+						backup: null,
+						loaded: null,
+						ok: false,
+						error: `no cache directory for v${target}`,
+					};
+				}
+				let rewritten = 0;
+				for (const r of rows) {
+					if (r.projectPath?.startsWith(HERE) && r.version !== target) {
+						r.version = target;
+						rewritten++;
+					}
+				}
+				return {
+					pluginId,
+					target,
+					rewritten,
+					backup: null,
+					loaded: target,
+					ok: true,
+				};
+			},
+			// The loader: the first relevant row.
+			loadedVersion: async () => rows[0]?.version ?? null,
+		};
+		return { rows, deps, repaired, saved, row };
+	}
+
+	const update = () =>
+		item({
+			installed: "8.0.0",
+			available: "8.1.3",
+			target: "8.1.3",
+			beforeVersions: { project: "8.0.0" },
+		});
+
+	test("7.5.2: under 2.1.281 this project's row follows to the fetched version, reported as updated", async () => {
+		const { deps, row, repaired, saved } = registry("2.1.281");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.1.3");
+		expect(row(OTHER).version).toBe("8.1.3"); // the CLI's change stands
+		expect(repaired).toEqual(["8.1.3"]);
+		expect(saved).toEqual(["8.1.3"]);
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "dev@magus",
+				detail: `project → 8.1.3 · Claude Code updated ${OTHER} instead of this project — moved this project's record to v8.1.3 too`,
+			},
+		]);
+	});
+
+	test("7.5.2: under 2.1.280 the CLI updates this project's row and nothing extra happens", async () => {
+		const { deps, row, repaired } = registry("2.1.280");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.1.3");
+		expect(result.ok).toBe(1);
+		// Exactly 7.5.1's outcome: the older row ahead of this one is brought
+		// forward by the loader check (B4), and no misdirection is reported.
+		expect(repaired).toEqual(["8.1.3"]);
+		expect(rows[0]?.detail).toBe(
+			"project → 8.1.3 · Claude Code now loads v8.1.3 here (1 older record moved forward)",
+		);
+	});
+
+	test("7.5.2: a version the CLI did not cache is not followed — still an honest no change", async () => {
+		const { deps, row } = registry("2.1.281", []);
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.0.0");
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			`no change — the installer exited 0 but dev@magus is still 8.0.0 (Claude Code updated ${OTHER} instead of this project, and this project's record could not follow: no cache directory for v8.1.3)`,
+		);
+	});
+
+	test("7.5.2 review: a row of ANOTHER repository moving to the target is not followed", async () => {
+		const { deps, row, repaired } = registry("unrelated");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.0.0");
+		expect(repaired).toEqual([]);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			"no change — the installer exited 0 but dev@magus is still 8.0.0",
+		);
+	});
+
+	test("7.5.2 review: this repository's row moving to a version other than the target is not followed", async () => {
+		const { deps, row, repaired } = registry("other-version");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.0.0");
+		expect(repaired).toEqual([]);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			`no change — the installer exited 0 but dev@magus is still 8.0.0 (Claude Code updated ${OTHER} instead of this project, and this project's record could not follow: it went to v8.5.0, not the v8.1.3 this update asked for)`,
+		);
+	});
+
+	test("7.5.2: the TUI's per-scope update key follows it too", async () => {
+		const { deps, row } = registry("2.1.281");
+		expect(await updatePluginInScope("dev@magus", "project", HERE, deps)).toBe(
+			"8.1.3",
+		);
+		expect(row(HERE).version).toBe("8.1.3");
+	});
+});

package/src/services/claude-settings.ts

@@ -1991,6 +1991,24 @@ function belongsToThisRepository(
 	return repoRootForPath(entry.projectPath, cache) === cwdRoot;
 }
 
+/**
+ * Is `entry` a row of the repository `projectPath` is in — one
+ * {@link repairStaleLoad} may rewrite? The same predicate, for callers that
+ * judge one row at a time.
+ */
+export function rowBelongsToRepository(
+	entry: InstalledPluginEntry,
+	projectPath: string,
+): boolean {
+	const cache: RepoRootCache = new Map();
+	return belongsToThisRepository(
+		entry,
+		projectPath,
+		repoRootForPath(projectPath, cache),
+		cache,
+	);
+}
+
 /** A plugin whose loader-resolved version is behind a row this repair can rewrite. */
 export interface StaleLoad {
 	pluginId: string;

package/src/services/update-engine.ts

@@ -31,6 +31,7 @@
 
 import path from "node:path";
 import type {
+	InstalledPluginEntry,
 	ProfileSkillRef,
 	ResolvedBin,
 	SkillInfo,
@@ -43,9 +44,12 @@ import { installPlugin, repairPlugin, updatePlugin } from "./claude-cli.js";
 import {
 	type StaleLoadRepairResult,
 	loadedVersionHere,
+	readInstalledPluginsRegistry,
 	repairStaleLoad,
+	rowBelongsToRepository,
 } from "./claude-settings.js";
 import {
+	compareVersions,
 	isRepairablyBehind,
 	readInstalledVersionForScope,
 	saveInstalledPluginVersionForScope,
@@ -192,6 +196,21 @@ export interface PluginApplyDeps {
 		pluginId: string,
 		projectPath: string,
 	) => Promise<string | null>;
+	/**
+	 * Every registry row for a plugin, read fresh — compared before and after
+	 * `update` to see WHICH row Claude Code moved (see
+	 * {@link followMisdirectedUpdate}). Optional so a test double that does not
+	 * model the registry skips the comparison.
+	 */
+	registryRows?: (pluginId: string) => Promise<readonly InstalledPluginEntry[]>;
+	/**
+	 * Is a row this project's repository's — the rows the stale-load repair may
+	 * rewrite. Defaults to that repair's own predicate (`rowBelongsToRepository`).
+	 */
+	inThisRepository?: (
+		row: InstalledPluginEntry,
+		projectPath: string,
+	) => boolean;
 }
 
 export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
@@ -202,8 +221,129 @@ export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
 	saveInstalled: saveInstalledPluginVersionForScope,
 	repairStaleLoad,
 	loadedVersion: loadedVersionHere,
+	registryRows: async (pluginId) => {
+		const rows = (await readInstalledPluginsRegistry()).plugins?.[pluginId];
+		return Array.isArray(rows) ? rows : [];
+	},
 };
 
+/**
+ * An update Claude Code applied to another project's row instead of this one.
+ *
+ * Claude Code 2.1.281 changed `claude plugin update P --scope project`: it
+ * updates the FIRST registry row relevant to the repository — the row its
+ * loader would pick — not the row of the project it runs in. Measured
+ * 2026-09-24 on two APFS clones of one sandbox, same registry, cwd = the
+ * project:
+ *
+ *   2.1.280  updated from 8.0.0 to 8.1.3 for scope project (<sandbox>/magus-src)
+ *   2.1.281  updated from 8.0.0 to 8.1.3 for scope project (<sandbox>/magus-src/tools/claudeup)
+ *
+ * Both exit 0; under 2.1.281 this project's row stays at 8.0.0.
+ */
+export interface MisdirectedUpdate {
+	/** Where Claude Code wrote instead: each moved row's project path, or scope. */
+	elsewhere: string[];
+	/** The version it moved them to. */
+	version: string;
+	/** Why this project's row did not follow to `version`; null when it did. */
+	notFollowed: string | null;
+}
+
+/** One registry row's identity: scope, and the project it belongs to. */
+function rowKey(
+	row: Pick<InstalledPluginEntry, "scope" | "projectPath">,
+): string {
+	const where = row.projectPath ? path.resolve(row.projectPath) : "";
+	return `${row.scope}\u0000${where}`;
+}
+
+async function readRows(
+	deps: PluginApplyDeps,
+	pluginId: string,
+): Promise<readonly InstalledPluginEntry[] | null> {
+	if (!deps.registryRows) return null;
+	try {
+		return await deps.registryRows(pluginId);
+	} catch {
+		return null; // No readable registry: nothing to compare.
+	}
+}
+
+/**
+ * After `claude plugin update P --scope <scope>`: if this project's row did not
+ * move but another row OF THIS REPOSITORY did — Claude Code 2.1.281 updating
+ * the repository's first relevant row instead (see {@link MisdirectedUpdate})
+ * — move this project's row forward to that version, with the registry
+ * rewrite the stale-load repair performs. That repair refuses a version whose
+ * cache directory does not exist.
+ *
+ * Only rows the repair itself would rewrite count (`inThisRepository`): a row
+ * of another repository that happens to move while the CLI runs says nothing
+ * about this update. And when the update's `target` is known, the row must
+ * have reached exactly that version, or it is not followed.
+ *
+ * The row Claude Code moved is left as it is: it belongs to this repository,
+ * and bringing this repository's rows forward is what the repair does anyway.
+ * Null when there was nothing to follow — this project's row moved (2.1.280),
+ * or no row of this repository moved at all.
+ */
+async function followMisdirectedUpdate(
+	deps: PluginApplyDeps,
+	pluginId: string,
+	scope: PluginScope,
+	projectPath: string,
+	before: readonly InstalledPluginEntry[],
+	target: string | null,
+): Promise<MisdirectedUpdate | null> {
+	const now = await deps.readInstalled(pluginId, scope, projectPath);
+	const after = await readRows(deps, pluginId);
+	if (!now || !after) return null;
+	const inThisRepository = deps.inThisRepository ?? rowBelongsToRepository;
+	const was = new Map(before.map((row) => [rowKey(row), row.version]));
+	const moved = after.filter(
+		(row) =>
+			row.version &&
+			was.get(rowKey(row)) !== row.version &&
+			inThisRepository(row, projectPath),
+	);
+	const mine = rowKey({
+		scope,
+		projectPath: scope === "user" ? undefined : projectPath,
+	});
+	if (moved.length === 0 || moved.some((row) => rowKey(row) === mine)) {
+		return null;
+	}
+	const version = moved
+		.map((row) => row.version)
+		.reduce((a, b) => ((compareVersions(b, a) ?? 0) > 0 ? b : a));
+	if (!isRepairablyBehind(version, now)) return null;
+	const elsewhere = moved.map((row) => row.projectPath ?? `${row.scope} scope`);
+	if (target && version !== target) {
+		return {
+			elsewhere,
+			version,
+			notFollowed: `it went to v${version}, not the v${target} this update asked for`,
+		};
+	}
+	const repair = await deps.repairStaleLoad(pluginId, version, projectPath);
+	return {
+		elsewhere,
+		version,
+		notFollowed: repair.ok
+			? null
+			: (repair.error ?? "the registry was not rewritten"),
+	};
+}
+
+/** The words for a misdirected update, for an item's detail. */
+function describeMisdirected(m: MisdirectedUpdate): string {
+	const where = m.elsewhere.join(", ");
+	return m.notFollowed === null
+		? `Claude Code updated ${where} instead of this project — moved this project's record to v${m.version} too`
+		: `Claude Code updated ${where} instead of this project, and this project's record could not follow: ${m.notFollowed}`;
+}
+
 /**
  * After a plugin landed at `target` for `projectPath`: make sure that is the
  * version Claude Code actually loads there, and bring the loader forward when
@@ -319,10 +459,26 @@ async function advanceInScope(
 	pluginId: string,
 	scope: PluginScope,
 	projectPath: string,
-): Promise<void> {
+	/** The version this update targets, when known — see followMisdirectedUpdate. */
+	target: string | null = null,
+): Promise<MisdirectedUpdate | null> {
 	const here = await deps.readInstalled(pluginId, scope, projectPath);
-	if (here) await deps.update(pluginId, scope);
-	else await deps.install(pluginId, scope);
+	if (!here) {
+		await deps.install(pluginId, scope);
+		return null;
+	}
+	const before = await readRows(deps, pluginId);
+	await deps.update(pluginId, scope);
+	return before
+		? followMisdirectedUpdate(
+				deps,
+				pluginId,
+				scope,
+				projectPath,
+				before,
+				target,
+			)
+		: null;
 }
 
 /**
@@ -449,6 +605,7 @@ export async function applyPlugins(
 		report.begin(item.pluginId);
 		const startedAt = Date.now();
 		const landed: Array<[PluginScope, string | null]> = [];
+		const misdirected: MisdirectedUpdate[] = [];
 
 		try {
 			for (const scope of scopes) {
@@ -467,7 +624,14 @@ export async function applyPlugins(
 				} else if (item.action === "install") {
 					await deps.install(item.pluginId, scope);
 				} else {
-					await advanceInScope(deps, item.pluginId, scope, projectPath);
+					const m = await advanceInScope(
+						deps,
+						item.pluginId,
+						scope,
+						projectPath,
+						item.target,
+					);
+					if (m) misdirected.push(m);
 				}
 
 				// Record what LANDED, not what we asked for.
@@ -520,19 +684,24 @@ export async function applyPlugins(
 				);
 				result.failed.push(item.pluginId);
 			} else if (noMove && !forward) {
+				const why = misdirected.map(describeMisdirected);
 				report.finish(
 					true,
 					item.pluginId,
-					`no change — ${noMove}`,
+					`no change — ${noMove}${why.length > 0 ? ` (${why.join("; ")})` : ""}`,
 					Date.now() - startedAt,
 				);
 				result.unchanged.push(item.pluginId);
 			} else {
 				const moved = `${scopes.join(", ")}${item.target ? ` → ${item.target}` : ""}`;
+				const notes = [
+					...misdirected.map(describeMisdirected),
+					...(forward ? [describeLoadForward(forward)] : []),
+				];
 				report.finish(
 					true,
 					item.pluginId,
-					forward ? `${moved} · ${describeLoadForward(forward)}` : moved,
+					[moved, ...notes].join(" · "),
 					Date.now() - startedAt,
 				);
 				result.ok++;
@@ -621,8 +790,12 @@ export async function updatePluginInScope(
 	deps: PluginApplyDeps = REAL_PLUGIN_DEPS,
 ): Promise<string | null> {
 	// Same guard as the apply loop, for the same reason — see advanceInScope.
+	// A misdirected update is followed there; the version read back afterwards
+	// is what this returns.
 	return applyOneInScope(
-		(id, sc) => advanceInScope(deps, id, sc, projectPath),
+		async (id, sc) => {
+			await advanceInScope(deps, id, sc, projectPath);
+		},
 		pluginId,
 		scope,
 		projectPath,