claudeup 4.31.0 → 4.32.1

package/package.json

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

package/src/__tests__/content-drift.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Content drift: a plugin whose files changed without its version changing.
+ *
+ * Hermetic — builds a real git marketplace under a temp CLAUDE_CONFIG_DIR.
+ * Real git is used deliberately: the detection IS a git question, and mocking
+ * it would only test the mock.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	clearContentDriftCache,
+	hasContentDrift,
+} from "../services/content-drift.js";
+
+let configDir: string;
+let prevConfigDir: string | undefined;
+let repo: string;
+
+const git = (args: string[]) =>
+	spawnSync("git", args, { cwd: repo, encoding: "utf-8" });
+
+const head = () => git(["rev-parse", "HEAD"]).stdout.trim();
+
+beforeEach(async () => {
+	prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	configDir = await fs.mkdtemp(path.join(os.tmpdir(), "drift-"));
+	process.env.CLAUDE_CONFIG_DIR = configDir;
+	clearContentDriftCache();
+
+	repo = path.join(configDir, "plugins", "marketplaces", "probemp");
+	await fs.mkdir(path.join(repo, "plugins", "alpha", "skills"), {
+		recursive: true,
+	});
+	await fs.mkdir(path.join(repo, "plugins", "beta"), { recursive: true });
+	await fs.writeFile(path.join(repo, "plugins", "alpha", "skills", "s.md"), "v1");
+	await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v1");
+
+	git(["init", "-q", "-b", "main"]);
+	git(["config", "user.email", "probe@example.invalid"]);
+	git(["config", "user.name", "probe"]);
+	git(["add", "-A"]);
+	git(["commit", "-q", "-m", "release 1.0.0"]);
+});
+
+afterEach(async () => {
+	if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
+	await fs.rm(configDir, { recursive: true, force: true });
+});
+
+describe("hasContentDrift", () => {
+	test("no drift when the plugin's files are untouched", async () => {
+		const sha = head();
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+			}),
+		).toBe(false);
+	});
+
+	test("drift when the plugin's files change under an unchanged version", async () => {
+		const sha = head();
+		// Republish: same version, different content — what publish-dist.sh does.
+		await fs.writeFile(
+			path.join(repo, "plugins", "alpha", "skills", "s.md"),
+			"v2 — different content, same version",
+		);
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "republish 1.0.0"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+			}),
+		).toBe(true);
+	});
+
+	test("a change to ANOTHER plugin does not flag this one", async () => {
+		// The reason this compares the plugin subtree and not the marketplace
+		// HEAD: any commit to any plugin would otherwise flag every plugin.
+		const sha = head();
+		await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v2");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "unrelated change"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+			}),
+		).toBe(false);
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "beta",
+				installedSha: sha,
+			}),
+		).toBe(true);
+	});
+
+	test("deleting a skill counts as drift", async () => {
+		// The live case: dev@magus 3.0.1 lost tui-progress/SKILL.md while still
+		// declaring 3.0.1, so the version compare reported "up to date".
+		const sha = head();
+		await fs.rm(path.join(repo, "plugins", "alpha", "skills", "s.md"));
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "drop a skill"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+			}),
+		).toBe(true);
+	});
+
+	test("stays silent when it cannot answer honestly", async () => {
+		// No recorded sha, unknown sha (force-push/shallow clone), and unknown
+		// marketplace must all report false rather than nag for a reinstall.
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: undefined,
+			}),
+		).toBe(false);
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: "0".repeat(40),
+			}),
+		).toBe(false);
+		expect(
+			await hasContentDrift({
+				marketplace: "does-not-exist",
+				pluginName: "alpha",
+				installedSha: head(),
+			}),
+		).toBe(false);
+	});
+});

package/src/__tests__/dual-write-prevention.test.ts

