@vellumai/assistant 0.12.4-staging.3 → 0.12.4-staging.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.4-staging.3",
+  "version": "0.12.4-staging.4",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cli/commands/__tests__/plugins.test.ts

@@ -66,6 +66,20 @@ let platformInstallCalls: Array<{ name: string; force?: boolean }> = [];
 let upgradePluginCalls: UpgradePluginOptions[] = [];
 let catalogMatches: PluginSearchMatch[] = [];
 let catalogError: Error | null = null;
+const CATALOG_COMMIT = "a".repeat(40);
+
+function githubCatalogMatch(name: string): PluginSearchMatch {
+  return {
+    name,
+    path: `github:example-org/${name}@${CATALOG_COMMIT}`,
+    category: null,
+    source: {
+      kind: "github",
+      repo: `example-org/${name}`,
+      ref: CATALOG_COMMIT,
+    },
+  };
+}
 
 /**
  * Queued daemon IPC responses. The default (empty queue) is a transport
@@ -269,7 +283,10 @@ beforeEach(() => {
   installPluginCalls = [];
   platformInstallCalls = [];
   upgradePluginCalls = [];
-  catalogMatches = [];
+  catalogMatches = [
+    githubCatalogMatch("example"),
+    githubCatalogMatch("imessage"),
+  ];
   catalogError = null;
   ipcResults = [];
   inspectResult = null;
@@ -485,6 +502,17 @@ describe("plugins install - declared-schedules consent", () => {
     ]);
     expect(r.exitCode).toBe(0);
   });
+
+  test("does not use the outage fallback for a gated integration", async () => {
+    catalogError = new Error("catalog unavailable");
+
+    const r = await runCommand(["plugins", "install", "gamma"]);
+
+    expect(installPluginCalls).toHaveLength(0);
+    expect(platformInstallCalls).toHaveLength(0);
+    expect(r.stderr).toContain("not in the marketplace catalog");
+    expect(r.exitCode).toBe(1);
+  });
 });
 
 describe("plugins upgrade - declared-schedules consent (local fallback)", () => {

package/src/cli/commands/plugins.ts

@@ -238,7 +238,15 @@ export function registerPluginsCommand(program: Command): void {
               const platformEnabled =
                 libs.catalogLocal.arePlatformFeaturesEnabled();
               if (platformEnabled) {
+                if (!libs.catalogLocal.isPluginCatalogEntryVisible(nameOrUrl)) {
+                  console.error(
+                    `Plugin "${nameOrUrl}" is not in the marketplace catalog.`,
+                  );
+                  process.exitCode = 1;
+                  return;
+                }
                 let match;
+                let catalogResolved = false;
                 try {
                   match = (
                     await libs.catalogCache.getPluginCatalog(
@@ -246,10 +254,18 @@ export function registerPluginsCommand(program: Command): void {
                       { fetch: globalThis.fetch.bind(globalThis) },
                     )
                   ).matches.find((candidate) => candidate.name === nameOrUrl);
+                  catalogResolved = true;
                 } catch {
                   // The install endpoint remains authoritative and can succeed
                   // independently when catalog discovery is unavailable.
                 }
+                if (!match && catalogResolved) {
+                  console.error(
+                    `Plugin "${nameOrUrl}" is not in the marketplace catalog.`,
+                  );
+                  process.exitCode = 1;
+                  return;
+                }
                 if (match?.source.kind === "local") {
                   result = await libs.installGitHub.installPlugin(
                     {

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

@@ -306,6 +306,35 @@ describe("inspectPlugin", () => {
     expect(result.remote?.commit).toBe(SHA_B);
   });
 
+  test("hides an uninstalled gated integration without fetching the marketplace", async () => {
+    let fetchCalls = 0;
+    const fetch = (async () => {
+      fetchCalls += 1;
+      return new Response("unexpected request", { status: 500 });
+    }) as FetchLike;
+
+    await expect(
+      inspectPlugin(
+        { name: "gamma" },
+        { fetch, workspacePluginsDir: workspace },
+      ),
+    ).rejects.toBeInstanceOf(PluginInspectNotFoundError);
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("keeps an installed gated integration inspectable", async () => {
+    installPlugin(workspace, "gamma", { sidecar: null });
+    const fetch = makeFetch({ marketplace: manifestWith("gamma", SHA_B) });
+
+    const result = await inspectPlugin(
+      { name: "gamma" },
+      { fetch, workspacePluginsDir: workspace },
+    );
+
+    expect(result.installed).toBe(true);
+    expect(result.local?.description).toBe("Installed copy.");
+  });
+
   test("previews an uninstalled bundled provider offline without fetching GitHub", async () => {
     const savedDisablePlatform = process.env.VELLUM_DISABLE_PLATFORM;
     const savedIsPlatform = process.env.IS_PLATFORM;

package/src/cli/lib/__tests__/plugin-catalog-cache.test.ts

@@ -19,6 +19,7 @@ import {
 import type { FetchLike } from "../fetch-like.js";
 import {
   getPluginCatalog,
+  getPluginCatalogForInstalledMetadata,
   invalidatePluginCatalogCache,
   mergePlatformCatalogWithBundledLocals,
   PLUGIN_CATALOG_CACHE_TTL_MS,
@@ -102,7 +103,7 @@ describe("getPluginCatalog", () => {
 
     // THEN the platform is fetched exactly once — the second call is cached
     expect(calls()).toBe(1);
-    expect(first).toBe(second);
+    expect(first).toEqual(second);
     expect(githubNames(first)).toEqual(["a"]);
     expect(first.ref).toBe("main");
   });
@@ -161,7 +162,10 @@ describe("getPluginCatalog", () => {
     delete process.env.IS_PLATFORM;
 
     const { fetch, calls } = platformFetch(["ignored"]);
-    const deps: SearchPluginsDeps = { fetch };
+    const deps: SearchPluginsDeps = {
+      fetch,
+      featureFlagEnabled: () => true,
+    };
 
     // WHEN we request the catalog
     const result = await getPluginCatalog("main", deps);
@@ -173,6 +177,32 @@ describe("getPluginCatalog", () => {
     // The requested ref is echoed onto the wire contract.
     expect(result.ref).toBe("main");
   });
+
+  test("applies feature-flag visibility to bundled catalog entries", async () => {
+    process.env.VELLUM_DISABLE_PLATFORM = "true";
+    delete process.env.IS_PLATFORM;
+
+    const { fetch } = platformFetch(["ignored"]);
+    const result = await getPluginCatalog("main", {
+      fetch,
+      featureFlagEnabled: () => false,
+    });
+
+    expect(result.matches.map((match) => match.name)).not.toContain("gamma");
+    expect(result.matches.map((match) => match.name)).toContain("fathom");
+  });
+
+  test("preserves hidden entries for installed-plugin metadata", async () => {
+    process.env.VELLUM_DISABLE_PLATFORM = "true";
+    delete process.env.IS_PLATFORM;
+
+    const { fetch } = platformFetch(["ignored"]);
+    const result = await getPluginCatalogForInstalledMetadata("main", {
+      fetch,
+    });
+
+    expect(result.matches.map((match) => match.name)).toContain("gamma");
+  });
 });
 
 describe("mergePlatformCatalogWithBundledLocals", () => {

package/src/cli/lib/__tests__/plugin-catalog-local.test.ts

@@ -13,6 +13,7 @@ import bundledManifest from "../bundled-marketplace.json" with { type: "json" };
 import {
   buildBundledPluginCatalog,
   readBundledPluginCatalog,
+  resolveBundledPluginSource,
 } from "../plugin-catalog-local.js";
 import { marketplaceManifestSchema } from "../plugin-marketplace.js";
 import { marketplaceMatch } from "../search-plugins.js";
@@ -96,3 +97,17 @@ describe("readBundledPluginCatalog", () => {
     expect(readBundledPluginCatalog()).toBe(readBundledPluginCatalog());
   });
 });
+
+describe("resolveBundledPluginSource", () => {
+  test("hides a QA integration while its feature flag is off", () => {
+    expect(resolveBundledPluginSource("gamma", () => false)).toBeNull();
+  });
+
+  test("resolves a QA integration while its feature flag is on", () => {
+    expect(resolveBundledPluginSource("gamma", () => true)).toEqual({
+      kind: "local",
+      path: "plugins/mcp-catalog/gamma",
+      version: "1.0.2",
+    });
+  });
+});

package/src/cli/lib/__tests__/plugin-catalog-resolve.test.ts

@@ -195,6 +195,27 @@ describe("catalog-backed resolvers (bundled, offline)", () => {
       await resolvePluginSourceFromCatalog("no-such-plugin", rejectingDeps),
     ).toBeNull();
   });
+
+  test("does not resolve a QA integration while its feature flag is off", async () => {
+    expect(
+      await resolvePluginSourceFromCatalog("gamma", {
+        ...rejectingDeps,
+        featureFlagEnabled: () => false,
+      }),
+    ).toBeNull();
+  });
+
+  test("resolves a QA integration while its feature flag is on", async () => {
+    expect(
+      await resolvePluginSourceFromCatalog("gamma", {
+        ...rejectingDeps,
+        featureFlagEnabled: () => true,
+      }),
+    ).toMatchObject({
+      kind: "local",
+      path: "plugins/mcp-catalog/gamma",
+    });
+  });
 });
 
 describe("catalog-backed resolvers (platform enabled)", () => {

package/src/cli/lib/__tests__/plugin-catalog-visibility.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  filterPluginCatalogByFeatureFlags,
+  MCP_CATALOG_QA_INTEGRATIONS_FLAG,
+} from "../plugin-catalog-visibility.js";
+import type { PluginCatalog, PluginSearchMatch } from "../search-plugins.js";
+
+function match(name: string): PluginSearchMatch {
+  return {
+    name,
+    path: `local:plugins/mcp-catalog/${name}@1.0.0`,
+    category: null,
+    source: {
+      kind: "local",
+      path: `plugins/mcp-catalog/${name}`,
+      version: "1.0.0",
+    },
+  };
+}
+
+function catalog(names: string[]): PluginCatalog {
+  return { ref: "main", matches: names.map(match) };
+}
+
+describe("filterPluginCatalogByFeatureFlags", () => {
+  test("hides QA integrations while the flag is off", () => {
+    const input = catalog([
+      "fathom",
+      "gamma",
+      "guru",
+      "intercom",
+      "ramp",
+      "semrush",
+      "typeform",
+      "notion",
+    ]);
+
+    const result = filterPluginCatalogByFeatureFlags(input, (key) => {
+      expect(key).toBe(MCP_CATALOG_QA_INTEGRATIONS_FLAG);
+      return false;
+    });
+
+    expect(result.matches.map((entry) => entry.name)).toEqual([
+      "fathom",
+      "notion",
+    ]);
+  });
+
+  test("returns the full catalog while the flag is on", () => {
+    const input = catalog([
+      "fathom",
+      "gamma",
+      "guru",
+      "intercom",
+      "ramp",
+      "semrush",
+      "typeform",
+    ]);
+
+    const result = filterPluginCatalogByFeatureFlags(input, () => true);
+
+    expect(result).toBe(input);
+  });
+});

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

@@ -513,6 +513,49 @@ describe("getPluginDetails (bundled catalog, offline)", () => {
     expect(details.ref).toBe(historicalRef);
   });
 
+  test("hides a gated integration at an explicit historical ref", async () => {
+    const historicalRef = "a".repeat(40);
+    let fetchCalls = 0;
+    const fetch = (async () => {
+      fetchCalls += 1;
+      return new Response("unexpected request", { status: 500 });
+    }) as FetchLike;
+
+    await expect(
+      getPluginDetails(
+        { name: "gamma", ref: historicalRef },
+        { fetch, workspacePluginsDir: workspace },
+      ),
+    ).rejects.toBeInstanceOf(PluginDetailsNotFoundError);
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("keeps an installed gated integration visible at an explicit historical ref", async () => {
+    const target = join(workspace, "gamma");
+    mkdirSync(target, { recursive: true });
+    writeFileSync(join(target, "README.md"), "# Installed Gamma");
+    writeFileSync(
+      join(target, "package.json"),
+      JSON.stringify({ version: "1.0.0", description: "local gamma" }),
+    );
+    let fetchCalls = 0;
+    const fetch = (async () => {
+      fetchCalls += 1;
+      return new Response("unexpected request", { status: 500 });
+    }) as FetchLike;
+
+    const details = await getPluginDetails(
+      { name: "gamma", ref: "a".repeat(40) },
+      { fetch, workspacePluginsDir: workspace },
+    );
+
+    expect(details.installed).toBe(true);
+    expect(details.readme).toBe("# Installed Gamma");
+    expect(details.description).toBe("local gamma");
+    expect(details.source).toBeNull();
+    expect(fetchCalls).toBe(0);
+  });
+
   test("degrades gracefully when the historical marketplace fetch fails", async () => {
     // GIVEN an installed copy and a historical ref whose marketplace fetch errors
     const historicalRef = "a".repeat(40);

package/src/cli/lib/__tests__/plugins-install-offline.test.ts

@@ -172,6 +172,17 @@ describe("plugins install by name — disable-platform mode", () => {
     expect(message).toContain("not in the bundled marketplace catalog");
   });
 
+  test("does not install a feature-gated bundled integration", async () => {
+    process.env.VELLUM_DISABLE_PLATFORM = "true";
+    delete process.env.IS_PLATFORM;
+
+    await runInstall("gamma");
+
+    expect(installPluginCalls).toHaveLength(0);
+    expect(platformInstallCalls).toHaveLength(0);
+    expect(process.exitCode).toBe(1);
+  });
+
   test("uses the platform install endpoint when platform features are enabled", async () => {
     delete process.env.VELLUM_DISABLE_PLATFORM;
     delete process.env.IS_PLATFORM;
@@ -184,6 +195,21 @@ describe("plugins install by name — disable-platform mode", () => {
     expect(process.exitCode).not.toBe(1);
   });
 
+  test("does not install a name absent from a successful platform catalog", async () => {
+    delete process.env.VELLUM_DISABLE_PLATFORM;
+    delete process.env.IS_PLATFORM;
+    const errSpy = spyOn(console, "error").mockImplementation(() => {});
+
+    await runInstall("gamma");
+
+    expect(installPluginCalls).toHaveLength(0);
+    expect(platformInstallCalls).toHaveLength(0);
+    expect(process.exitCode).toBe(1);
+    expect(String(errSpy.mock.calls[0]?.[0])).toContain(
+      "not in the marketplace catalog",
+    );
+  });
+
   test("installs a platform-visible local package without the platform tar endpoint", async () => {
     delete process.env.VELLUM_DISABLE_PLATFORM;
     delete process.env.IS_PLATFORM;

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

@@ -31,6 +31,7 @@ import {
   arePlatformFeaturesEnabled,
   readBundledLocalPluginCatalog,
 } from "./plugin-catalog-local.js";
+import { isPluginCatalogEntryVisible } from "./plugin-catalog-visibility.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import {
   compareFingerprint,
@@ -338,6 +339,10 @@ export async function inspectPlugin(
   const local = entry ? readLocal(entry, readInstallMeta(entry.target)) : null;
   const surfaces = entry ? detectPluginSurfaces(entry.target) : null;
 
+  if (!installed && !isPluginCatalogEntryVisible(name)) {
+    throw new PluginInspectNotFoundError(name);
+  }
+
   let remote: PluginRemoteInfo | null = null;
   let remoteError: string | null = null;
   const installedLocalSource = local?.source?.kind === "local";

package/src/cli/lib/plugin-catalog-cache.ts

@@ -14,6 +14,7 @@ import {
   readBundledPluginCatalog,
 } from "./plugin-catalog-local.js";
 import { fetchPluginCatalogFromPlatform } from "./plugin-catalog-platform.js";
+import { filterPluginCatalogByFeatureFlags } from "./plugin-catalog-visibility.js";
 import type { PluginCatalog, SearchPluginsDeps } from "./search-plugins.js";
 
 /** How long a fetched catalog is served before a refresh is attempted. */
