@@ -101,6 +101,31 @@ describe('persisted-message', () => {
     }
   )
 
+  it("persists a resolved operation's inherited grouping with its arguments", () => {
+    const persisted = buildPersistedAssistantMessage({
+      success: true,
+      content: '',
+      toolCalls: [],
+      contentBlocks: [
+        {
+          type: 'tool_call',
+          timestamp: 1,
+          toolCall: {
+            id: 'gateway-call',
+            name: 'mcp-server-get_overview',
+            status: 'success',
+            params: { category_id: null },
+            activity: { id: 'gauge-read', title: 'Reading Gauge', completedTitle: 'Read Gauge' },
+          },
+        },
+      ],
+    })
+    expect(persisted.contentBlocks?.[0].toolCall?.params).toEqual({
+      category_id: null,
+      activity: { id: 'gauge-read', title: 'Reading Gauge', completedTitle: 'Read Gauge' },
+    })
+  })
+
   it('preserves activity metadata on legacy tool blocks without inferring it from old titles', () => {
     const message = normalizeMessage({
       id: 'message-1',
 
@@ -24,6 +24,7 @@ import {
   MothershipStreamV1ToolOutcome,
   MothershipStreamV1ToolPhase,
 } from '@/lib/mothership/generated/mothership-stream-v1'
+import type { ToolActivity } from '@/lib/mothership/generated/protocol'
 import type {
   ContentBlock,
   LocalToolCallStatus,
@@ -273,6 +274,14 @@ export function displayContentOf(content: PersistedMessage): PersistedMessage |
 
 // Write: OrchestratorResult → PersistedMessage
 
+/** A call's arguments as history reads them, with an inherited display grouping restored. */
+function persistedParams(
+  params: Record<string, unknown>,
+  activity: ToolActivity | undefined
+): Record<string, unknown> {
+  return activity && params.activity === undefined ? { ...params, activity } : params
+}
+
 function resolveToolState(block: ContentBlock): PersistedToolState {
   const tc = block.toolCall
   if (!tc) return 'pending'
@@ -391,7 +400,7 @@ function mapContentBlockBody(block: ContentBlock): PersistedContentBlock {
         ...(isSubagentTool && isNonTerminal
           ? {}
           : block.toolCall.params
-            ? { params: block.toolCall.params }
+            ? { params: persistedParams(block.toolCall.params, block.toolCall.activity) }
             : {}),
         ...(block.calledBy ? { calledBy: block.calledBy } : {}),
         ...(block.toolCall.displayTitle
 
@@ -1,3 +1,4 @@
+import { flushMacrotask } from '@sim/testing/helpers/async'
 import { createDeferred } from '@sim/testing/helpers/deferred'
 import {
   mothershipAsyncRunsMock,
@@ -2252,6 +2253,60 @@ describe('sse-handlers tool lifecycle', () => {
     )
   })
 
+  it("executes a resolved MCP operation with its own arguments under the gateway's grouping", async () => {
+    isSimExecuted.mockReturnValue(false)
+    executeTool.mockResolvedValueOnce({ success: true, output: {} })
+    const grouping = { id: 'gauge-read', title: 'Reading Gauge', completedTitle: 'Read Gauge' }
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'gateway-mcp',
+          toolName: 'call_integration_tool',
+          arguments: {
+            toolId: 'mcp-server-get_overview',
+            description: 'Pulling the overview',
+            activity: grouping,
+            arguments: { category_id: null },
+          },
+          executor: MothershipStreamV1ToolExecutor.go,
+          mode: MothershipStreamV1ToolMode.sync,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'gateway-mcp',
+          toolName: 'mcp-server-get_overview',
+          arguments: { category_id: null },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await flushMacrotask()
+
+    expect(executeTool).toHaveBeenCalledWith(
+      'mcp-server-get_overview',
+      { category_id: null },
+      expect.any(Object)
+    )
+    expect(context.toolCalls.get('gateway-mcp')?.activity).toEqual(grouping)
+  })
+
   it("keeps an integration operation's own activity argument under the gateway's grouping", async () => {
     isSimExecuted.mockReturnValue(false)
     executeTool.mockResolvedValueOnce({ success: true, output: {} })
@@ -2295,7 +2350,7 @@ describe('sse-handlers tool lifecycle', () => {
       { interactive: false, timeout: 1000 }
     )
 
-    await sleep(0)
+    await flushMacrotask()
 
     expect(executeTool).toHaveBeenCalledWith(
       'azure_devops_create_work_item',
 
@@ -20,6 +20,7 @@ import {
   MothershipStreamV1ToolOutcome,
   type MothershipStreamV1ToolResultPayload,
 } from '@/lib/mothership/generated/mothership-stream-v1'
+import type { ToolActivity } from '@/lib/mothership/generated/protocol'
 import { TraceAttr } from '@/lib/mothership/generated/trace-attributes-v1'
 import { TraceSpan } from '@/lib/mothership/generated/trace-spans-v1'
 import { withCopilotSpan } from '@/lib/mothership/request/otel'
@@ -145,6 +146,11 @@ function applyToolDisplay(toolCall: ToolCallState | undefined): void {
 
 const INTEGRATION_GATEWAY_TOOL = 'call_integration_tool'
 
+/** A call's display grouping: carried in its own arguments, or inherited and held beside them. */
+function toolCallActivity(toolCall: ToolCallState | undefined): ToolActivity | undefined {
+  return toolCall?.activity ?? readToolActivity(toolCall?.params)
+}
+
 function handleToolArgsDelta(
   data: { argumentsDelta: string; toolCallId: string; toolName: string },
   context: StreamingContext
@@ -580,17 +586,18 @@ async function handleCallPhase(
   }
   /** Persist visible labels even when the introducing discovery call is omitted from the transcript. */
   const argsActivity = readToolActivity(args)
-  const suppliedActivity = argsActivity ?? readToolActivity(existing?.params)
+  const suppliedActivity = argsActivity ?? toolCallActivity(existing)
   const activity = suppliedActivity?.completedTitle
     ? suppliedActivity
     : suppliedActivity &&
       Array.from(context.toolCalls.values())
         .filter((tool) => tool.agentId === agentId && tool.parentToolCallId === parentToolCallId)
-        .map((tool) => readToolActivity(tool.params))
+        .map(toolCallActivity)
         .find((candidate) => candidate?.id === suppliedActivity.id && candidate.completedTitle)
-  // A tool's own `activity` argument (any value that is not a display label) is never replaced.
-  const ownsActivity = args?.activity !== undefined && !argsActivity
-  const displayArgs = activity && !ownsActivity ? { ...args, activity } : args
+  // Only a label the frame's own arguments carry is completed in place. An inherited one stays
+  // off the arguments, which execute as given (an MCP schema refuses keys it never declared).
+  const displayArgs = activity && argsActivity ? { ...args, activity } : args
+  if (existing && activity && !argsActivity) existing.activity = activity
   const isSubagent = scope === 'subagent'
   const ui = getToolCallUI(data)
 
 
@@ -3,7 +3,7 @@ import {
   type MothershipStreamV1CompletionStatus,
   MothershipStreamV1ToolOutcome,
 } from '@/lib/mothership/generated/mothership-stream-v1'
-import type { StreamActivityReceipt } from '@/lib/mothership/generated/protocol'
+import type { StreamActivityReceipt, ToolActivity } from '@/lib/mothership/generated/protocol'
 import type { RequestTraceV1Span } from '@/lib/mothership/generated/request-trace-v1'
 import type { ProviderToolCallIdentity } from '@/lib/mothership/request/go/tool-call-identity'
 import type { StreamEvent } from '@/lib/mothership/request/session'
@@ -42,6 +42,12 @@ export interface ToolCallState {
   activityDescription?: string
   /** Model-authored activity text for a gateway-resolved integration call. */
   integrationDescription?: string
+  /**
+   * Display grouping the call inherited rather than carried in its own arguments (a gateway's
+   * grouping on its resolved operation). Kept out of `params`, which execute as given; it is
+   * merged back only into the persisted arguments, where history reads it.
+   */
+  activity?: ToolActivity
   /** Accumulated partial JSON of the arguments while the model streams them. */
   streamingArgs?: string
   params?: Record<string, unknown>
 
@@ -10,7 +10,7 @@ import {
 import { toolsMock, toolsMockFns } from '@sim/testing/mocks/tools.mock'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
-import { getToolMetadata, getToolParams } from '@/tools/metadata'
+import { getToolMetadata } from '@/tools/metadata'
 import { slackGetUserTool } from '@/tools/slack/get_user'
 
 const { getToolEntry, isKnownTool, isSimExecuted, isClientExecuted } = vi.hoisted(() => ({
@@ -306,40 +306,6 @@ describe('copilot tool executor fallback', () => {
     )
   })
 
-  it('keeps display activity out of integration and MCP execution parameters', async () => {
-    isKnownTool.mockReturnValue(false)
-    isClientExecuted.mockReturnValue(false)
-    executeAppTool.mockResolvedValue({ success: true })
-    await executeTool(
-      'mcp-server-get_overview',
-      { activity: { id: 'gauge-read' }, category_id: null },
-      { userId: 'person', workflowId: '', workspaceId: 'workspace', requestMode: 'agent' }
-    )
-    const appParams = executeAppTool.mock.calls[0]?.[1]
-    expect(appParams).not.toHaveProperty('activity')
-    expect(appParams).toMatchObject({ category_id: null })
-  })
-
-  it.each([
-    ['a tool that declares it', 'azure_devops_create_work_item', { id: 'Development' }],
-    ['a value that is not a display label', 'mcp-server-log_time', 'Development'],
-  ])("keeps a tool's own activity for %s", async (_case, toolId, activity) => {
-    vi.mocked(getToolParams).mockImplementation((id) =>
-      id === 'azure_devops_create_work_item'
-        ? { activity: { type: 'string', required: false, visibility: 'user-or-llm' } }
-        : undefined
-    )
-    isKnownTool.mockReturnValue(false)
-    isClientExecuted.mockReturnValue(false)
-    executeAppTool.mockResolvedValue({ success: true })
-    await executeTool(
-      toolId,
-      { activity },
-      { userId: 'person', workflowId: '', workspaceId: 'workspace', requestMode: 'agent' }
-    )
-    expect(executeAppTool.mock.calls[0]?.[1]).toMatchObject({ activity })
-  })
-
   it('projects resolved secrets before logging registered handler failures', async () => {
     const secret = 'mounted-secret-value'
     const registry = new ResolvedSecretTraceRegistry([
 
@@ -1,7 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { type PermissionType, permissionSatisfies } from '@sim/platform-authz/workspace'
 import { toError } from '@sim/utils/errors'
-import { omit } from '@sim/utils/object'
 import { openResourceInputSchema } from '@/lib/api/contracts/mothership-resource-tools'
 import { observeContentDelivery } from '@/lib/core/application'
 import { withWorkspaceInvocationScope } from '@/lib/core/application/workspace-invocation-scope'
@@ -13,10 +12,9 @@ import { prepareCopilotEnvironmentContext } from '@/lib/mothership/environment-c
 import { isSearchIntegrationToolsEnabled } from '@/lib/mothership/feature-flags'
 import { isOwnerScopedFile } from '@/lib/mothership/file-owners'
 import { projectToolErrorMessageForCopilot } from '@/lib/mothership/request/tools/resolved-secret-result'
-import { readToolActivity } from '@/lib/mothership/tools/activity'
 import { recordSecretUsage } from '@/lib/secrets/usage/record'
 import { executeTool as executeAppTool } from '@/tools'
-import { getToolMetadata, getToolParams } from '@/tools/metadata'
+import { getToolMetadata } from '@/tools/metadata'
 import { getToolEntry, isClientExecuted, isKnownTool, isSimExecuted } from './router'
 import type { ToolExecutionContext, ToolExecutionResult, ToolHandler } from './types'
 
@@ -241,7 +239,7 @@ async function executeGatedTool(
       hasHandler(toolId) &&
       (!isKnownTool(toolId) || isSimExecuted(toolId) || usesHeadlessClientFallback)
     if (!canUseRegisteredHandler) {
-      const appParams = buildAppToolParams(withoutDisplayActivity(toolId, params), context)
+      const appParams = buildAppToolParams(params, context)
       const options = {
         ...(context.resolvedSecretTraceRegistry
           ? { resolvedSecretTraceRegistry: context.resolvedSecretTraceRegistry }
@@ -295,7 +293,8 @@ async function executeGatedTool(
     }
 
     try {
-      return await handler(omit(params, ['activity']), context)
+      const { activity: _activity, ...executionParams } = params
+      return await handler(executionParams, context)
     } catch (error) {
       const message = toError(error).message
       logger.error('Tool execution failed', {
@@ -331,21 +330,6 @@ function recordAppToolSecretUsage(context: ToolExecutionContext): void {
   })
 }
 
-/**
- * The chat's grouping label rides on a call's arguments for presentation and persistence, so an
- * integration or MCP tool would receive an `activity` it never declared and a strict schema
- * refuses. It is dropped only when it reads as that label and the tool declares no `activity` of
- * its own (Azure DevOps work items take an Activity field).
- */
-function withoutDisplayActivity(
-  toolId: string,
-  params: Record<string, unknown>
-): Record<string, unknown> {
-  return readToolActivity(params) && !getToolParams(toolId)?.activity
-    ? omit(params, ['activity'])
-    : params
-}
-
 function buildAppToolParams(
   params: Record<string, unknown>,
   context: ToolExecutionContext