diff --git a/app/api/mcp-servers/[id]/test/route.ts b/app/api/mcp-servers/[id]/test/route.ts
new file mode 100644
index 00000000..709fba17
--- /dev/null
+++ b/app/api/mcp-servers/[id]/test/route.ts
@@ -0,0 +1,26 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { requireUserId } from "@/lib/auth";
+import { testSavedMcpServer } from "@/lib/mcp-servers/diagnostics";
+
+const defaultDeps = { requireUserId };
+
+export function createMcpServerTestHandler(deps = defaultDeps) {
+  return async function POST(
+    request: Request,
+    { params }: { params: Promise<{ id: string }> }
+  ) {
+    const userId = await deps.requireUserId();
+    if (userId instanceof Response) return userId;
+    const { id } = await params;
+    if (!z.string().uuid().safeParse(id).success)
+      return NextResponse.json({ error: "Invalid server id" }, { status: 400 });
+    const result = await testSavedMcpServer(userId, id, request.signal);
+    return NextResponse.json(result ?? { error: "Server not found" }, {
+      status: result ? 200 : 404,
+      headers: { "Cache-Control": "no-store" },
+    });
+  };
+}
+
+export const POST = createMcpServerTestHandler();
diff --git a/components/settings/mcp-servers-page-client.tsx b/components/settings/mcp-servers-page-client.tsx
index 4a5287dc..f4fcaf38 100644
--- a/components/settings/mcp-servers-page-client.tsx
+++ b/components/settings/mcp-servers-page-client.tsx
@@ -5,6 +5,7 @@ import useSWR from "swr";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { fetchJsonObject } from "@/lib/client-fetch";
+import type { McpDiagnosticResult } from "@/lib/mcp-servers/diagnostic-result";
 
 import type { McpServer, McpServersResponse, FormState } from "./mcp-servers/types";
 import { EMPTY_FORM } from "./mcp-servers/types";
