@mycadet/assistant 0.12.9 → 0.12.11

package/src/cli/lib/__tests__/plugin-details.test.ts

@@ -1,17 +1,15 @@
 /**
  * Tests for {@link getPluginDetails}.
  *
- * At the default ref, the catalog entry is resolved from the gated plugin
- * catalog (the same source search and install-by-name use): these tests run
- * with platform features disabled (`CADET_DISABLE_CLOUD`) so the catalog is
- * the bundled manifest — real plugin names / pinned SHAs, zero network. An
- * explicit historical `ref` instead reads the GitHub `plugins/marketplace.json`
- * at that revision (a git lookup, matching pin history / inspect). GitHub is
- * replaced with an
+ * At the default ref, the catalog entry is resolved from the mocked cloud
+ * plugin catalog (the same source search and install-by-name use) — real
+ * plugin names / pinned SHAs, zero network. An explicit historical `ref`
+ * instead reads the GitHub `plugins/marketplace.json` at that revision (a git
+ * lookup, matching pin history / inspect). GitHub is replaced with an
  * in-memory Contents API fixture passed via the `fetch` dependency, and the
  * installed-copy path is exercised against a real temp directory passed via
- * `workspacePluginsDir` — no globals are monkey-patched. The fixture answers two
- * URL shapes:
+ * `workspacePluginsDir` — no globals are monkey-patched. The fixture answers
+ * two URL shapes:
  *   - directory listings (`/contents/<path>` → entry array or 404),
  *   - raw file downloads (a listing entry's `download_url`).
  *
@@ -27,12 +25,13 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import type { FetchLike } from "../fetch-like.js";
 import { invalidatePluginCatalogCache } from "../plugin-catalog-cache.js";
-import { readBundledPluginCatalog } from "../plugin-catalog-local.js";
 import {
   getPluginDetails,
   PluginDetailsNotFoundError,
 } from "../plugin-details.js";
+import type { MarketplaceEntry } from "../plugin-marketplace.js";
 import {
+  marketplaceMatch,
   PluginCatalogUnavailableError,
   type PluginSearchMatch,
 } from "../search-plugins.js";
@@ -75,6 +74,24 @@ function makeFetch(config: FixtureConfig): FetchLike {
       return new Response(config.raw[url], { status: 200 });
     }
 
+    if (url.includes("/v1/plugins")) {
+      return new Response(
+        JSON.stringify({
+          plugins: CATALOG_FIXTURES.map((e) => ({
+            name: e.name,
+            ...(e.source.source === "github"
+              ? { repo: e.source.repo, ref: e.source.ref }
+              : {}),
+            description: e.description,
+            category: e.category,
+            homepage: e.homepage,
+            license: e.license,
+          })),
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }
+
     if (url.includes("/contents")) {
       const key = listingKey(url);
       const entries = config.listings?.[key];
@@ -107,16 +124,64 @@ function splitOnce(s: string, sep: string): [string, string] {
   return [s.slice(0, i), s.slice(i + sep.length)];
 }
 
-/** The bundled catalog entry for {@link name} — the source under test. */
+/**
+ * Catalog fixture rows served to the mocked cloud catalog — the source under
+ * test. Former bundled-catalog entries, now exercised through the platform
+ * fetch path.
+ */
+const CATALOG_FIXTURES: MarketplaceEntry[] = [
+  {
+    name: "caveman",
+    source: {
+      source: "github",
+      repo: "JuliusBrussee/caveman",
+      ref: "63a91ecadbf4c4719a4602a5abb00883f9966034",
+    },
+    description:
+      "Ultra-compressed communication mode that strips filler words to cut token usage.",
+    category: "productivity",
+    homepage: "https://github.com/JuliusBrussee/caveman",
+    license: "MIT",
+  },
+  {
+    name: "simple-memory",
+    source: {
+      source: "github",
+      repo: "vargasjr-dev/simple-memory",
+      ref: "ed09a4c01bf18e4ac8859faee94cb65c7cbd1ca3",
+    },
+    description:
+      "Reference memory plugin that exercises the full plugin API with low-cost variants of Cadet's memory defaults.",
+    category: "memory",
+    homepage: "https://github.com/vargasjr-dev/simple-memory",
+    license: "MIT",
+  },
+  {
+    name: "dynamic-notch",
+    source: {
+      source: "github",
+      repo: "AnitaKirkovska/dynamic-notch",
+      ref: "9729c3685d60d00d1de73a183b03122b9fa1f8f4",
+    },
+    description:
+      "Put your Cadet assistant inside your MacBook's notch: click to chat, hold Ctrl+Option to talk, and get a floating task bulb while it works, with live-streamed replies and per-sentence voice.",
+    category: "interface",
+    homepage: "https://github.com/AnitaKirkovska/dynamic-notch",
+    license: "MIT",
+  },
+];
+
+/** The catalog fixture entry for {@link name} — the source under test. */
 function bundledMatch(name: string): PluginSearchMatch & {
   source: Extract<PluginSearchMatch["source"], { kind: "github" }>;
 } {
-  const match = readBundledPluginCatalog().matches.find((m) => m.name === name);
-  if (!match) {
-    throw new Error(`bundled catalog has no entry for "${name}"`);
+  const entry = CATALOG_FIXTURES.find((e) => e.name === name);
+  if (!entry) {
+    throw new Error(`catalog fixture has no entry for "${name}"`);
   }
+  const match = marketplaceMatch(entry);
   if (match.source.kind !== "github") {
-    throw new Error(`bundled catalog entry "${name}" is not GitHub-backed`);
+    throw new Error(`catalog fixture entry "${name}" is not GitHub-backed`);
   }
   return match as PluginSearchMatch & {
     source: Extract<PluginSearchMatch["source"], { kind: "github" }>;
@@ -142,34 +207,16 @@ function sha16(buf: Buffer): string {
   return createHash("sha256").update(buf).digest("hex").slice(0, 16);
 }
 
-const ORIGINAL_ENV = {
-  IS_CLOUD: process.env.IS_CLOUD,
-  CADET_DISABLE_CLOUD: process.env.CADET_DISABLE_CLOUD,
-};
-
-function restoreEnv(): void {
-  for (const [key, value] of Object.entries(ORIGINAL_ENV)) {
-    if (value === undefined) {
-      delete process.env[key];
-    } else {
-      process.env[key] = value;
-    }
-  }
-}
-
 let workspace: string;
 
-describe("getPluginDetails (bundled catalog, offline)", () => {
+describe("getPluginDetails (mocked cloud catalog)", () => {
   beforeEach(() => {
     workspace = mkdtempSync(join(tmpdir(), "plugin-details-"));
     invalidatePluginCatalogCache();
-    process.env.CADET_DISABLE_CLOUD = "true";
-    delete process.env.IS_CLOUD;
   });
 
   afterEach(() => {
     rmSync(workspace, { recursive: true, force: true });
-    restoreEnv();
   });
 
   test("resolves an external plugin: catalog metadata + repo README/package.json", async () => {
@@ -234,6 +281,23 @@ describe("getPluginDetails (bundled catalog, offline)", () => {
       if (url === "raw://caveman/readme") {
         return new Response("# Caveman", { status: 200 });
       }
+      if (url.includes("/v1/plugins")) {
+        return new Response(
+          JSON.stringify({
+            plugins: CATALOG_FIXTURES.map((e) => ({
+              name: e.name,
+              ...(e.source.source === "github"
+                ? { repo: e.source.repo, ref: e.source.ref }
+                : {}),
+              description: e.description,
+              category: e.category,
+              homepage: e.homepage,
+              license: e.license,
+            })),
+          }),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      }
       return new Response("unexpected url: " + url, { status: 500 });
     }) as FetchLike;
 
@@ -465,68 +529,24 @@ describe("getPluginDetails (bundled catalog, offline)", () => {
     expect(details.source).toEqual(caveman.source);
   });
 
-  test("resolves an explicit historical ref via the GitHub marketplace, not the gated catalog", async () => {
-    // GIVEN an explicit historical ref and a name absent from the gated catalog
+  test("an explicit historical ref no longer resolves — the catalog has no history", async () => {
+    // The retired local marketplace manifest could be read at any git ref;
+    // the cloud catalog has no revisions, so a historical ref resolves to
+    // nothing and a not-installed plugin 404s.
     const historicalRef = "a".repeat(40);
-    const historicalRepo = "octo/time-machine";
-    const marketplaceRefs: string[] = [];
-    const fetch = (async (input: RequestInfo | URL) => {
-      const url = typeof input === "string" ? input : input.toString();
-      // The marketplace manifest, read at the requested historical ref
-      if (url.includes("/contents/plugins/marketplace.json")) {
-        marketplaceRefs.push(new URL(url).searchParams.get("ref") ?? "");
-        return new Response(
-          JSON.stringify({
-            name: "cadet",
-            plugins: [
-              {
-                name: "time-traveler",
-                source: {
-                  source: "github",
-                  repo: historicalRepo,
-                  ref: "b".repeat(40),
-                },
-                description: "historical description",
-                homepage: "https://historical.example.com",
-                license: "MIT",
-              },
-            ],
-          }),
-          { status: 200 },
-        );
-      }
-      // The entry's own external repo, read at its pinned source ref
-      if (url.includes("/contents") && url.includes(historicalRepo)) {
-        return new Response(
-          JSON.stringify([fileEntry("README.md", "raw://hist/readme")]),
-          { status: 200, headers: { "content-type": "application/json" } },
-        );
-      }
-      if (url === "raw://hist/readme") {
-        return new Response("# Time Traveler (historical)", { status: 200 });
-      }
-      return new Response("unexpected url: " + url, { status: 500 });
+    let fetchCalls = 0;
+    const fetch = (async () => {
+      fetchCalls += 1;
+      return new Response("unexpected request", { status: 500 });
     }) as FetchLike;
 
-    // WHEN we resolve the detail view at the historical ref
-    const details = await getPluginDetails(
-      { name: "time-traveler", ref: historicalRef },
-      { fetch, workspacePluginsDir: workspace },
-    );
-
-    // THEN the marketplace manifest was read at the requested historical ref
-    expect(marketplaceRefs).toContain(historicalRef);
-    // AND source + metadata come from that historical entry, not the gated catalog
-    expect(details.source).toEqual({
-      kind: "github",
-      repo: historicalRepo,
-      ref: "b".repeat(40),
-    });
-    expect(details.description).toBe("historical description");
-    expect(details.homepage).toBe("https://historical.example.com");
-    expect(details.license).toBe("MIT");
-    expect(details.readme).toContain("historical");
-    expect(details.ref).toBe(historicalRef);
+    await expect(
+      getPluginDetails(
+        { name: "time-traveler", ref: historicalRef },
+        { fetch, workspacePluginsDir: workspace },
+      ),
+    ).rejects.toBeInstanceOf(PluginDetailsNotFoundError);
+    expect(fetchCalls).toBe(0);
   });
 
   test("hides a gated integration at an explicit historical ref", async () => {
@@ -738,14 +758,11 @@ describe("getPluginDetails (catalog unavailable, platform enabled)", () => {
   beforeEach(() => {
     workspace = mkdtempSync(join(tmpdir(), "plugin-details-"));
     invalidatePluginCatalogCache();
-    delete process.env.IS_CLOUD;
-    delete process.env.CADET_DISABLE_CLOUD;
   });
 
   afterEach(() => {
     rmSync(workspace, { recursive: true, force: true });
     invalidatePluginCatalogCache();
-    restoreEnv();
   });
 
   test("an installed copy still renders from disk when the catalog is down", async () => {

package/src/cli/lib/__tests__/search-plugins.test.ts

@@ -8,7 +8,6 @@
 
 import { describe, expect, test } from "bun:test";
 
-import { buildBundledPluginCatalog } from "../plugin-catalog-local.js";
 import type { MarketplaceEntry } from "../plugin-marketplace.js";
 import {
   assertValidSearchPattern,
@@ -58,13 +57,7 @@ function entry(
 /** Build a resolved {@link PluginCatalog} from raw entries the way the catalog
  * sources do (dedupe by name, project, sort), reusing the real projection. */
 function catalog(entries: MarketplaceEntry[], ref = "main"): PluginCatalog {
-  return {
-    ...buildBundledPluginCatalog({
-      name: "mycadet",
-      plugins: entries,
-    }),
-    ref,
-  };
+  return { ref, matches: projectMarketplaceEntries(entries) };
 }
 
 describe("filterPluginCatalog", () => {
@@ -151,13 +144,13 @@ describe("assertValidSearchPattern", () => {
 });
 
 describe("marketplaceMatch", () => {
-  test("projects a bundled MCP package and its integration metadata", () => {
+  test("projects an MCP package's integration metadata", () => {
     const match = marketplaceMatch({
       name: "fathom",
       source: {
-        source: "local",
-        path: "plugins/mcp-catalog/fathom",
-        version: "1.0.0",
+        source: "github",
+        repo: "acme/fathom",
+        ref: SHA_A,
       },
       integration: {
         kind: "mcp",
@@ -172,12 +165,12 @@ describe("marketplaceMatch", () => {
 
     expect(match).toMatchObject({
       name: "fathom",
-      path: "local:plugins/mcp-catalog/fathom@1.0.0",
+      path: `github:acme/fathom@${SHA_A}`,
       integration: { kind: "mcp", logo: "fathom.png" },
       source: {
-        kind: "local",
-        path: "plugins/mcp-catalog/fathom",
-        version: "1.0.0",
+        kind: "github",
+        repo: "acme/fathom",
+        ref: SHA_A,
       },
     });
   });

package/src/cli/lib/__tests__/uninstall-plugin.test.ts

@@ -43,7 +43,7 @@ mock.module("../../../mcp/mcp-oauth-provider.js", () => ({
 }));
 
 import { resetHookCacheForTests } from "../../../hooks/hook-loader.js";
-import { getWorkspacePluginsDir } from "../../../util/platform.js";
+import { getWorkspacePluginsDir } from "../../../util/layout.js";
 import { InvalidPluginNameError } from "../install-from-github.js";
 const { PluginNotInstalledError, uninstallPlugin } =
   await import("../uninstall-plugin.js");

package/src/cli/lib/__tests__/upgrade-plugin.test.ts

@@ -28,6 +28,7 @@ import {
   PluginNotFoundError,
   PluginSourceUnavailableError,
 } from "../install-from-github.js";
+import { invalidatePluginCatalogCache } from "../plugin-catalog-cache.js";
 import { computeFingerprint } from "../plugin-fingerprint.js";
 import { PluginNotInstalledError } from "../uninstall-plugin.js";
 import {
@@ -40,7 +41,7 @@ import {
 const SHA_A = "a".repeat(40);
 const SHA_B = "b".repeat(40);
 const CANON_REPO = "vargasjr-dev/mycadet";
-const MANIFEST_URL = `https://api.github.com/repos/${CANON_REPO}/contents/plugins/marketplace.json`;
+const CATALOG_URL = "https://test-cloud.mycadet.ai/v1/plugins/";
 const CONTENTS = `https://api.github.com/repos/${CANON_REPO}/contents/`;
 
 /** A marketplace manifest pinning `name` to `ref`. */
@@ -60,11 +61,11 @@ function manifestWith(name: string, ref: string): unknown {
 }
 
 /**
- * Build a `fetch` that serves the marketplace manifest and answers the GitHub
- * Contents API listing (used by the adapter-stub lookup) with a 404, so the
- * clone is treated as a raw external tree. `manifest: undefined` answers the
- * manifest with 404; `manifestStatus` overrides the manifest status to
- * simulate a transient marketplace failure.
+ * Build a `fetch` that serves the plugin catalog (a manifest flattened into
+ * cloud rows) and answers the GitHub Contents API listing (used by the
+ * adapter-stub lookup) with a 404, so the clone is treated as a raw external
+ * tree. `manifest: undefined` serves an empty catalog; `manifestStatus`
+ * overrides the catalog status to simulate a transient failure.
  */
 function makeFetch(opts: {
   manifest?: unknown;
@@ -73,16 +74,33 @@ function makeFetch(opts: {
 }): FetchLike {
   return (async (input: RequestInfo | URL) => {
     const url = typeof input === "string" ? input : input.toString();
-    if (url.startsWith(MANIFEST_URL)) {
+    if (url.startsWith(CATALOG_URL)) {
       if (opts.manifestStatus !== undefined && opts.manifestStatus !== 200) {
-        return new Response("manifest unavailable", {
+        return new Response("catalog unavailable", {
           status: opts.manifestStatus,
         });
       }
       if (opts.manifest === undefined) {
-        return new Response("not found", { status: 404 });
+        return new Response(JSON.stringify({ plugins: [] }), { status: 200 });
       }
-      return new Response(JSON.stringify(opts.manifest), { status: 200 });
+      const manifest = opts.manifest as {
+        plugins?: Array<{
+          name: string;
+          source?: { source: string; repo?: string; ref?: string };
+          description?: string;
+          category?: string;
+          license?: string;
+        }>;
+      };
+      const rows = (manifest.plugins ?? []).map((entry) => ({
+        name: entry.name,
+        ...(entry.source?.repo ? { repo: entry.source.repo } : {}),
+        ...(entry.source?.ref ? { ref: entry.source.ref } : {}),
+        description: entry.description,
+        category: entry.category,
+        license: entry.license,
+      }));
+      return new Response(JSON.stringify({ plugins: rows }), { status: 200 });
     }
     // The remote commit date `inspect` resolves to surface the human-readable
     // "to" timestamp; absent it 404s and the timestamp degrades to null.
@@ -230,6 +248,9 @@ beforeEach(() => {
   ws = mkdtempSync(join(tmpdir(), "upgrade-plugin-"));
   pluginsDir = join(ws, "plugins");
   mkdirSync(pluginsDir, { recursive: true });
+  invalidatePluginCatalogCache();
+  delete process.env.CADET_DISABLE_CLOUD;
+  delete process.env.IS_CLOUD;
 });
 
 afterEach(() => {
@@ -285,15 +306,15 @@ describe("upgradePlugin", () => {
     expect(result.toTimestamp).toBe("2026-06-05T08:12:24.000Z");
   });
 
-  test("a dry run resolves the target timestamp from the marketplace pin", async () => {
-    // GIVEN an installed copy and a marketplace pin whose commit GitHub dates
+  test("a dry run previews the target pin without a timestamp", async () => {
+    // GIVEN an installed copy and a marketplace pin that has advanced — the
+    // cloud catalog carries no commit dates, so the target timestamp is null
     installCopy(pluginsDir, "level-up", {
       commit: SHA_A,
       committedAt: "2026-06-01T12:34:56.000Z",
     });
     const fetch = makeFetch({
       manifest: manifestWith("level-up", SHA_B),
-      remoteCommitDate: "2026-06-05T08:12:24.000Z",
     });
 
     // WHEN a dry-run upgrade is performed (git must never run)
@@ -302,9 +323,9 @@ describe("upgradePlugin", () => {
       { fetch, runGit: unusedGitRunner, workspacePluginsDir: pluginsDir },
     );
 
-    // THEN the preview shows the timestamp move resolved without a clone
+    // THEN the preview shows the recorded timestamp and a null target one
     expect(result.fromTimestamp).toBe("2026-06-01T12:34:56.000Z");
-    expect(result.toTimestamp).toBe("2026-06-05T08:12:24.000Z");
+    expect(result.toTimestamp).toBeNull();
   });
 
   test("is a no-op when the installed commit already equals the pin", async () => {
@@ -498,6 +519,7 @@ describe("upgradePlugin", () => {
       },
     );
     expect(dry.outcome).toBe("would-upgrade");
+    invalidatePluginCatalogCache();
 
     // No-op: the install already sits at the pin.
     const noop = await upgradePlugin(
@@ -1245,6 +1267,7 @@ describe("upgradePlugin confirmStaged consent gate", () => {
       },
     );
     expect(dry.outcome).toBe("would-upgrade");
+    invalidatePluginCatalogCache();
 
     const noop = await upgradePlugin(
       { name: "level-up" },

package/src/cli/lib/diff-plugin.ts

@@ -39,7 +39,7 @@ import { join } from "node:path";
 import { createTwoFilesPatch } from "diff";
 
 import { PRESERVED_ENTRIES } from "../../plugins/plugin-tree-walk.js";
-import { getWorkspacePluginsDir } from "../../util/platform.js";
+import { getWorkspacePluginsDir } from "../../util/layout.js";
 import type { FetchLike } from "./fetch-like.js";
 import {
   type GitRunner,

package/src/cli/lib/inspect-plugin.ts

@@ -29,25 +29,18 @@ import {
   type InstalledPluginInfo,
   readInstalledPlugin,
 } from "./list-installed-plugins.js";
-import {
-  areCloudFeaturesEnabled,
-  readBundledLocalPluginCatalog,
-} from "./plugin-catalog-local.js";
+import { getPluginCatalog } from "./plugin-catalog-cache.js";
 import { isPluginCatalogEntryVisible } from "./plugin-catalog-visibility.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import {
   compareFingerprint,
   type FingerprintComparison,
 } from "./plugin-fingerprint.js";
-import {
-  fetchMarketplaceEntries,
-  type MarketplaceEntry,
-} from "./plugin-marketplace.js";
 import {
   detectPluginSurfaces,
   type PluginSurfaces,
 } from "./plugin-surfaces.js";
-import type { PluginCatalog, PluginSearchMatch } from "./search-plugins.js";
+import type { PluginSearchMatch } from "./search-plugins.js";
 import { USER_AGENT } from "./user-agent.js";
 
 /** Full commit SHA (40 hex SHA-1 or 64 hex SHA-256). */
@@ -118,8 +111,6 @@ export interface PluginLocalInfo {
 
 /** The marketplace's current pin and advertised metadata for a plugin. */
 export interface PluginRemoteInfo {
-  /** Present for a package embedded in the assistant distribution. */
-  readonly kind?: "local";
   /** `owner/repo` of the external plugin repository. */
   readonly repo: string;
   /** Repo-relative directory holding the plugin root; `""` = repo root. */
@@ -138,8 +129,6 @@ export interface PluginRemoteInfo {
   readonly category: string | null;
   /** Ref of the canonical repo the marketplace manifest was read from. */
   readonly marketplaceRef: string;
-  /** Bundled package version. Present when {@link kind} is `local`. */
-  readonly version?: string;
 }
 
 /** Resolved inspection of a single plugin. */
@@ -186,8 +175,6 @@ export interface InspectPluginDeps {
   readonly fetch: FetchLike;
   /** Override the workspace plugins directory. Falls back to the live workspace. */
   readonly workspacePluginsDir?: string;
-  /** Override the embedded local-package catalog for focused tests. */
-  readonly localCatalog?: PluginCatalog;
 }
 
 function readLocal(
@@ -221,58 +208,20 @@ function readLocal(
   };
 }
 
-function readRemote(
-  entry: MarketplaceEntry,
-  marketplaceRef: string,
-  committedAt: string | null,
-): PluginRemoteInfo {
-  if (entry.source.source === "local") {
-    return {
-      kind: "local",
-      repo: "",
-      path: entry.source.path,
-      commit: entry.source.version,
-      committedAt: null,
-      description: entry.description ?? null,
-      homepage: entry.homepage ?? null,
-      license: entry.license ?? null,
-      category: entry.category ?? null,
-      marketplaceRef,
-      version: entry.source.version,
-    };
-  }
-  return {
-    repo: entry.source.repo,
-    path: entry.source.path ?? "",
-    commit: entry.source.ref,
-    committedAt,
-    description: entry.description ?? null,
-    homepage: entry.homepage ?? null,
-    license: entry.license ?? null,
-    category: entry.category ?? null,
-    marketplaceRef,
-  };
-}
-
-function readLocalPackageRemote(
+function readCatalogRemote(
   match: PluginSearchMatch,
   marketplaceRef: string,
-): PluginRemoteInfo | null {
-  if (match.source.kind !== "local") {
-    return null;
-  }
+): PluginRemoteInfo {
   return {
-    kind: "local",
-    repo: "",
-    path: match.source.path,
-    commit: match.source.version,
+    repo: match.source.repo,
+    path: match.source.path ?? "",
+    commit: match.source.ref,
     committedAt: null,
     description: match.description ?? null,
     homepage: match.homepage ?? null,
     license: match.license ?? null,
     category: match.category,
     marketplaceRef,
-    version: match.source.version,
   };
 }
 
@@ -346,38 +295,13 @@ export async function inspectPlugin(
 
   let remote: PluginRemoteInfo | null = null;
   let remoteError: string | null = null;
-  const installedLocalSource = local?.source?.kind === "local";
-  const useBundledLocalCatalog =
-    installedLocalSource || (!installed && !areCloudFeaturesEnabled());
   try {
-    if (useBundledLocalCatalog) {
-      const catalog = deps.localCatalog ?? readBundledLocalPluginCatalog();
-      const match = catalog.matches.find(
-        (candidate) =>
-          candidate.name === name &&
-          candidate.source.kind === "local" &&
-          (!installedLocalSource ||
-            candidate.source.path === local.source?.path),
-      );
-      remote = match ? readLocalPackageRemote(match, catalog.ref) : null;
-    }
-    if (!remote && !installedLocalSource) {
-      const entries = await fetchMarketplaceEntries(
-        { fetch: deps.fetch },
-        { ref: marketplaceRef },
-      );
-      const match = entries.find((entry) => entry.name === name);
-      if (match) {
-        const committedAt =
-          match.source.source === "github"
-            ? await fetchCommitDate(
-                match.source.repo,
-                match.source.ref,
-                deps.fetch,
-              )
-            : null;
-        remote = readRemote(match, marketplaceRef, committedAt);
-      }
+    const catalog = await getPluginCatalog(marketplaceRef, {
+      fetch: deps.fetch,
+    });
+    const match = catalog.matches.find((candidate) => candidate.name === name);
+    if (match) {
+      remote = readCatalogRemote(match, marketplaceRef);
     }
   } catch (err) {
     remoteError = err instanceof Error ? err.message : String(err);
@@ -408,14 +332,6 @@ function classify(
   if (!remote) {
     return "not-in-marketplace";
   }
-  if (remote.kind === "local") {
-    if (local?.source?.kind !== "local") {
-      return "unknown-provenance";
-    }
-    return local.source.version === remote.version
-      ? "up-to-date"
-      : "update-available";
-  }
   if (!local?.commit) {
     return "unknown-provenance";
   }