Sounds like you want to do this
/ Application \
/ .------. \
. < Domain > .
\ '------' /
And you're not sure how the adapter fits in. This is the adapter pattern:
That works fine when the flow of control is just going from the outside in. How does it ever get back out?
Here's an extremely similar architecture that shows how to solve that problem:
The names and shapes are different and really not that important. The cool thing here is down in that lower right corner. Uncle bob calls that a plugin (because everyone has to have different names for these things). It shows how to get in and out of lower layers without dependencies going the wrong direction. The <I> thing marks the interfaces.
This all comes down to respecting the dependency inversion principle. Following that can look like this:
Notice how that looks a lot like the adapter? The difference is just one more interface. It also looks a lot like that plugin if you just rotate the last 2 boxes 90 degrees and then flip the whole thing.
To me, this whole "architecture" thing is about managing what is allowed to know about what while still getting things done.
You were concerned about passing things contained in the domain. I hope this shows you that where something is contained isn't the issue. The issue is where the interface lives. You'll notice presenter's interface isn't even in the same layer. You should rely on interfaces only so long as they are defined no further from the core than you are. That way you can always peel off and swap out outer layers. The inner layers won't know a thing has changed. They don't know about the outer layers. They don't want to know.