@@ -30,6 +31,7 @@ export function McpServersPageClient() {
   const [deleteTarget, setDeleteTarget] = useState<McpServer | null>(null);
   const [deleting, setDeleting] = useState(false);
   const [pageError, setPageError] = useState<string | null>(null);
+  const [testResults, setTestResults] = useState<Record<string, McpDiagnosticResult>>({});
 
   const stats = useMemo(
     () => ({
@@ -160,10 +162,11 @@ export function McpServersPageClient() {
             <div className="space-y-3">
               {servers.map((server) => (
                 <ServerCard
-                  key={server.id}
+                  key={`${server.id}:${server.updatedAt}`}
                   server={server}
                   onEdit={openEditDialog}
                   onDelete={setDeleteTarget}
+                  onTestResult={(result) => setTestResults((current) => ({ ...current, [server.id]: result }))}
                 />
               ))}
             </div>
@@ -180,6 +183,10 @@ export function McpServersPageClient() {
         onFormChange={setForm}
         onClose={closeDialog}
         onSave={() => void handleSave()}
+        toolNames={(() => {
+          const result = editingServer ? testResults[editingServer.id] : undefined;
+          return result?.status === "success" && result.serverUpdatedAt === editingServer?.updatedAt ? result.tools.map((tool) => tool.name) : [];
+        })()}
       />
 
       <DeleteServerDialog
diff --git a/components/settings/mcp-servers/connection-test.tsx b/components/settings/mcp-servers/connection-test.tsx
new file mode 100644
index 00000000..11766a33
--- /dev/null
+++ b/components/settings/mcp-servers/connection-test.tsx
@@ -0,0 +1,70 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { diagnosticMessages, diagnosticResultSchema, type McpDiagnosticResult } from "@/lib/mcp-servers/diagnostic-result";
+import type { McpServer } from "./types";
+
+export function ConnectionTest({ server, onResult }: {
+  server: McpServer;
+  onResult: (result: McpDiagnosticResult) => void;
+}) {
+  const [testing, setTesting] = useState(false);
+  const [result, setResult] = useState<McpDiagnosticResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const activeTest = useRef<AbortController | null>(null);
+  useEffect(() => () => activeTest.current?.abort(), []);
+  async function testConnection() {
+    const controller = new AbortController();
+    activeTest.current = controller;
+    setTesting(true);
+    setResult(null);
+    setError(null);
+    try {
+      const response = await fetch(`/api/mcp-servers/${server.id}/test`, { method: "POST", signal: controller.signal });
+      if (controller.signal.aborted) return;
+      if (!response.ok) {
+        setError(response.status === 401 ? "Sign in again to test this connection." : response.status === 404 ? "This server no longer exists. Refresh the page." : "The test could not complete. Try again.");
+        return;
+      }
+      const data = diagnosticResultSchema.parse(await response.json());
+      if (controller.signal.aborted) return;
+      if (data.serverUpdatedAt && data.serverUpdatedAt !== server.updatedAt) {
+        setError("The saved settings changed. Refresh the page, then test again.");
+        return;
+      }
+      setResult(data);
+      onResult(data);
+    } catch {
+      if (!controller.signal.aborted) setError("The test could not complete. Check your connection and try again.");
+    } finally {
+      if (!controller.signal.aborted) setTesting(false);
+    }
+  }
+  if (server.transport === "stdio") return null;
+  const success = result?.status === "success" ? result : null;
+  const available = success?.tools.filter((tool) => tool.approval !== "deny") ?? [];
+  const automatic = available.filter((tool) => tool.approval !== "prompt").length;
+  const prompts = available.length - automatic;
+  return <div className="space-y-2 border-t border-border pt-3">
+    <div className="flex flex-wrap items-center gap-3">
+      <Button type="button" size="sm" variant="outline" disabled={testing} onClick={() => void testConnection()}>{testing ? "Testing connection..." : "Test connection"}</Button>
+      <p className="text-xs text-muted-foreground">Lists tools without running them.</p>
+    </div>
+    <div role="status" aria-live="polite" className="space-y-1 text-sm">
+      {!result && !error && !testing && <p className="text-muted-foreground">Not tested in this visit.</p>}
+      {error && <p className="text-destructive">{error}</p>}
+      {result?.status === "error" && <p className="text-destructive">{diagnosticMessages[result.code]}</p>}
+      {success && <>
+        <p>Connection test passed. {success.tools.length} {success.tools.length === 1 ? "tool" : "tools"} found.</p>
+        {success.enabled ? <p className="text-muted-foreground">{automatic} available in workspace chat. Control approval required: {prompts}. Blocked: {success.tools.length - available.length}.</p> : <p className="text-muted-foreground">This server is disabled. Enable it to make its allowed tools available.</p>}
+        {success.tools.length === 0 && <p className="text-muted-foreground">The server did not advertise any tools.</p>}
+        {success.tools.length > 0 && <details>
+          <summary className="cursor-pointer text-sm">Discovered tools</summary>
+          <ul className="mt-2 space-y-1">{success.tools.map((tool) => <li key={tool.name} className="break-words"><span className="font-mono">{tool.name}</span>: {tool.approval === "deny" ? "Blocked" : tool.approval === "prompt" ? "Control only: approval required" : "Runs automatically"}</li>)}</ul>
+        </details>}
+      </>}
+      {result && <p className="text-xs text-muted-foreground">Last test: {new Date(result.checkedAt).toLocaleString()}. Availability can change.</p>}
+    </div>
+  </div>;
+}
diff --git a/components/settings/mcp-servers/dialogs.tsx b/components/settings/mcp-servers/dialogs.tsx
index f8924430..e8cd920b 100644
--- a/components/settings/mcp-servers/dialogs.tsx
+++ b/components/settings/mcp-servers/dialogs.tsx
@@ -26,6 +26,7 @@ import {
 } from "@/components/ui/alert-dialog";
 import type { McpServer, FormState } from "./types";
 import { KeyValueEditor } from "./key-value-editor";
+import { PermissionsEditor } from "./permissions-editor";
 
 interface McpServerDialogProps {
   open: boolean;
@@ -36,6 +37,7 @@ interface McpServerDialogProps {
   onFormChange: (updater: (current: FormState) => FormState) => void;
   onClose: (open: boolean) => void;
   onSave: () => void;
+  toolNames?: string[];
 }
 
 export function McpServerDialog({
@@ -47,6 +49,7 @@ export function McpServerDialog({
   onFormChange,
   onClose,
   onSave,
+  toolNames,
 }: McpServerDialogProps) {
   const dialogTitle = editingServer ? "Edit MCP server" : "Add MCP server";
   const dialogDescription = editingServer
@@ -194,6 +197,12 @@ export function McpServerDialog({
             </TabsContent>
           </Tabs>
 
+          {form.transport === "http" && <PermissionsEditor
+            extraText={form.extraText}
+            toolNames={toolNames}
+            onChange={(extraText) => onFormChange((current) => ({ ...current, extraText }))}
+          />}
+
           <div className="space-y-2">
             <Label htmlFor="mcp-server-extra">Extra JSON</Label>
             <Textarea
diff --git a/components/settings/mcp-servers/helpers.ts b/components/settings/mcp-servers/helpers.ts
index ad8fd233..76009f28 100644
--- a/components/settings/mcp-servers/helpers.ts
+++ b/components/settings/mcp-servers/helpers.ts
@@ -1,5 +1,6 @@
 import type { McpServer, KeyValueEntry, FormState } from "./types";
 import { EMPTY_FORM } from "./types";
+import { readToolPolicy } from "@/lib/mcp-servers/policy";
 
 export function createEntry(partial?: Partial<KeyValueEntry>): KeyValueEntry {
   return {
@@ -85,7 +86,7 @@ export function summarizeServer(server: McpServer) {
   return `${server.url ?? "No URL"} - ${headerCount} headers`;
 }
 
-function parseExtra(extraText: string) {
+export function parseExtra(extraText: string) {
   const trimmed = extraText.trim();
   if (!trimmed) {
     return {};
@@ -173,6 +174,13 @@ function buildKeyValuePayload(entries: KeyValueEntry[], label: string) {
 
 export function buildPayload(form: FormState) {
   const extra = parseExtra(form.extraText);
+  if (form.transport === "http") {
+    try {
+      readToolPolicy(extra);
+    } catch {
+      throw new Error("Correct the tool permissions before saving.");
+    }
+  }
   const env = buildKeyValuePayload(form.envEntries, "Environment");
   const headers = buildKeyValuePayload(form.headerEntries, "Header");
   const base = {
diff --git a/components/settings/mcp-servers/permissions-editor.tsx b/components/settings/mcp-servers/permissions-editor.tsx
new file mode 100644
index 00000000..88cc1319
--- /dev/null
+++ b/components/settings/mcp-servers/permissions-editor.tsx
@@ -0,0 +1,103 @@
+"use client";
+
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { readToolPolicy, toolApproval, updateToolPolicy, normalizeToolNames, type ToolApproval } from "@/lib/mcp-servers/policy";
+import { parseExtra } from "./helpers";
+
+export function PermissionsEditor({ extraText, onChange, toolNames = [] }: {
+  extraText: string;
+  onChange: (value: string) => void;
+  toolNames?: string[];
+}) {
+  const [newTool, setNewTool] = useState("");
+  let extra: Record<string, unknown>;
+  let policy: ReturnType<typeof readToolPolicy>;
+  try {
+    extra = parseExtra(extraText);
+    policy = readToolPolicy(extra);
+  } catch {
+    return <p role="alert" className="text-sm text-destructive">Tool permissions are invalid. Correct the permission fields in Extra JSON before saving.</p>;
+  }
+  const write = (value: Record<string, unknown>) => onChange(JSON.stringify(value, null, 2));
+  const names = [...new Set([...toolNames, ...Object.keys(policy.tools ?? {}), ...(policy.enabled_tools ?? []), ...(policy.disabled_tools ?? [])])].filter(Boolean).sort();
+  const setMode = (mode: ToolApproval | "inherit", tool?: string) => write(updateToolPolicy(extra, { mode, tool }));
+  const lines = (value: string) => value ? value.split("\n") : [];
+
+  return <section aria-label="Tool permissions" className="space-y-4 border-t border-border pt-4">
+    <div>
+      <h3 className="text-sm font-medium">Tool permissions</h3>
+      <p className="text-sm text-muted-foreground">Choose which tools agents can use. Changes apply on the next turn.</p>
+    </div>
+    <div className="space-y-2">
+      <Label htmlFor="mcp-default-approval">Default approval</Label>
+      <Select value={policy.default_tools_approval_mode === "approve" ? "auto" : policy.default_tools_approval_mode ?? "auto"} onValueChange={(value) => setMode(value as ToolApproval)}>
+        <SelectTrigger id="mcp-default-approval"><SelectValue /></SelectTrigger>
+        <SelectContent>
+          <SelectItem value="auto">Run automatically</SelectItem>
+          <SelectItem value="prompt">Ask in Control</SelectItem>
+        </SelectContent>
+      </Select>
+      <p className="text-sm text-muted-foreground">Tools that need approval are available in Control only, not workspace chat. The CLI also receives these permissions.</p>
+    </div>
+    <div className="flex items-center gap-3">
+      <Switch id="mcp-all-tools" checked={policy.enabled_tools === undefined} onCheckedChange={(checked) => {
+        const next = { ...extra };
+        if (checked) delete next.enabled_tools;
+        else next.enabled_tools = [];
+        write(next);
+      }} />
+      <Label htmlFor="mcp-all-tools">Allow all tools unless blocked</Label>
+    </div>
+    {policy.enabled_tools !== undefined && <div className="space-y-2">
+      <Label htmlFor="mcp-allowed-tools">Allowed tools (one name per line)</Label>
+      <Textarea id="mcp-allowed-tools" value={policy.enabled_tools.join("\n")} onChange={(event) => write({ ...extra, enabled_tools: lines(event.target.value) })} onBlur={(event) => write({ ...extra, enabled_tools: normalizeToolNames(lines(event.target.value)) })} />
+      <p className="text-sm text-muted-foreground">An empty list allows no tools. New tools stay unavailable until added here.</p>
+    </div>}
+    <div className="space-y-2">
+      <Label htmlFor="mcp-blocked-tools">Blocked tools (one name per line)</Label>
+      <Textarea id="mcp-blocked-tools" value={(policy.disabled_tools ?? []).join("\n")} onChange={(event) => write({ ...extra, disabled_tools: lines(event.target.value) })} onBlur={(event) => write({ ...extra, disabled_tools: normalizeToolNames(lines(event.target.value)) })} />
+      <p className="text-sm text-muted-foreground">Blocked tools remain unavailable even if their approval allows them.</p>
+    </div>
+    <div className="space-y-3">
+      <h4 className="text-sm font-medium">Per-tool approval</h4>
+      {names.map((name) => {
+        const entry = policy.tools?.[name];
+        const mode = entry?.approval_mode === "approve" ? "auto" : entry?.approval_mode ?? "inherit";
+        const effective = toolApproval(policy, name);
+        return <div key={name} className="grid gap-2 border-b border-border pb-3 sm:grid-cols-[minmax(0,1fr)_minmax(0,1fr)]">
+          <div className="min-w-0">
+            <p className="break-all font-mono text-sm">{name}</p>
+            <p className="text-xs text-muted-foreground">{effective === "deny" ? "Blocked" : effective === "prompt" ? "Control only: approval required" : "Workspace chat and Control"}</p>
+            {entry?.enabled === false && <div className="mt-2 flex items-center gap-2">
+              <Switch aria-label={`Enable ${name}`} checked={false} onCheckedChange={() => {
+                const tools = (extra.tools ?? {}) as Record<string, Record<string, unknown>>;
+                write({ ...extra, tools: { ...tools, [name]: { ...tools[name], enabled: true } } });
+              }} />
+              <span className="text-xs">Disabled in saved settings</span>
+            </div>}
+          </div>
+          <Select disabled={entry?.enabled === false} value={mode} onValueChange={(value) => setMode(value as ToolApproval | "inherit", name)}>
+            <SelectTrigger aria-label={`Approval for ${name}`}><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="inherit">Use default</SelectItem>
+              <SelectItem value="auto">Run automatically</SelectItem>
+              <SelectItem value="prompt">Ask in Control</SelectItem>
+              <SelectItem value="deny">Block</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>;
+      })}
+      <div className="flex flex-col gap-2 sm:flex-row">
+        <Input aria-label="Tool name for approval override" placeholder="Exact tool name" value={newTool} onChange={(event) => setNewTool(event.target.value)} />
+        <Button type="button" variant="outline" disabled={!newTool.trim() || names.includes(newTool.trim())} onClick={() => { setMode("inherit", newTool.trim()); setNewTool(""); }}>Add tool rule</Button>
+      </div>
+      <p className="text-xs text-muted-foreground">Test the saved connection to list its tools, or enter an exact tool name.</p>
+    </div>
+  </section>;
+}
diff --git a/components/settings/mcp-servers/server-card.tsx b/components/settings/mcp-servers/server-card.tsx
index 07bafe4e..cb2a0ab6 100644
--- a/components/settings/mcp-servers/server-card.tsx
+++ b/components/settings/mcp-servers/server-card.tsx
@@ -4,14 +4,17 @@ import { Button } from "@/components/ui/button";
 import { Badge } from "@/components/ui/badge";
 import type { McpServer } from "./types";
 import { formatTimestamp, summarizeServer } from "./helpers";
+import { ConnectionTest } from "./connection-test";
+import type { McpDiagnosticResult } from "@/lib/mcp-servers/diagnostic-result";
 
 interface ServerCardProps {
   server: McpServer;
   onEdit: (server: McpServer) => void;
   onDelete: (server: McpServer) => void;
+  onTestResult: (result: McpDiagnosticResult) => void;
 }
 
-export function ServerCard({ server, onEdit, onDelete }: ServerCardProps) {
+export function ServerCard({ server, onEdit, onDelete, onTestResult }: ServerCardProps) {
   return (
     <div className="rounded-lg border border-border bg-background/60 p-4">
       <div className="flex flex-col gap-3 md:flex-row md:items-start md:justify-between">
@@ -69,6 +72,7 @@ export function ServerCard({ server, onEdit, onDelete }: ServerCardProps) {
           </Button>
         </div>
       </div>
+      {server.transport === "http" && <div className="mt-3"><ConnectionTest server={server} onResult={onTestResult} /></div>}
     </div>
   );
 }
diff --git a/lib/connections/mcp-tools.ts b/lib/connections/mcp-tools.ts
index ea957cfa..9cf59629 100644
--- a/lib/connections/mcp-tools.ts
+++ b/lib/connections/mcp-tools.ts
@@ -21,7 +21,11 @@ export async function getMcpTools(
 
 export async function getRemoteMcpTools(
   transport: ReturnType<typeof buildMcpTransport>,
-  options: { validateRequests?: boolean; startupSignal?: AbortSignal } = {}
+  options: {
+    validateRequests?: boolean;
+    startupSignal?: AbortSignal;
+    cleanupSignal?: () => AbortSignal;
+  } = {}
 ): Promise<McpToolsResult> {
   await assertSafeOutboundHttpUrlWithDns(transport.url, "mcp_url");
   options.startupSignal?.throwIfAborted();
@@ -36,14 +40,20 @@ export async function getRemoteMcpTools(
       fetch: options.validateRequests
         ? async (input, init) => {
             const url = input instanceof Request ? input.url : String(input);
+            // Teardown must remain possible after discovery is cancelled.
+            const cleanupSignal =
+              init?.method === "DELETE" ? options.cleanupSignal?.() : undefined;
             await assertSafeOutboundHttpUrlWithDns(url, "mcp_url");
+            const signals = cleanupSignal
+              ? [cleanupSignal]
+              : [
+                  ...(starting && options.startupSignal
+                    ? [options.startupSignal]
+                    : []),
+                  ...(init?.signal ? [init.signal] : []),
+                ];
             const signal =
-              starting && options.startupSignal
-                ? AbortSignal.any([
-                    options.startupSignal,
-                    ...(init?.signal ? [init.signal] : []),
-                  ])
-                : init?.signal;
+              signals.length > 0 ? AbortSignal.any(signals) : undefined;
             signal?.throwIfAborted();
             return fetch(input, { ...init, signal, redirect: "error" });
           }
diff --git a/lib/mcp-servers/chat.ts b/lib/mcp-servers/chat.ts
index 001be36a..61cd08aa 100644
--- a/lib/mcp-servers/chat.ts
+++ b/lib/mcp-servers/chat.ts
@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { Tool } from "ai";
-import { z } from "zod";
+import { readToolPolicy, toolApproval } from "./policy";
 import { supabaseAdmin } from "@/lib/supabase/admin";
 import {
   getRemoteMcpTools,
@@ -12,26 +12,11 @@ import { normalizeStringRecord } from "./validation";
 import { resolveVaultSecrets } from "./secrets";
 import type { McpServerRow } from "./types";
 
-type ChatServerRow = Pick<
+export type ChatServerRow = Pick<
   McpServerRow,
   "id" | "name" | "url" | "header_refs" | "header_plain" | "extra"
 >;
 
-const toolPolicySchema = z.object({
-  enabled_tools: z.array(z.string()).optional(),
-  disabled_tools: z.array(z.string()).optional(),
-  default_tools_approval_mode: z.enum(["auto", "approve", "prompt"]).optional(),
-  tools: z
-    .record(
-      z.string(),
-      z.object({
-        enabled: z.boolean().optional(),
-        approval_mode: z.enum(["auto", "approve", "prompt", "deny"]).optional(),
-      })
-    )
-    .optional(),
-});
-
 export async function listSavedHttpMcpServers(
   userId: string,
   db = supabaseAdmin
@@ -47,17 +32,10 @@ export async function listSavedHttpMcpServers(
   return (data ?? []) as ChatServerRow[];
 }
 
-function toolApproval(policy: z.infer<typeof toolPolicySchema>, name: string) {
-  if (policy.enabled_tools && !policy.enabled_tools.includes(name))
-    return "deny";
-  if (policy.disabled_tools?.includes(name)) return "deny";
-  const perTool = policy.tools?.[name];
-  if (perTool?.enabled === false) return "deny";
-  // CLI approval.ts defines "approve" as pre-approved, equivalent to "auto".
-  return perTool?.approval_mode ?? policy.default_tools_approval_mode;
-}
-
-function duringStartup<T>(work: Promise<T>, signal: AbortSignal): Promise<T> {
+export function duringStartup<T>(
+  work: Promise<T>,
+  signal: AbortSignal
+): Promise<T> {
   let onAbort: () => void;
   const aborted = new Promise<never>((_resolve, reject) => {
     onAbort = () => reject(signal.reason);
@@ -69,8 +47,18 @@ function duringStartup<T>(work: Promise<T>, signal: AbortSignal): Promise<T> {
   });
 }
 
-async function loadSavedServer(server: ChatServerRow, signal: AbortSignal) {
-  const policy = toolPolicySchema.parse(server.extra ?? {});
+export class MissingMcpSecretError extends Error {}
+
+// Return partial results before Control's outer deadline.
+export const SAVED_MCP_STARTUP_TIMEOUT_MS =
+  CONNECTION_TOOL_STARTUP_TIMEOUT_MS - 2000;
+
+export async function loadSavedServer(
+  server: ChatServerRow,
+  signal: AbortSignal,
+  cleanupSignal?: () => AbortSignal
+) {
+  const policy = readToolPolicy(server.extra);
   if (!server.url) throw new Error("Missing MCP URL");
   // Local HTTP servers still sync to the CLI. The hosted runtime must not
   // read their secrets or dial private addresses.
@@ -82,7 +70,8 @@ async function loadSavedServer(server: ChatServerRow, signal: AbortSignal) {
   signal.throwIfAborted();
   for (const [name, id] of Object.entries(refs)) {
     const value = secrets.get(id);
-    if (value === undefined) throw new Error("Missing MCP secret");
+    if (value === undefined)
+      throw new MissingMcpSecretError("Missing MCP secret");
     headers[name] = value;
   }
   // Detach a healthy session from the shared deadline: its startup requests
@@ -96,7 +85,7 @@ async function loadSavedServer(server: ChatServerRow, signal: AbortSignal) {
       policy,
       loaded: await getRemoteMcpTools(
         { type: "http", url: server.url, headers },
-        { validateRequests: true, startupSignal: startup.signal }
+        { validateRequests: true, startupSignal: startup.signal, cleanupSignal }
       ),
     };
   } finally {
@@ -116,7 +105,7 @@ export async function loadSavedMcpServerTools(
   const timer = setTimeout(
     () => startup.abort(new Error("MCP startup timed out")),
     // Leave time to return healthy results before Control's outer deadline.
-    CONNECTION_TOOL_STARTUP_TIMEOUT_MS - 2000
+    SAVED_MCP_STARTUP_TIMEOUT_MS
   );
   try {
     const servers = await duringStartup(
diff --git a/lib/mcp-servers/diagnostic-result.test.ts b/lib/mcp-servers/diagnostic-result.test.ts
new file mode 100644
index 00000000..755c8be6
--- /dev/null
+++ b/lib/mcp-servers/diagnostic-result.test.ts
@@ -0,0 +1,38 @@
+import { expect, it } from "vitest";
+import {
+  diagnosticMessages,
+  diagnosticResultSchema,
+} from "./diagnostic-result";
+
+const timestamps = {
+  checkedAt: "2026-09-22T00:00:00Z",
+  serverUpdatedAt: "2026-09-22T00:00:00Z",
+};
+it("accepts known diagnostic outcomes and rejects malformed responses", () => {
+  for (const code of Object.keys(diagnosticMessages))
+    expect(
+      diagnosticResultSchema.safeParse({ ...timestamps, status: "error", code })
+        .success
+    ).toBe(true);
+  expect(
+    diagnosticResultSchema.safeParse({
+      ...timestamps,
+      status: "success",
+      enabled: true,
+      tools: [{ name: "search", approval: "prompt" }],
+    }).success
+  ).toBe(true);
+  for (const data of [
+    null,
+    {},
+    { ...timestamps, status: "error", code: "raw-secret-message" },
+    { ...timestamps, status: "success", enabled: true, tools: "all" },
+    {
+      ...timestamps,
+      status: "success",
+      enabled: true,
+      tools: [{ name: "search", approval: "unknown" }],
+    },
+  ])
+    expect(diagnosticResultSchema.safeParse(data).success).toBe(false);
+});
diff --git a/lib/mcp-servers/diagnostic-result.ts b/lib/mcp-servers/diagnostic-result.ts
new file mode 100644
index 00000000..8f1aca85
--- /dev/null
+++ b/lib/mcp-servers/diagnostic-result.ts
@@ -0,0 +1,61 @@
+import type { ToolApproval } from "./policy";
+import { z } from "zod";
+
+export const diagnosticMessages = {
+  settings_unavailable:
+    "Mogplex could not read the saved connection. Try again later.",
+  invalid_policy:
+    "The tool permissions are invalid. Edit the server and correct its permission fields in Extra JSON.",
+  unsafe_url:
+    "The URL must resolve to a public HTTP or HTTPS server. Local servers work through the CLI only.",
+  missing_secret:
+    "A saved header secret is missing. Edit the server and enter its value again.",
+  authentication:
+    "The server rejected access. Check the saved authorization header and its permissions.",
+  timeout:
+    "The server did not finish the connection test in time. Check the server, then test again.",
+  connection:
+    "The connection test failed. Check the server URL, Streamable HTTP support, and saved headers.",
+  cli_only:
+    "Local servers run through the CLI. Test this server from the CLI on your computer.",
+} as const;
+
+export type DiagnosticCode = keyof typeof diagnosticMessages;
+export type McpDiagnosticResult = {
+  checkedAt: string;
+  serverUpdatedAt: string;
+} & (
+  | {
+      status: "success";
+      enabled: boolean;
+      tools: Array<{ name: string; approval: ToolApproval }>;
+    }
+  | { status: "error"; code: DiagnosticCode }
+);
+
+const timestamps = {
+  checkedAt: z.string().datetime(),
+  serverUpdatedAt: z.string(),
+};
+export const diagnosticResultSchema: z.ZodType<McpDiagnosticResult> =
+  z.discriminatedUnion("status", [
+    z.object({
+      ...timestamps,
+      status: z.literal("success"),
+      enabled: z.boolean(),
+      tools: z.array(
+        z.object({
+          name: z.string(),
+          approval: z.enum(["auto", "approve", "prompt", "deny"]),
+        })
+      ),
+    }),
+    z.object({
+      ...timestamps,
+      status: z.literal("error"),
+      code: z.custom<DiagnosticCode>(
+        (value) =>
+          typeof value === "string" && Object.hasOwn(diagnosticMessages, value)
+      ),
+    }),
+  ]);
diff --git a/lib/mcp-servers/diagnostics.test.ts b/lib/mcp-servers/diagnostics.test.ts
new file mode 100644
index 00000000..9107df94
--- /dev/null
+++ b/lib/mcp-servers/diagnostics.test.ts
@@ -0,0 +1,333 @@
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { testSavedMcpServer } from "./diagnostics";
+import type { McpServerRow } from "./types";
+
+const id = "11111111-1111-4111-8111-111111111111";
+let row: McpServerRow;
+let requests: Request[];
+let methods: string[];
+let missingSecret: boolean;
+let httpStatus: number;
+let stall: boolean;
+let stallClose: boolean;
+let tools: string[];
+let onDiscovery: () => void;
+let databaseFailure: boolean;
+let discoveryError: Error | undefined;
+
+beforeEach(() => {
+  vi.stubEnv("MOGPLEX_DATA_BACKEND", "supabase");
+  vi.stubEnv("NEXT_PUBLIC_SUPABASE_URL", "https://db.example.com");
+  vi.stubEnv("SUPABASE_SERVICE_ROLE_KEY", "fixture-service-key");
+  row = {
+    id,
+    user_id: "owner",
+    name: "Docs",
+    transport: "http",
+    enabled: true,
+    command: null,
+    args: [],
+    env_refs: {},
+    env_plain: {},
+    url: "https://8.8.8.8/mcp",
+    header_refs: { Authorization: "secret-id" },
+    header_plain: {},
+    extra: {},
+    created_at: "2026-09-22T00:00:00Z",
+    updated_at: "2026-09-22T01:00:00Z",
+  };
+  requests = [];
+  methods = [];
+  missingSecret = false;
+  httpStatus = 200;
+  stall = false;
+  stallClose = false;
+  tools = ["search", "publish", "delete"];
+  onDiscovery = () => undefined;
+  databaseFailure = false;
+  discoveryError = undefined;
+  vi.stubGlobal(
+    "fetch",
+    async (input: RequestInfo | URL, init?: RequestInit) => {
+      const request = new Request(input, init);
+      requests.push(request);
+      const url = new URL(request.url);
+      if (url.pathname.endsWith("/user_mcp_servers")) {
+        if (databaseFailure)
+          return Response.json(
+            { message: "fixture-secret-never-return", code: "DB_UNAVAILABLE" },
+            { status: 503 }
+          );
+        return Response.json(
+          url.searchParams.get("user_id") === `eq.${row.user_id}` &&
+            url.searchParams.get("id") === `eq.${row.id}`
+            ? row
+            : null
+        );
+      }
+      if (url.pathname.endsWith("/decrypted_secrets"))
+        return Response.json(
+          missingSecret
+            ? []
+            : [
+                {
+                  id: "secret-id",
+                  decrypted_secret: "Bearer fixture-secret-never-return",
+                },
+              ]
+        );
+      if (request.method === "DELETE" && stallClose)
+        return new Promise<Response>((_resolve, reject) => {
+          request.signal.addEventListener(
+            "abort",
+            () => reject(request.signal.reason),
+            { once: true }
+          );
+          onDiscovery();
+        });
+      if (request.method === "DELETE")
+        return new Response(null, { status: 204 });
+      const body = await request.json();
+      methods.push(body.method);
+      if (body.method === "notifications/initialized")
+        return new Response(null, { status: 202 });
+      if (body.method === "tools/list") {
+        if (discoveryError) throw discoveryError;
+        if (stall)
+          return new Promise<Response>((_resolve, reject) => {
+            request.signal.addEventListener(
+              "abort",
+              () => reject(request.signal.reason),
+              { once: true }
+            );
+            onDiscovery();
+          });
+        if (httpStatus !== 200)
+          return new Response("fixture-secret-never-return", {
+            status: httpStatus,
+          });
+      }
+      const result =
+        body.method === "initialize"
+          ? {
+              protocolVersion: "2025-06-18",
+              capabilities: { tools: {} },
+              serverInfo: { name: "fixture", version: "1" },
+            }
+          : {
+              tools: tools.map((name) => ({
+                name,
+                inputSchema: { type: "object", properties: {} },
+              })),
+            };
+      return Response.json(
+        { jsonrpc: "2.0", id: body.id, result },
+        { headers: { "mcp-session-id": "fixture-session" } }
+      );
+    }
+  );
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+
+it("discovers saved tools with Vault headers, explains effective permissions, and closes without executing tools", async () => {
+  row.extra = {
+    default_tools_approval_mode: "prompt",
+    tools: {
+      search: { approval_mode: "approve" },
+      delete: { approval_mode: "deny" },
+    },
+  };
+  const result = await testSavedMcpServer("owner", id);
+  expect(result).toMatchObject({
+    status: "success",
+    enabled: true,
+    serverUpdatedAt: row.updated_at,
+    tools: [
+      { name: "search", approval: "approve" },
+      { name: "publish", approval: "prompt" },
+      { name: "delete", approval: "deny" },
+    ],
+  });
+  expect(methods).toContain("tools/list");
+  expect(methods).not.toContain("tools/call");
+  expect(requests.filter((r) => r.method === "DELETE")).toHaveLength(1);
+  expect(
+    requests
+      .filter((r) => r.url.startsWith("https://8.8.8.8"))
+      .every(
+        (r) =>
+          r.headers.get("authorization") ===
+          "Bearer fixture-secret-never-return"
+      )
+  ).toBe(true);
+  expect(JSON.stringify(result)).not.toMatch(
+    /fixture-secret|header_refs|8\.8\.8\.8/
+  );
+});
+
+it.each(["other", "owner"])(
+  "isolates missing or other-owner servers before credentials are read (%s)",
+  async (user) => {
+    expect(
+      await testSavedMcpServer(user, user === "owner" ? "missing-id" : id)
+    ).toBeNull();
+    expect(requests).toHaveLength(1);
+  }
+);
+
+it("reports database failure without treating it as a missing server or exposing details", async () => {
+  databaseFailure = true;
+  const warning = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+  const result = await testSavedMcpServer("owner", id);
+  expect(result).toMatchObject({
+    status: "error",
+    code: "settings_unavailable",
+  });
+  expect(JSON.stringify(result)).not.toContain("fixture-secret");
+  expect(methods).toEqual([]);
+  expect(warning).toHaveBeenCalledWith(
+    "[mcp-servers] Connection test failed",
+    expect.objectContaining({
+      code: "settings_unavailable",
+      databaseCode: "DB_UNAVAILABLE",
+    })
+  );
+  expect(JSON.stringify(warning.mock.calls)).not.toContain("fixture-secret");
+});
+
+it("recognizes authentication errors nested in a transport failure", async () => {
+  discoveryError = new Error("fixture-secret-never-return", {
+    cause: { statusCode: 401 },
+  });
+  const result = await testSavedMcpServer("owner", id);
+  expect(result).toMatchObject({ status: "error", code: "authentication" });
+  expect(JSON.stringify(result)).not.toContain("fixture-secret");
+});
+
+it("reports disabled and empty servers truthfully while allowing a test", async () => {
+  row.enabled = false;
+  tools = [];
+  expect(await testSavedMcpServer("owner", id)).toMatchObject({
+    status: "success",
+    enabled: false,
+    tools: [],
+  });
+});
+
+it.each([
+  { change: { transport: "stdio" as const }, code: "cli_only" },
+  { change: { url: "http://127.0.0.1/mcp" }, code: "unsafe_url" },
+  { change: { url: "file:///etc/passwd" }, code: "unsafe_url" },
+  { change: { extra: { enabled_tools: "all" } }, code: "invalid_policy" },
+])(
+  "returns $code before reading secrets or contacting the server",
+  async ({ change, code }) => {
+    Object.assign(row, change);
+    expect(await testSavedMcpServer("owner", id)).toMatchObject({
+      status: "error",
+      code,
+    });
+    expect(requests).toHaveLength(1);
+  }
+);
+
+it("reports a missing secret without trying anonymous access", async () => {
+  missingSecret = true;
+  expect(await testSavedMcpServer("owner", id)).toMatchObject({
+    status: "error",
+    code: "missing_secret",
+  });
+  expect(methods).toEqual([]);
+});
+
+it.each([401, 403, 404])(
+  "classifies HTTP %s without returning the upstream body",
+  async (status) => {
+    httpStatus = status;
+    const result = await testSavedMcpServer("owner", id);
+    expect(result).toMatchObject({
+      status: "error",
+      code: status === 404 ? "connection" : "authentication",
+    });
+    expect(JSON.stringify(result)).not.toContain("fixture-secret");
+    // A 404 expires the SDK's session, so there is no session left to delete.
+    expect(requests.filter((r) => r.method === "DELETE")).toHaveLength(
+      status === 404 ? 0 : 1
+    );
+  }
+);
+
+it("bounds stalled discovery and aborts the network request", async () => {
+  vi.useFakeTimers();
+  stall = true;
+  const started = new Promise<void>((resolve) => {
+    onDiscovery = resolve;
+  });
+  const result = testSavedMcpServer("owner", id);
+  await started;
+  await vi.advanceTimersByTimeAsync(6001);
+  expect(await result).toMatchObject({ status: "error", code: "timeout" });
+  expect(
+    requests.filter((request) => request.method === "DELETE")
+  ).toHaveLength(1);
+  expect(
+    requests.some(
+      (r) => r.url.startsWith("https://8.8.8.8") && r.signal.aborted
+    )
+  ).toBe(true);
+});
+
+it("honors request cancellation", async () => {
+  stall = true;
+  const started = new Promise<void>((resolve) => {
+    onDiscovery = resolve;
+  });
+  const controller = new AbortController();
+  const result = testSavedMcpServer("owner", id, controller.signal);
+  await started;
+  controller.abort();
+  expect(await result).toMatchObject({ status: "error", code: "timeout" });
+  expect(
+    requests.filter((request) => request.method === "DELETE")
+  ).toHaveLength(1);
+});
+
+it("preserves successful discovery while bounding a stalled session close", async () => {
+  vi.useFakeTimers();
+  stallClose = true;
+  const closing = new Promise<void>((resolve) => {
+    onDiscovery = resolve;
+  });
+  const result = testSavedMcpServer("owner", id);
+  await closing;
+  await vi.advanceTimersByTimeAsync(2001);
+  expect(await result).toMatchObject({
+    status: "success",
+    tools: [{ name: "search" }, { name: "publish" }, { name: "delete" }],
+  });
+  expect(
+    requests.find((request) => request.method === "DELETE")?.signal.aborted
+  ).toBe(true);
+});
+
+it("bounds stalled discovery plus stalled teardown within eight seconds", async () => {
+  vi.useFakeTimers();
+  stall = true;
+  stallClose = true;
+  const started = new Promise<void>((resolve) => {
+    onDiscovery = resolve;
+  });
+  const result = testSavedMcpServer("owner", id);
+  await started;
+  await vi.advanceTimersByTimeAsync(8001);
+  expect(await result).toMatchObject({ status: "error", code: "timeout" });
+  expect(
+    requests.find((request) => request.method === "DELETE")?.signal.aborted
+  ).toBe(true);
+});
diff --git a/lib/mcp-servers/diagnostics.ts b/lib/mcp-servers/diagnostics.ts
new file mode 100644
index 00000000..3b2c82e7
--- /dev/null
+++ b/lib/mcp-servers/diagnostics.ts
@@ -0,0 +1,153 @@
+import { z } from "zod";
+import { supabaseAdmin } from "@/lib/supabase/admin";
+import { UnsafeOutboundUrlError } from "@/lib/security/outbound-url";
+import {
+  duringStartup,
+  loadSavedServer,
+  MissingMcpSecretError,
+  SAVED_MCP_STARTUP_TIMEOUT_MS,
+  type ChatServerRow,
+} from "./chat";
+import { toolApproval } from "./policy";
+import type { DiagnosticCode, McpDiagnosticResult } from "./diagnostic-result";
+
+function failureCode(error: unknown, signal: AbortSignal): DiagnosticCode {
+  // Cancellation shares this code: the disconnected caller needs no response,
+  // and the request has the same bounded teardown as a discovery timeout.
+  if (signal.aborted) return "timeout";
+  if (error instanceof z.ZodError) return "invalid_policy";
+  if (error instanceof UnsafeOutboundUrlError) return "unsafe_url";
+  if (error instanceof MissingMcpSecretError) return "missing_secret";
+  const visited = new Set<unknown>();
+  let cause = error;
+  while (cause && typeof cause === "object" && !visited.has(cause)) {
+    visited.add(cause);
+    if (
+      "statusCode" in cause &&
+      (cause.statusCode === 401 || cause.statusCode === 403)
+    )
+      return "authentication";
+    cause = "cause" in cause ? cause.cause : undefined;
+  }
+  return "connection";
+}
+
+export async function getSavedMcpServerForTest(
+  userId: string,
+  id: string,
+  db = supabaseAdmin
+) {
+  return db
+    .from("user_mcp_servers")
+    .select(
+      "id, name, url, header_refs, header_plain, extra, transport, enabled, updated_at"
+    )
+    .eq("user_id", userId)
+    .eq("id", id)
+    .maybeSingle();
+}
+
+async function closeDiagnosticSession(
+  loading: ReturnType<typeof loadSavedServer>
+) {
+  try {
+    const { loaded } = await loading;
+    await loaded.cleanup();
+  } catch {
+    /* Discovery failures are reported by the caller. */
+  }
+}
+
+/** Saved definitions only: never accept a caller-supplied URL or secret reference. */
+export async function testSavedMcpServer(
+  userId: string,
+  id: string,
+  requestSignal?: AbortSignal
+): Promise<McpDiagnosticResult | null> {
+  const deadline = new AbortController();
+  const cleanup = new AbortController();
+  let cleanupTimer: ReturnType<typeof setTimeout> | undefined;
+  // Keep the complete test within the existing eight-second connection budget.
+  const getCleanupSignal = () => {
+    cleanupTimer ??= setTimeout(() => cleanup.abort(), 2000);
+    return cleanup.signal;
+  };
+  let loading: ReturnType<typeof loadSavedServer> | undefined;
+  const signal = requestSignal
+    ? AbortSignal.any([deadline.signal, requestSignal])
+    : deadline.signal;
+  const timer = setTimeout(
+    () => deadline.abort(),
+    SAVED_MCP_STARTUP_TIMEOUT_MS
+  );
+  let updatedAt = "";
+  let readingSettings = true;
+  try {
+    const { data, error } = await duringStartup(
+      getSavedMcpServerForTest(userId, id),
+      signal
+    );
+    if (error) throw error;
+    if (!data) return null;
+    readingSettings = false;
+    const server = data as ChatServerRow & {
+      transport: string;
+      enabled: boolean;
+      updated_at: string;
+    };
+    updatedAt = server.updated_at;
+    if (server.transport !== "http")
+      return {
+        status: "error",
+        code: "cli_only",
+        checkedAt: new Date().toISOString(),
+        serverUpdatedAt: updatedAt,
+      };
+    loading = loadSavedServer(server, signal, getCleanupSignal);
+    const { loaded, policy } = await duringStartup(loading, signal);
+    return {
+      status: "success",
+      enabled: server.enabled,
+      tools: Object.keys(loaded.tools).map((name) => ({
+        name,
+        approval: toolApproval(policy, name),
+      })),
+      checkedAt: new Date().toISOString(),
+      serverUpdatedAt: updatedAt,
+    };
+  } catch (error) {
+    const code = readingSettings
+      ? "settings_unavailable"
+      : failureCode(error, signal);
+    console.warn("[mcp-servers] Connection test failed", {
+      userId,
+      serverId: id,
+      code,
+      ...(readingSettings &&
+      error &&
+      typeof error === "object" &&
+      "code" in error
+        ? { databaseCode: error.code }
+        : {}),
+    });
+    return {
+      status: "error",
+      code,
+      checkedAt: new Date().toISOString(),
+      serverUpdatedAt: updatedAt,
+    };
+  } finally {
+    clearTimeout(timer);
+    deadline.abort();
+    if (loading) {
+      // Await teardown after success, cancellation, or failure, without masking
+      // the discovery result. The same fresh signal bounds its DELETE request.
+      await duringStartup(
+        closeDiagnosticSession(loading),
+        getCleanupSignal()
+      ).catch(() => undefined);
+    }
+    clearTimeout(cleanupTimer);
+    cleanup.abort();
+  }
+}
diff --git a/lib/mcp-servers/normalization.ts b/lib/mcp-servers/normalization.ts
index a6594def..76a6cbe5 100644
--- a/lib/mcp-servers/normalization.ts
+++ b/lib/mcp-servers/normalization.ts
@@ -7,6 +7,7 @@ import type {
   McpServerUpdateInput,
 } from "./types";
 import { McpServerValidationError } from "./types";
+import { readToolPolicy } from "./policy";
 import {
   isObject,
   normalizeName,
@@ -94,7 +95,21 @@ function normalizeSecretMutationRecord(
   return record;
 }
 
-function validateExtraKeys(extra: JsonObject, transport: "stdio" | "http") {
+function validateExtraKeys(
+  extra: JsonObject,
+  transport: "stdio" | "http",
+  validatePolicy = true
+) {
+  if (transport === "http" && validatePolicy) {
+    try {
+      readToolPolicy(extra);
+    } catch {
+      throw new McpServerValidationError(
+        "Correct the tool permissions before saving.",
+        "INVALID_TOOL_POLICY"
+      );
+    }
+  }
   const reservedKeys =
     transport === "stdio"
       ? RESERVED_STDIO_EXTRA_KEYS
@@ -227,7 +242,11 @@ export function normalizeMcpServerUpdateInput(
       : normalizeStringArray(input.args, "args");
   const extra =
     input.extra === undefined ? existing.extra : normalizeExtra(input.extra);
-  validateExtraKeys(extra, nextTransport);
+  validateExtraKeys(
+    extra,
+    nextTransport,
+    input.extra !== undefined || nextTransport !== existing.transport
+  );
 
   if (nextTransport === "stdio") {
     if (input.url !== undefined && asTrimmedString(input.url)) {
diff --git a/lib/mcp-servers/policy.test.ts b/lib/mcp-servers/policy.test.ts
new file mode 100644
index 00000000..6b801b6f
--- /dev/null
+++ b/lib/mcp-servers/policy.test.ts
@@ -0,0 +1,173 @@
+import { describe, expect, it } from "vitest";
+import {
+  readToolPolicy,
+  toolApproval,
+  updateToolPolicy,
+  normalizeToolNames,
+} from "./policy";
+import {
+  normalizeMcpServerCreateInput,
+  normalizeMcpServerUpdateInput,
+} from "./normalization";
+import {
+  buildPayload,
+  serverToForm,
+} from "@/components/settings/mcp-servers/helpers";
+
+describe("saved MCP permission controls", () => {
+  it("uses automatic approval when no rule exists and rejects invalid defaults", () => {
+    expect(toolApproval(readToolPolicy({}), "search")).toBe("auto");
+    for (const mode of ["deny", "inherit"] as const) {
+      expect(() => updateToolPolicy({}, { mode })).toThrow(
+        "Invalid default permission"
+      );
+    }
+  });
+
+  it("allows disabling and renaming legacy rows without accepting a new invalid policy", () => {
+    const existing = {
+      ...normalizeMcpServerCreateInput({
+        name: "docs",
+        transport: "http",
+        url: "https://example.com/mcp",
+      }),
+      id: "server",
+      envRefs: {},
+      headerRefs: {},
+      createdAt: "2026-09-22",
+      updatedAt: "2026-09-22",
+      extra: { enabled_tools: "all" },
+    };
+    expect(
+      normalizeMcpServerUpdateInput({ enabled: false }, existing)
+    ).toMatchObject({ enabled: false, extra: existing.extra });
+    expect(
+      normalizeMcpServerUpdateInput({ name: "renamed" }, existing)
+    ).toMatchObject({ name: "renamed", extra: existing.extra });
+    expect(() =>
+      normalizeMcpServerUpdateInput({ extra: existing.extra }, existing)
+    ).toThrow("Correct the tool permissions");
+    expect(
+      normalizeMcpServerUpdateInput({ extra: { enabled_tools: [] } }, existing)
+        .extra
+    ).toEqual({ enabled_tools: [] });
+    expect(() => readToolPolicy(existing.extra)).toThrow();
+    expect(() =>
+      normalizeMcpServerUpdateInput(
+        { transport: "http", url: "https://example.com/mcp" },
+        { ...existing, transport: "stdio", command: "server", url: null }
+      )
+    ).toThrow("Correct the tool permissions");
+  });
+
+  it("normalizes edited tool lists without changing the original stored array", () => {
+    const original = [" search ", "", "search", "  ", "publish"];
+    expect(normalizeToolNames(original)).toEqual(["search", "publish"]);
+    expect(original[0]).toBe(" search ");
+    expect(normalizeToolNames([" ", ""])).toEqual([]);
+  });
+  it("rejects malformed HTTP permissions on the API and browser save paths", () => {
+    expect(() =>
+      normalizeMcpServerCreateInput({
+        name: "docs",
+        transport: "http",
+        url: "https://example.com/mcp",
+        extra: { tools: { search: { approval_mode: "unknown" } } },
+      })
+    ).toThrow("Correct the tool permissions");
+    expect(() =>
+      buildPayload({
+        ...serverToForm(null),
+        extraText: '{"enabled_tools":"all"}',
+      })
+    ).toThrow("Correct the tool permissions");
+  });
+
+  it("keeps CLI metadata and strict permissions through browser and API serialization", () => {
+    const extra = {
+      cwd: "/repo",
+      enabled_tools: [],
+      disabled_tools: ["delete"],
+      tools: { publish: { approval_mode: "prompt", custom: 7 } },
+    };
+    const form = {
+      ...serverToForm(null),
+      name: "docs",
+      url: "https://example.com/mcp",
+      extraText: JSON.stringify(extra),
+    };
+    const payload = buildPayload(form);
+    expect(normalizeMcpServerCreateInput(payload).extra).toEqual(extra);
+  });
+  it("preserves CLI fields and unrelated tool metadata when changing a permission", () => {
+    const extra = {
+      cwd: "/repo",
+      tools: {
+        publish: { approval_mode: "prompt", custom: 42 },
+        search: { enabled: false },
+      },
+    };
+    const changed = updateToolPolicy(extra, { tool: "publish", mode: "auto" });
+    expect(changed).toEqual({
+      cwd: "/repo",
+      tools: {
+        publish: { approval_mode: "auto", custom: 42 },
+        search: { enabled: false },
+      },
+    });
+    expect(extra.tools.publish.approval_mode).toBe("prompt");
+  });
+
+  it("keeps allowlists, blocklists and disabled tools stronger than approval overrides", () => {
+    const policy = readToolPolicy({
+      enabled_tools: ["publish", "delete", "disabled"],
+      disabled_tools: ["delete"],
+      default_tools_approval_mode: "prompt",
+      tools: {
+        publish: { approval_mode: "approve" },
+        delete: { approval_mode: "auto" },
+        disabled: { enabled: false },
+      },
+    });
+    expect(toolApproval(policy, "search")).toBe("deny");
+    expect(toolApproval(policy, "delete")).toBe("deny");
+    expect(toolApproval(policy, "disabled")).toBe("deny");
+    expect(toolApproval(policy, "publish")).toBe("approve");
+  });
+
+  it("supports removing an override without losing other tool fields", () => {
+    const changed = updateToolPolicy(
+      {
+        tools: {
+          search: { enabled: false, approval_mode: "prompt", custom: true },
+        },
+      },
+      { tool: "search", mode: "inherit" }
+    );
+    expect(changed).toEqual({
+      tools: { search: { enabled: false, custom: true } },
+    });
+  });
+
+  it("rejects malformed policies instead of silently relaxing them", () => {
+    for (const extra of [
+      { enabled_tools: "all" },
+      { tools: { search: { enabled: "no" } } },
+      { default_tools_approval_mode: "unknown" },
+    ]) {
+      expect(() => readToolPolicy(extra)).toThrow();
+      expect(() => updateToolPolicy(extra, { mode: "auto" })).toThrow();
+    }
+  });
+
+  it("edits the default without changing per-tool permissions or allowlists", () => {
+    const extra = {
+      enabled_tools: [],
+      disabled_tools: ["delete"],
+      tools: { publish: { approval_mode: "prompt" } },
+    };
+    const changed = updateToolPolicy(extra, { mode: "auto" });
+    expect(changed).toEqual({ ...extra, default_tools_approval_mode: "auto" });
+    expect(toolApproval(readToolPolicy(changed), "publish")).toBe("deny");
+  });
+});
diff --git a/lib/mcp-servers/policy.ts b/lib/mcp-servers/policy.ts
new file mode 100644
index 00000000..8f401149
--- /dev/null
+++ b/lib/mcp-servers/policy.ts
@@ -0,0 +1,55 @@
+import { z } from "zod";
+
+export const toolPolicySchema = z.object({
+  enabled_tools: z.array(z.string()).optional(),
+  disabled_tools: z.array(z.string()).optional(),
+  default_tools_approval_mode: z.enum(["auto", "approve", "prompt"]).optional(),
+  tools: z
+    .record(
+      z.string(),
+      z.object({
+        enabled: z.boolean().optional(),
+        approval_mode: z.enum(["auto", "approve", "prompt", "deny"]).optional(),
+      })
+    )
+    .optional(),
+});
+
+export type ToolPolicy = z.infer<typeof toolPolicySchema>;
+export type ToolApproval = "auto" | "approve" | "prompt" | "deny";
+
+export function normalizeToolNames(names: string[]): string[] {
+  return [...new Set(names.map((name) => name.trim()).filter(Boolean))];
+}
+
+export function readToolPolicy(extra: unknown): ToolPolicy {
+  return toolPolicySchema.parse(extra ?? {});
+}
+
+export function toolApproval(policy: ToolPolicy, name: string): ToolApproval {
+  if (policy.enabled_tools && !policy.enabled_tools.includes(name))
+    return "deny";
+  if (policy.disabled_tools?.includes(name)) return "deny";
+  const perTool = policy.tools?.[name];
+  if (perTool?.enabled === false) return "deny";
+  // CLI approval.ts defines "approve" as pre-approved, equivalent to "auto".
+  return perTool?.approval_mode ?? policy.default_tools_approval_mode ?? "auto";
+}
+
+// Update the original object, not Zod's projection: preserve unknown CLI fields.
+export function updateToolPolicy(
+  extra: Record<string, unknown>,
+  change: { tool?: string; mode: ToolApproval | "inherit" }
+): Record<string, unknown> {
+  readToolPolicy(extra);
+  if (change.tool === undefined) {
+    if (change.mode === "deny" || change.mode === "inherit")
+      throw new Error("Invalid default permission");
+    return { ...extra, default_tools_approval_mode: change.mode };
+  }
+  const tools = (extra.tools ?? {}) as Record<string, Record<string, unknown>>;
+  const entry = { ...tools[change.tool] };
+  if (change.mode === "inherit") delete entry.approval_mode;
+  else entry.approval_mode = change.mode;
+  return { ...extra, tools: { ...tools, [change.tool]: entry } };
+}
diff --git a/tests/db/mcp-servers-chat.test.ts b/tests/db/mcp-servers-chat.test.ts
index d1d4ce0c..1a91920d 100644
--- a/tests/db/mcp-servers-chat.test.ts
+++ b/tests/db/mcp-servers-chat.test.ts
@@ -3,6 +3,7 @@ import { PGlite } from "@electric-sql/pglite";
 import { expect, it } from "vitest";
 import { createPostgrestShim } from "@/lib/db/postgrest-shim";
 import { listSavedHttpMcpServers } from "@/lib/mcp-servers/chat";
+import { getSavedMcpServerForTest } from "@/lib/mcp-servers/diagnostics";
 
 it("reads only the caller's enabled HTTP catalog entries and sees disabling and deletion on the next turn", async () => {
   const pg = await PGlite.create();
@@ -34,6 +35,16 @@ it("reads only the caller's enabled HTTP catalog entries and sees disabling and
     expect(
       (await listSavedHttpMcpServers(owner, db)).map((row) => row.name)
     ).toEqual(["active"]);
+    const { rows: diagnosticRows } = await pg.query<{ id: string }>(
+      "select id from user_mcp_servers where user_id=$1 and name='disabled'",
+      [owner]
+    );
+    const target = diagnosticRows[0].id;
+    expect(
+      (await getSavedMcpServerForTest(owner, target, db)).data
+    ).toMatchObject({ name: "disabled", enabled: false });
+    expect((await getSavedMcpServerForTest(other, target, db)).data).toBeNull();
+    expect((await getSavedMcpServerForTest(owner, other, db)).data).toBeNull();
     await pg.query(
       "update user_mcp_servers set enabled=false where user_id=$1 and name='active'",
       [owner]
diff --git a/tests/e2e/mcp-permissions-diagnostics.spec.ts b/tests/e2e/mcp-permissions-diagnostics.spec.ts
new file mode 100644
index 00000000..7faf4853
--- /dev/null
+++ b/tests/e2e/mcp-permissions-diagnostics.spec.ts
@@ -0,0 +1,434 @@
+import { expect, test, fulfillJson } from "./helpers/run-checks-fixtures";
+import { enableScopedE2EAuth, scopedPath } from "./helpers/auth";
+import type { Page } from "@playwright/test";
+import type { McpServer } from "@/components/settings/mcp-servers/types";
+import { readToolPolicy, toolApproval } from "@/lib/mcp-servers/policy";
+import type { DiagnosticCode } from "@/lib/mcp-servers/diagnostic-result";
+
+async function setup(page: Page, extra: Record<string, unknown> = {}) {
+  await enableScopedE2EAuth(page);
+  let server: McpServer = {
+    id: "11111111-1111-4111-8111-111111111111",
+    name: "Documentation",
+    enabled: true,
+    transport: "http",
+    command: null,
+    args: [],
+    envPlain: {},
+    envSecretNames: [],
+    url: "https://docs.example.com/mcp",
+    headerPlain: {},
+    headerSecretNames: ["Authorization"],
+    extra,
+    createdAt: "2026-09-22T01:00:00Z",
+    updatedAt: "2026-09-22T01:00:00Z",
+  };
+  const saved: Record<string, unknown>[] = [];
+  let testCount = 0;
+  await page.route("**/api/mcp-servers", (route) =>
+    fulfillJson(route, { servers: [server] })
+  );
+  await page.route(`**/api/mcp-servers/${server.id}`, async (route) => {
+    const body = route.request().postDataJSON();
+    saved.push(body);
+    server = {
+      ...server,
+      ...body,
+      updatedAt: new Date(Date.parse(server.updatedAt) + 1000).toISOString(),
+    };
+    await fulfillJson(route, { server });
+  });
+  await page.route(`**/api/mcp-servers/${server.id}/test`, async (route) => {
+    testCount++;
+    const policy = readToolPolicy(server.extra);
+    await fulfillJson(route, {
+      status: "success",
+      enabled: server.enabled,
+      checkedAt: new Date().toISOString(),
+      serverUpdatedAt: server.updatedAt,
+      tools: ["search", "publish", "delete"].map((name) => ({
+        name,
+        approval: toolApproval(policy, name),
+      })),
+    });
+  });
+  await page.goto(scopedPath("connections?tab=mcp"));
+  return { saved, testCount: () => testCount };
+}
+
+test("tests saved connections on demand and edits approval rules without losing saved restrictions or secrets", async ({
+  page,
+}) => {
+  const fixture = await setup(page, {
+    cwd: "/repo",
+    disabled_tools: ["delete"],
+    tools: { publish: { approval_mode: "prompt", custom: 17 } },
+  });
+  await expect(page.getByText("Not tested in this visit.")).toBeVisible();
+  expect(fixture.testCount()).toBe(0);
+  await page
+    .getByRole("button", { name: "Test connection", exact: true })
+    .click();
+  await expect(
+    page.getByText("Connection test passed. 3 tools found.")
+  ).toBeVisible();
+  await expect(
+    page.getByText(
+      "1 available in workspace chat. Control approval required: 1. Blocked: 1."
+    )
+  ).toBeVisible();
+  await page.getByText("Discovered tools", { exact: true }).click();
+  await expect(
+    page.getByText("publish: Control only: approval required")
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await expect(page.getByPlaceholder("Overwrite saved secret")).toHaveValue("");
+  await page
+    .getByRole("combobox", { name: "Default approval", exact: true })
+    .click();
+  await page
+    .getByRole("option", { name: "Ask in Control", exact: true })
+    .click();
+  await page
+    .getByRole("combobox", { name: "Approval for search", exact: true })
+    .click();
+  await page
+    .getByRole("option", { name: "Run automatically", exact: true })
+    .click();
+  await page.getByRole("button", { name: "Save changes" }).click();
+  await expect(page.getByText("Not tested in this visit.")).toBeVisible();
+  expect(fixture.saved[0]).toMatchObject({
+    headerSecrets: {},
+    extra: {
+      cwd: "/repo",
+      disabled_tools: ["delete"],
+      default_tools_approval_mode: "prompt",
+      tools: {
+        publish: { approval_mode: "prompt", custom: 17 },
+        search: { approval_mode: "auto" },
+      },
+    },
+  });
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await expect(
+    page.getByRole("combobox", { name: "Default approval", exact: true })
+  ).toHaveText("Ask in Control");
+  await page.getByRole("button", { name: "Cancel", exact: true }).click();
+  await page.reload();
+  await expect(page.getByText("Not tested in this visit.")).toBeVisible();
+  expect(fixture.testCount()).toBe(1);
+});
+
+test("allowlist editing supports keyboard newlines and never makes an empty allowlist permissive", async ({
+  page,
+}) => {
+  const fixture = await setup(page);
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await page
+    .getByRole("switch", { name: "Allow all tools unless blocked" })
+    .click();
+  await expect(
+    page.getByLabel("Allowed tools (one name per line)")
+  ).toHaveValue("");
+  await page.getByRole("button", { name: "Save changes" }).click();
+  expect(fixture.saved[0]).toMatchObject({ extra: { enabled_tools: [] } });
+  await page
+    .getByRole("button", { name: "Test connection", exact: true })
+    .click();
+  await expect(
+    page.getByText(
+      "0 available in workspace chat. Control approval required: 0. Blocked: 3."
+    )
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  const allowed = page.getByLabel("Allowed tools (one name per line)");
+  await allowed.fill("search");
+  await allowed.press("End");
+  await allowed.press("Enter");
+  await allowed.pressSequentially("publish");
+  await expect(allowed).toHaveValue("search\npublish");
+  await allowed.fill(" search \nsearch\n \npublish ");
+  await page
+    .getByLabel("Blocked tools (one name per line)")
+    .fill(" publish \n\npublish");
+  await page.getByRole("button", { name: "Save changes" }).click();
+  expect(fixture.saved[1]).toMatchObject({
+    extra: {
+      enabled_tools: ["search", "publish"],
+      disabled_tools: ["publish"],
+    },
+  });
+});
+
+test("invalid saved permissions stay blocked and can be repaired without changing CLI settings", async ({
+  page,
+}) => {
+  const fixture = await setup(page, { cwd: "/repo", enabled_tools: "all" });
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await expect(page.getByRole("alert")).toContainText(
+    "Tool permissions are invalid"
+  );
+  await page.getByRole("button", { name: "Save changes" }).click();
+  await expect(
+    page.getByText("Correct the tool permissions before saving.")
+  ).toBeVisible();
+  expect(fixture.saved).toHaveLength(0);
+  await page
+    .getByLabel("Extra JSON", { exact: true })
+    .fill('{"cwd":"/repo","enabled_tools":[]}');
+  await page.getByRole("button", { name: "Save changes" }).click();
+  expect(fixture.saved[0]).toMatchObject({
+    extra: { cwd: "/repo", enabled_tools: [] },
+  });
+});
+
+test("shows pending, failure and retry states without automatic tests", async ({
+  page,
+}) => {
+  await setup(page);
+  let resolveTest!: () => void;
+  const responseReady = new Promise<void>((resolve) => {
+    resolveTest = resolve;
+  });
+  let calls = 0;
+  await page.route("**/api/mcp-servers/*/test", async (route) => {
+    calls++;
+    await responseReady;
+    await fulfillJson(route, {
+      status: "error",
+      code: (calls === 1
+        ? "authentication"
+        : "settings_unavailable") satisfies DiagnosticCode,
+      checkedAt: new Date().toISOString(),
+      serverUpdatedAt: "2026-09-22T01:00:00Z",
+    });
+  });
+  await page
+    .getByRole("button", { name: "Test connection", exact: true })
+    .click();
+  await expect(
+    page.getByRole("button", { name: "Testing connection..." })
+  ).toBeDisabled();
+  resolveTest();
+  await expect(
+    page.getByText(
+      "The server rejected access. Check the saved authorization header and its permissions."
+    )
+  ).toBeVisible();
+  expect(calls).toBe(1);
+  await page
+    .getByRole("button", { name: "Test connection", exact: true })
+    .click();
+  await expect(
+    page.getByRole("button", { name: "Test connection", exact: true })
+  ).toBeEnabled();
+  expect(calls).toBe(2);
+  await expect(
+    page.getByText(
+      "Mogplex could not read the saved connection. Try again later."
+    )
+  ).toBeVisible();
+});
+
+test("lets users add and remove tool approval overrides, and preserves disabled rules", async ({
+  page,
+}) => {
+  const fixture = await setup(page, {
+    tools: { search: { enabled: false, custom: true } },
+  });
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await expect(
+    page.getByRole("combobox", { name: "Approval for search" })
+  ).toBeDisabled();
+  await page.getByRole("switch", { name: "Enable search" }).click();
+  await expect(
+    page.getByRole("combobox", { name: "Approval for search" })
+  ).toBeEnabled();
+  await page.getByLabel("Tool name for approval override").fill("publish");
+  await page.getByRole("button", { name: "Add tool rule" }).click();
+  await page.getByRole("combobox", { name: "Approval for publish" }).click();
+  await page.getByRole("option", { name: "Block", exact: true }).click();
+  await page.getByRole("button", { name: "Save changes" }).click();
+  expect(fixture.saved[0]).toMatchObject({
+    extra: {
+      tools: {
+        search: { enabled: true, custom: true },
+        publish: { approval_mode: "deny" },
+      },
+    },
+  });
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await page.getByRole("combobox", { name: "Approval for publish" }).click();
+  await page.getByRole("option", { name: "Use default", exact: true }).click();
+  await page.getByRole("button", { name: "Save changes" }).click();
+  expect(
+    (fixture.saved[1].extra as { tools: { publish: object } }).tools.publish
+  ).toEqual({});
+});
+
+test("cancels an in-flight connection test when saved settings change", async ({
+  page,
+}) => {
+  await setup(page);
+  let release!: () => void;
+  const ready = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  await page.route("**/api/mcp-servers/*/test", async (route) => {
+    await ready;
+    await fulfillJson(route, {
+      status: "success",
+      enabled: true,
+      tools: [],
+      checkedAt: new Date().toISOString(),
+      serverUpdatedAt: "2026-09-22T01:00:00Z",
+    });
+  });
+  const ended = new Promise<string>((resolve) => {
+    page.on("requestfailed", (request) => {
+      if (request.url().endsWith("/test")) resolve("cancelled");
+    });
+    page.on("requestfinished", (request) => {
+      if (request.url().endsWith("/test")) resolve("completed");
+    });
+  });
+  await page
+    .getByRole("button", { name: "Test connection", exact: true })
+    .click();
+  await expect(
+    page.getByRole("button", { name: "Testing connection..." })
+  ).toBeDisabled();
+  await page.getByRole("button", { name: "Edit", exact: true }).click();
+  await page.getByRole("button", { name: "Save changes" }).click();
+  await expect(page.getByText("Not tested in this visit.")).toBeVisible();
+  release();
+  expect(await ended).toBe("cancelled");
+  await expect(
+    page.getByText("Connection test passed. 0 tools found.")
+  ).not.toBeVisible();
+});
+
+for (const variant of [
+  { name: "desktop-light", theme: "light", width: 1440, height: 1000 },
+  { name: "desktop-dark", theme: "dark", width: 1440, height: 1000 },
+  { name: "mobile-dark", theme: "dark", width: 390, height: 844 },
+] as const) {
+  test(`permissions and diagnostics remain usable in ${variant.name}`, async ({
+    page,
+  }) => {
+    await page.setViewportSize({
+      width: variant.width,
+      height: variant.height,
+    });
+    await page.addInitScript(
+      (theme) => localStorage.setItem("mogplex-theme", theme),
+      variant.theme
+    );
+    await page.emulateMedia({ colorScheme: variant.theme });
+    await page.route(/\/api\/settings(?:\?.*)?$/, (route) =>
+      fulfillJson(route, { theme: variant.theme })
+    );
+    await setup(page, { default_tools_approval_mode: "prompt" });
+    await expect(page.locator("html")).toHaveClass(
+      new RegExp(`(^| )${variant.theme}( |$)`)
+    );
+    await page
+      .getByRole("button", { name: "Test connection", exact: true })
+      .click();
+    await expect(
+      page.getByText("Connection test passed. 3 tools found.")
+    ).toBeVisible();
+    await expect(page.locator("html")).toHaveClass(
+      new RegExp(`(^| )${variant.theme}( |$)`)
+    );
+    await page.screenshot({
+      path: `/tmp/mcp-controls-${variant.name}-diagnostics.png`,
+      fullPage: true,
+    });
+    await page.getByRole("button", { name: "Edit", exact: true }).click();
+    await page
+      .getByRole("combobox", { name: "Default approval", exact: true })
+      .scrollIntoViewIfNeeded();
+    await expect(
+      page.getByRole("combobox", { name: "Default approval", exact: true })
+    ).toHaveText("Ask in Control");
+    expect(
+      await page
+        .getByRole("dialog")
+        .evaluate((element) => element.scrollWidth <= element.clientWidth)
+    ).toBe(true);
+    await page.screenshot({
+      path: `/tmp/mcp-controls-${variant.name}-permissions.png`,
+    });
+    await page.getByRole("button", { name: "Cancel", exact: true }).click();
+  });
+}
+
+test("reports disabled and empty servers without promising tools are available", async ({
+  page,
+}) => {
+  await setup(page);
+  await page.route("**/api/mcp-servers/*/test", (route) =>
+    fulfillJson(route, {
+      status: "success",
+      enabled: false,
+      tools: [],
+      checkedAt: new Date().toISOString(),
+      serverUpdatedAt: "2026-09-22T01:00:00Z",
+    })
+  );
+  await page
+    .getByRole("button", { name: "Test connection", exact: true })
+    .click();
+  await expect(
+    page.getByText("Connection test passed. 0 tools found.")
+  ).toBeVisible();
+  await expect(
+    page.getByText(
+      "This server is disabled. Enable it to make its allowed tools available."
+    )
+  ).toBeVisible();
+  await expect(
+    page.getByText("The server did not advertise any tools.")
+  ).toBeVisible();
+});
+
+test("handles unavailable, malformed, and stale test responses without displaying a success", async ({
+  page,
+}) => {
+  await setup(page);
+  for (const scenario of [
+    { status: 401, body: {}, text: "Sign in again to test this connection." },
+    {
+      status: 404,
+      body: {},
+      text: "This server no longer exists. Refresh the page.",
+    },
+    { status: 503, body: {}, text: "The test could not complete. Try again." },
+    {
+      status: 200,
+      body: { status: "success", tools: "invalid" },
+      text: "The test could not complete. Check your connection and try again.",
+    },
+    {
+      status: 200,
+      body: {
+        status: "success",
+        tools: [],
+        enabled: true,
+        checkedAt: new Date().toISOString(),
+        serverUpdatedAt: "2026-09-22T03:00:00Z",
+      },
+      text: "The saved settings changed. Refresh the page, then test again.",
+    },
+  ]) {
+    await page.route("**/api/mcp-servers/*/test", (route) =>
+      fulfillJson(route, scenario.body, scenario.status)
+    );
+    await page
+      .getByRole("button", { name: "Test connection", exact: true })
+      .click();
+    await expect(page.getByText(scenario.text, { exact: true })).toBeVisible();
+    await expect(page.getByText(/Connection test passed/)).toHaveCount(0);
+  }
+});
diff --git a/tests/e2e/mcp-servers-settings.spec.ts b/tests/e2e/mcp-servers-settings.spec.ts
index 0aa8ff1a..b6207554 100644
--- a/tests/e2e/mcp-servers-settings.spec.ts
+++ b/tests/e2e/mcp-servers-settings.spec.ts
@@ -199,7 +199,7 @@ test("Connections MCP tab supports add, edit, secret overwrite, and delete witho
       "Runs on your computer through the CLI. Not available in web chat."
     )
   ).toBeVisible();
-  await page.getByLabel("Name").fill("supabase");
+  await page.getByLabel("Name", { exact: true }).fill("supabase");
   await page.getByLabel("Command").fill("npx");
   await page
     .getByLabel("Args")
@@ -241,7 +241,7 @@ test("Connections MCP tab supports add, edit, secret overwrite, and delete witho
   await expect(page.getByText("No synced MCP servers yet.")).toBeVisible();
 
   await page.getByRole("button", { name: "Add server" }).click();
-  await page.getByLabel("Name").fill("remote-docs");
+  await page.getByLabel("Name", { exact: true }).fill("remote-docs");
   await page
     .getByLabel("URL", { exact: true })
     .fill("https://docs.example.com/mcp");
diff --git a/tests/unit/mcp-server-test-route.test.ts b/tests/unit/mcp-server-test-route.test.ts
new file mode 100644
index 00000000..df57fb95
--- /dev/null
+++ b/tests/unit/mcp-server-test-route.test.ts
@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { NextResponse } from "next/server";
+
+async function loadRoute() {
+  process.env.MOGPLEX_DATA_BACKEND = "supabase";
+  process.env.NEXT_PUBLIC_SUPABASE_URL = "https://db.example.com";
+  process.env.SUPABASE_SERVICE_ROLE_KEY = "fixture-service-key";
+  return import("../../app/api/mcp-servers/[id]/test/route");
+}
+const id = "11111111-1111-4111-8111-111111111111";
+const request = () =>
+  new Request(`https://mogplex.com/api/mcp-servers/${id}/test`, {
+    method: "POST",
+  });
+
+test("connection test requires authentication before reading saved data", async () => {
+  const { createMcpServerTestHandler } = await loadRoute();
+  const response = await createMcpServerTestHandler({
+    requireUserId: async () =>
+      NextResponse.json({ error: "Unauthorized" }, { status: 401 }),
+  })(request(), { params: Promise.resolve({ id }) });
+  assert.equal(response.status, 401);
+});
+
+test("connection test rejects invalid identifiers", async () => {
+  const { createMcpServerTestHandler } = await loadRoute();
+  const response = await createMcpServerTestHandler({
+    requireUserId: async () => "owner",
+  })(request(), { params: Promise.resolve({ id: "bad-id" }) });
+  assert.equal(response.status, 400);
+});
+
+test("connection test returns a private, uncached result from the saved record and ignores supplied URLs", async (t) => {
+  const { createMcpServerTestHandler } = await loadRoute();
+  t.mock.method(globalThis, "fetch", async (input: RequestInfo | URL) => {
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    assert.equal(url.hostname, "db.example.com");
+    assert.equal(url.searchParams.get("user_id"), "eq.owner");
+    assert.equal(url.searchParams.get("id"), `eq.${id}`);
+    return Response.json({
+      id,
+      transport: "stdio",
+      updated_at: "2026-09-22T00:00:00Z",
+    });
+  });
+  const response = await createMcpServerTestHandler({
+    requireUserId: async () => "owner",
+  })(
+    new Request(request(), {
+      method: "POST",
+      body: JSON.stringify({
+        url: "http://127.0.0.1/private",
+        header_refs: { Authorization: "other-secret" },
+      }),
+    }),
+    { params: Promise.resolve({ id }) }
+  );
+  assert.equal(response.status, 200);
+  assert.equal(response.headers.get("cache-control"), "no-store");
+  assert.equal((await response.json()).code, "cli_only");
+});
+
+test("connection test returns 404 for a missing or inaccessible saved record", async (t) => {
+  const { createMcpServerTestHandler } = await loadRoute();
+  t.mock.method(globalThis, "fetch", async () => Response.json(null));
+  const response = await createMcpServerTestHandler({
+    requireUserId: async () => "owner",
+  })(request(), { params: Promise.resolve({ id }) });
+  assert.equal(response.status, 404);
+});