claudeup 4.25.0 → 4.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.25.0",
+  "version": "4.27.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.25.0",
-    "claudeup-darwin-x64": "4.25.0",
-    "claudeup-linux-x64": "4.25.0"
+    "claudeup-darwin-arm64": "4.27.0",
+    "claudeup-darwin-x64": "4.27.0",
+    "claudeup-linux-x64": "4.27.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

@@ -1,5 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { diffVersions } from "../services/version-snapshot.js";
+import {
+  diffVersions,
+  isKnownVersion,
+  UNKNOWN_VERSION,
+} from "../services/version-snapshot.js";
 
 /**
  * Plugins get updated by things claudeup does not control — Claude Code's own
@@ -8,20 +12,60 @@ import { diffVersions } from "../services/version-snapshot.js";
  * source; logging only claudeup's own actions catches none of them.
  */
 
-describe("diffVersions", () => {
-  test("reports a genuine version transition", () => {
+describe("isKnownVersion", () => {
+  test('"0.0.0" is not a usable version', () => {
+    // Claude Code records this for a plugin whose version it cannot determine.
+    expect(isKnownVersion(UNKNOWN_VERSION)).toBe(false);
+    expect(isKnownVersion(undefined)).toBe(false);
+    expect(isKnownVersion("")).toBe(false);
+    expect(isKnownVersion("1.0.0")).toBe(true);
+  });
+});
+
+describe("diffVersions — first run", () => {
+  test("no baseline reports nothing at all", () => {
+    // Without this, the first launch would flag every installed plugin as new,
+    // which is both wrong and the fastest way to train someone to ignore badges.
     expect(
-      diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
-    ).toEqual([{ pluginId: "dev@magus", from: "2.12.0", to: "2.12.1" }]);
+      diffVersions(null, { "dev@magus": "2.12.1", "a@mp": UNKNOWN_VERSION }),
+    ).toEqual([]);
   });
 
-  test("first run reports nothing — otherwise every plugin looks updated", () => {
-    expect(diffVersions(null, { "dev@magus": "2.12.1" })).toEqual([]);
+  test("an empty baseline is NOT the same as no baseline", () => {
+    // A real snapshot that happens to be empty means we have looked before and
+    // saw nothing, so anything present now is genuinely new.
+    const changes = diffVersions({}, { "dev@magus": "2.12.1" });
+    expect(changes).toEqual([
+      { pluginId: "dev@magus", kind: "installed", to: "2.12.1" },
+    ]);
   });
+});
 
-  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([]);
+describe("diffVersions — installs", () => {
+  test("a plugin absent from the baseline is reported as installed, not updated", () => {
+    const changes = diffVersions({ "other@mp": "1.0.0" }, { "new@mp": "3.1.0" });
+    expect(changes).toEqual([
+      { pluginId: "new@mp", kind: "installed", to: "3.1.0" },
+    ]);
+  });
+
+  test("an install with an unknown version is still reported", () => {
+    // The version is unusable but the install is real — the UI shows "new"
+    // with no version rather than suppressing the plugin entirely.
+    const changes = diffVersions({}, { "a@mp": UNKNOWN_VERSION });
+    expect(changes).toEqual([
+      { pluginId: "a@mp", kind: "installed", to: UNKNOWN_VERSION },
+    ]);
+  });
+});
+
+describe("diffVersions — updates", () => {
+  test("reports a genuine version transition", () => {
+    expect(
+      diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
+    ).toEqual([
+      { pluginId: "dev@magus", kind: "updated", from: "2.12.0", to: "2.12.1" },
+    ]);
   });
 
   test("unchanged versions report nothing", () => {
@@ -30,32 +74,38 @@ describe("diffVersions", () => {
     ).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("learning a previously unknown version is not an update", () => {
+    // This is exactly what v4.22.0's registry overlay caused: versions that
+    // could not be resolved suddenly could be. Reporting it would announce
+    // claudeup's own bugfix as if the user's plugins had changed.
+    expect(diffVersions({ "a@mp": UNKNOWN_VERSION }, { "a@mp": "5.3.0" })).toEqual([]);
   });
 
+  test("losing a known version is not an update either", () => {
+    expect(diffVersions({ "a@mp": "5.3.0" }, { "a@mp": UNKNOWN_VERSION })).toEqual([]);
+  });
+
+  test("a downgrade IS reported", () => {
+    // Rolling back is a real change, arguably the most important to surface.
+    expect(diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" })).toEqual([
+      { pluginId: "a@mp", kind: "updated", from: "2.0.0", to: "1.0.0" },
+    ]);
+  });
+});
+
+describe("diffVersions — removals and mixed sets", () => {
   test("a removed plugin is not reported", () => {
     expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
   });
 
-  test("reports every changed plugin, leaving unchanged ones out", () => {
+  test("classifies each plugin independently in one pass", () => {
     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" },
+      { same: "1.0.0", moved: "2.0.0", learned: UNKNOWN_VERSION },
+      { same: "1.0.0", moved: "2.1.0", learned: "9.0.0", fresh: "0.1.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" }]);
+    expect(changes).toEqual([
+      { pluginId: "moved", kind: "updated", from: "2.0.0", to: "2.1.0" },
+      { pluginId: "fresh", kind: "installed", to: "0.1.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

@@ -78,6 +78,11 @@ export interface PluginInfo {
 	 * rather than by claudeup itself. Drives the "updated" badge.
 	 */
 	recentlyUpdatedFrom?: string;
+	/**
+	 * Set when claudeup is seeing this plugin installed for the first time.
+	 * Never set on the very first run, when there is no baseline to compare to.
+	 */
+	recentlyInstalled?: boolean;
 }
 
 /**
@@ -154,7 +159,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);
 		}
 	}
@@ -339,7 +349,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

@@ -1,32 +1,51 @@
 /**
- * version-snapshot.ts — detect plugin version changes that happened outside claudeup.
+ * version-snapshot.ts — detect plugin 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.
+ * anything the next time claudeup opens, so versions move underfoot silently.
  *
  * 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.
+ * so a TTL expiry or a corrupt cache can never make plugins look changed.
  */
 
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import os from "node:os";
 
-export interface VersionChange {
+/**
+ * Sentinel recorded by Claude Code for a plugin that is installed but whose
+ * version is unknown — every plugin in the official Anthropic marketplace uses
+ * it. It is not a real version and must never be rendered as one.
+ */
+export const UNKNOWN_VERSION = "0.0.0";
+
+/** True when a version string carries no usable information. */
+export function isKnownVersion(v: string | undefined): v is string {
+  return !!v && v !== UNKNOWN_VERSION;
+}
+
+export type PluginChangeKind = "installed" | "updated";
+
+export interface PluginChange {
   pluginId: string;
-  from: string;
+  kind: PluginChangeKind;
+  /** Previous version. Only set for "updated", and always a known version. */
+  from?: string;
+  /** Current version. May be UNKNOWN_VERSION — callers must not render it raw. */
   to: string;
 }
 
 interface SnapshotFile {
   /** pluginId -> installedVersion as of the last time claudeup rendered it. */
   seen: Record<string, string>;
+  /** Set on the run that first created the baseline. */
+  seededAt: string;
   updatedAt: string;
 }
 
@@ -41,35 +60,56 @@ async function read(): Promise<SnapshotFile | null> {
     if (!data || typeof data.seen !== "object" || data.seen === null) return null;
     return data;
   } catch {
-    return null; // absent or corrupt — treated as "first run"
+    return null; // absent or corrupt — treated as "no baseline yet"
   }
 }
 
 /**
- * Diff the versions currently installed against the previous snapshot.
+ * Diff what is installed now against the previous snapshot.
+ *
+ * Three cases are deliberately silent, because each reflects claudeup's own
+ * knowledge changing rather than anything happening to the user's plugins:
+ *
+ *  1. No baseline (first run). Every plugin would otherwise be reported as
+ *     newly installed on the very first launch — a guaranteed false flood that
+ *     trains the user to ignore the badge. The first run seeds and says nothing.
  *
- * 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
+ *  2. A version moving to or from UNKNOWN_VERSION. That is claudeup learning
+ *     (or losing) a version it could not previously resolve — notably after
+ *     v4.22.0 taught it to read the registry — not the plugin changing.
+ *
+ *  3. A plugin disappearing. Uninstalls are visible elsewhere; nothing to badge.
+ *
+ * A downgrade IS reported: rolling back is a real change worth surfacing.
  */
 export function diffVersions(
   previous: Record<string, string> | null,
   current: Record<string, string>,
-): VersionChange[] {
+): PluginChange[] {
   if (!previous) return [];
-  const changes: VersionChange[] = [];
+
+  const changes: PluginChange[] = [];
   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 });
+
+    // Never seen before → newly installed, not an update. There is no
+    // meaningful "from", and `to` may legitimately be UNKNOWN_VERSION.
+    if (from === undefined) {
+      changes.push({ pluginId, kind: "installed", to });
+      continue;
+    }
+
+    if (from === to) continue;
+
+    // One side carries no real version: we learned or lost it, nothing moved.
+    if (!isKnownVersion(from) || !isKnownVersion(to)) continue;
+
+    changes.push({ pluginId, kind: "updated", from, to });
   }
   return changes;
 }
 
-/** Load the previous snapshot's version map, or null on first run. */
+/** Load the previous snapshot's version map, or null when no baseline exists. */
 export async function loadSeenVersions(): Promise<Record<string, string> | null> {
   const data = await read();
   return data ? data.seen : null;
@@ -77,7 +117,7 @@ export async function loadSeenVersions(): Promise<Record<string, string> | 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
+ * Best-effort: a failure here must never break the UI — it only means the badge
  * shows again next launch.
  */
 export async function saveSeenVersions(
@@ -86,9 +126,12 @@ export async function saveSeenVersions(
   try {
     const file = snapshotPath();
     await fs.mkdir(path.dirname(file), { recursive: true });
+    const existing = await read();
+    const now = new Date().toISOString();
     const payload: SnapshotFile = {
       seen: current,
-      updatedAt: new Date().toISOString(),
+      seededAt: existing?.seededAt ?? now,
+      updatedAt: now,
     };
     await fs.writeFile(file, JSON.stringify(payload, null, 2), "utf-8");
   } catch {

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,28 @@ 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";
+import { isKnownVersion } from "../../services/version-snapshot.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 +56,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}
@@ -118,19 +126,28 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
   // to render exactly like a healthy install.
   const notInstalled = isEnabledButNotInstalled(plugin);
 
-  // Build version string — only show if plugin is installed in at least one scope
+  // A known version is one we can actually show. "0.0.0" means installed with an
+  // unknown version (every official Anthropic plugin records it) — never render it.
+  const shownVersion = isKnownVersion(plugin.installedVersion)
+    ? plugin.installedVersion
+    : undefined;
+
   let versionStr = "";
   if (plugin.isOrphaned) {
     versionStr = " deprecated";
   } else if (notInstalled) {
     versionStr = " not installed";
-  } else if (hasAnyScope && plugin.installedVersion && plugin.installedVersion !== "0.0.0") {
-    if (plugin.recentlyUpdatedFrom) {
+  } else if (hasAnyScope) {
+    if (plugin.recentlyUpdatedFrom && shownVersion) {
       // 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}`;
+      versionStr = ` v${plugin.recentlyUpdatedFrom} → v${shownVersion} updated`;
+    } else if (plugin.recentlyInstalled) {
+      // Newly seen. Version is optional here: a plugin can be genuinely
+      // installed with no version we can name.
+      versionStr = shownVersion ? ` v${shownVersion} new` : " new";
+    } else if (shownVersion) {
+      versionStr = ` v${shownVersion}`;
       if (plugin.hasUpdate && plugin.version) {
         versionStr += ` → v${plugin.version}`;
       }
@@ -153,9 +170,7 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
 
   if (plugin.isOrphaned) {
     const ver =
-      plugin.installedVersion && plugin.installedVersion !== "0.0.0"
-        ? ` v${plugin.installedVersion}`
-        : "";
+      isKnownVersion(plugin.installedVersion) ? ` v${plugin.installedVersion}` : "";
     return (
       <text>
         <span fg={theme.colors.danger}> ■■■ </span>
@@ -177,7 +192,7 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
       <MetaText
         text={versionStr}
         tone={
-          plugin.recentlyUpdatedFrom
+          plugin.recentlyUpdatedFrom || plugin.recentlyInstalled
             ? "success"
             : notInstalled || plugin.hasUpdate
               ? "warning"
@@ -232,9 +247,9 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
     components.push(`${Object.keys(plugin.lspServers).length} LSP`);
   }
 
-  const showVersion = plugin.version && plugin.version !== "0.0.0";
+  const showVersion = isKnownVersion(plugin.version ?? undefined);
   const showInstalledVersion =
-    isInstalled && plugin.installedVersion && plugin.installedVersion !== "0.0.0";
+    isInstalled && isKnownVersion(plugin.installedVersion);
 
   return (
     <box flexDirection="column">

package/src/ui/screens/PluginsScreen.tsx

@@ -90,7 +90,12 @@ export function PluginsScreen() {
 			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;
+				if (!target) continue;
+				if (change.kind === "updated") {
+					target.recentlyUpdatedFrom = change.from;
+				} else {
+					target.recentlyInstalled = true;
+				}
 			}
 			// Record now so the same change is not reported on the next launch.
 			void saveSeenVersions(current);