@@ -24,6 +25,8 @@ interface CacheEntry {
   timestamp: number;
 }
 
+type PluginCatalogLoadDeps = Pick<SearchPluginsDeps, "fetch">;
+
 const cache = new Map<string, CacheEntry>();
 
 /** Add bundled local packages without overriding platform-authoritative rows. */
@@ -50,9 +53,9 @@ export function mergePlatformCatalogWithBundledLocals(
  * fetch failure propagates so the caller can surface it (e.g. map a rate-limit
  * to 503) — no stale catalog is ever served.
  */
-export async function getPluginCatalog(
+async function loadPluginCatalog(
   ref: string,
-  deps: SearchPluginsDeps,
+  deps: PluginCatalogLoadDeps,
 ): Promise<PluginCatalog> {
   if (!arePlatformFeaturesEnabled()) {
     return { ...readBundledPluginCatalog(), ref };
@@ -69,6 +72,25 @@ export async function getPluginCatalog(
   return merged;
 }
 
+/** Installable catalog with feature-flag visibility applied. */
+export async function getPluginCatalog(
+  ref: string,
+  deps: SearchPluginsDeps,
+): Promise<PluginCatalog> {
+  return filterPluginCatalogByFeatureFlags(
+    await loadPluginCatalog(ref, deps),
+    deps.featureFlagEnabled,
+  );
+}
+
+/** Category metadata for plugins already installed, including hidden entries. */
+export async function getPluginCatalogForInstalledMetadata(
+  ref: string,
+  deps: PluginCatalogLoadDeps,
+): Promise<PluginCatalog> {
+  return loadPluginCatalog(ref, deps);
+}
+
 /** Invalidate the cache (for testing or forced refresh). */
 export function invalidatePluginCatalogCache(): void {
   cache.clear();

package/src/cli/lib/plugin-catalog-local.ts

@@ -13,6 +13,10 @@
  */
 
 import bundledManifest from "./bundled-marketplace.json" with { type: "json" };
+import {
+  isPluginCatalogEntryVisible,
+  type PluginCatalogFeatureFlagResolver,
+} from "./plugin-catalog-visibility.js";
 import {
   type MarketplaceEntry,
   marketplaceManifestSchema,
@@ -27,6 +31,7 @@ import {
 // Re-exported so `local`-tagged CLI commands can gate on platform features
 // without importing `platform/` directly (cli/no-daemon-internals allows lib).
 export { arePlatformFeaturesEnabled } from "../../platform/feature-gate.js";
+export { isPluginCatalogEntryVisible };
 
 let memoizedEntries: readonly MarketplaceEntry[] | undefined;
 
@@ -80,6 +85,10 @@ export function readBundledLocalPluginCatalog(): PluginCatalog {
  */
 export function resolveBundledPluginSource(
   name: string,
+  isFeatureFlagEnabled?: PluginCatalogFeatureFlagResolver,
 ): ResolvedPluginSource | null {
+  if (!isPluginCatalogEntryVisible(name, isFeatureFlagEnabled)) {
+    return null;
+  }
   return resolveMarketplaceSource(name, bundledEntries());
 }

package/src/cli/lib/plugin-catalog-visibility.ts

@@ -0,0 +1,41 @@
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import type { PluginCatalog } from "./search-plugins.js";
+
+export const MCP_CATALOG_QA_INTEGRATIONS_FLAG = "mcp-catalog-qa-integrations";
+
+const MCP_CATALOG_QA_INTEGRATION_NAMES = new Set([
+  "gamma",
+  "guru",
+  "intercom",
+  "ramp",
+  "semrush",
+  "typeform",
+]);
+
+export type PluginCatalogFeatureFlagResolver = (key: string) => boolean;
+
+export function isPluginCatalogEntryVisible(
+  name: string,
+  isFeatureFlagEnabled: PluginCatalogFeatureFlagResolver = isAssistantFeatureFlagEnabled,
+): boolean {
+  return (
+    !MCP_CATALOG_QA_INTEGRATION_NAMES.has(name) ||
+    isFeatureFlagEnabled(MCP_CATALOG_QA_INTEGRATIONS_FLAG)
+  );
+}
+
+/**
+ * Hide catalog entries whose OAuth flows are still being validated. Installed
+ * plugins are unaffected because this filter only applies to catalog reads.
+ */
+export function filterPluginCatalogByFeatureFlags(
+  catalog: PluginCatalog,
+  isFeatureFlagEnabled: PluginCatalogFeatureFlagResolver = isAssistantFeatureFlagEnabled,
+): PluginCatalog {
+  const matches = catalog.matches.filter((match) =>
+    isPluginCatalogEntryVisible(match.name, isFeatureFlagEnabled),
+  );
+  return matches.length === catalog.matches.length
+    ? catalog
+    : { ...catalog, matches };
+}

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

@@ -46,6 +46,7 @@ import {
   findCatalogEntry,
   resolveSourceFromMatch,
 } from "./plugin-catalog-resolve.js";
+import { isPluginCatalogEntryVisible } from "./plugin-catalog-visibility.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import { readValidatedPluginIcon } from "./plugin-icon-file.js";
 import { fetchMarketplaceEntries } from "./plugin-marketplace.js";
@@ -156,8 +157,8 @@ export class PluginDetailsNotFoundError extends Error {
  * Resolve the detail view for {@link opts.name}.
  *
  * Throws {@link PluginDetailsNotFoundError} when the name is neither installed
- * locally nor present in the catalog (gated at the default ref, the GitHub
- * marketplace at an explicit historical ref). A gated-catalog outage
+ * locally nor present in the visibility-gated catalog at either the default
+ * or an explicit historical ref. A gated-catalog outage
  * ({@link PluginCatalogUnavailableError}) degrades to the on-disk fields only
  * when a local copy exists; with nothing installed to render it propagates so
  * the caller can map the transient failure to a retryable 503 rather than a
@@ -400,11 +401,10 @@ async function fetchRawFile(
 /**
  * Resolve the external catalog entry claiming {@link name}.
  *
- * The default ref reads the gated catalog (the same source search / install
- * use). An explicit historical {@link ref} reads the GitHub marketplace
- * manifest at that revision — the gated catalog is ref-agnostic, so honoring a
- * reviewed/rolled-back revision is inherently a git lookup, matching the pin
- * history / inspect carve-out.
+ * Both default and historical-ref lookups apply catalog visibility first. The
+ * default ref then reads the gated catalog used by search and install, while an
+ * explicit historical {@link ref} reads the GitHub marketplace manifest at
+ * that revision.
  *
  * A gated-catalog outage (fail-hard {@link PluginCatalogUnavailableError})
  * propagates when nothing is installed — there is nothing to render and the
@@ -420,6 +420,9 @@ async function resolveCatalogEntry(
   fetchFn: FetchLike,
   installed: boolean,
 ): Promise<PluginSearchMatch | null> {
+  if (!isPluginCatalogEntryVisible(name)) {
+    return null;
+  }
   try {
     const match =
       ref === DEFAULT_PLUGIN_REF

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

@@ -19,6 +19,8 @@ import type { MarketplaceEntry } from "./plugin-marketplace.js";
 export interface SearchPluginsDeps {
   /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
   readonly fetch: FetchLike;
+  /** Optional feature-flag resolver for deterministic tests. */
+  readonly featureFlagEnabled?: (key: string) => boolean;
 }
 
 /** Where a catalog match comes from. */

package/src/config/feature-flag-registry.json

@@ -338,6 +338,14 @@
       "description": "Show the Add Server action on the MCP settings page. The MCP page itself remains visible; this flag gates only creating new Model Context Protocol server connections.",
       "defaultEnabled": false
     },
+    {
+      "id": "mcp-catalog-qa-integrations",
+      "scope": "assistant",
+      "key": "mcp-catalog-qa-integrations",
+      "label": "MCP Catalog QA Integrations",
+      "description": "Show Gamma, Guru, Intercom, Ramp, Semrush, and Typeform in the installable plugin catalog while their OAuth flows are validated. When off, catalog search, detail, and install-by-name cannot resolve them. Existing installed connections remain available.",
+      "defaultEnabled": false
+    },
     {
       "id": "os-beta",
       "scope": "assistant",
@@ -557,7 +565,7 @@
       "scope": "both",
       "key": "sidebar-done",
       "label": "Sidebar Done",
-      "description": "Turns archiving a chat into marking it done: the sidebar row carries a Done check instead of the overflow menu, an Old chats page lists the full history, and done chats stay findable in search by default. Off keeps today's Archive wording, the overflow menu, and search that hides archived rows unless the query asks for them.",
+      "description": "Turns archiving a chat into marking it done: the sidebar row carries a Done check instead of the overflow menu, an All chats page lists the full history, and done chats stay findable in search by default. Off keeps today's Archive wording, the overflow menu, and search that hides archived rows unless the query asks for them.",
       "defaultEnabled": false
     }
   ]

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -165,8 +165,14 @@ const getCatalogSpy = mock(
   },
 );
 
+const getInstalledMetadataCatalogSpy = mock(
+  (ref: string, deps: SearchPluginsDeps): Promise<PluginCatalog> =>
+    getCatalogSpy(ref, deps),
+);
+
 mock.module("../../../cli/lib/plugin-catalog-cache.js", () => ({
   getPluginCatalog: getCatalogSpy,
+  getPluginCatalogForInstalledMetadata: getInstalledMetadataCatalogSpy,
 }));
 
 // Mock uninstallPlugin. The handler's error mapping is the wiring under
@@ -471,6 +477,7 @@ beforeEach(() => {
 describe("GET /v1/plugins", () => {
   beforeEach(() => {
     getCatalogSpy.mockClear();
+    getInstalledMetadataCatalogSpy.mockClear();
     // Default to an empty catalog so every installed plugin's category resolves
     // to `null` (bucketed under "system"). Tests that exercise real categories
     // override this.
@@ -849,6 +856,7 @@ describe("GET /v1/plugins", () => {
     );
 
     const map = await loadCategoryMapBounded();
+    expect(getInstalledMetadataCatalogSpy).toHaveBeenCalledTimes(1);
     expect(map.get("alpha")).toBe("productivity");
   });
 

package/src/runtime/routes/plugins-routes.ts

@@ -48,7 +48,10 @@ import {
   type InstalledPluginInfo,
   listInstalledPlugins,
 } from "../../cli/lib/list-installed-plugins.js";
-import { getPluginCatalog } from "../../cli/lib/plugin-catalog-cache.js";
+import {
+  getPluginCatalog,
+  getPluginCatalogForInstalledMetadata,
+} from "../../cli/lib/plugin-catalog-cache.js";
 import { resolvePluginSourceFromCatalog } from "../../cli/lib/plugin-catalog-resolve.js";
 import {
   DEFAULT_PIN_HISTORY_LIMIT,
@@ -969,7 +972,7 @@ export async function loadCategoryMapBounded(
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     const catalog = await Promise.race([
-      getPluginCatalog(DEFAULT_PLUGIN_REF, {
+      getPluginCatalogForInstalledMetadata(DEFAULT_PLUGIN_REF, {
         fetch: globalThis.fetch.bind(globalThis),
       }),
       new Promise<null>((resolve) => {