claudeup 4.24.0 → 4.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.24.0",
+  "version": "4.26.0",
   "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.24.0",
-    "claudeup-darwin-x64": "4.24.0",
-    "claudeup-linux-x64": "4.24.0"
+    "claudeup-darwin-arm64": "4.26.0",
+    "claudeup-darwin-x64": "4.26.0",
+    "claudeup-linux-x64": "4.26.0"
   }
 }

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

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import {
+  clearMarketplaceCache,
+  fetchMarketplacePlugins,
+  getMarketplaceVersion,
+} from "../services/marketplace-fetcher";
+
+/**
+ * Coverage for capturing a marketplace's `metadata.version` during a fetch.
+ *
+ * The plugins TUI header renders "Name vX.Y.Z (count)" when a marketplace
+ * declares a version, so `fetchMarketplacePlugins` must stash the version and
+ * expose it via `getMarketplaceVersion`. Marketplaces without a version must
+ * yield `undefined` rather than crashing or leaking a stray "vundefined".
+ */
+
+const realFetch = globalThis.fetch;
+
+function mockFetchOnce(body: unknown): void {
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    })) as typeof fetch;
+}
+
+describe("fetchMarketplacePlugins — metadata.version capture", () => {
+  beforeEach(() => {
+    clearMarketplaceCache();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = realFetch;
+    clearMarketplaceCache();
+  });
+
+  it("captures metadata.version so getMarketplaceVersion returns it", async () => {
+    mockFetchOnce({
+      metadata: { version: "8.0.0" },
+      plugins: [{ name: "dev", description: "Dev workflow" }],
+    });
+
+    await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+
+    expect(getMarketplaceVersion("magus")).toBe("8.0.0");
+  });
+
+  it("yields undefined when marketplace.json has no metadata.version", async () => {
+    mockFetchOnce({
+      plugins: [{ name: "core", description: "Anthropic core plugin" }],
+    });
+
+    await fetchMarketplacePlugins("official", "anthropics/official");
+
+    expect(getMarketplaceVersion("official")).toBeUndefined();
+  });
+
+  it("yields undefined for a marketplace with metadata but no version field", async () => {
+    mockFetchOnce({
+      metadata: { description: "no version here" },
+      plugins: [{ name: "core", description: "" }],
+    });
+
+    await fetchMarketplacePlugins("no-version", "owner/no-version");
+
+    expect(getMarketplaceVersion("no-version")).toBeUndefined();
+  });
+
+  it("clears captured versions on clearMarketplaceCache", async () => {
+    mockFetchOnce({
+      metadata: { version: "1.0.0" },
+      plugins: [],
+    });
+
+    await fetchMarketplacePlugins("magus-marketing", "MadAppGang/magus-marketing");
+    expect(getMarketplaceVersion("magus-marketing")).toBe("1.0.0");
+
+    clearMarketplaceCache();
+    expect(getMarketplaceVersion("magus-marketing")).toBeUndefined();
+  });
+});

