diff --git a/e2e/server-catalog.spec.ts b/e2e/server-catalog.spec.ts
index 27ece6bc..e654804e 100644
--- a/e2e/server-catalog.spec.ts
+++ b/e2e/server-catalog.spec.ts
@@ -70,6 +70,7 @@ async function mockCatalog(page: import("@playwright/test").Page, servers: Catal
 test.describe("Server catalog page", () => {
   test.beforeEach(async ({ page, apiMock }) => {
     await apiMock.mockSession();
+    await apiMock.mockPermissions();
 
     await page.addInitScript(() => {
       sessionStorage.setItem("mcpgateway_token", "mock-token-12345");
@@ -224,7 +225,7 @@ test.describe("Server catalog page", () => {
     await expect(page.getByRole("heading", { name: "Globalping" })).toBeVisible();
   });
 
-  test("adds an open server without refetching its card", async ({ page, apiMock }) => {
+  test("adds an open server then refreshes its gateway id", async ({ page, apiMock }) => {
     let registered = false;
     let catalogCalls = 0;
     let registerCalls = 0;
@@ -235,7 +236,13 @@ test.describe("Server catalog page", () => {
         status: 200,
         contentType: "application/json",
         body: JSON.stringify({
-          servers: [{ ...OPEN_SERVER, is_registered: registered }],
+          servers: [
+            {
+              ...OPEN_SERVER,
+              is_registered: registered,
+              gateway_id: registered ? "gateway-public-notes" : null,
+            },
+          ],
           total: 1,
           categories: ["Productivity"],
           auth_types: ["Open"],
@@ -276,7 +283,9 @@ test.describe("Server catalog page", () => {
     await expect(page.getByRole("button", { name: "Add Public Notes" })).toHaveCount(0);
     await expect(page.getByRole("button", { name: "View Public Notes" })).toHaveCount(0);
     await expect(page.getByRole("button", { name: "Actions for Public Notes" })).toBeVisible();
-    expect(catalogCalls).toBe(catalogCallsBeforeAdd);
+    await expect.poll(() => catalogCalls).toBe(catalogCallsBeforeAdd + 1);
+    await page.getByRole("button", { name: "Actions for Public Notes" }).click();
+    await expect(page.getByRole("menuitem", { name: "Disconnect" })).toBeVisible();
   });
 
   test("removes a stale server and moves focus to its 404 notification", async ({ page }) => {
diff --git a/openapi.json b/openapi.json
index 30026ea8..7fb971f6 100644
--- a/openapi.json
+++ b/openapi.json
@@ -39786,6 +39786,18 @@
             "description": "Whether server is already registered",
             "default": false
           },
+          "gateway_id": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Gateway Id",
+            "description": "ID of the caller-visible gateway matched to this catalog server"
+          },
           "is_available": {
             "type": "boolean",
             "title": "Is Available",
@@ -53129,4 +53141,4 @@
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/api/catalog.test.ts b/src/api/catalog.test.ts
index 51c3d7b5..e2ee7478 100644
--- a/src/api/catalog.test.ts
+++ b/src/api/catalog.test.ts
@@ -2,7 +2,12 @@ import { describe, expect, it } from "vitest";
 import { http, HttpResponse } from "msw";
 
 import { server } from "@/test/mocks/server";
-import { registerCatalogServer } from "./catalog";
+import {
+  disconnectCatalogGateway,
+  getGatewayImpactPreview,
+  registerCatalogServer,
+  testCatalogServer,
+} from "./catalog";
 
 describe("registerCatalogServer", () => {
   it("POSTs the URL-encoded catalog id through the API proxy", async () => {
@@ -27,4 +32,60 @@ describe("registerCatalogServer", () => {
       message: "Registered",
     });
   });
+
+  it("DELETEs an encoded gateway ID and preserves async lifecycle metadata", async () => {
+    let requestPath = "";
+    server.use(
+      http.delete("*/api/v1/gateways/:gatewayId", ({ request }) => {
+        requestPath = new URL(request.url).pathname;
+        return HttpResponse.json(
+          { status: "deleting" },
+          { status: 202, headers: { "Retry-After": "2" } },
+        );
+      }),
+    );
+
+    const result = await disconnectCatalogGateway("gateway/id");
+
+    expect(requestPath).toBe("/api/v1/gateways/gateway%2Fid");
+    expect(result.status).toBe(202);
+    expect(result.headers.get("Retry-After")).toBe("2");
+  });
+
+  it("tests catalog URL with a safe fixed GET request", async () => {
+    let body: unknown;
+    server.use(
+      http.post("*/api/v1/mcp-servers/test", async ({ request }) => {
+        body = await request.json();
+        return HttpResponse.json({ statusCode: 204, latencyMs: 21 });
+      }),
+    );
+
+    await expect(testCatalogServer("https://catalog.example/mcp")).resolves.toEqual({
+      statusCode: 204,
+      latencyMs: 21,
+    });
+    expect(body).toEqual({
+      method: "GET",
+      baseUrl: "https://catalog.example/mcp",
+      path: "",
+      headers: { Accept: "text/event-stream" },
+    });
+  });
+
+  it("gets only the backend-provided disconnect impact preview", async () => {
+    server.use(
+      http.get("*/api/v1/gateways/:gatewayId/impact-preview", () =>
+        HttpResponse.json({
+          gatewayId: "gateway-1",
+          servers: [{ id: "server-1", name: "Visible server" }],
+        }),
+      ),
+    );
+
+    await expect(getGatewayImpactPreview("gateway-1")).resolves.toEqual({
+      gatewayId: "gateway-1",
+      servers: [{ id: "server-1", name: "Visible server" }],
+    });
+  });
 });
diff --git a/src/api/catalog.ts b/src/api/catalog.ts
index cdf08a0d..d946f2cd 100644
--- a/src/api/catalog.ts
+++ b/src/api/catalog.ts
@@ -1,5 +1,17 @@
 import { api } from "./client";
-import type { CatalogServerRegisterResponse } from "@/generated/types";
+import type {
+  CatalogServerRegisterResponse,
+  GatewayRead,
+  GatewayTestRequest,
+  GatewayTestResponse,
+} from "@/generated/types";
+
+export interface GatewayImpactPreview {
+  gatewayId: string;
+  servers: Array<{ id: string; name: string }>;
+}
+
+export type CatalogGatewayDeleteResponse = GatewayRead | { status?: string; message?: string };
 
 /** Register an open catalog entry through the authenticated BFF proxy. */
 export async function registerCatalogServer(
@@ -9,3 +21,29 @@ export async function registerCatalogServer(
     `/v1/catalog/${encodeURIComponent(catalogId)}/register`,
   );
 }
+
+/** Delete gateway selected by caller-visible catalog registration state. */
+export function disconnectCatalogGateway(gatewayId: string) {
+  return api.deleteWithMeta<CatalogGatewayDeleteResponse>(
+    `/v1/gateways/${encodeURIComponent(gatewayId)}`,
+  );
+}
+
+/** Test the catalog server URL using stored credentials when backend has them. */
+export function testCatalogServer(url: string): Promise<GatewayTestResponse> {
+  const request: GatewayTestRequest = {
+    method: "GET",
+    baseUrl: url,
+    path: "",
+    // Streamable HTTP MCP servers require this for a GET connection check.
+    headers: { Accept: "text/event-stream" },
+  };
+  return api.post<GatewayTestResponse>("/v1/mcp-servers/test", request);
+}
+
+/** Preview caller-visible virtual servers affected by disconnecting a gateway. */
+export function getGatewayImpactPreview(gatewayId: string): Promise<GatewayImpactPreview> {
+  return api.get<GatewayImpactPreview>(
+    `/v1/gateways/${encodeURIComponent(gatewayId)}/impact-preview`,
+  );
+}
diff --git a/src/api/client.ts b/src/api/client.ts
index d326a28b..6e0de44e 100644
--- a/src/api/client.ts
+++ b/src/api/client.ts
@@ -123,6 +123,7 @@ interface RequestOptions {
 export interface ResponseWithMeta<T> {
   data: T;
   status: number;
+  headers: Headers;
 }
 
 async function requestWithMeta<T>(
@@ -192,11 +193,11 @@ async function requestWithMeta<T>(
 
   // 204 No Content
   if (response.status === 204) {
-    return { data: undefined as T, status: response.status };
+    return { data: undefined as T, status: response.status, headers: response.headers };
   }
 
   const data = (await response.json()) as T;
-  return { data, status: response.status };
+  return { data, status: response.status, headers: response.headers };
 }
 
 async function request<T>(path: string, options: RequestOptions = {}): Promise<T> {
@@ -241,6 +242,13 @@ export const api = {
     return requestWithMeta<T>(path, { method: "POST", body, ...opts });
   },
 
+  deleteWithMeta<T>(
+    path: string,
+    opts?: Omit<RequestOptions, "method" | "body">,
+  ): Promise<ResponseWithMeta<T>> {
+    return requestWithMeta<T>(path, { method: "DELETE", ...opts });
+  },
+
   put<T>(path: string, body?: unknown, opts?: Omit<RequestOptions, "method" | "body">): Promise<T> {
     return request<T>(path, { method: "PUT", body, ...opts });
   },
diff --git a/src/components/server-catalog/CatalogResults.test.tsx b/src/components/server-catalog/CatalogResults.test.tsx
index 7a7c5a9f..5adeb0ca 100644
--- a/src/components/server-catalog/CatalogResults.test.tsx
+++ b/src/components/server-catalog/CatalogResults.test.tsx
@@ -18,7 +18,12 @@ const availableServer: CatalogServer = {
   is_registered: false,
 };
 
-function catalogResults(server: CatalogServer, addingServerIds: ReadonlySet<string> = new Set()) {
+function catalogResults(
+  server: CatalogServer,
+  addingServerIds: ReadonlySet<string> = new Set(),
+  testingServerIds: ReadonlySet<string> = new Set(),
+  disconnectingServerIds: ReadonlySet<string> = new Set(),
+) {
   return (
     <CatalogResults
       servers={[server]}
@@ -26,6 +31,12 @@ function catalogResults(server: CatalogServer, addingServerIds: ReadonlySet<stri
       onView={vi.fn()}
       onAdd={vi.fn()}
       addingServerIds={addingServerIds}
+      onTest={vi.fn()}
+      onDisconnect={vi.fn()}
+      testingServerIds={testingServerIds}
+      disconnectingServerIds={disconnectingServerIds}
+      canTest={false}
+      canDisconnect={false}
     />
   );
 }
@@ -64,4 +75,38 @@ describe("CatalogResults", () => {
 
     expect(await screen.findByRole("menu")).toHaveAttribute("data-align", "end");
   });
+
+  it("shows testing and disconnecting status on the affected card", () => {
+    const connectedServer = { ...availableServer, is_registered: true, gateway_id: "gateway-1" };
+    const { rerender } = renderWithProviders(
+      catalogResults(connectedServer, new Set(), new Set([connectedServer.id])),
+    );
+
+    expect(screen.getByText("Testing connection…")).toHaveAttribute("role", "status");
+
+    rerender(catalogResults(connectedServer, new Set(), new Set(), new Set([connectedServer.id])));
+
+    expect(screen.getByText("Disconnecting…")).toHaveAttribute("role", "status");
+    expect(screen.queryByText("Connected")).not.toBeInTheDocument();
+  });
+
+  it("routes bundled catalog logos through the BFF", () => {
+    const { container } = renderWithProviders(
+      catalogResults({ ...availableServer, logo_url: "/static/catalog-icons/asana.png" }),
+    );
+
+    const logo = container.querySelector("img");
+
+    expect(logo).toHaveAttribute("src", "/api/static/catalog-icons/asana.png");
+    expect(logo).toHaveClass("size-full", "object-contain");
+    expect(logo?.parentElement).not.toHaveClass("bg-muted");
+  });
+
+  it("rejects local logo paths outside the catalog icon directory", () => {
+    const { container } = renderWithProviders(
+      catalogResults({ ...availableServer, logo_url: "/static/admin.png" }),
+    );
+
+    expect(container.querySelector("img")).not.toBeInTheDocument();
+  });
 });
diff --git a/src/components/server-catalog/CatalogResults.tsx b/src/components/server-catalog/CatalogResults.tsx
index 1dbe6956..1178c74d 100644
--- a/src/components/server-catalog/CatalogResults.tsx
+++ b/src/components/server-catalog/CatalogResults.tsx
@@ -25,9 +25,18 @@ import type { CatalogServer } from "@/generated/types";
 import { useDebouncedValue } from "@/hooks/useDebouncedValue";
 import { getTagLabels } from "@/utils/tags";
 
+const EMPTY_PENDING_IDS: ReadonlySet<string> = new Set();
+const CATALOG_ICON_PATH = /^\/static\/catalog-icons\/[A-Za-z0-9][A-Za-z0-9._-]*\.png$/;
+
 function getSafeExternalUrl(value: string | null | undefined): string | null {
   if (!value) return null;
 
+  // Catalog icons are packaged by the API under this fixed path. Route them
+  // through the authenticated BFF so the browser never needs an API origin.
+  if (CATALOG_ICON_PATH.test(value)) {
+    return `/api${value}`;
+  }
+
   try {
     const parsed = new URL(value);
     return parsed.protocol === "https:" && !parsed.username && !parsed.password
@@ -51,14 +60,11 @@ function CatalogLogo({ server }: { server: CatalogServer }) {
   }
 
   return (
-    <div
-      aria-hidden="true"
-      className="flex size-8 shrink-0 items-center justify-center rounded-md bg-muted"
-    >
+    <div aria-hidden="true" className="size-8 shrink-0">
       <img
         src={logoUrl}
         alt=""
-        className="size-4 object-contain"
+        className="size-full object-contain"
         loading="lazy"
         decoding="async"
         referrerPolicy="no-referrer"
@@ -72,12 +78,24 @@ function CatalogCard({
   server,
   onView,
   onAdd,
+  onTest,
+  onDisconnect,
   isAdding,
+  isTesting,
+  isDisconnecting,
+  canTest,
+  canDisconnect,
 }: {
   server: CatalogServer;
   onView: (trigger: HTMLElement) => void;
   onAdd: () => void;
+  onTest: () => void;
+  onDisconnect: () => void;
   isAdding: boolean;
+  isTesting: boolean;
+  isDisconnecting: boolean;
+  canTest: boolean;
+  canDisconnect: boolean;
 }) {
   const intl = useIntl();
   const headingId = useId();
@@ -117,10 +135,20 @@ function CatalogCard({
             <div className="mt-auto flex min-h-6 items-center gap-3 pt-4">
               {server.is_registered ? (
                 <>
-                  <span className="inline-flex items-center gap-1.5 text-sm font-medium text-foreground">
-                    <CircleCheck className="size-4 text-green-500" aria-hidden="true" />
-                    {intl.formatMessage({ id: "mcpServer.catalog.connected" })}
-                  </span>
+                  {isDisconnecting ? (
+                    <span role="status" className="text-sm font-medium text-muted-foreground">
+                      {intl.formatMessage({ id: "mcpServer.catalog.disconnecting" })}
+                    </span>
+                  ) : isTesting ? (
+                    <span role="status" className="text-sm font-medium text-muted-foreground">
+                      {intl.formatMessage({ id: "mcpServer.catalog.testing" })}
+                    </span>
+                  ) : (
+                    <span className="inline-flex items-center gap-1.5 text-sm font-medium text-foreground">
+                      <CircleCheck className="size-4 text-green-500" aria-hidden="true" />
+                      {intl.formatMessage({ id: "mcpServer.catalog.connected" })}
+                    </span>
+                  )}
                   <DropdownMenu>
                     <DropdownMenuTrigger asChild>
                       <Button
@@ -154,6 +182,27 @@ function CatalogCard({
                       >
                         {intl.formatMessage({ id: "mcpServer.catalog.viewDetails" })}
                       </DropdownMenuItem>
+                      {canTest && (
+                        <DropdownMenuItem
+                          disabled={server.requires_oauth_config || isTesting || isDisconnecting}
+                          onSelect={onTest}
+                          title={
+                            server.requires_oauth_config
+                              ? intl.formatMessage({ id: "mcpServer.catalog.testOAuthPending" })
+                              : undefined
+                          }
+                        >
+                          {intl.formatMessage({ id: "mcpServer.catalog.test" })}
+                        </DropdownMenuItem>
+                      )}
+                      {canDisconnect && server.gateway_id && (
+                        <DropdownMenuItem
+                          disabled={isTesting || isDisconnecting}
+                          onSelect={onDisconnect}
+                        >
+                          {intl.formatMessage({ id: "mcpServer.catalog.disconnect" })}
+                        </DropdownMenuItem>
+                      )}
                     </DropdownMenuContent>
                   </DropdownMenu>
                 </>
@@ -287,12 +336,24 @@ export function CatalogResults({
   onView,
   onAdd,
   addingServerIds,
+  onTest,
+  onDisconnect,
+  testingServerIds = EMPTY_PENDING_IDS,
+  disconnectingServerIds = EMPTY_PENDING_IDS,
+  canTest,
+  canDisconnect,
 }: {
   servers: CatalogServer[];
   emptyStateMessageId: string;
   onView: (server: CatalogServer, trigger: HTMLElement) => void;
   onAdd: (server: CatalogServer) => void;
   addingServerIds: ReadonlySet<string>;
+  onTest: (server: CatalogServer) => void;
+  onDisconnect: (server: CatalogServer) => void;
+  testingServerIds?: ReadonlySet<string>;
+  disconnectingServerIds?: ReadonlySet<string>;
+  canTest: boolean;
+  canDisconnect: boolean;
 }) {
   const intl = useIntl();
   const announcedCount = useDebouncedValue(servers.length, 300);
@@ -313,7 +374,13 @@ export function CatalogResults({
               server={server}
               onView={(trigger) => onView(server, trigger)}
               onAdd={() => onAdd(server)}
+              onTest={() => onTest(server)}
+              onDisconnect={() => onDisconnect(server)}
               isAdding={addingServerIds.has(server.id)}
+              isTesting={testingServerIds.has(server.id)}
+              isDisconnecting={disconnectingServerIds.has(server.id)}
+              canTest={canTest}
+              canDisconnect={canDisconnect}
             />
           ))}
         </ul>
diff --git a/src/components/servers/ConfirmDialog.tsx b/src/components/servers/ConfirmDialog.tsx
index cc88388e..a3698bcd 100644
--- a/src/components/servers/ConfirmDialog.tsx
+++ b/src/components/servers/ConfirmDialog.tsx
@@ -1,4 +1,5 @@
 import { useCallback } from "react";
+import type { ReactNode } from "react";
 import {
   Dialog,
   DialogContent,
@@ -14,7 +15,7 @@ interface ConfirmDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   title: string;
-  description: string;
+  description: ReactNode;
   confirmLabel?: string;
   cancelLabel?: string;
   variant?: "default" | "destructive";
@@ -68,7 +69,9 @@ export function ConfirmDialog({
       <DialogContent role={role} onCloseAutoFocus={onCloseAutoFocus}>
         <DialogHeader>
           <DialogTitle>{title}</DialogTitle>
-          <DialogDescription>{description}</DialogDescription>
+          <DialogDescription asChild>
+            <div>{description}</div>
+          </DialogDescription>
         </DialogHeader>
         <DialogFooter>
           <Button variant="outline" onClick={handleCancel} disabled={isLoading}>
diff --git a/src/components/ui/inline-notification.test.tsx b/src/components/ui/inline-notification.test.tsx
index d6645f25..3763ea6c 100644
--- a/src/components/ui/inline-notification.test.tsx
+++ b/src/components/ui/inline-notification.test.tsx
@@ -49,6 +49,15 @@ describe("InlineNotification", () => {
     });
   });
 
+  describe("info type", () => {
+    it("renders with role='status' and neutral text", () => {
+      render(<InlineNotification type="info" message="Disconnect pending" />);
+
+      expect(screen.getByRole("status")).toHaveTextContent("Disconnect pending");
+      expect(screen.getByText("Disconnect pending")).toHaveClass("text-blue-600");
+    });
+  });
+
   describe("dismiss button", () => {
     it("renders dismiss button when onDismiss is provided", () => {
       render(<InlineNotification type="success" message="Done" onDismiss={vi.fn()} />);
@@ -86,4 +95,19 @@ describe("InlineNotification", () => {
       ).toBeInTheDocument();
     });
   });
+
+  it("renders and runs an optional action", async () => {
+    const onClick = vi.fn();
+    render(
+      <InlineNotification
+        type="error"
+        message="Disconnect is still running"
+        action={{ label: "Retry", onClick }}
+      />,
+    );
+
+    await userEvent.click(screen.getByRole("button", { name: "Retry" }));
+
+    expect(onClick).toHaveBeenCalledOnce();
+  });
 });
diff --git a/src/components/ui/inline-notification.tsx b/src/components/ui/inline-notification.tsx
index 97b19dc3..797df808 100644
--- a/src/components/ui/inline-notification.tsx
+++ b/src/components/ui/inline-notification.tsx
@@ -1,10 +1,14 @@
 import { forwardRef } from "react";
-import { CircleCheck, CircleAlert, X } from "lucide-react";
+import { CircleAlert, CircleCheck, Info, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
 
 interface InlineNotificationProps {
-  type: "success" | "error";
+  type: "success" | "error" | "info";
   message: string;
+  action?: {
+    label: string;
+    onClick: () => void;
+  };
   onDismiss?: () => void;
   dismissLabel?: string;
   tabIndex?: number;
@@ -12,41 +16,59 @@ interface InlineNotificationProps {
 
 export const InlineNotification = forwardRef<HTMLDivElement, InlineNotificationProps>(
   function InlineNotification(
-    { type, message, onDismiss, dismissLabel = "Dismiss notification", tabIndex },
+    { type, message, action, onDismiss, dismissLabel = "Dismiss notification", tabIndex },
     ref,
   ) {
     const isSuccess = type === "success";
+    const isError = type === "error";
 
     return (
       <div
         ref={ref}
-        role={isSuccess ? "status" : "alert"}
+        role={isError ? "alert" : "status"}
         tabIndex={tabIndex}
         className="flex items-center justify-between rounded-md border border-neutral-200 bg-background p-3 dark:border-neutral-800"
       >
         <div className="flex items-center gap-2">
           {isSuccess ? (
             <CircleCheck className="h-4 w-4 shrink-0 text-green-500" aria-hidden="true" />
-          ) : (
+          ) : isError ? (
             <CircleAlert className="h-4 w-4 shrink-0 text-red-500" aria-hidden="true" />
+          ) : (
+            <Info className="h-4 w-4 shrink-0 text-blue-500" aria-hidden="true" />
           )}
           <p
-            className={`text-sm ${isSuccess ? "text-green-500" : "text-red-600 dark:text-red-400"}`}
+            className={`text-sm ${
+              isSuccess
+                ? "text-green-500"
+                : isError
+                  ? "text-red-600 dark:text-red-400"
+                  : "text-blue-600 dark:text-blue-400"
+            }`}
           >
             {message}
           </p>
         </div>
-        {onDismiss && (
-          <Button
-            type="button"
-            variant="ghost"
-            size="icon"
-            onClick={onDismiss}
-            aria-label={dismissLabel}
-            className="ml-2 shrink-0 p-1 opacity-60 hover:opacity-100 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500"
-          >
-            <X className="h-4 w-4" aria-hidden="true" />
-          </Button>
+        {(action || onDismiss) && (
+          <div className="ml-2 flex shrink-0 items-center gap-1">
+            {action && (
+              <Button type="button" variant="outline" size="sm" onClick={action.onClick}>
+                {action.label}
+              </Button>
+            )}
+            {onDismiss && (
+              <Button
+                type="button"
+                variant="ghost"
+                size="icon"
+                onClick={onDismiss}
+                aria-label={dismissLabel}
+                className="p-1 opacity-60 hover:opacity-100 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500"
+              >
+                <X className="h-4 w-4" aria-hidden="true" />
+              </Button>
+            )}
+          </div>
         )}
       </div>
     );
diff --git a/src/i18n/locales/en-US/mcpServer.json b/src/i18n/locales/en-US/mcpServer.json
index db19bf59..0f979a11 100644
--- a/src/i18n/locales/en-US/mcpServer.json
+++ b/src/i18n/locales/en-US/mcpServer.json
@@ -99,6 +99,24 @@
   "mcpServer.catalog.alreadyConnected": "{name} is already connected.",
   "mcpServer.catalog.actionsFor": "Actions for {name}",
   "mcpServer.catalog.viewDetails": "View details",
+  "mcpServer.catalog.test": "Test connection",
+  "mcpServer.catalog.testing": "Testing connection…",
+  "mcpServer.catalog.testOAuthPending": "Complete OAuth configuration before testing this server.",
+  "mcpServer.catalog.testSuccess": "{name} connection succeeded with status {statusCode} in {latencyMs} ms.",
+  "mcpServer.catalog.testFailure": "{name} connection failed with status {statusCode} in {latencyMs} ms.",
+  "mcpServer.catalog.testError": "Unable to test {name}. Try again.",
+  "mcpServer.catalog.disconnect": "Disconnect",
+  "mcpServer.catalog.disconnecting": "Disconnecting…",
+  "mcpServer.catalog.disconnectAccepted": "{name} is disconnecting.",
+  "mcpServer.catalog.disconnectTitle": "Disconnect MCP server",
+  "mcpServer.catalog.disconnectDescription": "Disconnect {name}? This removes its gateway and cannot be undone.",
+  "mcpServer.catalog.disconnectImpactLoading": "Checking affected virtual servers…",
+  "mcpServer.catalog.disconnectImpact": "Affected virtual servers",
+  "mcpServer.catalog.disconnectImpactNone": "No affected virtual servers found.",
+  "mcpServer.catalog.disconnectImpactError": "Could not check affected virtual servers. You can still disconnect this server.",
+  "mcpServer.catalog.disconnectSuccess": "{name} disconnected.",
+  "mcpServer.catalog.disconnectError": "Unable to disconnect {name}. Try again.",
+  "mcpServer.catalog.disconnectPending": "{name} is still disconnecting. You can retry shortly.",
   "mcpServer.catalog.viewOptions": "Catalog view",
   "mcpServer.catalog.transport": "Transport",
   "mcpServer.catalog.status": "Status",
diff --git a/src/i18n/locales/es-ES/mcpServer.json b/src/i18n/locales/es-ES/mcpServer.json
index 804c570b..ea2a3301 100644
--- a/src/i18n/locales/es-ES/mcpServer.json
+++ b/src/i18n/locales/es-ES/mcpServer.json
@@ -99,6 +99,24 @@
   "mcpServer.catalog.alreadyConnected": "{name} ya está conectado.",
   "mcpServer.catalog.actionsFor": "Acciones para {name}",
   "mcpServer.catalog.viewDetails": "Ver detalles",
+  "mcpServer.catalog.test": "Probar conexión",
+  "mcpServer.catalog.testing": "Probando conexión…",
+  "mcpServer.catalog.testOAuthPending": "Completa la configuración de OAuth antes de probar este servidor.",
+  "mcpServer.catalog.testSuccess": "La conexión con {name} se realizó correctamente con el estado {statusCode} en {latencyMs} ms.",
+  "mcpServer.catalog.testFailure": "La conexión con {name} falló con el estado {statusCode} en {latencyMs} ms.",
+  "mcpServer.catalog.testError": "No se pudo probar {name}. Inténtalo de nuevo.",
+  "mcpServer.catalog.disconnect": "Desconectar",
+  "mcpServer.catalog.disconnecting": "Desconectando…",
+  "mcpServer.catalog.disconnectAccepted": "{name} se está desconectando.",
+  "mcpServer.catalog.disconnectTitle": "Desconectar servidor MCP",
+  "mcpServer.catalog.disconnectDescription": "¿Desconectar {name}? Esto elimina su puerta de enlace y no se puede deshacer.",
+  "mcpServer.catalog.disconnectImpactLoading": "Comprobando servidores virtuales afectados…",
+  "mcpServer.catalog.disconnectImpact": "Servidores virtuales afectados",
+  "mcpServer.catalog.disconnectImpactNone": "No se encontraron servidores virtuales afectados.",
+  "mcpServer.catalog.disconnectImpactError": "No se pudieron comprobar los servidores virtuales afectados. Aún puedes desconectar este servidor.",
+  "mcpServer.catalog.disconnectSuccess": "{name} se desconectó.",
+  "mcpServer.catalog.disconnectError": "No se pudo desconectar {name}. Inténtalo de nuevo.",
+  "mcpServer.catalog.disconnectPending": "{name} todavía se está desconectando. Puedes reintentar en breve.",
   "mcpServer.catalog.viewOptions": "Vista del catálogo",
   "mcpServer.catalog.transport": "Transporte",
   "mcpServer.catalog.status": "Estado",
diff --git a/src/i18n/locales/pt-BR/mcpServer.json b/src/i18n/locales/pt-BR/mcpServer.json
index 8235290d..5d8ad312 100644
--- a/src/i18n/locales/pt-BR/mcpServer.json
+++ b/src/i18n/locales/pt-BR/mcpServer.json
@@ -99,6 +99,24 @@
   "mcpServer.catalog.alreadyConnected": "{name} já está conectado.",
   "mcpServer.catalog.actionsFor": "Ações para {name}",
   "mcpServer.catalog.viewDetails": "Ver detalhes",
+  "mcpServer.catalog.test": "Testar conexão",
+  "mcpServer.catalog.testing": "Testando conexão…",
+  "mcpServer.catalog.testOAuthPending": "Conclua a configuração do OAuth antes de testar este servidor.",
+  "mcpServer.catalog.testSuccess": "A conexão com {name} foi bem-sucedida com status {statusCode} em {latencyMs} ms.",
+  "mcpServer.catalog.testFailure": "A conexão com {name} falhou com status {statusCode} em {latencyMs} ms.",
+  "mcpServer.catalog.testError": "Não foi possível testar {name}. Tente novamente.",
+  "mcpServer.catalog.disconnect": "Desconectar",
+  "mcpServer.catalog.disconnecting": "Desconectando…",
+  "mcpServer.catalog.disconnectAccepted": "{name} está desconectando.",
+  "mcpServer.catalog.disconnectTitle": "Desconectar servidor MCP",
+  "mcpServer.catalog.disconnectDescription": "Desconectar {name}? Isso remove o gateway e não pode ser desfeito.",
+  "mcpServer.catalog.disconnectImpactLoading": "Verificando servidores virtuais afetados…",
+  "mcpServer.catalog.disconnectImpact": "Servidores virtuais afetados",
+  "mcpServer.catalog.disconnectImpactNone": "Nenhum servidor virtual afetado foi encontrado.",
+  "mcpServer.catalog.disconnectImpactError": "Não foi possível verificar os servidores virtuais afetados. Você ainda pode desconectar este servidor.",
+  "mcpServer.catalog.disconnectSuccess": "{name} foi desconectado.",
+  "mcpServer.catalog.disconnectError": "Não foi possível desconectar {name}. Tente novamente.",
+  "mcpServer.catalog.disconnectPending": "{name} ainda está desconectando. Você pode tentar novamente em breve.",
   "mcpServer.catalog.viewOptions": "Visualização do catálogo",
   "mcpServer.catalog.transport": "Transporte",
   "mcpServer.catalog.status": "Status",
diff --git a/src/pages/ServerCatalog.test.tsx b/src/pages/ServerCatalog.test.tsx
index 6e751655..6b056b13 100644
--- a/src/pages/ServerCatalog.test.tsx
+++ b/src/pages/ServerCatalog.test.tsx
@@ -1,9 +1,14 @@
 import type { ReactElement } from "react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 
-import { registerCatalogServer } from "@/api/catalog";
+import {
+  disconnectCatalogGateway,
+  getGatewayImpactPreview,
+  registerCatalogServer,
+  testCatalogServer,
+} from "@/api/catalog";
 import { ApiError } from "@/api/client";
 import type { CatalogListResponse, CatalogServer } from "@/generated/types";
 import { useQuery } from "@/hooks/useQuery";
@@ -14,12 +19,25 @@ import { ServerCatalog } from "./ServerCatalog";
 vi.mock("@/hooks/useQuery", () => ({
   useQuery: vi.fn(),
 }));
+const authState = vi.hoisted(() => ({
+  hasPermission: vi.fn<(permission: string) => boolean>(() => true),
+  permissionsLoading: false,
+}));
+vi.mock("@/auth/useAuth", () => ({
+  useAuth: () => authState,
+}));
 vi.mock("@/api/catalog", () => ({
   registerCatalogServer: vi.fn(),
+  disconnectCatalogGateway: vi.fn(),
+  getGatewayImpactPreview: vi.fn(),
+  testCatalogServer: vi.fn(),
 }));
 
 const mockUseQuery = vi.mocked(useQuery);
 const mockRegisterCatalogServer = vi.mocked(registerCatalogServer);
+const mockDisconnectCatalogGateway = vi.mocked(disconnectCatalogGateway);
+const mockGetGatewayImpactPreview = vi.mocked(getGatewayImpactPreview);
+const mockTestCatalogServer = vi.mocked(testCatalogServer);
 
 const openConnected: CatalogServer = {
   id: "open-connected",
@@ -32,6 +50,7 @@ const openConnected: CatalogServer = {
   tags: ["network", "observability"],
   transport: "STREAMABLEHTTP",
   is_registered: true,
+  gateway_id: "gateway-globalping",
 };
 
 const openAvailable: CatalogServer = {
@@ -121,6 +140,15 @@ describe("ServerCatalog", () => {
       server_id: "registered-server",
       message: "Registered",
     });
+    authState.hasPermission.mockReturnValue(true);
+    authState.permissionsLoading = false;
+    mockDisconnectCatalogGateway.mockResolvedValue({
+      status: 200,
+      data: { status: "success" },
+      headers: new Headers(),
+    });
+    mockGetGatewayImpactPreview.mockResolvedValue({ gatewayId: "gateway-globalping", servers: [] });
+    mockTestCatalogServer.mockResolvedValue({ statusCode: 200, latencyMs: 12 });
   });
 
   it("uses the catalog GET endpoint and shared loader", () => {
@@ -187,6 +215,326 @@ describe("ServerCatalog", () => {
     expect(mockRegisterCatalogServer).toHaveBeenCalledWith("open-available");
   });
 
+  it("tests a connected catalog server and reports status plus latency", async () => {
+    const user = userEvent.setup();
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Test connection" }));
+
+    await waitFor(() =>
+      expect(mockTestCatalogServer).toHaveBeenCalledWith("https://globalping.example/mcp"),
+    );
+    expect(
+      await screen.findByText("Globalping connection succeeded with status 200 in 12 ms."),
+    ).toBeVisible();
+  });
+
+  it("reports a failed connection distinctly from a successful connection", async () => {
+    const user = userEvent.setup();
+    mockTestCatalogServer.mockResolvedValue({ statusCode: 503, latencyMs: 12 });
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Test connection" }));
+
+    expect(
+      await screen.findByText("Globalping connection failed with status 503 in 12 ms."),
+    ).toBeVisible();
+  });
+
+  it("reports an empty connectivity response as a test error", async () => {
+    const user = userEvent.setup();
+    mockTestCatalogServer.mockResolvedValue(null);
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Test connection" }));
+
+    expect(await screen.findByText("Unable to test Globalping. Try again.")).toBeVisible();
+    expect(screen.queryByText(/status 0/i)).not.toBeInTheDocument();
+  });
+
+  it("keeps notifications from independent server mutations", async () => {
+    const user = userEvent.setup();
+    mockTestCatalogServer.mockResolvedValue({ statusCode: 503, latencyMs: 12 });
+    mockRegisterCatalogServer.mockRejectedValue(new Error("Network error"));
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Test connection" }));
+    await screen.findByText("Globalping connection failed with status 503 in 12 ms.");
+
+    await user.click(screen.getByRole("button", { name: "Add Public Notes" }));
+    expect(await screen.findByText("Unable to add this server. Try again.")).toBeVisible();
+    expect(
+      screen.getByText("Globalping connection failed with status 503 in 12 ms."),
+    ).toBeVisible();
+  });
+
+  it("disables Test when OAuth configuration remains incomplete", async () => {
+    const user = userEvent.setup();
+    mockUseQuery.mockReturnValue(
+      queryResult({
+        data: {
+          ...response,
+          servers: [{ ...openConnected, requires_oauth_config: true }],
+          total: 1,
+        },
+      }),
+    );
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+
+    expect(screen.getByRole("menuitem", { name: "Test connection" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+  });
+
+  it("hides connected-server mutations without their permissions", async () => {
+    const user = userEvent.setup();
+    authState.hasPermission.mockReturnValue(false);
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+
+    expect(screen.queryByRole("menuitem", { name: "Test connection" })).not.toBeInTheDocument();
+    expect(screen.queryByRole("menuitem", { name: "Disconnect" })).not.toBeInTheDocument();
+    expect(screen.getByRole("menuitem", { name: "View details" })).toBeInTheDocument();
+  });
+
+  it("loads disconnect impact for a caller allowed to delete but not test", async () => {
+    const user = userEvent.setup();
+    authState.hasPermission.mockImplementation((permission) => permission === "gateways.delete");
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    expect(screen.queryByRole("menuitem", { name: "Test connection" })).not.toBeInTheDocument();
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+
+    await waitFor(() =>
+      expect(mockGetGatewayImpactPreview).toHaveBeenCalledWith("gateway-globalping"),
+    );
+  });
+
+  it("confirms disconnect, shows affected virtual servers, then refetches catalog", async () => {
+    const user = userEvent.setup();
+    const refetch = vi.fn().mockResolvedValue(response);
+    mockUseQuery.mockReturnValue(queryResult({ refetch }));
+    mockGetGatewayImpactPreview.mockResolvedValue({
+      gatewayId: "gateway-globalping",
+      servers: [{ id: "virtual-1", name: "Production assistant" }],
+    });
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+
+    const dialog = await screen.findByRole("alertdialog");
+    expect(within(dialog).getByText("Production assistant")).toBeInTheDocument();
+    await user.click(within(dialog).getByRole("button", { name: "Disconnect" }));
+
+    await waitFor(() =>
+      expect(mockDisconnectCatalogGateway).toHaveBeenCalledWith("gateway-globalping"),
+    );
+    expect(refetch).toHaveBeenCalledOnce();
+    expect(await screen.findByText("Globalping disconnected.")).toBeInTheDocument();
+  });
+
+  it("announces impact-preview loading to screen readers", async () => {
+    const user = userEvent.setup();
+    let resolvePreview: (preview: { gatewayId: string; servers: never[] }) => void;
+    mockGetGatewayImpactPreview.mockReturnValue(
+      new Promise((resolve) => {
+        resolvePreview = resolve;
+      }),
+    );
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+
+    const impactAnnouncement = screen.getByText("Checking affected virtual servers…", {
+      selector: "[aria-live]",
+    });
+    expect(impactAnnouncement).toHaveAttribute("aria-live", "polite");
+    expect(impactAnnouncement).toHaveAttribute("aria-atomic", "true");
+    resolvePreview!({ gatewayId: "gateway-globalping", servers: [] });
+  });
+
+  it("distinguishes an empty impact preview from a failed preview", async () => {
+    const user = userEvent.setup();
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+    expect(await screen.findByText("No affected virtual servers found.")).toBeVisible();
+
+    await user.click(screen.getByRole("button", { name: "Cancel" }));
+    mockGetGatewayImpactPreview.mockRejectedValue(new Error("Preview unavailable"));
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+
+    expect(
+      await screen.findByText(
+        "Could not check affected virtual servers. You can still disconnect this server.",
+      ),
+    ).toBeVisible();
+  });
+
+  it("waits for catalog state after an async disconnect", async () => {
+    const user = userEvent.setup();
+    const refetch = vi.fn().mockResolvedValue({
+      ...response,
+      servers: [{ ...openConnected, is_registered: false, gateway_id: null }],
+    });
+    mockUseQuery.mockReturnValue(queryResult({ refetch }));
+    mockDisconnectCatalogGateway.mockResolvedValue({
+      status: 202,
+      data: { status: "deleting" },
+      headers: new Headers({ "Retry-After": "0.001" }),
+    });
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+    const dialog = await screen.findByRole("alertdialog");
+    await user.click(within(dialog).getByRole("button", { name: "Disconnect" }));
+
+    await waitFor(() => expect(refetch).toHaveBeenCalledOnce(), { timeout: 1_000 });
+    expect(await screen.findByText("Globalping disconnected.")).toBeInTheDocument();
+  });
+
+  it("closes an accepted async disconnect and marks the card as disconnecting", async () => {
+    const user = userEvent.setup();
+    const refetch = vi.fn(() => new Promise<CatalogListResponse>(() => {}));
+    mockUseQuery.mockReturnValue(queryResult({ refetch }));
+    mockDisconnectCatalogGateway.mockResolvedValue({
+      status: 202,
+      data: { status: "deleting" },
+      headers: new Headers({ "Retry-After": "0.001" }),
+    });
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+    const dialog = await screen.findByRole("alertdialog");
+    await user.click(within(dialog).getByRole("button", { name: "Disconnect" }));
+
+    await waitFor(() => expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument());
+    const acceptedNotification = await screen.findByText("Globalping is disconnecting.");
+    expect(acceptedNotification.closest('[role="status"]')).toBeVisible();
+    expect(screen.getByText("Disconnecting…")).toHaveAttribute("role", "status");
+  });
+
+  it("retries async disconnect status without sending DELETE again", async () => {
+    const user = userEvent.setup();
+    const refetch = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("Temporary catalog failure"))
+      .mockResolvedValue(response);
+    mockUseQuery.mockReturnValue(queryResult({ refetch }));
+    mockDisconnectCatalogGateway.mockClear();
+    mockDisconnectCatalogGateway.mockResolvedValue({
+      status: 202,
+      data: { status: "deleting" },
+      headers: new Headers({ "Retry-After": "0.001" }),
+    });
+
+    renderWithRouter(<ServerCatalog />);
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+    const dialog = await screen.findByRole("alertdialog");
+
+    vi.useFakeTimers();
+    try {
+      fireEvent.click(within(dialog).getByRole("button", { name: "Disconnect" }));
+
+      await act(async () => {
+        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(60_000);
+      });
+
+      expect(
+        screen.getByText("Globalping is still disconnecting. You can retry shortly."),
+      ).toBeVisible();
+      fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(60_000);
+      });
+
+      expect(
+        screen.getByText("Globalping is still disconnecting. You can retry shortly."),
+      ).toBeVisible();
+      refetch.mockResolvedValue({
+        ...response,
+        servers: [{ ...openConnected, is_registered: false, gateway_id: null }],
+      });
+      fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(1_000);
+      });
+
+      expect(screen.getByText("Globalping disconnected.")).toBeVisible();
+      expect(mockDisconnectCatalogGateway).toHaveBeenCalledOnce();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("reports persistent catalog polling failures as errors", async () => {
+    const user = userEvent.setup();
+    const refetch = vi.fn().mockRejectedValue(new ApiError(500, null, "HTTP 500"));
+    mockUseQuery.mockReturnValue(queryResult({ refetch }));
+    mockDisconnectCatalogGateway.mockResolvedValue({
+      status: 202,
+      data: { status: "deleting" },
+      headers: new Headers({ "Retry-After": "0.001" }),
+    });
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+    const dialog = await screen.findByRole("alertdialog");
+
+    vi.useFakeTimers();
+    try {
+      fireEvent.click(within(dialog).getByRole("button", { name: "Disconnect" }));
+      await act(async () => {
+        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(60_000);
+      });
+
+      expect(screen.getByText("Unable to disconnect Globalping. Try again.")).toBeVisible();
+      expect(refetch).toHaveBeenCalledTimes(3);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("keeps catalog state unchanged when backend rejects disconnect ownership", async () => {
+    const user = userEvent.setup();
+    const refetch = vi.fn();
+    mockUseQuery.mockReturnValue(queryResult({ refetch }));
+    mockDisconnectCatalogGateway.mockRejectedValue(
+      new ApiError(403, { detail: "Only the owner can delete this gateway" }, "HTTP 403"),
+    );
+    renderWithRouter(<ServerCatalog />);
+
+    await user.click(screen.getByRole("button", { name: "Actions for Globalping" }));
+    await user.click(screen.getByRole("menuitem", { name: "Disconnect" }));
+    const dialog = await screen.findByRole("alertdialog");
+    await user.click(within(dialog).getByRole("button", { name: "Disconnect" }));
+
+    expect(await screen.findByText("Unable to disconnect Globalping. Try again.")).toBeVisible();
+    expect(refetch).not.toHaveBeenCalled();
+    expect(screen.getAllByText("Connected")).toHaveLength(2);
+  });
+
   it("reports catalog registration failures", async () => {
     const user = userEvent.setup();
     mockRegisterCatalogServer.mockRejectedValue(new Error("network detail must not leak"));
@@ -200,7 +548,7 @@ describe("ServerCatalog", () => {
     expect(screen.queryByText(/network detail/i)).not.toBeInTheDocument();
   });
 
-  it("registers an available server without refetching the catalog", async () => {
+  it("registers an available server then refetches authoritative gateway state", async () => {
     const user = userEvent.setup();
     const refetch = vi.fn().mockResolvedValue(undefined);
     const setData = vi.fn();
@@ -216,11 +564,11 @@ describe("ServerCatalog", () => {
     ) => CatalogListResponse | undefined;
     expect(
       updateCatalog(response)?.servers.find((server) => server.id === openAvailable.id),
-    ).toMatchObject({ is_registered: true });
-    expect(refetch).not.toHaveBeenCalled();
+    ).toMatchObject({ is_registered: true, gateway_id: "registered-server" });
+    expect(refetch).toHaveBeenCalledOnce();
   });
 
-  it("treats an already-registered response as connected without refetching", async () => {
+  it("refetches an already-registered response to obtain its gateway ID", async () => {
     const user = userEvent.setup();
     const refetch = vi.fn().mockResolvedValue(undefined);
     const setData = vi.fn();
@@ -233,8 +581,8 @@ describe("ServerCatalog", () => {
     await user.click(screen.getByRole("button", { name: "Add Public Notes" }));
 
     expect(await screen.findByText("Public Notes is already connected.")).toBeInTheDocument();
-    expect(setData).toHaveBeenCalledOnce();
-    expect(refetch).not.toHaveBeenCalled();
+    expect(setData).not.toHaveBeenCalled();
+    expect(refetch).toHaveBeenCalledOnce();
     expect(screen.queryByText("Server already registered")).not.toBeInTheDocument();
   });
 
@@ -311,7 +659,7 @@ describe("ServerCatalog", () => {
 
     resolveNotes({ success: true, server_id: "notes", message: "Registered" });
     await waitFor(() => expect(setData).toHaveBeenCalledTimes(2));
-    expect(refetch).not.toHaveBeenCalled();
+    expect(refetch).toHaveBeenCalledTimes(2);
   });
 
   it("shows connected status in details opened from the action menu", async () => {
diff --git a/src/pages/ServerCatalog.tsx b/src/pages/ServerCatalog.tsx
index d671560e..b75fc979 100644
--- a/src/pages/ServerCatalog.tsx
+++ b/src/pages/ServerCatalog.tsx
@@ -2,8 +2,15 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { ReactNode, Ref } from "react";
 import { useIntl } from "react-intl";
 
-import { registerCatalogServer } from "@/api/catalog";
+import {
+  disconnectCatalogGateway,
+  getGatewayImpactPreview,
+  registerCatalogServer,
+  testCatalogServer,
+  type GatewayImpactPreview,
+} from "@/api/catalog";
 import { ApiError } from "@/api/client";
+import { useAuth } from "@/auth/useAuth";
 import {
   CatalogResults,
   CatalogServerDetailsDialog,
@@ -13,6 +20,7 @@ import {
   type CatalogFilterSection,
 } from "@/components/server-catalog/CatalogToolbar";
 import { EmptyStatePlaceholder } from "@/components/dashboard/EmptyStatePlaceholder";
+import { ConfirmDialog } from "@/components/servers/ConfirmDialog";
 import { Button } from "@/components/ui/button";
 import { InlineNotification } from "@/components/ui/inline-notification";
 import { Loading } from "@/components/ui/loading";
@@ -37,8 +45,22 @@ interface CatalogFilters {
 }
 
 interface RegistrationNotification {
-  type: "success" | "error";
+  id: string;
+  type: "success" | "error" | "info";
   message: string;
+  retryCatalogServer?: CatalogServer;
+}
+
+type ImpactPreviewStatus = "idle" | "loading" | "loaded" | "error";
+
+const DISCONNECT_POLL_TIMEOUT_MS = 30_000;
+const DEFAULT_DISCONNECT_POLL_MS = 1_000;
+
+class DisconnectPollTimeoutError extends Error {
+  constructor() {
+    super("Catalog disconnect did not finish in time");
+    this.name = "DisconnectPollTimeoutError";
+  }
 }
 
 type QueryUpdateValue = string | string[] | boolean | null;
@@ -153,19 +175,83 @@ function setCatalogServerRegistration(
   catalog: CatalogListResponse | undefined,
   serverId: string,
   isRegistered: boolean,
+  gatewayId?: string | null,
 ): CatalogListResponse | undefined {
   if (!catalog) return catalog;
 
   const serverIndex = catalog.servers.findIndex((server) => server.id === serverId);
-  if (serverIndex === -1 || catalog.servers[serverIndex].is_registered === isRegistered) {
+  if (
+    serverIndex === -1 ||
+    (catalog.servers[serverIndex].is_registered === isRegistered && gatewayId === undefined)
+  ) {
     return catalog;
   }
 
   const servers = [...catalog.servers];
-  servers[serverIndex] = { ...servers[serverIndex], is_registered: isRegistered };
+  servers[serverIndex] = {
+    ...servers[serverIndex],
+    is_registered: isRegistered,
+    ...(gatewayId === undefined ? {} : { gateway_id: gatewayId }),
+  };
   return { ...catalog, servers };
 }
 
+function getRetryAfterMs(value: string | null): number {
+  const seconds = Number(value);
+  const dateDelay = value ? Date.parse(value) - Date.now() : Number.NaN;
+  const delayMs = Number.isFinite(seconds) && seconds > 0 ? seconds * 1_000 : dateDelay;
+
+  return Number.isFinite(delayMs) && delayMs > 0
+    ? Math.min(DISCONNECT_POLL_TIMEOUT_MS, Math.max(250, delayMs))
+    : DEFAULT_DISCONNECT_POLL_MS;
+}
+
+function delay(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const onAbort = () => {
+      window.clearTimeout(timeoutId);
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    const timeoutId = window.setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === "AbortError";
+}
+
+function usePendingIds() {
+  const pendingIdsRef = useRef(new Set<string>());
+  const [pendingIds, setPendingIds] = useState<ReadonlySet<string>>(() => new Set());
+
+  const begin = useCallback((id: string): boolean => {
+    if (pendingIdsRef.current.has(id)) return false;
+    pendingIdsRef.current.add(id);
+    setPendingIds(new Set(pendingIdsRef.current));
+    return true;
+  }, []);
+
+  const end = useCallback((id: string) => {
+    pendingIdsRef.current.delete(id);
+    setPendingIds(new Set(pendingIdsRef.current));
+  }, []);
+
+  const isPending = useCallback((id: string) => pendingIdsRef.current.has(id), []);
+
+  return useMemo(
+    () => ({ pendingIds, begin, end, isPending }),
+    [begin, end, isPending, pendingIds],
+  );
+}
+
 function removeCatalogServer(
   catalog: CatalogListResponse | undefined,
   serverId: string,
@@ -208,16 +294,37 @@ function CatalogPageLayout({
 
 export function ServerCatalog() {
   const intl = useIntl();
+  const { hasPermission, permissionsLoading } = useAuth();
   const [selectedServer, setSelectedServer] = useState<CatalogServer | null>(null);
-  const [addingServerIds, setAddingServerIds] = useState<ReadonlySet<string>>(() => new Set());
-  const [registrationNotification, setRegistrationNotification] =
-    useState<RegistrationNotification | null>(null);
-  const addingServerIdsRef = useRef(new Set<string>());
+  const { pendingIds: addingServerIds, begin: beginAdding, end: endAdding } = usePendingIds();
+  const {
+    pendingIds: testingServerIds,
+    begin: beginTesting,
+    end: endTesting,
+    isPending: isTesting,
+  } = usePendingIds();
+  const {
+    pendingIds: disconnectingServerIds,
+    begin: beginDisconnecting,
+    end: endDisconnecting,
+    isPending: isDisconnecting,
+  } = usePendingIds();
+  const [registrationNotifications, setRegistrationNotifications] = useState<
+    RegistrationNotification[]
+  >([]);
+  const [disconnectServer, setDisconnectServer] = useState<CatalogServer | null>(null);
+  const [impactPreview, setImpactPreview] = useState<GatewayImpactPreview | null>(null);
+  const [impactPreviewStatus, setImpactPreviewStatus] = useState<ImpactPreviewStatus>("idle");
+  const impactRequestIdRef = useRef(0);
+  const disconnectPollAbortControllersRef = useRef(new Map<string, AbortController>());
   const lastViewTriggerRef = useRef<HTMLElement | null>(null);
   const pageHeadingRef = useRef<HTMLHeadingElement | null>(null);
-  const registrationNotificationRef = useRef<HTMLDivElement | null>(null);
-  const shouldFocusRegistrationNotificationRef = useRef(false);
+  const registrationNotificationRefs = useRef(new Map<string, HTMLDivElement>());
+  const notificationToFocusRef = useRef<string | null>(null);
+  const shouldRedirectDisconnectCloseFocusRef = useRef(false);
   const { data, error, isLoading, refetch, setData } = useQuery<CatalogListResponse>(CATALOG_PATH);
+  const canTest = !permissionsLoading && hasPermission("gateways.read");
+  const canDisconnect = !permissionsLoading && hasPermission("gateways.delete");
   const { filters, updateQuery, toggleFilterOption, clearFilterSection, clearAllFilters } =
     useCatalogFilters();
   const [search, setSearch] = useState(filters.search);
@@ -234,11 +341,38 @@ export function ServerCatalog() {
   }, [debouncedSearch, filters.search, updateQuery]);
 
   useEffect(() => {
-    if (!registrationNotification || !shouldFocusRegistrationNotificationRef.current) return;
+    const notificationId = notificationToFocusRef.current;
+    if (!notificationId) return;
+
+    notificationToFocusRef.current = null;
+    registrationNotificationRefs.current.get(notificationId)?.focus();
+  }, [registrationNotifications]);
+
+  useEffect(
+    () => () => {
+      impactRequestIdRef.current += 1;
+      disconnectPollAbortControllersRef.current.forEach((controller) => controller.abort());
+      disconnectPollAbortControllersRef.current.clear();
+    },
+    [],
+  );
 
-    shouldFocusRegistrationNotificationRef.current = false;
-    registrationNotificationRef.current?.focus();
-  }, [registrationNotification]);
+  const showRegistrationNotification = useCallback(
+    (notification: RegistrationNotification, shouldFocus = false) => {
+      if (shouldFocus) notificationToFocusRef.current = notification.id;
+      setRegistrationNotifications((current) => [
+        ...current.filter((existing) => existing.id !== notification.id),
+        notification,
+      ]);
+    },
+    [],
+  );
+
+  const dismissRegistrationNotification = useCallback((notificationId: string) => {
+    setRegistrationNotifications((current) =>
+      current.filter((notification) => notification.id !== notificationId),
+    );
+  }, []);
 
   // Only the search box filters ahead of the URL, so the grid can react to the
   // debounced value. Category, provider and tag selections are committed to the
@@ -287,76 +421,392 @@ export function ServerCatalog() {
 
   const handleAdd = useCallback(
     async (server: CatalogServer) => {
-      if (addingServerIdsRef.current.has(server.id)) return;
-
-      addingServerIdsRef.current.add(server.id);
-      setAddingServerIds(new Set(addingServerIdsRef.current));
-      setRegistrationNotification(null);
+      if (!beginAdding(server.id)) return;
+      dismissRegistrationNotification(`add:${server.id}`);
       try {
         const result = await registerCatalogServer(server.id);
         if (!result.success) {
-          setRegistrationNotification({
+          showRegistrationNotification({
+            id: `add:${server.id}`,
             type: "error",
             message: result.message || intl.formatMessage({ id: "mcpServer.catalog.addError" }),
           });
           return;
         }
 
-        setData((current) => setCatalogServerRegistration(current, server.id, true));
+        setData((current) =>
+          setCatalogServerRegistration(current, server.id, true, result.server_id),
+        );
+        void refreshCatalogSilently();
       } catch (registrationError) {
         if (registrationError instanceof ApiError && registrationError.status === 409) {
-          setData((current) => setCatalogServerRegistration(current, server.id, true));
-          setRegistrationNotification({
+          showRegistrationNotification({
+            id: `add:${server.id}`,
             type: "success",
             message: intl.formatMessage(
               { id: "mcpServer.catalog.alreadyConnected" },
               { name: server.name },
             ),
           });
+          await refreshCatalogSilently();
           return;
         }
 
         if (registrationError instanceof ApiError && registrationError.status === 404) {
           setData((current) => removeCatalogServer(current, server.id));
-          shouldFocusRegistrationNotificationRef.current = true;
-          setRegistrationNotification({
-            type: "error",
-            message: intl.formatMessage(
-              { id: "mcpServer.catalog.addNotFound" },
-              { name: server.name },
-            ),
-          });
+          showRegistrationNotification(
+            {
+              id: `add:${server.id}`,
+              type: "error",
+              message: intl.formatMessage(
+                { id: "mcpServer.catalog.addNotFound" },
+                { name: server.name },
+              ),
+            },
+            true,
+          );
           await refreshCatalogSilently();
           return;
         }
 
-        setRegistrationNotification({
+        showRegistrationNotification({
+          id: `add:${server.id}`,
           type: "error",
           message: intl.formatMessage({ id: "mcpServer.catalog.addError" }),
         });
       } finally {
-        addingServerIdsRef.current.delete(server.id);
-        setAddingServerIds(new Set(addingServerIdsRef.current));
+        endAdding(server.id);
+      }
+    },
+    [
+      beginAdding,
+      dismissRegistrationNotification,
+      endAdding,
+      intl,
+      refreshCatalogSilently,
+      setData,
+      showRegistrationNotification,
+    ],
+  );
+
+  const handleTest = useCallback(
+    async (server: CatalogServer) => {
+      if (server.requires_oauth_config || isDisconnecting(server.id) || !beginTesting(server.id)) {
+        return;
+      }
+
+      dismissRegistrationNotification(`test:${server.id}`);
+
+      try {
+        const result = await testCatalogServer(server.url);
+        if (!result) {
+          showRegistrationNotification(
+            {
+              id: `test:${server.id}`,
+              type: "error",
+              message: intl.formatMessage(
+                { id: "mcpServer.catalog.testError" },
+                { name: server.name },
+              ),
+            },
+            true,
+          );
+          return;
+        }
+
+        const statusCode = result.statusCode ?? 0;
+        const succeeded = statusCode >= 200 && statusCode < 300;
+        showRegistrationNotification(
+          {
+            id: `test:${server.id}`,
+            type: succeeded ? "success" : "error",
+            message: intl.formatMessage(
+              {
+                id: succeeded ? "mcpServer.catalog.testSuccess" : "mcpServer.catalog.testFailure",
+              },
+              { name: server.name, statusCode, latencyMs: result.latencyMs ?? 0 },
+            ),
+          },
+          true,
+        );
+      } catch {
+        showRegistrationNotification(
+          {
+            id: `test:${server.id}`,
+            type: "error",
+            message: intl.formatMessage(
+              { id: "mcpServer.catalog.testError" },
+              { name: server.name },
+            ),
+          },
+          true,
+        );
+      } finally {
+        endTesting(server.id);
+      }
+    },
+    [
+      beginTesting,
+      dismissRegistrationNotification,
+      endTesting,
+      intl,
+      isDisconnecting,
+      showRegistrationNotification,
+    ],
+  );
+
+  const handleDisconnect = useCallback(
+    (server: CatalogServer) => {
+      if (!server.gateway_id || isTesting(server.id) || isDisconnecting(server.id)) return;
+
+      setDisconnectServer(server);
+      setImpactPreview(null);
+      setImpactPreviewStatus("idle");
+      const requestId = ++impactRequestIdRef.current;
+      if (!canDisconnect) return;
+
+      setImpactPreviewStatus("loading");
+      void getGatewayImpactPreview(server.gateway_id)
+        .then((preview) => {
+          if (impactRequestIdRef.current === requestId) {
+            setImpactPreview(preview);
+            setImpactPreviewStatus("loaded");
+          }
+        })
+        // Preview is optional. A permission or ownership race must not disclose
+        // the protected list or block a deletion the caller may perform.
+        .catch(() => {
+          if (impactRequestIdRef.current === requestId) {
+            setImpactPreview(null);
+            setImpactPreviewStatus("error");
+          }
+        });
+    },
+    [canDisconnect, isDisconnecting, isTesting],
+  );
+
+  const handleDisconnectDialogOpenChange = useCallback((open: boolean) => {
+    if (open) return;
+    impactRequestIdRef.current += 1;
+    setDisconnectServer(null);
+    setImpactPreview(null);
+    setImpactPreviewStatus("idle");
+  }, []);
+
+  const waitForCatalogDisconnect = useCallback(
+    async (catalogId: string, initialDelayMs: number, signal: AbortSignal) => {
+      const deadline = Date.now() + DISCONNECT_POLL_TIMEOUT_MS;
+      let delayMs = initialDelayMs;
+      let consecutivePollErrors = 0;
+
+      while (Date.now() < deadline) {
+        await delay(delayMs, signal);
+        try {
+          const catalog = await refetch();
+          const server = catalog.servers.find((candidate) => candidate.id === catalogId);
+          if (!server?.is_registered || !server.gateway_id) return;
+          consecutivePollErrors = 0;
+        } catch (error) {
+          if (isAbortError(error)) throw error;
+          consecutivePollErrors += 1;
+          if (
+            (error instanceof ApiError && error.status >= 400 && error.status < 500) ||
+            consecutivePollErrors >= 3
+          ) {
+            throw error;
+          }
+          // Deletion has already been accepted. Keep polling through transient
+          // catalog failures, but surface persistent or authorization failures.
+        }
+        delayMs = DEFAULT_DISCONNECT_POLL_MS;
+      }
+
+      throw new DisconnectPollTimeoutError();
+    },
+    [refetch],
+  );
+
+  const handleDisconnectStatusRetry = useCallback(
+    async (server: CatalogServer) => {
+      if (!beginDisconnecting(server.id)) return;
+
+      let pollController: AbortController | null = null;
+      dismissRegistrationNotification(`disconnect:${server.id}`);
+      try {
+        pollController = new AbortController();
+        disconnectPollAbortControllersRef.current.set(server.id, pollController);
+        await waitForCatalogDisconnect(
+          server.id,
+          DEFAULT_DISCONNECT_POLL_MS,
+          pollController.signal,
+        );
+        showRegistrationNotification(
+          {
+            id: `disconnect:${server.id}`,
+            type: "success",
+            message: intl.formatMessage(
+              { id: "mcpServer.catalog.disconnectSuccess" },
+              { name: server.name },
+            ),
+          },
+          true,
+        );
+      } catch (error) {
+        if (isAbortError(error)) return;
+        showRegistrationNotification(
+          {
+            id: `disconnect:${server.id}`,
+            type: error instanceof DisconnectPollTimeoutError ? "info" : "error",
+            message: intl.formatMessage(
+              {
+                id:
+                  error instanceof DisconnectPollTimeoutError
+                    ? "mcpServer.catalog.disconnectPending"
+                    : "mcpServer.catalog.disconnectError",
+              },
+              { name: server.name },
+            ),
+            ...(error instanceof DisconnectPollTimeoutError ? { retryCatalogServer: server } : {}),
+          },
+          true,
+        );
+      } finally {
+        if (disconnectPollAbortControllersRef.current.get(server.id) === pollController) {
+          disconnectPollAbortControllersRef.current.delete(server.id);
+        }
+        endDisconnecting(server.id);
       }
     },
-    [intl, refreshCatalogSilently, setData],
+    [
+      beginDisconnecting,
+      dismissRegistrationNotification,
+      endDisconnecting,
+      intl,
+      showRegistrationNotification,
+      waitForCatalogDisconnect,
+    ],
   );
 
+  const confirmDisconnect = useCallback(async () => {
+    const gatewayId = disconnectServer?.gateway_id;
+    if (!disconnectServer || !gatewayId || !beginDisconnecting(disconnectServer.id)) {
+      return;
+    }
+
+    const server = disconnectServer;
+    let pollController: AbortController | null = null;
+
+    try {
+      const response = await disconnectCatalogGateway(gatewayId);
+      if (response.status === 202) {
+        setDisconnectServer(null);
+        setImpactPreview(null);
+        setImpactPreviewStatus("idle");
+        showRegistrationNotification(
+          {
+            id: `disconnect:${server.id}`,
+            type: "info",
+            message: intl.formatMessage(
+              { id: "mcpServer.catalog.disconnectAccepted" },
+              { name: server.name },
+            ),
+          },
+          true,
+        );
+        pollController = new AbortController();
+        disconnectPollAbortControllersRef.current.set(server.id, pollController);
+        await waitForCatalogDisconnect(
+          server.id,
+          getRetryAfterMs(response.headers.get("Retry-After")),
+          pollController.signal,
+        );
+      } else {
+        setData((current) => setCatalogServerRegistration(current, server.id, false, null));
+        void refreshCatalogSilently();
+        shouldRedirectDisconnectCloseFocusRef.current = true;
+      }
+      impactRequestIdRef.current += 1;
+      setDisconnectServer(null);
+      setImpactPreview(null);
+      showRegistrationNotification(
+        {
+          id: `disconnect:${server.id}`,
+          type: "success",
+          message: intl.formatMessage(
+            { id: "mcpServer.catalog.disconnectSuccess" },
+            { name: server.name },
+          ),
+        },
+        true,
+      );
+    } catch (error) {
+      if (isAbortError(error)) return;
+      if (error instanceof DisconnectPollTimeoutError) {
+        setDisconnectServer(null);
+        setImpactPreview(null);
+      }
+      showRegistrationNotification(
+        {
+          id: `disconnect:${server.id}`,
+          type: error instanceof DisconnectPollTimeoutError ? "info" : "error",
+          message: intl.formatMessage(
+            {
+              id:
+                error instanceof DisconnectPollTimeoutError
+                  ? "mcpServer.catalog.disconnectPending"
+                  : "mcpServer.catalog.disconnectError",
+            },
+            { name: server.name },
+          ),
+          ...(error instanceof DisconnectPollTimeoutError ? { retryCatalogServer: server } : {}),
+        },
+        true,
+      );
+    } finally {
+      if (disconnectPollAbortControllersRef.current.get(server.id) === pollController) {
+        disconnectPollAbortControllersRef.current.delete(server.id);
+      }
+      endDisconnecting(server.id);
+    }
+  }, [
+    beginDisconnecting,
+    disconnectServer,
+    endDisconnecting,
+    intl,
+    refreshCatalogSilently,
+    setData,
+    showRegistrationNotification,
+    waitForCatalogDisconnect,
+  ]);
+
   const handleDetailsOpenChange = useCallback((open: boolean) => {
     if (open) return;
     setSelectedServer(null);
     window.setTimeout(() => lastViewTriggerRef.current?.focus(), 0);
   }, []);
 
-  const handleRegistrationNotificationDismiss = useCallback(() => {
-    const notification = registrationNotificationRef.current;
-    const shouldRestoreFocus = notification?.contains(notification.ownerDocument.activeElement);
-    setRegistrationNotification(null);
-    if (shouldRestoreFocus) {
-      window.setTimeout(() => pageHeadingRef.current?.focus(), 0);
-    }
+  const handleDisconnectDialogCloseAutoFocus = useCallback((event: Event) => {
+    if (!shouldRedirectDisconnectCloseFocusRef.current) return;
+
+    // A synchronous delete swaps the actions trigger for Add, so Radix cannot
+    // restore focus to the removed trigger.
+    event.preventDefault();
+    shouldRedirectDisconnectCloseFocusRef.current = false;
+    pageHeadingRef.current?.focus();
   }, []);
 
+  const handleRegistrationNotificationDismiss = useCallback(
+    (notificationId: string) => {
+      const notification = registrationNotificationRefs.current.get(notificationId);
+      const shouldRestoreFocus = notification?.contains(notification.ownerDocument.activeElement);
+      dismissRegistrationNotification(notificationId);
+      if (shouldRestoreFocus) {
+        window.setTimeout(() => pageHeadingRef.current?.focus(), 0);
+      }
+    },
+    [dismissRegistrationNotification],
+  );
+
   if (isLoading && !data) {
     return (
       <CatalogPageLayout headingRef={pageHeadingRef}>
@@ -417,15 +867,32 @@ export function ServerCatalog() {
         onClearAll={clearAllFilters}
       />
 
-      {registrationNotification && (
+      {registrationNotifications.length > 0 && (
         <div className="mb-4">
-          <InlineNotification
-            ref={registrationNotificationRef}
-            type={registrationNotification.type}
-            message={registrationNotification.message}
-            tabIndex={-1}
-            onDismiss={handleRegistrationNotificationDismiss}
-          />
+          <div className="space-y-2">
+            {registrationNotifications.map((notification) => (
+              <InlineNotification
+                key={notification.id}
+                ref={(element) => {
+                  if (element) registrationNotificationRefs.current.set(notification.id, element);
+                  else registrationNotificationRefs.current.delete(notification.id);
+                }}
+                type={notification.type}
+                message={notification.message}
+                action={
+                  notification.retryCatalogServer
+                    ? {
+                        label: intl.formatMessage({ id: "mcpServer.catalog.retry" }),
+                        onClick: () =>
+                          void handleDisconnectStatusRetry(notification.retryCatalogServer!),
+                      }
+                    : undefined
+                }
+                tabIndex={-1}
+                onDismiss={() => handleRegistrationNotificationDismiss(notification.id)}
+              />
+            ))}
+          </div>
         </div>
       )}
 
@@ -435,9 +902,74 @@ export function ServerCatalog() {
         onView={handleView}
         onAdd={(server) => void handleAdd(server)}
         addingServerIds={addingServerIds}
+        onTest={(server) => void handleTest(server)}
+        onDisconnect={handleDisconnect}
+        testingServerIds={testingServerIds}
+        disconnectingServerIds={disconnectingServerIds}
+        canTest={canTest}
+        canDisconnect={canDisconnect}
       />
 
       <CatalogServerDetailsDialog server={selectedServer} onOpenChange={handleDetailsOpenChange} />
+
+      <ConfirmDialog
+        open={disconnectServer !== null}
+        role="alertdialog"
+        onOpenChange={handleDisconnectDialogOpenChange}
+        title={intl.formatMessage({ id: "mcpServer.catalog.disconnectTitle" })}
+        description={
+          <div className="space-y-3">
+            <p>
+              {intl.formatMessage(
+                { id: "mcpServer.catalog.disconnectDescription" },
+                { name: disconnectServer?.name ?? "" },
+              )}
+            </p>
+            <p className="sr-only" aria-live="polite" aria-atomic="true">
+              {impactPreviewStatus === "loading"
+                ? intl.formatMessage({ id: "mcpServer.catalog.disconnectImpactLoading" })
+                : ""}
+            </p>
+            {impactPreviewStatus === "loading" && (
+              <p className="text-sm text-muted-foreground">
+                {intl.formatMessage({ id: "mcpServer.catalog.disconnectImpactLoading" })}
+              </p>
+            )}
+            {impactPreviewStatus === "loaded" && impactPreview?.servers.length === 0 && (
+              <p className="text-sm text-muted-foreground">
+                {intl.formatMessage({ id: "mcpServer.catalog.disconnectImpactNone" })}
+              </p>
+            )}
+            {impactPreviewStatus === "error" && (
+              <p className="text-sm text-muted-foreground">
+                {intl.formatMessage({ id: "mcpServer.catalog.disconnectImpactError" })}
+              </p>
+            )}
+            {impactPreviewStatus === "loaded" &&
+              impactPreview &&
+              impactPreview.servers.length > 0 && (
+                <div>
+                  <p className="mb-1 text-sm font-medium">
+                    {intl.formatMessage({ id: "mcpServer.catalog.disconnectImpact" })}
+                  </p>
+                  <ul className="list-inside list-disc text-sm">
+                    {impactPreview.servers.map((server) => (
+                      <li key={server.id}>{server.name}</li>
+                    ))}
+                  </ul>
+                </div>
+              )}
+          </div>
+        }
+        confirmLabel={intl.formatMessage({ id: "mcpServer.catalog.disconnect" })}
+        cancelLabel={intl.formatMessage({ id: "common.button.cancel" })}
+        variant="destructive"
+        onConfirm={confirmDisconnect}
+        isLoading={disconnectServer ? disconnectingServerIds.has(disconnectServer.id) : false}
+        loadingLabel={intl.formatMessage({ id: "mcpServer.catalog.disconnecting" })}
+        closeOnConfirm={false}
+        onCloseAutoFocus={handleDisconnectDialogCloseAutoFocus}
+      />
     </CatalogPageLayout>
   );
 }