@@ -94,7 +94,10 @@ describe("PluginsScreen — no dual-write after CLI operations", () => {
 
 // Mutable state shared between mock factories and test assertions.
 let mockSaveGlobal: ReturnType<typeof mock>;
+let mockSaveProject: ReturnType<typeof mock>;
+let mockSaveLocal: ReturnType<typeof mock>;
 let mockUpdatePlugin: ReturnType<typeof mock>;
+let mockRepairPlugin: ReturnType<typeof mock>;
 let mockIsClaudeAvailable: ReturnType<typeof mock>;
 let mockGetAvailablePlugins: ReturnType<typeof mock>;
 
@@ -123,6 +126,8 @@ mock.module("../services/claude-settings.js", () => ({
   getLocalEnabledPlugins: mock(() => Promise.resolve({})),
   saveGlobalInstalledPluginVersion: (...args: unknown[]) =>
     mockSaveGlobal(...args),
+  saveLocalInstalledPluginVersion: (...args: unknown[]) =>
+    mockSaveLocal(...args),
   readGlobalSettings: mock(() => Promise.resolve({ hooks: {} })),
   writeGlobalSettings: mock(() => Promise.resolve()),
 }));
@@ -130,6 +135,7 @@ mock.module("../services/claude-settings.js", () => ({
 mock.module("../services/claude-cli.js", () => ({
   ...actualClaudeCli,
   updatePlugin: (...args: unknown[]) => mockUpdatePlugin(...args),
+  repairPlugin: (...args: unknown[]) => mockRepairPlugin(...args),
   isClaudeAvailable: (...args: unknown[]) => mockIsClaudeAvailable(...args),
   addMarketplace: mock(() => Promise.resolve()),
   updateMarketplace: mock(() => Promise.resolve()),
@@ -139,6 +145,7 @@ mock.module("../services/plugin-manager.js", () => ({
   ...actualPluginManager,
   getAvailablePlugins: (...args: unknown[]) =>
     mockGetAvailablePlugins(...args),
+  saveInstalledPluginVersion: (...args: unknown[]) => mockSaveProject(...args),
   clearMarketplaceCache: mock(() => undefined),
 }));
 
@@ -173,26 +180,35 @@ mock.module("fs-extra", () => ({
 // Now import the module under test (after mock.module registrations).
 const { prerunClaude } = await import("../prerunner/index.js");
 
-// Helper: build a minimal PluginInfo-like object
-function makePlugin(overrides: Partial<{
-  id: string;
+interface ScopeStatusLike {
   enabled: boolean;
-  hasUpdate: boolean;
-  installedVersion: string;
-  version: string;
-}> = {}): {
+  version?: string;
+}
+interface PluginLike {
   id: string;
   enabled: boolean;
   hasUpdate: boolean;
+  contentStale?: boolean;
   installedVersion: string;
   version: string;
-} {
+  userScope?: ScopeStatusLike;
+  projectScope?: ScopeStatusLike;
+  localScope?: ScopeStatusLike;
+}
+
+/**
+ * Minimal PluginInfo-like object. The per-scope status matters: the prerunner
+ * updates the scopes that actually hold an outdated install, so a fixture with
+ * no scope status describes a plugin installed nowhere and is correctly skipped.
+ */
+function makePlugin(overrides: Partial<PluginLike> = {}): PluginLike {
   return {
     id: "test-plugin@magus",
     enabled: true,
     hasUpdate: true,
     installedVersion: "1.0.0",
     version: "1.1.0",
+    userScope: { enabled: true, version: "1.0.0" },
     ...overrides,
   };
 }
@@ -200,7 +216,10 @@ function makePlugin(overrides: Partial<{
 describe("prerunner — saveGlobalInstalledPluginVersion call count", () => {
   beforeEach(() => {
     mockSaveGlobal = mock(() => Promise.resolve());
+    mockSaveProject = mock(() => Promise.resolve());
+    mockSaveLocal = mock(() => Promise.resolve());
     mockUpdatePlugin = mock(() => Promise.resolve());
+    mockRepairPlugin = mock(() => Promise.resolve());
     mockIsClaudeAvailable = mock(() => Promise.resolve(true));
     mockGetAvailablePlugins = mock(() =>
       Promise.resolve([makePlugin()]),
@@ -219,6 +238,130 @@ describe("prerunner — saveGlobalInstalledPluginVersion call count", () => {
     expect(mockSaveGlobal).toHaveBeenCalledTimes(1);
   });
 
+  /**
+   * The prerunner used to call `updatePlugin(id, "user")` unconditionally.
+   * `hasUpdate` is computed from the CURRENT PROJECT's resolved version, but
+   * installs live per project in installed_plugins.json — 495 of 496 magus
+   * installs on the reporter's machine are project-scoped. So it detected
+   * project drift, updated user scope, reported success, and left the project
+   * untouched, re-detecting the identical drift on every subsequent run.
+   */
+  it("updates the PROJECT scope when that is where the outdated install is", async () => {
+    mockGetAvailablePlugins = mock(() =>
+      Promise.resolve([
+        makePlugin({
+          userScope: undefined,
+          projectScope: { enabled: true, version: "1.0.0" },
+        }),
+      ]),
+    );
+
+    await prerunClaude(["--help"], { force: true });
+
+    expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
+    expect(mockUpdatePlugin.mock.calls[0]?.[1]).toBe("project");
+    expect(mockSaveProject).toHaveBeenCalledTimes(1);
+    expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
+  });
+
+  it("updates every scope that is outdated, not just the first", async () => {
+    mockGetAvailablePlugins = mock(() =>
+      Promise.resolve([
+        makePlugin({
+          userScope: { enabled: true, version: "1.0.0" },
+          projectScope: { enabled: true, version: "1.0.0" },
+          localScope: { enabled: true, version: "1.1.0" }, // already current
+        }),
+      ]),
+    );
+
+    await prerunClaude(["--help"], { force: true });
+
+    const scopes = mockUpdatePlugin.mock.calls
+      .map((c: unknown[]) => c[1])
+      .sort();
+    expect(scopes).toEqual(["project", "user"]);
+    expect(mockSaveLocal).toHaveBeenCalledTimes(0);
+  });
+
+  /**
+   * A content-stale plugin has no version bump to install over, and
+   * `claude plugin install` no-ops on "already installed" (verified against the
+   * real marketplace in autotest/plugin-system/probe-05). The prerunner must
+   * therefore repair — uninstall+install — not update.
+   */
+  it("repairs a content-stale plugin instead of updating it", async () => {
+    mockGetAvailablePlugins = mock(() =>
+      Promise.resolve([
+        makePlugin({
+          hasUpdate: false,
+          contentStale: true,
+          installedVersion: "1.0.0",
+          version: "1.0.0",
+          userScope: undefined,
+          projectScope: { enabled: true, version: "1.0.0" },
+        }),
+      ]),
+    );
+
+    await prerunClaude(["--help"], { force: true });
+
+    expect(mockRepairPlugin).toHaveBeenCalledTimes(1);
+    expect(mockRepairPlugin.mock.calls[0]?.[1]).toBe("project");
+    expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
+  });
+
+  it("prefers a real version update over a repair when both apply", async () => {
+    // A pending version bump reinstalls the files anyway, so repairing as well
+    // would double the work and the uninstall window.
+    mockGetAvailablePlugins = mock(() =>
+      Promise.resolve([
+        makePlugin({ hasUpdate: true, contentStale: true }),
+      ]),
+    );
+
+    await prerunClaude(["--help"], { force: true });
+
+    expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
+    expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
+  });
+
+  it("does not repair when the CLI is unavailable", async () => {
+    mockIsClaudeAvailable = mock(() => Promise.resolve(false));
+    mockGetAvailablePlugins = mock(() =>
+      Promise.resolve([
+        makePlugin({
+          hasUpdate: false,
+          contentStale: true,
+          version: "1.0.0",
+          projectScope: { enabled: true, version: "1.0.0" },
+        }),
+      ]),
+    );
+
+    await prerunClaude(["--help"], { force: true });
+
+    expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
+  });
+
+  it("does nothing when no scope holds an outdated install", async () => {
+    // hasUpdate can be true from a stale settings base while every real
+    // install is already current. Updating "somewhere" would be a guess.
+    mockGetAvailablePlugins = mock(() =>
+      Promise.resolve([
+        makePlugin({
+          userScope: { enabled: true, version: "1.1.0" },
+          projectScope: undefined,
+        }),
+      ]),
+    );
+
+    await prerunClaude(["--help"], { force: true });
+
+    expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
+    expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
+  });
+
   it("does NOT call saveGlobalInstalledPluginVersion when CLI is unavailable", async () => {
     // CLI unavailable — we must NOT write phantom state.
     mockIsClaudeAvailable = mock(() => Promise.resolve(false));

package/src/__tests__/marketplace-refresh.test.ts

@@ -214,14 +214,19 @@ describe("refreshRegisteredMarketplaces — selection & skips", () => {
 		expect(r.skipped).toEqual(["local"]);
 	});
 
-	it("skips a marketplace with autoUpdate === false", async () => {
+	it("reports a marketplace with autoUpdate === false separately from ordinary skips", async () => {
+		// Not lumped into `skipped`: opting out here freezes the catalog, so the
+		// marketplace's plugins read as up to date forever. The caller has to be
+		// able to tell the user, which it cannot do if this looks like "no clone
+		// on disk". A real magus clone sat 11 days behind exactly this way.
 		installClone("magus");
 		publishV2();
 		configured = { magus: gh() };
 		autoUpdate = { magus: false };
 		const r = await refreshRegisteredMarketplaces();
 		expect(r.refreshed).toEqual([]);
-		expect(r.skipped).toEqual(["magus"]);
+		expect(r.autoUpdateDisabled).toEqual(["magus"]);
+		expect(r.skipped).toEqual([]);
 	});
 
 	it("honors the skip set (already handled this run)", async () => {

package/src/__tests__/moved-marketplace.test.ts

@@ -0,0 +1,87 @@
+/**
+ * An orphaned plugin that merely changed marketplace is not deprecated.
+ *
+ * Splitting `magus` into `magus` + `magus-marketing` left `seo@magus`,
+ * `instantly@magus`, `video-editing@magus` and `nanobanana@magus` installed
+ * under a namespace that no longer lists them. They rendered as bare
+ * "deprecated", whose only action is deletion — which drops a plugin that is
+ * still published, just under a different id.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+
+/**
+ * Mirrors `findPluginInOtherMarketplace` in plugin-manager.ts, which is module
+ * -private. Kept in lockstep with it; the behaviour, not the binding, is what
+ * these tests pin.
+ */
+function findPluginInOtherMarketplace(
+	pluginName: string,
+	currentMarketplace: string,
+	localMarketplaces: Map<string, LocalMarketplace>,
+): string | undefined {
+	for (const [name, mp] of localMarketplaces) {
+		if (name === currentMarketplace) continue;
+		if (mp.plugins.some((p) => p.name === pluginName)) return name;
+	}
+	return undefined;
+}
+
+const mp = (name: string, plugins: string[]): [string, LocalMarketplace] => [
+	name,
+	{
+		name,
+		description: "",
+		plugins: plugins.map((p) => ({
+			name: p,
+			version: "1.0.0",
+			description: "",
+		})),
+	},
+];
+
+describe("moved-marketplace detection", () => {
+	test("finds a plugin that moved to a sibling marketplace", () => {
+		const marketplaces = new Map([
+			mp("magus", ["dev", "terminal"]),
+			mp("magus-marketing", ["seo", "instantly", "video-editing"]),
+		]);
+
+		expect(findPluginInOtherMarketplace("seo", "magus", marketplaces)).toBe(
+			"magus-marketing",
+		);
+	});
+
+	test("a genuinely retired plugin reports no destination", () => {
+		// `conductor` was removed at magus v8.0.0 and republished nowhere.
+		const marketplaces = new Map([
+			mp("magus", ["dev"]),
+			mp("magus-marketing", ["seo"]),
+		]);
+
+		expect(
+			findPluginInOtherMarketplace("conductor", "magus", marketplaces),
+		).toBeUndefined();
+	});
+
+	test("does not propose the marketplace it is already installed from", () => {
+		const marketplaces = new Map([mp("magus", ["dev"])]);
+		expect(findPluginInOtherMarketplace("dev", "magus", marketplaces)).toBe(
+			undefined,
+		);
+	});
+
+	test("a renamed plugin is not matched — the name is the identity", () => {
+		// nanobanana became image-generate. Names differ, so this correctly
+		// reports no destination rather than guessing at a rename.
+		const marketplaces = new Map([
+			mp("magus", ["dev"]),
+			mp("magus-marketing", ["image-generate"]),
+		]);
+
+		expect(
+			findPluginInOtherMarketplace("nanobanana", "magus", marketplaces),
+		).toBeUndefined();
+	});
+});

package/src/__tests__/scope-action.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import {
+  isInstalledInScope,
+  resolveScopeAction,
+} from "../services/plugin-manager.js";
+
+/**
+ * The scope keys (u / p / l) and the Enter scope picker both decide between
+ * install, update and uninstall. That decision used to read `scope.enabled` —
+ * the `enabledPlugins` flag from a settings file — and ignore `scope.version`,
+ * which is the registry-backed answer to "did Claude Code actually install
+ * this".
+ *
+ * Those two disagree in a real, common state: a plugin listed in
+ * `enabledPlugins` with no entry in `installed_plugins.json` for the current
+ * project path. The list row renders it "not installed" (isEnabledButNotInstalled),
+ * and pressing its scope key ran `claude plugin uninstall`. The user asked to
+ * install the thing the UI told them was missing, and it was removed instead.
+ */
+
+describe("isInstalledInScope", () => {
+  test("enabled with a registry version is installed", () => {
+    expect(isInstalledInScope({ enabled: true, version: "3.0.2" })).toBe(true);
+  });
+
+  test("enabled with NO version is not installed — the broken state", () => {
+    // dev@magus, measured: `.claude/settings.json` had "dev@magus": true while
+    // installed_plugins.json had no entry resolving for the project path.
+    expect(isInstalledInScope({ enabled: true })).toBe(false);
+  });
+
+  test("a version with the flag off is not installed either", () => {
+    expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(false);
+  });
+
+  test("an absent scope is not installed", () => {
+    expect(isInstalledInScope(undefined)).toBe(false);
+  });
+
+  test('"0.0.0" counts as installed — Anthropic official plugins record it', () => {
+    expect(isInstalledInScope({ enabled: true, version: "0.0.0" })).toBe(true);
+  });
+});
+
+describe("resolveScopeAction", () => {
+  test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
+    // This is the reported bug. Before the fix this returned "uninstall".
+    expect(resolveScopeAction({ enabled: true }, "3.0.2")).toBe("install");
+  });
+
+  test("a scope that was never enabled resolves to install", () => {
+    expect(resolveScopeAction(undefined, "3.0.2")).toBe("install");
+    expect(resolveScopeAction({ enabled: false }, "3.0.2")).toBe("install");
+  });
+
+  test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
+    expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, "3.0.2")).toBe(
+      "uninstall",
+    );
+  });
+
+  test("a healthy install behind the catalog resolves to update", () => {
+    expect(resolveScopeAction({ enabled: true, version: "2.9.0" }, "3.0.2")).toBe(
+      "update",
+    );
+  });
+
+  test('an unknown catalog version ("0.0.0") never fabricates an update', () => {
+    // There is nothing to update *to*, so toggling must still mean uninstall.
+    expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, "0.0.0")).toBe(
+      "uninstall",
+    );
+  });
+
+  test("installed with unknown version resolves to update when a real version is published", () => {
+    // "0.0.0" installed against a real catalog version is a genuine upgrade
+    // path, not the broken state — it must not be treated as uninstall.
+    expect(resolveScopeAction({ enabled: true, version: "0.0.0" }, "3.0.2")).toBe(
+      "update",
+    );
+  });
+});

package/src/__tests__/version-snapshot.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, test } from "bun:test";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import {
   diffVersions,
   isKnownVersion,
+  loadSeenVersions,
+  saveSeenVersions,
   UNKNOWN_VERSION,
 } from "../services/version-snapshot.js";
 
@@ -109,3 +114,83 @@ describe("diffVersions — removals and mixed sets", () => {
     ]);
   });
 });
+
+describe("per-project baselines", () => {
+  /**
+   * The baseline used to be one flat map for the whole machine, but the
+   * versions written into it are resolved per project. Two projects
+   * legitimately on different versions overwrote each other's baseline, so
+   * every differing plugin was reported as "updated" on the next render — a
+   * change that never happened.
+   *
+   * CLAUDE_CONFIG_DIR, not HOME: os.homedir() reads the passwd database on
+   * macOS and ignores $HOME, so a HOME-only override writes to the operator's
+   * real ~/.claude. That is not hypothetical — it happened while writing these.
+   */
+  const withSandbox = async (fn: () => Promise<void>): Promise<void> => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "vsnap-"));
+    const prev = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = dir;
+    try {
+      await fn();
+    } finally {
+      if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+      else process.env.CLAUDE_CONFIG_DIR = prev;
+      await fs.rm(dir, { recursive: true, force: true });
+    }
+  };
+
+  test("a project with no baseline of its own reports nothing", async () => {
+    await withSandbox(async () => {
+      await saveSeenVersions("/proj/a", { "statusline@magus": "2.2.0" });
+      const baseline = await loadSeenVersions("/proj/b");
+      expect(baseline).toBeNull();
+      expect(diffVersions(baseline, { "statusline@magus": "2.5.0" })).toEqual([]);
+    });
+  });
+
+  test("saving one project preserves the others", async () => {
+    await withSandbox(async () => {
+      await saveSeenVersions("/proj/a", { "gtd@magus": "2.0.0" });
+      await saveSeenVersions("/proj/b", { "gtd@magus": "2.0.1" });
+      expect(await loadSeenVersions("/proj/a")).toEqual({ "gtd@magus": "2.0.0" });
+      expect(await loadSeenVersions("/proj/b")).toEqual({ "gtd@magus": "2.0.1" });
+    });
+  });
+
+  test("a real update inside one project is still reported", async () => {
+    await withSandbox(async () => {
+      await saveSeenVersions("/proj/a", { "dev@magus": "3.0.0" });
+      const previous = await loadSeenVersions("/proj/a");
+      expect(diffVersions(previous, { "dev@magus": "3.0.1" })).toEqual([
+        { pluginId: "dev@magus", kind: "updated", from: "3.0.0", to: "3.0.1" },
+      ]);
+    });
+  });
+
+  test("a pre-migration flat baseline is adopted once, then replaced", async () => {
+    await withSandbox(async () => {
+      const file = path.join(
+        process.env.CLAUDE_CONFIG_DIR as string,
+        "claudeup-version-snapshot.json",
+      );
+      await fs.writeFile(
+        file,
+        JSON.stringify({
+          seen: { "dev@magus": "3.0.0" },
+          seededAt: "2026-07-29T00:00:00.000Z",
+          updatedAt: "2026-07-29T00:00:00.000Z",
+        }),
+      );
+
+      // Legacy shape carries no project, so it stands in for whoever asks first
+      // rather than being thrown away.
+      expect(await loadSeenVersions("/proj/a")).toEqual({ "dev@magus": "3.0.0" });
+
+      await saveSeenVersions("/proj/a", { "dev@magus": "3.0.1" });
+      // Once per-project entries exist, the flat map is no longer consulted.
+      expect(await loadSeenVersions("/proj/b")).toBeNull();
+      expect(await loadSeenVersions("/proj/a")).toEqual({ "dev@magus": "3.0.1" });
+    });
+  });
+});