package/src/__tests__/owned-marketplaces.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Change B: our own marketplaces (magus, magus-marketing) are always listed in
+ * the plugins TUI — even when unregistered — and sorted to the top.
+ *
+ * `magus-marketing` is deliberately NOT `featured`, so before this change it was
+ * invisible until manually registered. The `owned` flag both (a) qualifies it
+ * for the plugin-manager "always include" gate and (b) sorts it first.
+ */
+import { describe, expect, it } from "bun:test";
+import {
+	defaultMarketplaces,
+	getAllMarketplaces,
+} from "../data/marketplaces.js";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+import type { Marketplace } from "../types/index.js";
+import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
+
+describe("owned marketplaces", () => {
+	it("marks magus and magus-marketing as owned, and leaves others untouched", () => {
+		const magus = defaultMarketplaces.find((m) => m.name === "magus");
+		const marketing = defaultMarketplaces.find(
+			(m) => m.name === "magus-marketing",
+		);
+		expect(magus?.owned).toBe(true);
+		expect(marketing?.owned).toBe(true);
+		expect(
+			defaultMarketplaces.find((m) => m.name === "claude-plugins-official")
+				?.owned,
+		).toBeUndefined();
+	});
+
+	it("qualifies magus-marketing for the always-show gate without being featured", () => {
+		const marketing = defaultMarketplaces.find(
+			(m) => m.name === "magus-marketing",
+		);
+		expect(marketing).toBeDefined();
+		// The plugin-manager gate: configured || official || featured || owned.
+		const alwaysShown = !!(
+			marketing?.official ||
+			marketing?.featured ||
+			marketing?.owned
+		);
+		expect(alwaysShown).toBe(true);
+		expect(marketing?.featured).toBeUndefined(); // and NOT via featured
+	});
+
+	it("sorts owned first and deprecated last, regardless of input order", () => {
+		const mk = (name: string, extra: Partial<Marketplace>): Marketplace => ({
+			name,
+			displayName: name,
+			source: { source: "github", repo: `x/${name}` },
+			description: "",
+			...extra,
+		});
+		// Deliberately "wrong" order: official, deprecated, owned.
+		const marketplaces: Marketplace[] = [
+			mk("official-one", { official: true }),
+			mk("claude-code-plugins", { deprecated: true }),
+			mk("mine", { owned: true }),
+		];
+
+		const items = buildPluginBrowserItems({
+			marketplaces,
+			plugins: [],
+			collapsedMarketplaces: new Set(),
+		});
+
+		const order: string[] = [];
+		for (const i of items)
+			if (i.kind === "category") order.push(i.marketplace.name);
+
+		expect(order[0]).toBe("mine"); // owned first
+		expect(order[order.length - 1]).toBe("claude-code-plugins"); // deprecated last
+	});
+
+	it("preserves owned when getAllMarketplaces rebuilds a locally-cached marketplace", () => {
+		// The local-cache path reconstructs the Marketplace object; owned must
+		// survive so already-cloned magus still sorts first / always shows.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				{
+					name: "Magus",
+					description: "",
+					gitRepo: "MadAppGang/magus",
+					plugins: [],
+				},
+			],
+		]);
+		const magus = getAllMarketplaces(local).find((m) => m.name === "magus");
+		expect(magus?.owned).toBe(true);
+	});
+});

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

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import { diffVersions } from "../services/version-snapshot.js";
+
+/**
+ * Plugins get updated by things claudeup does not control — Claude Code's own
+ * `plugin update` writes installed_plugins.json without touching claudeup's
+ * bookkeeping. Diffing what we last rendered against reality catches every
+ * source; logging only claudeup's own actions catches none of them.
+ */
+
+describe("diffVersions", () => {
+  test("reports a genuine version transition", () => {
+    expect(
+      diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
+    ).toEqual([{ pluginId: "dev@magus", from: "2.12.0", to: "2.12.1" }]);
+  });
+
+  test("first run reports nothing — otherwise every plugin looks updated", () => {
+    expect(diffVersions(null, { "dev@magus": "2.12.1" })).toEqual([]);
+  });
+
+  test("a newly installed plugin is not an update", () => {
+    // Absent from the snapshot means we have never seen it, not that it moved.
+    expect(diffVersions({}, { "dev@magus": "2.12.1" })).toEqual([]);
+  });
+
+  test("unchanged versions report nothing", () => {
+    expect(
+      diffVersions({ "dev@magus": "2.12.1" }, { "dev@magus": "2.12.1" }),
+    ).toEqual([]);
+  });
+
+  test('"0.0.0" transitions are ignored on both sides', () => {
+    // 0.0.0 means installed-with-unknown-version (Anthropic official plugins).
+    // Treating it as a real version produces bogus "0.0.0 → x" badges.
+    expect(
+      diffVersions({ "a@mp": "0.0.0" }, { "a@mp": "1.0.0" }),
+    ).toEqual([]);
+    expect(
+      diffVersions({ "a@mp": "1.0.0" }, { "a@mp": "0.0.0" }),
+    ).toEqual([]);
+  });
+
+  test("a removed plugin is not reported", () => {
+    expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
+  });
+
+  test("reports every changed plugin, leaving unchanged ones out", () => {
+    const changes = diffVersions(
+      { "a@mp": "1.0.0", "b@mp": "2.0.0", "c@mp": "3.0.0" },
+      { "a@mp": "1.1.0", "b@mp": "2.0.0", "c@mp": "4.0.0" },
+    );
+    expect(changes.map((c) => c.pluginId).sort()).toEqual(["a@mp", "c@mp"]);
+  });
+
+  test("a downgrade is still reported", () => {
+    // Rolling back is a change the user should see, not silently hidden.
+    const changes = diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" });
+    expect(changes).toEqual([{ pluginId: "a@mp", from: "2.0.0", to: "1.0.0" }]);
+  });
+});

