diff --git a/apps/app/src/components/chat/message-list.tsx b/apps/app/src/components/chat/message-list.tsx
index 97228fea17..5bf046c8e5 100644
--- a/apps/app/src/components/chat/message-list.tsx
+++ b/apps/app/src/components/chat/message-list.tsx
@@ -82,6 +82,7 @@ import {
   getActiveToolLabel,
 } from "@/lib/tool-activity"
 import { cn } from "@/lib/utils"
+import type { ToolInvocationKnownServer } from "@/lib/tool-invocation-origin"
 import { groupMessages, isMessageGroup, getLastTextPart, getAssistantRenderGroups, getFileTitle, getMediaBadge, getMessageCreated, formatMessageTimestamp, type UIMessageWithIndex, getMessagesText, getSafeFileDownloadUrl } from "./utils"
 
 const SEARCH_HIGHLIGHT_MARK_CLASS = "rounded px-0.5 bg-amber-4/70 text-current"
@@ -105,6 +106,7 @@ function MessageTimestamp({ message, className }: { message: UIMessage; classNam
 
 interface ToolMessageProps {
   part: ToolUIPart | DynamicToolUIPart
+  knownServers?: readonly ToolInvocationKnownServer[]
 }
 
 /**
@@ -131,11 +133,11 @@ class ToolMessage extends React.Component<ToolMessageProps, { failed: boolean }>
         <div className="text-xs text-muted-foreground">Tool step unavailable</div>
       )
     }
-    return <ToolMessageInner part={this.props.part} />
+    return <ToolMessageInner part={this.props.part} knownServers={this.props.knownServers} />
   }
 }
 
-const ToolMessageInner = ({ part }: ToolMessageProps) => {
+const ToolMessageInner = ({ part, knownServers }: ToolMessageProps) => {
   if (isBashToolPart(part)) {
     return <BashTool part={part} />
   }
@@ -192,7 +194,7 @@ const ToolMessageInner = ({ part }: ToolMessageProps) => {
     return <EnvVarRequestTool part={part} />
   }
 
-  return <Tool toolPart={part} />
+  return <Tool toolPart={part} knownServers={knownServers} />
 }
 
 const isEmptyMessage = (message: UIMessage): boolean => message.parts.length === 0
@@ -334,10 +336,11 @@ type AssistantMessageProps = {
   isLastMessage: boolean
   isStreaming: boolean
   isLastStep: boolean
+  knownServers?: readonly ToolInvocationKnownServer[]
 }
 
 const AssistantMessage = React.memo(
-  ({ message }: AssistantMessageProps) => {
+  ({ message, knownServers }: AssistantMessageProps) => {
     const { showThinking, highlightQuery } = useMessageList()
     const assistantRenderGroups = React.useMemo(
       () => getAssistantRenderGroups(message.parts, showThinking),
@@ -387,7 +390,7 @@ const AssistantMessage = React.memo(
 
             return (
               <div key={`tool-${index}`} className="w-full">
-                <ToolMessage part={group.part} />
+                <ToolMessage part={group.part} knownServers={knownServers} />
               </div>
             )
           })}
@@ -567,10 +570,11 @@ type MessageComponentProps = {
   isLastMessage: boolean
   isStreaming: boolean
   isLastStep: boolean
+  knownServers?: readonly ToolInvocationKnownServer[]
 }
 
 const MessageComponent = React.memo(
-  ({ message, isLastMessage, isStreaming, isLastStep }: MessageComponentProps) => {
+  ({ message, isLastMessage, isStreaming, isLastStep, knownServers }: MessageComponentProps) => {
     if (isSessionErrorMessage(message)) {
       return <ErrorMessage error={getMessagesText([message]) || "Session failed"} />
     }
@@ -591,6 +595,7 @@ const MessageComponent = React.memo(
           isLastMessage={isLastMessage}
           isStreaming={isStreaming}
           isLastStep={isLastStep}
+          knownServers={knownServers}
         />
       )
     }
@@ -731,12 +736,14 @@ interface AssistantMessageGroupProps {
   items: UIMessageWithIndex[]
   messages: UIMessage[]
   isStreaming: boolean
+  knownServers?: readonly ToolInvocationKnownServer[]
 }
 
 function MessageGroup({
   items,
   messages,
   isStreaming,
+  knownServers,
 }: AssistantMessageGroupProps) {
   const { onRevertToUserMessage, onForkAtMessage } = useMessageList()
   const lastItem = items[items.length - 1]
@@ -786,6 +793,7 @@ function MessageGroup({
           isLastMessage={isLastMessage}
           isStreaming={isLastMessage && isStreaming}
           isLastStep={groupIndex === items.length - 1}
+          knownServers={knownServers}
         />
         <MessageArtifacts message={item.message} />
       </div>
@@ -842,9 +850,10 @@ interface MessageListProps {
   messages: UIMessage[]
   status: ThreadStatus
   retryStatus?: RetryStatus | null
+  knownMcpServers?: readonly ToolInvocationKnownServer[]
 }
 
-export function MessageList({ messages, status, retryStatus }: MessageListProps) {
+export function MessageList({ messages, status, retryStatus, knownMcpServers }: MessageListProps) {
   const isStreaming = status === "streaming" || status === "retrying"
   const items = React.useMemo(() => groupMessages(messages, status), [messages, status]);
   const error = useSessionErrorMessage();
@@ -865,6 +874,7 @@ export function MessageList({ messages, status, retryStatus }: MessageListProps)
               items={item.messages}
               messages={messages}
               isStreaming={isStreaming}
+              knownServers={knownMcpServers}
             />
           )
         }
@@ -880,6 +890,7 @@ export function MessageList({ messages, status, retryStatus }: MessageListProps)
               isLastMessage={isLastMessage}
               isStreaming={isLastMessage && isStreaming}
               isLastStep={isLastStep}
+              knownServers={knownMcpServers}
             />
             <MessageArtifacts message={item.message} />
           </div>
diff --git a/apps/app/src/components/ui/tool.tsx b/apps/app/src/components/ui/tool.tsx
index 959956f301..542f0e93c0 100644
--- a/apps/app/src/components/ui/tool.tsx
+++ b/apps/app/src/components/ui/tool.tsx
@@ -22,6 +22,7 @@ import {
   Wrench,
 } from "lucide-react"
 import type { DynamicToolUIPart, ToolUIPart } from "ai"
+import { toolInvocationOrigin, type ToolInvocationKnownServer } from "@/lib/tool-invocation-origin"
 
 function toolIcon(part: ToolPart) {
   const name = part.type === "dynamic-tool" ? part.toolName : part.type
@@ -56,6 +57,7 @@ export type ToolPart = ToolUIPart | DynamicToolUIPart
 export type ToolProps = {
   title?: string
   toolPart: ToolPart
+  knownServers?: readonly ToolInvocationKnownServer[]
   defaultOpen?: boolean
   className?: string
 }
@@ -116,11 +118,14 @@ function DiffLines({ diff }: { diff: string }) {
   )
 }
 
-const Tool = ({ title, toolPart, defaultOpen = false, className }: ToolProps) => {
+const Tool = ({ title, toolPart, knownServers, defaultOpen = false, className }: ToolProps) => {
   const { state, input } = toolPart
   const inFlight = isToolPartInFlight(toolPart)
   const isError = state === "output-error"
-  const label = title ?? getToolActivityLabel(toolPart)
+  const origin = toolPart.type === "dynamic-tool"
+    ? toolInvocationOrigin(toolPart.toolName, input, knownServers)
+    : null
+  const label = title ?? (origin?.connectionName ? origin.displayTool : getToolActivityLabel(toolPart))
   const hasInput = input !== null && input !== undefined
   const hasOutput = "output" in toolPart && toolPart.output !== undefined
   const inputDiff = getInputDiff(input)
@@ -143,6 +148,11 @@ const Tool = ({ title, toolPart, defaultOpen = false, className }: ToolProps) =>
           </span>
           <ChevronDown className="absolute size-4 opacity-0 transition-opacity group-hover:opacity-100 group-data-panel-open:rotate-180" />
         </span>
+        {origin?.connectionName ? (
+          <span className="shrink-0 rounded-md border border-border bg-muted px-1.5 py-0.5 text-[10px] font-medium text-muted-foreground">
+            {origin.connectionName}
+          </span>
+        ) : null}
         <span className="min-w-0 truncate">{label}</span>
         {isError ? (
           <span className="text-destructive shrink-0 text-xs">failed</span>
diff --git a/apps/app/src/lib/tool-invocation-origin.ts b/apps/app/src/lib/tool-invocation-origin.ts
new file mode 100644
index 0000000000..edcff6dfd2
--- /dev/null
+++ b/apps/app/src/lib/tool-invocation-origin.ts
@@ -0,0 +1,193 @@
+export type ToolInvocationKnownServer = {
+  id?: string | null;
+  name: string;
+  displayName?: string | null;
+};
+
+export type ToolInvocationOrigin = {
+  connectionName?: string;
+  displayTool: string;
+};
+
+type DirectToolOrigin = ToolInvocationOrigin & {
+  serverName: string;
+};
+
+const OPENWORK_CLOUD_SERVER_NAME = "openwork-cloud";
+const OPENWORK_CLOUD_LABEL = "OpenWork Cloud";
+const EXECUTE_CAPABILITY_TOOL_NAME = "execute_capability";
+
+const builtInToolNames = new Set([
+  "apply_patch",
+  "bash",
+  "edit",
+  "env_var_request",
+  "glob",
+  "grep",
+  "lsp",
+  "question",
+  "read",
+  "request_env_var",
+  "skill",
+  "task",
+  "todowrite",
+  "webfetch",
+  "websearch",
+  "write",
+]);
+
+const nonConnectionPrefixes = new Set([
+  "create",
+  "delete",
+  "diagnostic",
+  "diagnostics",
+  "execute",
+  "fetch",
+  "get",
+  "list",
+  "lookup",
+  "mutate",
+  "read",
+  "search",
+  "summarize",
+  "synthetic",
+  "update",
+  "write",
+]);
+
+const wordLabels: Record<string, string> = {
+  api: "API",
+  mcp: "MCP",
+  oauth: "OAuth",
+  openwork: "OpenWork",
+  servicenow: "ServiceNow",
+  ui: "UI",
+};
+
+function formatNameWord(word: string) {
+  const lower = word.toLowerCase();
+  const special = wordLabels[lower];
+  if (special) return special;
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+
+function formatConnectionName(value: string) {
+  const words = value.replace(/[_-]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  return words.length > 0 ? words.map(formatNameWord).join(" ") : value;
+}
+
+function serverCandidates(server: ToolInvocationKnownServer) {
+  const candidates: string[] = [];
+  const name = server.name.trim();
+  const id = server.id?.trim() ?? "";
+  if (name) candidates.push(name);
+  if (id && id !== name) candidates.push(id);
+  return candidates;
+}
+
+function candidateLength(server: ToolInvocationKnownServer) {
+  return Math.max(...serverCandidates(server).map((candidate) => candidate.length), 0);
+}
+
+function displayNameForServer(server: ToolInvocationKnownServer) {
+  const explicit = server.displayName?.trim();
+  if (explicit) return explicit;
+  return formatConnectionName(server.name);
+}
+
+function sortedKnownServers(knownServers: readonly ToolInvocationKnownServer[]) {
+  return [...knownServers].sort((left, right) => candidateLength(right) - candidateLength(left));
+}
+
+function resolveKnownConnectionName(id: string, knownServers: readonly ToolInvocationKnownServer[]) {
+  const trimmed = id.trim();
+  if (!trimmed) return null;
+  const match = knownServers.find((server) => {
+    const serverId = server.id?.trim() ?? "";
+    return serverId === trimmed || server.name.trim() === trimmed;
+  });
+  return match ? displayNameForServer(match) : null;
+}
+
+function directToolOrigin(toolName: string, knownServers: readonly ToolInvocationKnownServer[]): DirectToolOrigin | null {
+  for (const server of sortedKnownServers(knownServers)) {
+    for (const candidate of serverCandidates(server)) {
+      const prefix = `${candidate}_`;
+      if (!toolName.startsWith(prefix)) continue;
+      const displayTool = toolName.slice(prefix.length);
+      if (!displayTool) continue;
+      return {
+        connectionName: displayNameForServer(server),
+        displayTool,
+        serverName: server.name.trim(),
+      };
+    }
+  }
+
+  const openworkPrefix = `${OPENWORK_CLOUD_SERVER_NAME}_`;
+  if (toolName.startsWith(openworkPrefix)) {
+    const displayTool = toolName.slice(openworkPrefix.length);
+    if (displayTool) {
+      return {
+        connectionName: OPENWORK_CLOUD_LABEL,
+        displayTool,
+        serverName: OPENWORK_CLOUD_SERVER_NAME,
+      };
+    }
+  }
+
+  return null;
+}
+
+function fallbackDirectToolOrigin(toolName: string): DirectToolOrigin | null {
+  const separator = toolName.indexOf("_");
+  if (separator <= 0 || separator === toolName.length - 1) return null;
+  const serverName = toolName.slice(0, separator).trim();
+  const displayTool = toolName.slice(separator + 1).trim();
+  if (!serverName || !displayTool || nonConnectionPrefixes.has(serverName.toLowerCase())) return null;
+  return {
+    connectionName: formatConnectionName(serverName),
+    displayTool,
+    serverName,
+  };
+}
+
+function namedArgument(value: unknown) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || !("name" in value)) return null;
+  return typeof value.name === "string" ? value.name : null;
+}
+
+function mcpCapabilityNameParts(value: string) {
+  const match = value.match(/^mcp:([^:]+):(.+)$/);
+  const connectionId = match?.[1]?.trim() ?? "";
+  const toolName = match?.[2]?.trim() ?? "";
+  if (!connectionId || !toolName) return null;
+  return { connectionId, toolName };
+}
+
+export function toolInvocationOrigin(
+  toolName: string,
+  args?: unknown,
+  knownServers: readonly ToolInvocationKnownServer[] = [],
+): ToolInvocationOrigin {
+  if (builtInToolNames.has(toolName)) return { displayTool: toolName };
+
+  const direct = directToolOrigin(toolName, knownServers) ?? fallbackDirectToolOrigin(toolName);
+  if (!direct) return { displayTool: toolName };
+
+  if (direct.serverName === OPENWORK_CLOUD_SERVER_NAME && direct.displayTool === EXECUTE_CAPABILITY_TOOL_NAME) {
+    const parts = mcpCapabilityNameParts(namedArgument(args) ?? "");
+    if (parts) {
+      const connectionName = resolveKnownConnectionName(parts.connectionId, knownServers) ?? parts.connectionId;
+      return {
+        connectionName: `${OPENWORK_CLOUD_LABEL} → ${connectionName}`,
+        displayTool: parts.toolName,
+      };
+    }
+  }
+
+  return {
+    connectionName: direct.connectionName,
+    displayTool: direct.displayTool,
+  };
+}
diff --git a/apps/app/src/react-app/domains/connections/connection-display-state.ts b/apps/app/src/react-app/domains/connections/connection-display-state.ts
new file mode 100644
index 0000000000..54a058e4f8
--- /dev/null
+++ b/apps/app/src/react-app/domains/connections/connection-display-state.ts
@@ -0,0 +1,67 @@
+import type { McpStatus } from "@/app/types";
+
+export type ConnectionDisplayState =
+  | "configured"
+  | "auth_required"
+  | "protocol_ready"
+  | "error"
+  | "disabled";
+
+export type ConnectionDisplayStateLabelKey =
+  | "mcp.friendly_status_offline"
+  | "mcp.friendly_status_needs_signin"
+  | "mcp.friendly_status_ready"
+  | "mcp.friendly_status_issue"
+  | "mcp.friendly_status_paused";
+
+export type ConnectionDisplayTone = "neutral" | "warning" | "success" | "error";
+
+export type ConnectionDisplayStateInput = {
+  configured: boolean;
+  enabled?: boolean;
+  status?: McpStatus["status"] | null;
+  needsAuth?: boolean;
+  failed?: boolean;
+};
+
+export function connectionDisplayState(input: ConnectionDisplayStateInput): ConnectionDisplayState | null {
+  if (input.enabled === false || input.status === "disabled") return "disabled";
+  if (
+    input.status === "needs_auth" ||
+    input.status === "needs_client_registration" ||
+    input.needsAuth === true
+  ) return "auth_required";
+  if (input.status === "connected") return "protocol_ready";
+  if (input.status === "failed" || input.failed === true) return "error";
+  if (input.configured) return "configured";
+  return null;
+}
+
+export function connectionDisplayStateLabelKey(state: ConnectionDisplayState): ConnectionDisplayStateLabelKey {
+  switch (state) {
+    case "configured":
+      return "mcp.friendly_status_offline";
+    case "auth_required":
+      return "mcp.friendly_status_needs_signin";
+    case "protocol_ready":
+      return "mcp.friendly_status_ready";
+    case "error":
+      return "mcp.friendly_status_issue";
+    case "disabled":
+      return "mcp.friendly_status_paused";
+  }
+}
+
+export function connectionDisplayStateTone(state: ConnectionDisplayState): ConnectionDisplayTone {
+  switch (state) {
+    case "protocol_ready":
+      return "success";
+    case "auth_required":
+      return "warning";
+    case "error":
+      return "error";
+    case "configured":
+    case "disabled":
+      return "neutral";
+  }
+}
diff --git a/apps/app/src/react-app/domains/session/surface/session-surface.tsx b/apps/app/src/react-app/domains/session/surface/session-surface.tsx
index e16f730337..3b62a4a9fe 100644
--- a/apps/app/src/react-app/domains/session/surface/session-surface.tsx
+++ b/apps/app/src/react-app/domains/session/surface/session-surface.tsx
@@ -477,6 +477,10 @@ export function SessionSurface(props: SessionSurfaceProps) {
     () => createClient(props.opencodeBaseUrl, undefined, { token: props.openworkToken, mode: "openwork" }),
     [props.opencodeBaseUrl, props.openworkToken],
   );
+  const toolInvocationKnownServers = useMemo(
+    () => toolMcpServers.map((server) => ({ name: server.name })),
+    [toolMcpServers],
+  );
 
   const snapshotQueryKey = useMemo(
     () => reactSnapshotKey(props.workspaceId, props.sessionId),
@@ -1407,6 +1411,7 @@ export function SessionSurface(props: SessionSurfaceProps) {
                         messages={renderedMessages}
                         status={status}
                         retryStatus={liveStatus.type === "retry" ? liveStatus : null}
+                        knownMcpServers={toolInvocationKnownServers}
                       />
                     </MessageListProvider>
                   </EnvironmentVariableProvider>
diff --git a/apps/app/src/react-app/domains/settings/pages/connect-view.tsx b/apps/app/src/react-app/domains/settings/pages/connect-view.tsx
index 7e6eddb5d5..536832b4da 100644
--- a/apps/app/src/react-app/domains/settings/pages/connect-view.tsx
+++ b/apps/app/src/react-app/domains/settings/pages/connect-view.tsx
@@ -15,6 +15,11 @@ import { Skeleton } from "@/components/ui/skeleton";
 import { t } from "@/i18n";
 import { DenSignInSurface } from "@/react-app/domains/cloud/den-signin-surface";
 import { useDenAuth, type DenAuthStatus } from "@/react-app/domains/cloud/den-auth-provider";
+import {
+  connectionDisplayState,
+  connectionDisplayStateLabelKey,
+  type ConnectionDisplayState,
+} from "@/react-app/domains/connections/connection-display-state";
 import {
   canDisconnectNativeProviderAccount,
   connectionNeedsReconnect,
@@ -494,6 +499,46 @@ function connectGroupLabel(group: Exclude<ConnectRowGroup, "excluded">) {
   }
 }
 
+function connectionStateChipClass(state: ConnectionDisplayState) {
+  switch (state) {
+    case "protocol_ready":
+      return "bg-green-3 text-green-11";
+    case "auth_required":
+      return "bg-amber-3 text-amber-11";
+    case "error":
+      return "bg-red-3 text-red-11";
+    case "configured":
+    case "disabled":
+      return "bg-gray-3 text-gray-11";
+  }
+}
+
+function ConnectionStateChip(props: { state: ConnectionDisplayState }) {
+  return (
+    <span className={`shrink-0 rounded-md px-2 py-1 text-xs font-medium ${connectionStateChipClass(props.state)}`}>
+      {t(connectionDisplayStateLabelKey(props.state))}
+    </span>
+  );
+}
+
+function connectRowDisplayState(row: ConnectOrganizationRow): ConnectionDisplayState {
+  if (row.kind === "connection") {
+    return connectionDisplayState({
+      configured: true,
+      status: row.group === "needs_signin"
+        ? "needs_auth"
+        : row.connection.connected || row.connection.connectedForMe
+          ? "connected"
+          : undefined,
+    }) ?? "configured";
+  }
+
+  return connectionDisplayState({
+    configured: true,
+    status: row.group === "needs_signin" ? "needs_auth" : row.group === "ready" ? "connected" : undefined,
+  }) ?? "configured";
+}
+
 function ConnectRowIcon(props: { iconSlug?: string; iconSrc?: string; name: string; serviceUrl?: string }) {
   const resolved = resolveExtensionIconUrl({ iconSlug: props.iconSlug, iconSrc: props.iconSrc, serviceUrl: props.serviceUrl });
   const [failed, setFailed] = useState(false);
@@ -569,6 +614,7 @@ function ConnectOrganizationRow(props: {
   const connecting = connectableConnectionId ? props.connectingId === connectableConnectionId : false;
   const disconnectableConnectionId = row.kind === "connection" && canDisconnectNativeProviderAccount(row.connection) ? row.connection.id : null;
   const disconnecting = disconnectableConnectionId ? props.disconnectingId === disconnectableConnectionId : false;
+  const displayState = connectRowDisplayState(row);
 
   return (
     <div
@@ -588,6 +634,7 @@ function ConnectOrganizationRow(props: {
       </div>
       {row.group === "needs_signin" && connectableConnectionId ? (
         <div className="flex shrink-0 flex-wrap items-center justify-end gap-2">
+          <ConnectionStateChip state={displayState} />
           <Button
             size="sm"
             disabled={connecting}
@@ -603,22 +650,21 @@ function ConnectOrganizationRow(props: {
           ) : null}
         </div>
       ) : row.group === "needs_admin_setup" ? (
-        <Button size="sm" variant="outline" onClick={() => void openDesktopUrl(denManageConnectionsUrl())} title={setupNames.join(t("connect.row_meta_list_separator"))}>
-          {t("connect.row_action_set_up_connection")}
-        </Button>
+        <div className="flex shrink-0 flex-wrap items-center justify-end gap-2">
+          <ConnectionStateChip state={displayState} />
+          <Button size="sm" variant="outline" onClick={() => void openDesktopUrl(denManageConnectionsUrl())} title={setupNames.join(t("connect.row_meta_list_separator"))}>
+            {t("connect.row_action_set_up_connection")}
+          </Button>
+        </div>
       ) : disconnectableConnectionId ? (
         <div className="flex shrink-0 flex-wrap items-center justify-end gap-2">
-          <span className="rounded-md bg-green-3 px-2 py-1 text-xs font-medium text-green-11">
-            {t("connect.row_chip_ready")}
-          </span>
+          <ConnectionStateChip state={displayState} />
           <Button size="sm" variant="destructive" disabled={disconnecting} onClick={() => props.onDisconnect(disconnectableConnectionId)}>
             {disconnecting ? t("mcp.org_connection_disconnecting_action") : t("mcp.org_connection_disconnect_action")}
           </Button>
         </div>
       ) : (
-        <span className="shrink-0 rounded-md bg-green-3 px-2 py-1 text-xs font-medium text-green-11">
-          {t("connect.row_chip_ready")}
-        </span>
+        <ConnectionStateChip state={displayState} />
       )}
     </div>
   );
diff --git a/apps/app/src/react-app/domains/settings/pages/mcp-view.tsx b/apps/app/src/react-app/domains/settings/pages/mcp-view.tsx
index 24d97c3df4..b39d5d79ff 100644
--- a/apps/app/src/react-app/domains/settings/pages/mcp-view.tsx
+++ b/apps/app/src/react-app/domains/settings/pages/mcp-view.tsx
@@ -2,7 +2,6 @@
 import { useEffect, useReducer, useRef, useState, type SetStateAction } from "react";
 import {
   BookOpen,
-  CheckCircle2,
   ChevronDown,
   CircleAlert,
   Cloud,
@@ -52,6 +51,11 @@ import { ConfirmModal } from "../../../design-system/modals/confirm-modal";
 import { AddMcpModal } from "../../connections/modals/add-mcp-modal";
 import { ClaudePluginImportModal } from "../../connections/modals/claude-plugin-import-modal";
 import { canDisconnectNativeProviderAccount } from "../../connections/native-provider-connections";
+import {
+  connectionDisplayState,
+  connectionDisplayStateLabelKey,
+  type ConnectionDisplayState,
+} from "../../connections/connection-display-state";
 import type { OpenworkClaudePluginPreview } from "../../../../app/lib/openwork-server";
 import {
   isOpenWorkExtensionEnabled,
@@ -67,14 +71,6 @@ import {
   type McpViewLocalState,
 } from "./mcp-view-state";
 
-export type ReactMcpStatus =
-  | "connected"
-  | "needs_auth"
-  | "needs_client_registration"
-  | "failed"
-  | "disabled"
-  | "disconnected";
-
 export type SkillItem = {
   name: string;
   description?: string;
@@ -133,49 +129,32 @@ export type McpViewProps = {
 
 const builtInExtensionDisabledReason = "Disabled by organization";
 
-const statusDot = (status: ReactMcpStatus) => {
-  switch (status) {
-    case "connected":
+const statusDot = (state: ConnectionDisplayState) => {
+  switch (state) {
+    case "protocol_ready":
       return "bg-green-9";
-    case "needs_auth":
-    case "needs_client_registration":
+    case "auth_required":
       return "bg-amber-9";
+    case "configured":
     case "disabled":
       return "bg-gray-8";
-    case "disconnected":
-      return "bg-gray-7";
-    default:
+    case "error":
       return "bg-red-9";
   }
 };
 
-const friendlyStatus = (status: ReactMcpStatus) => {
-  switch (status) {
-    case "connected":
-      return t("mcp.friendly_status_ready");
-    case "needs_auth":
-    case "needs_client_registration":
-      return t("mcp.friendly_status_needs_signin");
-    case "disabled":
-      return t("mcp.friendly_status_paused");
-    case "disconnected":
-      return t("mcp.friendly_status_offline");
-    default:
-      return t("mcp.friendly_status_issue");
-  }
-};
+const friendlyStatus = (state: ConnectionDisplayState) => t(connectionDisplayStateLabelKey(state));
 
-const statusBadgeStyle = (status: ReactMcpStatus) => {
-  switch (status) {
-    case "connected":
+const statusChipStyle = (state: ConnectionDisplayState) => {
+  switch (state) {
+    case "protocol_ready":
       return "bg-green-3 text-green-11";
-    case "needs_auth":
-    case "needs_client_registration":
+    case "auth_required":
       return "bg-amber-3 text-amber-11";
+    case "configured":
     case "disabled":
-    case "disconnected":
       return "bg-gray-3 text-gray-11";
-    default:
+    case "error":
       return "bg-red-3 text-red-11";
   }
 };
@@ -437,14 +416,15 @@ export function McpView(props: McpViewProps) {
   const supportsOauth = (entry: McpServerEntry) =>
     entry.config.type === "remote" && entry.config.oauth !== false;
 
-  const resolveStatus = (entry: McpServerEntry): ReactMcpStatus => {
-    if (entry.config.enabled === false) return "disabled";
-    const resolved = props.mcpStatuses[entry.name];
-    return resolved?.status ?? "disconnected";
-  };
+  const resolveDisplayState = (entry: McpServerEntry): ConnectionDisplayState =>
+    connectionDisplayState({
+      configured: true,
+      enabled: entry.config.enabled !== false,
+      status: props.mcpStatuses[entry.name]?.status,
+    }) ?? "configured";
 
   const connectedCount = props.mcpServers.filter(
-    (entry) => resolveStatus(entry) === "connected",
+    (entry) => resolveDisplayState(entry) === "protocol_ready",
   ).length;
   const hiddenCount = quickConnectList.filter((entry) => isOpenWorkExtensionHidden(entry)).length +
     (props.installedSkills ?? []).filter((skill) => isOpenWorkExtensionHidden(getSkillHiddenId(skill))).length +
@@ -658,7 +638,7 @@ export function McpView(props: McpViewProps) {
         logoutTarget={logoutTarget}
         togglingMcp={togglingMcp}
         displayName={displayName}
-        resolveStatus={resolveStatus}
+        resolveDisplayState={resolveDisplayState}
         supportsOauth={supportsOauth}
         onSelect={props.setSelectedMcp}
         onAuthorize={props.authorizeMcp}
@@ -928,7 +908,7 @@ function McpQuickConnectSection(props: {
   disabledReasonForEntry: (entry: McpDirectoryInfo) => string | null;
   isConfigured: (entry: McpDirectoryInfo) => boolean;
   enablementForEntry?: (entry: McpDirectoryInfo) => { active: boolean; results: EnablementResult[] } | null;
-  statusForEntry: (entry: McpDirectoryInfo) => { status: ReactMcpStatus } | undefined;
+  statusForEntry: (entry: McpDirectoryInfo) => McpStatusMap[string] | undefined;
   onConnect: (entry: McpDirectoryInfo) => void;
   onDetail: (entry: McpDirectoryInfo) => void;
   onSkillDetail?: (skill: SkillItem) => void;
@@ -1066,7 +1046,7 @@ function McpConfiguredServersSection(props: {
   logoutTarget: string | null;
   togglingMcp: string | null;
   displayName: (name: string) => string;
-  resolveStatus: (entry: McpServerEntry) => ReactMcpStatus;
+  resolveDisplayState: (entry: McpServerEntry) => ConnectionDisplayState;
   supportsOauth: (entry: McpServerEntry) => boolean;
   onSelect: (name: string | null) => void;
   onAuthorize: (entry: McpServerEntry) => void;
@@ -1094,7 +1074,7 @@ function McpConfiguredServersSection(props: {
             <McpConfiguredServerRow
               key={entry.name}
               entry={entry}
-              status={props.resolveStatus(entry)}
+              displayState={props.resolveDisplayState(entry)}
               errorInfo={readMcpErrorInfo(props.statuses[entry.name])}
               selected={props.selectedMcp === entry.name}
               busy={props.busy}
@@ -1130,7 +1110,7 @@ function readMcpErrorInfo(status: McpStatusMap[string] | undefined) {
 
 function McpConfiguredServerRow(props: {
   entry: McpServerEntry;
-  status: ReactMcpStatus;
+  displayState: ConnectionDisplayState;
   errorInfo: string | null;
   selected: boolean;
   busy: boolean;
@@ -1151,15 +1131,17 @@ function McpConfiguredServerRow(props: {
     <div className={`rounded-xl border transition-all ${props.selected ? "border-blue-7 bg-blue-2 shadow-sm" : "border-dls-border bg-dls-surface hover:bg-dls-hover"}`}>
       <button type="button" className="w-full px-4 py-3.5 text-left" onClick={() => props.onSelect(props.selected ? null : props.entry.name)}>
         <div className="flex items-center gap-3">
-          <div className={`flex size-8 shrink-0 items-center justify-center rounded-lg border ${props.status === "connected" ? "border-green-6 bg-green-3" : serviceIconBg(props.entry.name)}`}>
-            <Icon size={15} className={props.status === "connected" ? "text-green-11" : serviceColor(props.entry.name)} />
+          <div className={`flex size-8 shrink-0 items-center justify-center rounded-lg border ${props.displayState === "protocol_ready" ? "border-green-6 bg-green-3" : serviceIconBg(props.entry.name)}`}>
+            <Icon size={15} className={props.displayState === "protocol_ready" ? "text-green-11" : serviceColor(props.entry.name)} />
           </div>
           <div className="min-w-0 flex-1">
             <div className="truncate text-sm font-medium text-dls-text">{props.displayName(props.entry.name)}</div>
           </div>
           <div className="flex shrink-0 items-center gap-2">
-            <div className={`size-2 rounded-full ${statusDot(props.status)}`} />
-            <span className="text-[11px] text-dls-secondary">{friendlyStatus(props.status)}</span>
+            <div className={`size-2 rounded-full ${statusDot(props.displayState)}`} />
+            <span className={`rounded-md px-2 py-0.5 text-[11px] font-medium ${statusChipStyle(props.displayState)}`}>
+              {friendlyStatus(props.displayState)}
+            </span>
           </div>
           <div className={`transition-transform ${props.selected ? "rotate-180" : ""}`}>
             <ChevronDown size={14} className="text-dls-secondary/40" />
@@ -1236,7 +1218,7 @@ function McpConfiguredServerDetails(props: Parameters<typeof McpConfiguredServer
 
 function McpConfiguredServerAuthActions(props: Parameters<typeof McpConfiguredServerRow>[0]) {
   if (!props.supportsOauth(props.entry)) return null;
-  if (props.status !== "connected") {
+  if (props.displayState !== "protocol_ready") {
     return (
       <>
         <div className="flex items-center justify-between gap-3 pt-1">
diff --git a/apps/app/tests/connection-display-state.test.ts b/apps/app/tests/connection-display-state.test.ts
new file mode 100644
index 0000000000..ff514cfd83
--- /dev/null
+++ b/apps/app/tests/connection-display-state.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  connectionDisplayState,
+  connectionDisplayStateLabelKey,
+} from "../src/react-app/domains/connections/connection-display-state";
+
+describe("connectionDisplayState", () => {
+  test("shows configured when config exists but runtime status is not observed", () => {
+    expect(connectionDisplayState({ configured: true })).toBe("configured");
+  });
+
+  test("returns null when no config or runtime signal exists", () => {
+    expect(connectionDisplayState({ configured: false })).toBeNull();
+  });
+
+  test("shows auth_required for auth signals", () => {
+    expect(connectionDisplayState({ configured: true, status: "needs_auth" })).toBe("auth_required");
+    expect(connectionDisplayState({ configured: true, status: "needs_client_registration" })).toBe("auth_required");
+    expect(connectionDisplayState({ configured: true, needsAuth: true })).toBe("auth_required");
+  });
+
+  test("shows protocol_ready only after the protocol status reports connected", () => {
+    expect(connectionDisplayState({ configured: true, status: "connected" })).toBe("protocol_ready");
+  });
+
+  test("shows error for failed status or failed signal", () => {
+    expect(connectionDisplayState({ configured: true, status: "failed" })).toBe("error");
+    expect(connectionDisplayState({ configured: true, failed: true })).toBe("error");
+  });
+
+  test("shows disabled for config or runtime disabled signals", () => {
+    expect(connectionDisplayState({ configured: true, enabled: false, status: "connected" })).toBe("disabled");
+    expect(connectionDisplayState({ configured: true, status: "disabled" })).toBe("disabled");
+  });
+
+  test("maps display states to static translation keys", () => {
+    expect(connectionDisplayStateLabelKey("configured")).toBe("mcp.friendly_status_offline");
+    expect(connectionDisplayStateLabelKey("auth_required")).toBe("mcp.friendly_status_needs_signin");
+    expect(connectionDisplayStateLabelKey("protocol_ready")).toBe("mcp.friendly_status_ready");
+    expect(connectionDisplayStateLabelKey("error")).toBe("mcp.friendly_status_issue");
+    expect(connectionDisplayStateLabelKey("disabled")).toBe("mcp.friendly_status_paused");
+  });
+});
diff --git a/apps/app/tests/tool-invocation-origin.test.ts b/apps/app/tests/tool-invocation-origin.test.ts
new file mode 100644
index 0000000000..dda6622937
--- /dev/null
+++ b/apps/app/tests/tool-invocation-origin.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+
+import { toolInvocationOrigin } from "../src/lib/tool-invocation-origin";
+
+describe("toolInvocationOrigin", () => {
+  test("parses direct MCP tool names with a known server prefix", () => {
+    expect(
+      toolInvocationOrigin("servicenow-direct_lookup_incident_records", undefined, [
+        { name: "servicenow-direct" },
+      ]),
+    ).toEqual({
+      connectionName: "ServiceNow Direct",
+      displayTool: "lookup_incident_records",
+    });
+  });
+
+  test("parses direct MCP tool names from their flat prefix when no server list is loaded", () => {
+    expect(toolInvocationOrigin("servicenow_lookup_incident_records")).toEqual({
+      connectionName: "ServiceNow",
+      displayTool: "lookup_incident_records",
+    });
+  });
+
+  test("parses OpenWork Cloud execute_capability MCP target names", () => {
+    expect(
+      toolInvocationOrigin("openwork-cloud_execute_capability", { name: "mcp:conn_123:lookup_incident_records" }, [
+        { id: "conn_123", name: "ServiceNow Shared" },
+      ]),
+    ).toEqual({
+      connectionName: "OpenWork Cloud → ServiceNow Shared",
+      displayTool: "lookup_incident_records",
+    });
+  });
+
+  test("includes the Cloud connection id when no connection name is known", () => {
+    expect(
+      toolInvocationOrigin("openwork-cloud_execute_capability", { name: "mcp:conn_456:lookup_records" }),
+    ).toEqual({
+      connectionName: "OpenWork Cloud → conn_456",
+      displayTool: "lookup_records",
+    });
+  });
+
+  test("leaves built-in tools without an origin badge", () => {
+    const result = toolInvocationOrigin("bash", { command: "pwd" }, [{ name: "servicenow-direct" }]);
+    expect(result.connectionName).toBeUndefined();
+    expect(result.displayTool).toBe("bash");
+
+    const envVarResult = toolInvocationOrigin("env_var_request", { key: "OPENAI_API_KEY" });
+    expect(envVarResult.connectionName).toBeUndefined();
+    expect(envVarResult.displayTool).toBe("env_var_request");
+  });
+
+  test("falls back to the direct Cloud tool when args are malformed", () => {
+    expect(toolInvocationOrigin("openwork-cloud_execute_capability", { name: "not-an-mcp-capability" })).toEqual({
+      connectionName: "OpenWork Cloud",
+      displayTool: "execute_capability",
+    });
+    expect(toolInvocationOrigin("openwork-cloud_execute_capability", "bad args")).toEqual({
+      connectionName: "OpenWork Cloud",
+      displayTool: "execute_capability",
+    });
+  });
+});
diff --git a/ee/apps/den-api/test/external-capabilities-search-divergence.test.ts b/ee/apps/den-api/test/external-capabilities-search-divergence.test.ts
index 17ca2df4f7..fc3944584f 100644
--- a/ee/apps/den-api/test/external-capabilities-search-divergence.test.ts
+++ b/ee/apps/den-api/test/external-capabilities-search-divergence.test.ts
@@ -430,7 +430,7 @@ test("dead-url execution returns a structured connection diagnostic instead of t
     organizationId: seed.organizationId,
     member: { orgMembershipId: seed.memberId, teamIds: [] },
     connectionId: connection.id,
-    toolName: "lookup_incidents",
+    toolName: "synthetic_servicenow_lookup",
     args: {},
     redirectUriBase,
   })
diff --git a/ee/apps/diagnostics/src/mcp.ts b/ee/apps/diagnostics/src/mcp.ts
index e881967663..7f697d7c16 100644
--- a/ee/apps/diagnostics/src/mcp.ts
+++ b/ee/apps/diagnostics/src/mcp.ts
@@ -35,7 +35,7 @@ function negotiatedVersion(message: Record<string, unknown>): string {
 
 function toolDefinition(profile: ReturnType<typeof diagnosticsConfig>["profile"]): Record<string, unknown> {
   const name = profile === "servicenow"
-    ? "lookup_incidents"
+    ? "synthetic_servicenow_lookup"
     : profile === "microsoft"
       ? "search_microsoft_365"
       : "diagnostics_check"
diff --git a/packages/enterprise-mcp-mock-server/src/profiles/profiles.ts b/packages/enterprise-mcp-mock-server/src/profiles/profiles.ts
index 5474844b01..1b8325d0b4 100644
--- a/packages/enterprise-mcp-mock-server/src/profiles/profiles.ts
+++ b/packages/enterprise-mcp-mock-server/src/profiles/profiles.ts
@@ -143,7 +143,7 @@ const profiles = deepFreeze(providerProfileSchema.array().parse([
     },
     tools: [
       {
-        name: "lookup_incidents",
+        name: "synthetic_servicenow_lookup",
         title: "Look up incidents",
         description: "Returns deterministic synthetic incidents visible to the mock runtime user.",
         kind: "read",
@@ -158,7 +158,7 @@ const profiles = deepFreeze(providerProfileSchema.array().parse([
         },
       },
       {
-        name: "get_incident",
+        name: "synthetic_servicenow_get_incident",
         title: "Get incident",
         description: "Returns one synthetic incident by incident number.",
         kind: "read",
@@ -170,7 +170,7 @@ const profiles = deepFreeze(providerProfileSchema.array().parse([
         },
       },
       {
-        name: "summarize_incident",
+        name: "synthetic_servicenow_summarize_incident",
         title: "Summarize incident",
         description: "Builds a deterministic summary of a synthetic incident.",
         kind: "read",
@@ -182,7 +182,7 @@ const profiles = deepFreeze(providerProfileSchema.array().parse([
         },
       },
       {
-        name: "create_incident",
+        name: "synthetic_servicenow_create_incident",
         title: "Create incident",
         description: "Creates a synthetic incident in the in-memory mutation ledger.",
         kind: "mutation",
diff --git a/packages/enterprise-mcp-mock-server/test/bounds-lifecycle.test.ts b/packages/enterprise-mcp-mock-server/test/bounds-lifecycle.test.ts
index 472af9d202..cc8ff1b4db 100644
--- a/packages/enterprise-mcp-mock-server/test/bounds-lifecycle.test.ts
+++ b/packages/enterprise-mcp-mock-server/test/bounds-lifecycle.test.ts
@@ -97,7 +97,7 @@ test("event and state buffers are capped, expire, and redact known secrets", ()
   assert.equal(state.refreshTokens.size, 100)
   assert.equal(state.sessions.size, 100)
   for (let index = 0; index < 1_020; index += 1) {
-    const prepared = state.prepareOperation("test-family", "create_incident", `idempotency-${index}`, { value: index })
+    const prepared = state.prepareOperation("test-family", "synthetic_servicenow_create_incident", `idempotency-${index}`, { value: index })
     if (prepared.kind === "prepared") state.transitionOperation(prepared.operation.operationId, "responded", `result-${index}`)
   }
   assert.equal(state.operations.size, 1000)
@@ -171,15 +171,15 @@ test("only a responded mutation can be reported as an idempotent duplicate", ()
     [oauthClientSecret],
     { now: Date.now, randomId: () => `id-${++counter}`, opaqueValue: (prefix) => `${prefix}-${++counter}` },
   )
-  const prepared = state.prepareOperation("family-a", "create_incident", "stable-idempotency-key", { value: 1 })
+  const prepared = state.prepareOperation("family-a", "synthetic_servicenow_create_incident", "stable-idempotency-key", { value: 1 })
   assert.equal(prepared.kind, "prepared")
-  assert.equal(state.prepareOperation("family-a", "create_incident", "stable-idempotency-key", { value: 1 }).kind, "reconcile")
+  assert.equal(state.prepareOperation("family-a", "synthetic_servicenow_create_incident", "stable-idempotency-key", { value: 1 }).kind, "reconcile")
   if (prepared.kind !== "prepared") throw new Error("Expected prepared operation")
   state.transitionOperation(prepared.operation.operationId, "committed", "synthetic:result")
-  assert.equal(state.prepareOperation("family-a", "create_incident", "stable-idempotency-key", { value: 1 }).kind, "reconcile")
+  assert.equal(state.prepareOperation("family-a", "synthetic_servicenow_create_incident", "stable-idempotency-key", { value: 1 }).kind, "reconcile")
   state.transitionOperation(prepared.operation.operationId, "responded", "synthetic:result")
-  assert.equal(state.prepareOperation("family-a", "create_incident", "stable-idempotency-key", { value: 1 }).kind, "duplicate")
-  assert.equal(state.prepareOperation("family-b", "create_incident", "stable-idempotency-key", { value: 1 }).kind, "prepared")
+  assert.equal(state.prepareOperation("family-a", "synthetic_servicenow_create_incident", "stable-idempotency-key", { value: 1 }).kind, "duplicate")
+  assert.equal(state.prepareOperation("family-b", "synthetic_servicenow_create_incident", "stable-idempotency-key", { value: 1 }).kind, "prepared")
 })
 
 test("bounded eviction never forgets an unresolved mutation outcome", () => {
@@ -191,15 +191,15 @@ test("bounded eviction never forgets an unresolved mutation outcome", () => {
     [oauthClientSecret],
     { now: Date.now, randomId: () => `id-${++counter}`, opaqueValue: (prefix) => `${prefix}-${++counter}` },
   )
-  const critical = state.prepareOperation("critical-client", "create_incident", "critical-key", { value: "critical" })
+  const critical = state.prepareOperation("critical-client", "synthetic_servicenow_create_incident", "critical-key", { value: "critical" })
   if (critical.kind !== "prepared") throw new Error("Expected critical operation to prepare")
   state.transitionOperation(critical.operation.operationId, "indeterminate", "critical-result")
   for (let index = 0; index < 1_100; index += 1) {
-    const filler = state.prepareOperation("filler-client", "create_incident", `filler-${index}`, { value: index })
+    const filler = state.prepareOperation("filler-client", "synthetic_servicenow_create_incident", `filler-${index}`, { value: index })
     if (filler.kind === "prepared") state.transitionOperation(filler.operation.operationId, "responded", `result-${index}`)
   }
   assert.equal(state.operations.has(critical.operation.operationId), true)
-  assert.equal(state.prepareOperation("critical-client", "create_incident", "critical-key", { value: "critical" }).kind, "reconcile")
+  assert.equal(state.prepareOperation("critical-client", "synthetic_servicenow_create_incident", "critical-key", { value: "critical" }).kind, "reconcile")
   assert.equal(state.operations.size, 1000)
 })
 
@@ -213,8 +213,8 @@ test("a ledger full of unresolved outcomes rejects new mutations instead of evic
     { now: Date.now, randomId: () => `id-${++counter}`, opaqueValue: (prefix) => `${prefix}-${++counter}` },
   )
   for (let index = 0; index < 1_000; index += 1) {
-    assert.equal(state.prepareOperation("capacity-client", "create_incident", `unresolved-${index}`, { value: index }).kind, "prepared")
+    assert.equal(state.prepareOperation("capacity-client", "synthetic_servicenow_create_incident", `unresolved-${index}`, { value: index }).kind, "prepared")
   }
-  assert.equal(state.prepareOperation("capacity-client", "create_incident", "one-too-many", { value: 1_001 }).kind, "capacity")
+  assert.equal(state.prepareOperation("capacity-client", "synthetic_servicenow_create_incident", "one-too-many", { value: 1_001 }).kind, "capacity")
   assert.equal(state.operations.size, 1_000)
 })
diff --git a/packages/enterprise-mcp-mock-server/test/mutation.test.ts b/packages/enterprise-mcp-mock-server/test/mutation.test.ts
index 5e45eca1b5..a682aa9b77 100644
--- a/packages/enterprise-mcp-mock-server/test/mutation.test.ts
+++ b/packages/enterprise-mcp-mock-server/test/mutation.test.ts
@@ -27,7 +27,7 @@ test("mutations require approval and enforce idempotent duplicate versus conflic
     const token = await authorizeManual(server.baseUrl, scenario, oauthClientSecret)
     const session = await initializeSession(server.baseUrl, scenario, token)
     const denied = await callRpc(server.baseUrl, scenario, session, 10, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: {
         short_description: "Synthetic denied mutation",
         idempotency_key: "mutation-key-denied",
@@ -44,21 +44,21 @@ test("mutations require approval and enforce idempotent duplicate versus conflic
       approved: true,
     }
     const first = await callRpc(server.baseUrl, scenario, session, 11, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: argumentsValue,
     })
     assert.equal(toolResultSchema.parse(first.envelope.result).isError, false)
     assert.equal(server.snapshot().counts.operations, 1)
 
     const duplicate = await callRpc(server.baseUrl, scenario, session, 12, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: argumentsValue,
     })
     assert.equal(toolResultSchema.parse(duplicate.envelope.result).isError, false)
     assert.equal(server.snapshot().counts.operations, 1)
 
     const reorderedDuplicate = await callRpc(server.baseUrl, scenario, session, 14, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: {
         approved: true,
         idempotency_key: "mutation-key-approved",
@@ -69,7 +69,7 @@ test("mutations require approval and enforce idempotent duplicate versus conflic
     assert.equal(server.snapshot().counts.operations, 1)
 
     const conflict = await callRpc(server.baseUrl, scenario, session, 13, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: { ...argumentsValue, short_description: "Different mutation with reused key" },
     })
     const conflictResult = toolResultSchema.parse(conflict.envelope.result)
@@ -93,7 +93,7 @@ test("timeout after commit remains indeterminate and requires reconciliation bef
     const token = await authorizeManual(server.baseUrl, scenario, oauthClientSecret)
     const session = await initializeSession(server.baseUrl, scenario, token)
     const params = {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: {
         short_description: "Synthetic indeterminate mutation",
         idempotency_key: "mutation-key-indeterminate",
@@ -137,7 +137,7 @@ test("local mutation approval fails before a configured provider fault can be em
     const token = await authorizeManual(server.baseUrl, scenario, oauthClientSecret)
     const session = await initializeSession(server.baseUrl, scenario, token)
     const denied = await callRpc(server.baseUrl, scenario, session, 50, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: {
         short_description: "Must not reach provider",
         idempotency_key: "local-approval-first",
@@ -163,7 +163,7 @@ test("safe-read probe mode rejects an explicit mutation override before any oper
       credentials: { clientSecret: oauthClientSecret },
       mode: "safe-read",
       callTool: {
-        name: "create_incident",
+        name: "synthetic_servicenow_create_incident",
         arguments: {
           short_description: "Must remain uncommitted",
           idempotency_key: "safe-read-mutation-rejected",
diff --git a/packages/enterprise-mcp-mock-server/test/protocol-security.test.ts b/packages/enterprise-mcp-mock-server/test/protocol-security.test.ts
index 92cf66b263..981a56ea1d 100644
--- a/packages/enterprise-mcp-mock-server/test/protocol-security.test.ts
+++ b/packages/enterprise-mcp-mock-server/test/protocol-security.test.ts
@@ -209,7 +209,7 @@ test("transport, JSON-RPC, protocol, and session validation stay precisely shape
     const unknown = await callRpc(server.baseUrl, scenario, session, 4, "unknown/method", {})
     assert.equal(unknown.envelope.error?.code, -32601)
     const invalidArguments = await callRpc(server.baseUrl, scenario, session, 5, "tools/call", {
-      name: "get_incident",
+      name: "synthetic_servicenow_get_incident",
       arguments: { number: 42, extra: true },
     })
     assert.equal(invalidArguments.envelope.error?.code, -32602)
@@ -308,7 +308,7 @@ test("provider tool faults expose top-level Den-compatible evidence and a detail
     const token = await authorizeManual(server.baseUrl, scenario, oauthClientSecret)
     const session = await initializeSession(server.baseUrl, scenario, token)
     const call = await callRpc(server.baseUrl, scenario, session, 31, "tools/call", {
-      name: "get_incident",
+      name: "synthetic_servicenow_get_incident",
       arguments: { number: "INC0000001" },
     })
     const result = z.object({
diff --git a/packages/enterprise-mcp-mock-server/test/scenario-continuity.test.ts b/packages/enterprise-mcp-mock-server/test/scenario-continuity.test.ts
index e79224ff40..b988f7faab 100644
--- a/packages/enterprise-mcp-mock-server/test/scenario-continuity.test.ts
+++ b/packages/enterprise-mcp-mock-server/test/scenario-continuity.test.ts
@@ -103,7 +103,7 @@ test("compatible scenario activation preserves established OAuth authority but c
     const token = await authorizeManual(server.baseUrl, scenario, oauthClientSecret)
     const oldSession = await initializeSession(server.baseUrl, scenario, token)
     const mutation = await callRpc(server.baseUrl, scenario, oldSession, 30, "tools/call", {
-      name: "create_incident",
+      name: "synthetic_servicenow_create_incident",
       arguments: {
         approved: true,
         idempotency_key: "continuity-operation-must-not-cross",