package/src/data/marketplaces.ts

@@ -1,5 +1,5 @@
-import type { Marketplace } from "../types/index.js";
 import type { LocalMarketplace } from "../services/local-marketplace.js";
+import type { Marketplace } from "../types/index.js";
 import { formatMarketplaceName } from "../utils/string-utils.js";
 
 /**
@@ -38,6 +38,7 @@ export const defaultMarketplaces: Marketplace[] = [
 			"Professional plugins for frontend, backend, and code analysis",
 		official: false,
 		featured: true, // Always show plugins (expanded by default)
+		owned: true, // Ours: always listed, sorted to the top
 	},
 	{
 		name: "magus-marketing",
@@ -49,6 +50,7 @@ export const defaultMarketplaces: Marketplace[] = [
 		description:
 			"SEO, cold email outreach, AI image generation, and video editing plugins",
 		official: false,
+		owned: true, // Ours: always listed even when uninstalled, sorted to the top
 		// Not featured: a niche channel, so keep it collapsed by default.
 	},
 	{
@@ -138,6 +140,7 @@ export function getAllMarketplaces(
 					defaultMp?.official ?? repo.toLowerCase().includes("anthropics/"),
 				featured: defaultMp?.featured,
 				deprecated: defaultMp?.deprecated,
+				owned: defaultMp?.owned,
 			});
 		}
 	}

package/src/data/predefined-profiles.ts

@@ -236,7 +236,6 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 			"statusline",
 			"multimodel",
 			"gtd",
-			"agentdev",
 		],
 		anthropicPlugins: [
 			"code-review",

package/src/services/marketplace-fetcher.ts

@@ -23,8 +23,26 @@ export interface MarketplacePlugin {
 // Session-level cache for fetched marketplace data (no TTL - persists until explicit refresh)
 const marketplaceCache = new Map<string, MarketplacePlugin[]>();
 
+// Session-level cache for each marketplace's declared version (from
+// marketplace.json's top-level `metadata.version`). Mirrors `marketplaceCache`
+// so the TUI can surface a marketplace's version without re-fetching. Only
+// populated for marketplaces that actually declare a version.
+const marketplaceVersionCache = new Map<string, string>();
+
 export function clearMarketplaceCache(): void {
   marketplaceCache.clear();
+  marketplaceVersionCache.clear();
+}
+
+/**
+ * Returns the version a marketplace declared in its `metadata.version`, if one
+ * was seen during a successful fetch this session. Returns `undefined` for
+ * marketplaces that declare no version (or haven't been fetched yet).
+ */
+export function getMarketplaceVersion(
+  marketplaceName: string,
+): string | undefined {
+  return marketplaceVersionCache.get(marketplaceName);
 }
 
 export async function fetchMarketplacePlugins(
@@ -75,9 +93,19 @@ export async function fetchMarketplacePlugins(
       homepage?: string;
       tags?: string[];
     }
-    const data = (await response.json()) as { plugins?: RawPlugin[] };
+    const data = (await response.json()) as {
+      plugins?: RawPlugin[];
+      metadata?: { version?: string };
+    };
     const plugins: MarketplacePlugin[] = [];
 
+    // Capture the marketplace's declared version (if any) so the TUI can
+    // display it. Absent/blank versions are simply not cached.
+    const version = data.metadata?.version;
+    if (typeof version === "string" && version.length > 0) {
+      marketplaceVersionCache.set(marketplaceName, version);
+    }
+
     if (data.plugins && Array.isArray(data.plugins)) {
       for (const plugin of data.plugins) {
         plugins.push({

package/src/services/plugin-manager.ts

@@ -72,6 +72,12 @@ export interface PluginInfo {
 	mcpServers?: string[];
 	lspServers?: Record<string, unknown>;
 	isOrphaned?: boolean;
+	/**
+	 * Set when this plugin's installed version changed since claudeup last
+	 * rendered it — including updates made by Claude Code or the prerunner
+	 * rather than by claudeup itself. Drives the "updated" badge.
+	 */
+	recentlyUpdatedFrom?: string;
 }
 
 /**
@@ -148,7 +154,12 @@ export async function getAvailablePlugins(
 	// Always include official and featured marketplaces so users can browse them
 	const marketplaceNames = new Set<string>();
 	for (const mp of defaultMarketplaces) {
-		if (configuredMarketplaces[mp.name] || mp.official || mp.featured) {
+		if (
+			configuredMarketplaces[mp.name] ||
+			mp.official ||
+			mp.featured ||
+			mp.owned
+		) {
 			marketplaceNames.add(mp.name);
 		}
 	}
@@ -333,7 +344,12 @@ export async function getGlobalAvailablePlugins(): Promise<PluginInfo[]> {
 	// Always include official and featured marketplaces so users can browse them
 	const marketplaceNames = new Set<string>();
 	for (const mp of defaultMarketplaces) {
-		if (configuredMarketplaces[mp.name] || mp.official || mp.featured) {
+		if (
+			configuredMarketplaces[mp.name] ||
+			mp.official ||
+			mp.featured ||
+			mp.owned
+		) {
 			marketplaceNames.add(mp.name);
 		}
 	}

package/src/services/version-snapshot.ts

@@ -0,0 +1,97 @@
+/**
+ * version-snapshot.ts — detect plugin version changes that happened outside claudeup.
+ *
+ * Plugins get updated by things claudeup does not control: Claude Code's own
+ * `plugin install`/`update`, the `claudeup claude` prerunner, or a direct CLI
+ * call. All of them write `installed_plugins.json`; none of them tell the user
+ * anything the next time claudeup opens, so versions silently move underfoot.
+ *
+ * Rather than log what claudeup itself did — which misses every other source —
+ * this records what claudeup last *saw* installed and diffs against reality on
+ * load. Any change is reported, regardless of who made it.
+ *
+ * The snapshot is advisory UI state, kept separate from the update-check cache
+ * so a TTL expiry or a corrupt cache can never make plugins look updated.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export interface VersionChange {
+  pluginId: string;
+  from: string;
+  to: string;
+}
+
+interface SnapshotFile {
+  /** pluginId -> installedVersion as of the last time claudeup rendered it. */
+  seen: Record<string, string>;
+  updatedAt: string;
+}
+
+function snapshotPath(): string {
+  return path.join(os.homedir(), ".claude", "claudeup-version-snapshot.json");
+}
+
+async function read(): Promise<SnapshotFile | null> {
+  try {
+    const raw = await fs.readFile(snapshotPath(), "utf-8");
+    const data = JSON.parse(raw) as SnapshotFile;
+    if (!data || typeof data.seen !== "object" || data.seen === null) return null;
+    return data;
+  } catch {
+    return null; // absent or corrupt — treated as "first run"
+  }
+}
+
+/**
+ * Diff the versions currently installed against the previous snapshot.
+ *
+ * Returns only genuine transitions. Deliberately excluded:
+ *  - first run (no snapshot): everything would look "updated"
+ *  - a plugin absent from the snapshot: newly installed, not updated
+ *  - unchanged versions
+ *  - "0.0.0", which means installed-with-unknown-version rather than a real one
+ */
+export function diffVersions(
+  previous: Record<string, string> | null,
+  current: Record<string, string>,
+): VersionChange[] {
+  if (!previous) return [];
+  const changes: VersionChange[] = [];
+  for (const [pluginId, to] of Object.entries(current)) {
+    const from = previous[pluginId];
+    if (!from || from === to) continue;
+    if (from === "0.0.0" || to === "0.0.0") continue;
+    changes.push({ pluginId, from, to });
+  }
+  return changes;
+}
+
+/** Load the previous snapshot's version map, or null on first run. */
+export async function loadSeenVersions(): Promise<Record<string, string> | null> {
+  const data = await read();
+  return data ? data.seen : null;
+}
+
+/**
+ * Persist what is installed now, so the same change is not reported twice.
+ * Best-effort: a failure here must never break the UI, it only means the badge
+ * shows again next launch.
+ */
+export async function saveSeenVersions(
+  current: Record<string, string>,
+): Promise<void> {
+  try {
+    const file = snapshotPath();
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const payload: SnapshotFile = {
+      seen: current,
+      updatedAt: new Date().toISOString(),
+    };
+    await fs.writeFile(file, JSON.stringify(payload, null, 2), "utf-8");
+  } catch {
+    // ignore
+  }
+}

package/src/types/index.ts

@@ -42,6 +42,7 @@ export interface Marketplace {
 	official?: boolean;
 	featured?: boolean; // Featured marketplaces have plugins fetched by default (like official)
 	deprecated?: boolean; // Deprecated marketplaces are sorted to the bottom of the list
+	owned?: boolean; // Our own marketplaces (magus*): always listed even when uninstalled, and sorted to the top
 }
 
 export interface DiscoveredMarketplace {

package/src/ui/adapters/pluginsAdapter.ts

@@ -97,12 +97,10 @@ export function buildPluginBrowserItems({
     pluginsByMarketplace.set(plugin.marketplace, existing);
   }
 
-  // Sort marketplaces: deprecated ones go to the bottom
-  const sortedMarketplaces = [...marketplaces].sort((a, b) => {
-    const aDeprecated = a.name === "claude-code-plugins" ? 1 : 0;
-    const bDeprecated = b.name === "claude-code-plugins" ? 1 : 0;
-    return aDeprecated - bDeprecated;
-  });
+  // Sort marketplaces: our own (magus*) first, deprecated last, others between.
+  const rank = (m: Marketplace) =>
+    m.owned ? 0 : m.deprecated || m.name === "claude-code-plugins" ? 2 : 1;
+  const sortedMarketplaces = [...marketplaces].sort((a, b) => rank(a) - rank(b));
 
   const items: PluginBrowserItem[] = [];
 

package/src/ui/components/CategoryHeader.tsx

@@ -3,6 +3,8 @@ import React from "react";
 interface CategoryHeaderProps {
 	/** Category title */
 	title: string;
+	/** Optional version to render after the title (e.g., "8.0.0" → " v8.0.0") */
+	version?: string;
 	/** Status badge (e.g., "✓ Configured", "3 plugins") */
 	status?: string;
 	/** Status badge color */
@@ -15,12 +17,14 @@ interface CategoryHeaderProps {
 
 export function CategoryHeader({
 	title,
+	version,
 	status,
 	statusColor = "green",
 	expanded = true,
 	count,
 }: CategoryHeaderProps) {
 	const expandIcon = expanded ? "▼" : "▶";
+	const versionBadge = version ? ` v${version}` : "";
 	const countBadge = count !== undefined ? ` (${count})` : "";
 	const statusText = status ? ` ${status}` : "";
 
@@ -31,6 +35,7 @@ export function CategoryHeader({
 			<span fg="white">
 				<strong> {title}</strong>
 			</span>
+			<span fg="#666666">{versionBadge}</span>
 			<span fg="#666666">{countBadge}</span>
 			<span fg="#666666"> ────</span>
 			<span fg={statusColor}>{statusText}</span>

package/src/ui/renderers/pluginRenderers.tsx

@@ -15,21 +15,27 @@ import {
 } from "../components/primitives/index.js";
 import { theme } from "../theme.js";
 import { highlightMatches } from "../../utils/fuzzy-search.js";
+import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
 import { isEnabledButNotInstalled } from "../../services/plugin-manager.js";
 
 // ─── Category renderers ───────────────────────────────────────────────────────
 
 function categoryRow(item: PluginCategoryItem, isSelected: boolean): React.ReactNode {
   const mp = item.marketplace;
+  // Marketplaces that declare a `metadata.version` render "Name v8.0.0 (15)";
+  // those without keep the plain "Name (15)" form.
+  const version = getMarketplaceVersion(mp.name);
 
   if (isSelected) {
     const arrow = item.isExpanded ? "▼" : "▶";
+    const versionLabel = version ? ` v${version}` : "";
     const count = item.pluginCount > 0 ? ` (${item.pluginCount})` : "";
     return (
       <SelectableRow selected={true}>
         <strong>
           {" "}
           {arrow} {mp.displayName}
+          {versionLabel}
           {count}{" "}
         </strong>
       </SelectableRow>
@@ -49,6 +55,7 @@ function categoryRow(item: PluginCategoryItem, isSelected: boolean): React.React
   return (
     <CategoryHeader
       title={mp.displayName}
+      version={version}
       expanded={item.isExpanded}
       count={item.pluginCount}
       status={item.badge}
@@ -125,9 +132,15 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
   } else if (notInstalled) {
     versionStr = " not installed";
   } else if (hasAnyScope && plugin.installedVersion && plugin.installedVersion !== "0.0.0") {
-    versionStr = ` v${plugin.installedVersion}`;
-    if (plugin.hasUpdate && plugin.version) {
-      versionStr += ` → v${plugin.version}`;
+    if (plugin.recentlyUpdatedFrom) {
+      // Show what actually happened, not just where it landed — the update may
+      // have come from Claude Code or the prerunner without ever telling us.
+      versionStr = ` v${plugin.recentlyUpdatedFrom} → v${plugin.installedVersion} updated`;
+    } else {
+      versionStr = ` v${plugin.installedVersion}`;
+      if (plugin.hasUpdate && plugin.version) {
+        versionStr += ` → v${plugin.version}`;
+      }
     }
   }
 
@@ -170,7 +183,13 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
       </span>
       <MetaText
         text={versionStr}
-        tone={notInstalled || plugin.hasUpdate ? "warning" : "muted"}
+        tone={
+          plugin.recentlyUpdatedFrom
+            ? "success"
+            : notInstalled || plugin.hasUpdate
+              ? "warning"
+              : "muted"
+        }
       />
     </text>
   );

package/src/ui/screens/PluginsScreen.tsx

@@ -7,6 +7,11 @@ import { ScrollableList } from "../components/ScrollableList.js";
 import { EmptyFilterState } from "../components/EmptyFilterState.js";
 import { fuzzyFilter } from "../../utils/fuzzy-search.js";
 import { getAllMarketplaces } from "../../data/marketplaces.js";
+import {
+	diffVersions,
+	loadSeenVersions,
+	saveSeenVersions,
+} from "../../services/version-snapshot.js";
 import {
 	getAvailablePlugins,
 	refreshAllMarketplaces,
@@ -73,6 +78,23 @@ export function PluginsScreen() {
 			const localMarketplaces = await getLocalMarketplacesInfo();
 			const allMarketplaces = getAllMarketplaces(localMarketplaces);
 			const pluginData = await getAvailablePlugins(state.projectPath);
+
+			// Surface version changes made outside claudeup (Claude Code's own
+			// plugin update, the prerunner, a manual CLI call). Diffing against
+			// what we last rendered catches all of them; logging only what
+			// claudeup did would miss every one.
+			const current: Record<string, string> = {};
+			for (const p of pluginData) {
+				if (p.installedVersion) current[p.id] = p.installedVersion;
+			}
+			const previous = await loadSeenVersions();
+			for (const change of diffVersions(previous, current)) {
+				const target = pluginData.find((p) => p.id === change.pluginId);
+				if (target) target.recentlyUpdatedFrom = change.from;
+			}
+			// Record now so the same change is not reported on the next launch.
+			void saveSeenVersions(current);
+
 			dispatch({
 				type: "PLUGINS_DATA_SUCCESS",
 				marketplaces: allMarketplaces,