diff --git a/src/renderer/src/components/NewWorkspaceComposerCard.file-drop.test.tsx b/src/renderer/src/components/NewWorkspaceComposerCard.file-drop.test.tsx
new file mode 100644
index 000000000000..579c495dfdf7
--- /dev/null
+++ b/src/renderer/src/components/NewWorkspaceComposerCard.file-drop.test.tsx
@@ -0,0 +1,279 @@
+// @vitest-environment happy-dom
+import type * as ReactI18nextModule from 'react-i18next'
+import { act, renderHook } from '@testing-library/react'
+import { useNewWorkspaceComposerFileDrop } from './new-workspace/use-new-workspace-composer-file-drop'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { renderCard, unmountCard } from './NewWorkspaceComposerCard.test-fixture'
+import { createRef } from 'react'
+import { resolveComposerAttachmentTarget } from '../hooks/composer-state/composer-attachment-target'
+import { useAttachmentDropState } from '../hooks/composer-state/attachment-drop-state'
+import type { ProjectGroup } from '../../../shared/project-group-types'
+
+const uploads = vi.hoisted(() => ({ importPaths: vi.fn() }))
+vi.mock('@/runtime/runtime-file-client', () => ({
+  importExternalPathsToRuntime: uploads.importPaths
+}))
+
+vi.mock('@/store', () => ({
+  useAppStore: Object.assign(
+    (selector: (state: unknown) => unknown) => selector({ settings: {}, projects: [], repos: [] }),
+    {
+      getState: () => ({
+        sshConnectionStates: connections,
+        sshStateByEnvironment: runtimeConnections
+      })
+    }
+  )
+}))
+vi.mock('react-i18next', async (importOriginal) => ({
+  ...(await importOriginal<typeof ReactI18nextModule>()),
+  useTranslation: () => ({})
+}))
+vi.mock('@/components/contextual-tours/use-contextual-tour', () => ({
+  useContextualTour: () => {}
+}))
+vi.mock('@/components/sidebar/AddRemoteHostDialog', () => ({ AddRemoteHostDialog: () => null }))
+vi.mock('./new-workspace/NewWorkspaceComposerProjectSection', () => ({
+  NewWorkspaceComposerProjectSection: () => null
+}))
+vi.mock('./new-workspace/NewWorkspaceComposerNameSection', () => ({
+  NewWorkspaceComposerNameSection: () => null
+}))
+vi.mock('./new-workspace/NewWorkspaceComposerAgentSection', () => ({
+  NewWorkspaceComposerAgentSection: () => null
+}))
+vi.mock('./new-workspace/NewWorkspaceComposerAdvancedSection', () => ({
+  NewWorkspaceComposerAdvancedSection: () => null
+}))
+vi.mock('./new-workspace/NewWorkspaceComposerFooter', () => ({
+  NewWorkspaceComposerFooter: () => <textarea />
+}))
+
+const runtimeConnections = vi.hoisted(
+  () => new Map<string, { connectionStates: Map<string, { connectionGeneration: number }> }>()
+)
+const connections = vi.hoisted(() => new Map<string, { connectionGeneration: number }>())
+const prepare = vi.fn(async ({ paths }: { paths: string[] }) => ({ paths, failures: [] }))
+const cards: HTMLDivElement[] = []
+beforeEach(() => {
+  vi.clearAllMocks()
+  connections.clear()
+  runtimeConnections.clear()
+  uploads.importPaths.mockResolvedValue({
+    results: [
+      {
+        status: 'imported',
+        destPath: '/folder/.orca/drops/a.txt',
+        kind: 'file'
+      }
+    ]
+  })
+  vi.stubGlobal('api', {
+    fs: {
+      getPathForFile: (file: File) => `/drop/${file.name}`,
+      prepareDroppedPaths: prepare
+    }
+  })
+})
+afterEach(() => {
+  for (const card of cards.splice(0)) {
+    unmountCard(card)
+  }
+  vi.unstubAllGlobals()
+})
+async function card(
+  attach: (paths: string[], current: () => boolean) => Promise<void>,
+  path = '/repo'
+) {
+  const container = await renderCard({
+    selectedRepoPath: path,
+    selectedRepoExecutionHostId: 'local',
+    onNativeFileDrop: attach,
+    projectHostSetupOptions: []
+  })
+  cards.push(container)
+  return container
+}
+async function drop(container: HTMLDivElement) {
+  const event = new Event('drop', { bubbles: true, cancelable: true, composed: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
+  Object.defineProperty(event, 'dataTransfer', {
+    value: { types: ['Files'], files: [new File(['x'], 'a.txt')] }
+  })
+  await act(async () => {
+    container.querySelector('textarea')!.dispatchEvent(event)
+  })
+}
+describe('new workspace card file drop ownership', () => {
+  it.each([
+    ['/folder/source-repo', false],
+    ['/outside/source-repo', false],
+    ['/folder/source-repo', true],
+    ['/outside/source-repo', true]
+  ] as const)(
+    'uploads into the selected folder project with task source %s (changes during preparation: %s)',
+    async (sourcePath, changesSource) => {
+      const attach = vi.fn()
+      const group: ProjectGroup = {
+        id: 'folder-project',
+        name: 'Folder',
+        parentPath: '/folder',
+        connectionId: 'ssh-a',
+        parentGroupId: null,
+        createdFrom: 'manual',
+        tabOrder: 0,
+        isCollapsed: false,
+        color: null,
+        createdAt: 0,
+        updatedAt: 0
+      }
+      connections.set('ssh-a', { connectionGeneration: 1 })
+      const initialProps: { source: string } = { source: sourcePath }
+      const hook = renderHook(
+        ({ source }: { source: string }) => {
+          const target = resolveComposerAttachmentTarget({
+            selectedProjectGroup: group,
+            selectedRepoPath: source,
+            selectedRepoExecutionHostId: 'ssh:ssh-a',
+            selectedRepoSettings: {},
+            connectionId: 'ssh-a'
+          })
+          const dropState = useAttachmentDropState({
+            agentPromptRef: { current: '' },
+            cancelPromptCaretFrame: () => {},
+            promptCaretFrameRef: { current: null },
+            promptTextareaRef: createRef<HTMLTextAreaElement>(),
+            connectionId: target.connectionId,
+            selectedRepoPath: target.path ?? undefined,
+            selectedRepoSettings: target.settings,
+            setAgentPrompt: () => {},
+            setAttachmentPaths: attach
+          })
+          return useNewWorkspaceComposerFileDrop({
+            projectPath: target.path,
+            hostId: target.hostId,
+            connectionId: target.connectionId,
+            applyDrop: dropState.applyNativeDrop
+          })
+        },
+        { initialProps }
+      )
+      const owner = document.createElement('div')
+      const textarea = document.createElement('textarea')
+      owner.append(textarea)
+      document.body.append(owner)
+      act(() => hook.result.current(owner))
+      try {
+        const gate = Promise.withResolvers<{ paths: string[]; failures: never[] }>()
+        prepare.mockImplementationOnce(() => gate.promise)
+        await drop(owner)
+        if (changesSource) {
+          hook.rerender({ source: '/different-task-source' })
+        }
+        await act(async () => gate.resolve({ paths: ['/drop/a.txt'], failures: [] }))
+        expect(uploads.importPaths).toHaveBeenCalledExactlyOnceWith(
+          expect.objectContaining({ worktreePath: '/folder', connectionId: 'ssh-a' }),
+          ['/drop/a.txt'],
+          '/folder/.orca/drops',
+          expect.any(Object)
+        )
+        expect(attach).toHaveBeenCalledOnce()
+      } finally {
+        act(() => hook.result.current(null))
+        hook.unmount()
+        owner.remove()
+      }
+    }
+  )
+  it('delivers to the card under the cursor even when another card mounts later', async () => {
+    const first = vi.fn(async () => {})
+    const second = vi.fn(async () => {})
+    const a = await card(first, '/repo-a')
+    const b = await card(second, '/repo-b')
+    await drop(a)
+    expect(first).toHaveBeenCalledExactlyOnceWith(['/drop/a.txt'], expect.any(Function))
+    expect(second).not.toHaveBeenCalled()
+    await drop(b)
+    expect(second).toHaveBeenCalledExactlyOnceWith(['/drop/a.txt'], expect.any(Function))
+    unmountCard(b)
+    cards.splice(cards.indexOf(b), 1)
+    await drop(a)
+    expect(first).toHaveBeenCalledTimes(2)
+    expect(a.querySelector('[data-native-file-drop-target]')).toBeNull()
+  })
+  it('keeps a preparation captured for the original card when another card mounts', async () => {
+    const gate = Promise.withResolvers<{ paths: string[]; failures: never[] }>()
+    prepare.mockImplementationOnce(() => gate.promise)
+    const first = vi.fn(async () => {})
+    const second = vi.fn(async () => {})
+    const a = await card(first)
+    await drop(a)
+    await card(second)
+    await act(async () => gate.resolve({ paths: ['/prepared/a.txt'], failures: [] }))
+    expect(first).toHaveBeenCalledExactlyOnceWith(['/prepared/a.txt'], expect.any(Function))
+    expect(second).not.toHaveBeenCalled()
+  })
+  it('abandons a preparation when its card unmounts', async () => {
+    const gate = Promise.withResolvers<{ paths: string[]; failures: never[] }>()
+    prepare.mockImplementationOnce(() => gate.promise)
+    const attach = vi.fn(async () => {})
+    const a = await card(attach)
+    await drop(a)
+    unmountCard(a)
+    cards.splice(cards.indexOf(a), 1)
+    await act(async () => gate.resolve({ paths: ['/prepared/a.txt'], failures: [] }))
+    expect(attach).not.toHaveBeenCalled()
+  })
+  it.each(['project', 'host', 'connection', 'runtime connection'] as const)(
+    'refuses a captured destination after its %s changes',
+    async (change) => {
+      const gate = Promise.withResolvers<{ paths: string[]; failures: never[] }>()
+      prepare.mockImplementationOnce(() => gate.promise)
+      const applyDrop = vi.fn(async () => {})
+      connections.set('ssh-a', { connectionGeneration: 1 })
+      runtimeConnections.set('runtime-a', {
+        connectionStates: new Map([['ssh-a', { connectionGeneration: 1 }]])
+      })
+      const input: Parameters<typeof useNewWorkspaceComposerFileDrop>[0] = {
+        projectPath: '/repo',
+        hostId: change === 'runtime connection' ? 'runtime:runtime-a' : 'ssh:ssh-a',
+        connectionId: 'ssh-a',
+        applyDrop
+      }
+      const hook = renderHook(
+        (args: Parameters<typeof useNewWorkspaceComposerFileDrop>[0]) =>
+          useNewWorkspaceComposerFileDrop(args),
+        { initialProps: input }
+      )
+      const owner = document.createElement('div')
+      const target = document.createElement('textarea')
+      owner.append(target)
+      document.body.append(owner)
+      act(() => hook.result.current(owner))
+      const event = new Event('drop', { bubbles: true, cancelable: true, composed: true })
+      Object.defineProperty(event, 'isTrusted', { value: true })
+      Object.defineProperty(event, 'dataTransfer', {
+        value: { types: ['Files'], files: [new File(['x'], 'a.txt')] }
+      })
+      await act(async () => target.dispatchEvent(event))
+      if (change === 'runtime connection') {
+        runtimeConnections.set('runtime-a', {
+          connectionStates: new Map([['ssh-a', { connectionGeneration: 2 }]])
+        })
+      } else if (change === 'connection') {
+        connections.set('ssh-a', { connectionGeneration: 2 })
+      } else {
+        hook.rerender({
+          ...input,
+          projectPath: change === 'project' ? '/other' : input.projectPath,
+          hostId: change === 'host' ? 'local' : input.hostId
+        })
+      }
+      await act(async () => gate.resolve({ paths: ['/prepared/a.txt'], failures: [] }))
+      expect(applyDrop).not.toHaveBeenCalled()
+      act(() => hook.result.current(null))
+      hook.unmount()
+      owner.remove()
+    }
+  )
+})
diff --git a/src/renderer/src/components/NewWorkspaceComposerCard.quick-file-drop.test.tsx b/src/renderer/src/components/NewWorkspaceComposerCard.quick-file-drop.test.tsx
new file mode 100644
index 000000000000..f1d6517b48bc
--- /dev/null
+++ b/src/renderer/src/components/NewWorkspaceComposerCard.quick-file-drop.test.tsx
@@ -0,0 +1,115 @@
+// @vitest-environment happy-dom
+import { act, cleanup, render, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { useComposerState } from '@/hooks/useComposerState'
+import NewWorkspaceComposerCard from './NewWorkspaceComposerCard'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import type * as I18nModule from '@/i18n/i18n'
+import type * as ReactI18nextModule from 'react-i18next'
+
+vi.mock('@/components/contextual-tours/use-contextual-tour', () => ({
+  useContextualTour: () => {}
+}))
+vi.mock('@/i18n/i18n', async (importOriginal) => ({
+  ...(await importOriginal<typeof I18nModule>()),
+  translate: (_key: string, fallback: string) => fallback
+}))
+vi.mock('react-i18next', async (importOriginal) => ({
+  ...(await importOriginal<typeof ReactI18nextModule>()),
+  useTranslation: () => ({})
+}))
+
+const prepare = vi.fn(async ({ paths }: { paths: string[] }) => ({ paths, failures: [] }))
+const stat = vi.fn(async () => ({ isDirectory: false }))
+const onFileDrop = vi.fn<Window['api']['ui']['onFileDrop']>(() => () => {})
+beforeEach(() => {
+  vi.clearAllMocks()
+  vi.stubGlobal('api', {
+    fs: {
+      getPathForFile: (file: File) => `/drop/${file.name}`,
+      prepareDroppedPaths: prepare,
+      stat
+    },
+    ui: { onFileDrop },
+    gh: {
+      repoSlug: vi.fn(async () => null),
+      listWorkItems: vi.fn(async () => ({ items: [], hasMore: false }))
+    },
+    sparsePresets: { list: vi.fn(async () => []) },
+    worktrees: { listRetiredNames: vi.fn(async () => ({ names: [], exhaustedTiers: 0 })) },
+    preflight: { detectAgents: vi.fn(async () => []) }
+  })
+  useAppStore.setState({
+    repos: [
+      {
+        id: 'local-project',
+        path: '/project',
+        displayName: 'Project',
+        badgeColor: 'var(--muted-foreground)',
+        addedAt: 0
+      }
+    ],
+    activeRepoId: 'local-project',
+    activeModal: 'new-workspace-composer',
+    projects: [],
+    projectGroups: [],
+    projectHostSetups: [],
+    newWorkspaceDraft: null,
+    worktreesByRepo: {},
+    sparsePresetsByRepo: {}
+  })
+})
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+})
+
+type FileDragTransfer = { types: string[]; files: File[]; dropEffect: string }
+
+function gesture(target: Element, type: string, transfer: FileDragTransfer) {
+  const event = new Event(type, { bubbles: true, cancelable: true, composed: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
+  Object.defineProperty(event, 'dataTransfer', { value: transfer })
+  target.dispatchEvent(event)
+}
+
+describe('quick-create modal card without an attachment destination', () => {
+  it('refuses an OS drop with the selected local project and does not show an accepting ring', async () => {
+    const hook = renderHook(() =>
+      useComposerState({
+        initialRepoId: 'local-project',
+        persistDraft: false
+      })
+    )
+    expect(hook.result.current.cardProps.selectedRepoPath).toBe('/project')
+    expect(hook.result.current.cardProps.selectedRepoExecutionHostId).toBe('local')
+    const { container } = render(
+      <TooltipProvider>
+        <NewWorkspaceComposerCard
+          {...hook.result.current.cardProps}
+          composerRef={hook.result.current.composerRef}
+          onComposerNodeChange={hook.result.current.onComposerNodeChange}
+          onCreate={() => {}}
+          primaryActionLabel="Create workspace"
+          quickAgent={null}
+          onQuickAgentChange={() => {}}
+        />
+      </TooltipProvider>
+    )
+    const card = container.querySelector('[data-workspace-composer-root]')!
+    expect(container.querySelector('textarea')?.getAttribute('placeholder')).toBe('Write a note')
+    expect(container.querySelector('[data-attachment-path]')).toBeNull()
+    const transfer = { types: ['Files'], files: [new File(['x'], 'notes.txt')], dropEffect: 'link' }
+    await act(async () => {
+      gesture(card, 'dragenter', transfer)
+      gesture(card, 'dragover', transfer)
+    })
+    expect(transfer.dropEffect).toBe('none')
+    expect(card.className).not.toContain('ring-2')
+    await act(async () => gesture(card, 'drop', transfer))
+    expect(prepare).not.toHaveBeenCalled()
+    expect(stat).not.toHaveBeenCalled()
+    expect(hook.result.current.cardProps.attachmentPaths).toEqual([])
+  })
+})
diff --git a/src/renderer/src/components/NewWorkspaceComposerCard.test-fixture.tsx b/src/renderer/src/components/NewWorkspaceComposerCard.test-fixture.tsx
index c8eb2b56f436..32047cce15a4 100644
--- a/src/renderer/src/components/NewWorkspaceComposerCard.test-fixture.tsx
+++ b/src/renderer/src/components/NewWorkspaceComposerCard.test-fixture.tsx
@@ -1,9 +1,16 @@
 import React, { act } from 'react'
-import { createRoot } from 'react-dom/client'
+import { createRoot, type Root } from 'react-dom/client'
 import NewWorkspaceComposerCard from './NewWorkspaceComposerCard'
 import type { NewWorkspaceProjectOption } from '@/lib/new-workspace-project-options'
 import type { ProjectHostSetupOption } from '@/lib/project-host-setup-options'
 
+const cardRoots = new WeakMap<HTMLDivElement, Root>()
+export function unmountCard(container: HTMLDivElement): void {
+  act(() => cardRoots.get(container)?.unmount())
+  cardRoots.delete(container)
+  container.remove()
+}
+
 export const projectOptions: NewWorkspaceProjectOption[] = [
   {
     kind: 'project-group',
@@ -47,6 +54,7 @@ export async function renderCard(
   const container = document.createElement('div')
   document.body.appendChild(container)
   const root = createRoot(container)
+  cardRoots.set(container, root)
   act(() => {
     root.render(
       <NewWorkspaceComposerCard
diff --git a/src/renderer/src/components/NewWorkspaceComposerCard.tsx b/src/renderer/src/components/NewWorkspaceComposerCard.tsx
index 5dac7dc8246d..1f62bbd97493 100644
--- a/src/renderer/src/components/NewWorkspaceComposerCard.tsx
+++ b/src/renderer/src/components/NewWorkspaceComposerCard.tsx
@@ -36,6 +36,7 @@ import {
   type NewWorkspaceComposerCardProps
 } from './new-workspace/new-workspace-composer-card-props'
 import { getSshStatusLabel } from './new-workspace/new-workspace-composer-ssh-status'
+import { useNewWorkspaceComposerFileDrop } from './new-workspace/use-new-workspace-composer-file-drop'
 import { useComposerFileDragOver } from './new-workspace/use-composer-file-drag-over'
 
 // Why lazy: this pulls the ~41 KB project-location browser onto the boot graph, and nothing
@@ -83,6 +84,12 @@ export default function NewWorkspaceComposerCard(
   const projectHostSetupOptions = props.projectHostSetupOptions ?? EMPTY_PROJECT_HOST_SETUP_OPTIONS
   const ephemeralVmRecipes = props.ephemeralVmRecipes ?? EMPTY_EPHEMERAL_VM_RECIPES
   const { isFileDragOver, dragHandlers } = useComposerFileDragOver()
+  const attachDropOwner = useNewWorkspaceComposerFileDrop({
+    projectPath: props.selectedRepoPath,
+    hostId: selectedRepoExecutionHostId,
+    connectionId: props.selectedRepoConnectionId,
+    applyDrop: props.onNativeFileDrop
+  })
   const openModal = useAppStore((state) => state.openModal)
   const activeModal = useAppStore((state) => state.activeModal)
   const defaultTuiAgent = useAppStore((state) => state.settings?.defaultTuiAgent ?? null)
@@ -184,12 +191,13 @@ export default function NewWorkspaceComposerCard(
       if (!node) {
         cancelNameInputFocusFrame()
       }
+      attachDropOwner(node)
       if (composerRef) {
         composerRef.current = node
       }
       onComposerNodeChange?.(node)
     },
-    [cancelNameInputFocusFrame, composerRef, onComposerNodeChange]
+    [attachDropOwner, cancelNameInputFocusFrame, composerRef, onComposerNodeChange]
   )
   const focusNameInput = React.useCallback((): void => {
     cancelNameInputFocusFrame()
@@ -289,12 +297,15 @@ export default function NewWorkspaceComposerCard(
       ref={setComposerNode}
       data-workspace-composer-root="true"
       data-sparse-preset-editing={sparseEditing ? 'true' : undefined}
-      data-native-file-drop-target="composer"
       onDragEnter={dragHandlers.onDragEnter}
       onDragLeave={dragHandlers.onDragLeave}
       className={cn(
         'flex min-h-0 min-w-0 flex-1 flex-col gap-1 rounded-md transition',
-        isFileDragOver && 'ring-2 ring-ring/30',
+        isFileDragOver &&
+          props.selectedRepoPath &&
+          selectedRepoExecutionHostId &&
+          props.onNativeFileDrop &&
+          'ring-2 ring-ring/30',
         containerClassName
       )}
     >
diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index ffc16d429f1a..2dd6a57b55a0 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -13,11 +13,10 @@ import type { NativeChatResolvedTarget } from './native-chat-composer-target'
 import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
 import { nativeChatImageSendBlock } from './native-chat-image-reattach'
 import { useNativeChatComposerHandle } from './use-native-chat-composer-handle'
-import { useNativeChatExternalAttachments } from './use-native-chat-external-attachments'
+import { useNativeChatFileDrops } from './use-native-chat-file-drops'
 import { useNativeChatComposerKeyDown } from './use-native-chat-composer-keydown'
 import { useNativeChatSendLifecycle } from './use-native-chat-send-lifecycle'
 import { useNativeChatSessionOptions } from './use-native-chat-session-options'
-import { useNativeChatFileAttachmentActions } from './use-native-chat-file-attachment-actions'
 import { useNativeChatDictation } from './use-native-chat-dictation'
 import { useNativeChatSessionOptionCommand } from './use-native-chat-session-option-command'
 import { useNativeChatComposerCatalog } from './use-native-chat-composer-catalog'
@@ -31,7 +30,6 @@ import { useNativeChatPtyComposerSend } from './use-native-chat-pty-composer-sen
 import { useNativeChatHeldQueueComposerSend } from './use-native-chat-held-queue-composer-send'
 import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 import { useNativeChatComposerAppMenuSelection } from './use-native-chat-composer-app-menu-selection'
-import { useNativeChatWorkspaceFileDrop } from './use-native-chat-workspace-file-drop'
 import { useNativeChatComposerSubmit } from './use-native-chat-composer-submit'
 
 export type {
@@ -182,21 +180,17 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       clearImageAttachments,
       removeImageAttachment
     } = attachments
-    useNativeChatWorkspaceFileDrop({
-      terminalTabId,
-      structuredWorktreeId: structuredTransport?.worktreeId,
-      disabled,
-      paneKey,
-      attachResolvedPaths,
-      setNotice
-    })
     const imageBlock = nativeChatImageSendBlock(imageAttachments)
     const sendHeld = disabled || structuredTransport?.sendOut === true || imageBlock.holdsSend
     const sendButtonDisabled = isWorking
       ? !hasPty || !onStop
       : sendHeld || (draft.trim() === '' && imageAttachments.length === 0)
 
-    const { attachExternalPaths, resolveAttachmentOwner } = useNativeChatExternalAttachments({
+    const { pickAttachments, resolveAttachmentOwner } = useNativeChatFileDrops({
+      paneKey,
+      draftScopeKey,
+      targetPtyId,
+      structuredTransport,
       terminalTabId,
       structuredWorktreeId: structuredTransport?.worktreeId,
       structuredSession: structuredTransport,
@@ -232,7 +226,6 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       setNotice
     })
 
-    const { pickAttachments } = useNativeChatFileAttachmentActions(paneKey, attachExternalPaths)
     const dictation = useNativeChatDictation(textareaRef)
     const { dispatch: dispatchSessionOptionCommand, isDispatching: isDispatchingSessionOption } =
       useNativeChatSessionOptionCommand({
@@ -362,7 +355,6 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
 
     return (
       <NativeChatComposerField
-        dropScopeKey={paneKey}
         draftScopeKey={draftScopeKey}
         textareaRef={textareaRef}
         draft={draft}
diff --git a/src/renderer/src/components/native-chat/NativeChatComposerField.tsx b/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
index 3baa6557a8f0..0abc1c22bc63 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
@@ -2,9 +2,9 @@ import { NativeChatPromptEditor } from './NativeChatPromptEditor'
 import type { NativeChatComposerInput } from './native-chat-composer-input'
 import type { ClipboardEventHandler, KeyboardEventHandler, RefObject } from 'react'
 import { useLayoutEffect, useRef } from 'react'
+import { flushSync } from 'react-dom'
 import type { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 import { cn } from '@/lib/utils'
-import { NATIVE_FILE_DROP_TARGET } from '../../../../shared/native-file-drop'
 import type { ComposerAutocomplete, NativeChatPickerItem } from './native-chat-composer-state'
 import { NativeChatMentionMenu, NativeChatPickerMenu } from './NativeChatAutocompleteMenus'
 import type { NativeChatMentionFiles } from './use-native-chat-mention-files'
@@ -35,7 +35,6 @@ import { useNativeChatComposerDraftUnsaved } from './use-native-chat-draft-unsav
 export type NativeChatComposerFieldProps = {
   /** Pane identity published to the drop pipeline so a native file drop lands
    *  only in the composer it was dropped on. */
-  dropScopeKey: string
   /** Owner of the draft the editor's document is saved with. */
   draftScopeKey: string
   textareaRef: RefObject<NativeChatComposerInput | null>
@@ -129,7 +128,6 @@ function imeComposedSegment(base: string, settled: string): string {
 }
 
 export function NativeChatComposerField({
-  dropScopeKey,
   draftScopeKey,
   textareaRef,
   draft,
@@ -268,8 +266,6 @@ export function NativeChatComposerField({
             className="mb-1.5"
           />
           <div
-            data-native-file-drop-target={NATIVE_FILE_DROP_TARGET.composer}
-            data-composer-scope-key={dropScopeKey}
             className={cn(
               // Why: always-on hairline (token-level border, not focus ring) —
               // no focus/click border flash. The box is a container, not a
@@ -319,6 +315,11 @@ export function NativeChatComposerField({
                 }
               }}
               onCompositionStart={() => {
+                if (imeEnterGesture.isComposing()) {
+                  imeEnterGesture.setComposing(false)
+                  // Settle the interrupted composition before the new one takes browser ownership.
+                  flushSync(() => settleImeValue(textareaRef.current!))
+                }
                 compositionBaseRef.current = textareaRef.current!.value
                 imeEnterGesture.setComposing(true)
               }}
diff --git a/src/renderer/src/components/native-chat/NativeChatPaneFileDropSurface.tsx b/src/renderer/src/components/native-chat/NativeChatPaneFileDropSurface.tsx
index 64732a566e63..580054ae7739 100644
--- a/src/renderer/src/components/native-chat/NativeChatPaneFileDropSurface.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatPaneFileDropSurface.tsx
@@ -1,7 +1,9 @@
 import { createContext, useContext, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { Paperclip } from 'lucide-react'
 import { translate } from '@/i18n/i18n'
-import { NATIVE_FILE_DROP_TARGET } from '../../../../shared/native-file-drop'
+import { toast } from 'sonner'
+import { createOsFileDropSequence, useOsFileDropOwner } from '@/hooks/use-os-file-drop-owner'
+import { getNativeFileDropRejectionMessage } from '@/hooks/useGlobalFileDrop'
 import {
   makeNativeChatPaneFileDropHandlers,
   type NativeChatPaneDropClaim
@@ -11,7 +13,7 @@ import {
  *  event time, so a guarded composer answers for the drag in front of it. */
 export type NativeChatPaneDropRegistration = {
   getClaim: () => NativeChatPaneDropClaim
-  scopeKey: string
+  destinationKey: string
 }
 
 type RegisterPaneDropClaim = (registration: NativeChatPaneDropRegistration) => () => void
@@ -28,10 +30,10 @@ export function useNativeChatPaneFileDropClaim(claim: NativeChatPaneDropClaim):
   useLayoutEffect(() => {
     claimRef.current = claim
   })
-  const { scopeKey, disabled } = claim
+  const { destinationKey, disabled } = claim
   const registration = useMemo<NativeChatPaneDropRegistration>(
-    () => ({ getClaim: () => claimRef.current, scopeKey }),
-    [scopeKey]
+    () => ({ getClaim: () => claimRef.current, destinationKey }),
+    [destinationKey]
   )
   // A guard transition ends the current hover before the next paint.
   useLayoutEffect(() => register?.(registration), [disabled, register, registration])
@@ -46,6 +48,22 @@ export function NativeChatPaneFileDropSurface({
 }): React.JSX.Element {
   const [registration, setRegistration] = useState<NativeChatPaneDropRegistration | null>(null)
   const [isDragActive, setIsDragActive] = useState(false)
+  const ownerRef = useRef<HTMLElement | null>(null)
+  const [sequence] = useState(createOsFileDropSequence)
+  const attachOwner = useOsFileDropOwner(ownerRef, {
+    consumer: 'agent',
+    sequence,
+    canAccept: () => Boolean(registration && !registration.getClaim().disabled),
+    captureDestination: () => registration?.getClaim().captureExternalDrop(),
+    onDrop: async (prepared, { destination }) => {
+      setIsDragActive(false)
+      for (const failure of prepared.failures) {
+        const message = getNativeFileDropRejectionMessage(failure)
+        toast.error(message.title, { description: message.description })
+      }
+      await destination?.(prepared.paths)
+    }
+  })
   const register = useMemo<RegisterPaneDropClaim>(
     () => (next) => {
       setRegistration(next)
@@ -64,7 +82,7 @@ export function NativeChatPaneFileDropSurface({
       }),
     [registration]
   )
-  // Subscribe before hover renders: preload can consume a drop before that commit.
+  // End hover even when the gesture finishes outside this pane.
   useLayoutEffect(() => {
     if (!registration) {
       return
@@ -80,14 +98,7 @@ export function NativeChatPaneFileDropSurface({
 
   return (
     <NativeChatPaneFileDropContext.Provider value={register}>
-      <div
-        className={className}
-        // Why: the preload route reads the nearest marker, so publishing the
-        // composer's scope here is what widens an OS drop to the whole pane.
-        data-native-file-drop-target={registration ? NATIVE_FILE_DROP_TARGET.composer : undefined}
-        data-composer-scope-key={registration?.scopeKey}
-        {...handlers}
-      >
+      <div className={className} ref={attachOwner} {...handlers}>
         {children}
         {isDragActive ? <NativeChatPaneFileDropOverlay /> : null}
       </div>
diff --git a/src/renderer/src/components/native-chat/native-chat-attachment-upload.test.ts b/src/renderer/src/components/native-chat/native-chat-attachment-upload.test.ts
index e5468ef2c62e..e3c6892f4585 100644
--- a/src/renderer/src/components/native-chat/native-chat-attachment-upload.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-attachment-upload.test.ts
@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { getRepoExecutionHostId } from '../../../../shared/execution-host'
 import type { AppState } from '@/store/types'
 import type { TerminalTab } from '../../../../shared/terminal-tab-types'
 
@@ -53,10 +54,10 @@ function terminalTab(overrides: Partial<TerminalTab> = {}): TerminalTab {
 }
 
 function state(overrides: Partial<AppState> = {}): AppState {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: This fixture supplies every store slice read by the attachment owner resolver.
   return {
+    detectedWorktreesByRepo: {},
     folderWorkspaces: [],
-    getKnownWorktreeById: (worktreeId: string) =>
-      worktreeId === 'wt-1' ? ({ id: 'wt-1', path: '/repo/worktree' } as never) : undefined,
     projectGroups: [],
     repos: [{ id: 'repo', connectionId: null }],
     settings: { activeRuntimeEnvironmentId: null },
@@ -65,7 +66,18 @@ function state(overrides: Partial<AppState> = {}): AppState {
       'wt-1': [terminalTab()]
     },
     worktreesByRepo: {
-      repo: [{ id: 'wt-1', repoId: 'repo', path: '/repo/worktree' } as never]
+      repo: [
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: The owner resolver reads only the catalog identity, path and host fields supplied here.
+        {
+          id: 'wt-1',
+          repoId: 'repo',
+          path: '/repo/worktree',
+          hostId:
+            overrides.repos?.length === 0
+              ? undefined
+              : getRepoExecutionHostId(overrides.repos?.[0] ?? { connectionId: null })
+        } as never
+      ]
     },
     ...overrides
   } as AppState
@@ -128,13 +140,13 @@ describe('resolveNativeChatAttachmentOwner', () => {
     ).toEqual({ kind: 'runtime' })
   })
 
-  it('routes unowned repos to the focused runtime host, matching terminal drops', () => {
+  it('keeps a recorded local workspace local when a runtime is focused', () => {
     expect(
       resolveNativeChatAttachmentOwner(
         state({ settings: { activeRuntimeEnvironmentId: 'env-9' } as AppState['settings'] }),
         'tab-1'
       )
-    ).toEqual({ kind: 'runtime' })
+    ).toEqual({ kind: 'local' })
   })
 
   it('reports not-ready when the tab has no worktree owner', () => {
diff --git a/src/renderer/src/components/native-chat/native-chat-attachment-upload.ts b/src/renderer/src/components/native-chat/native-chat-attachment-upload.ts
index 7d9e0dfc6cf0..928a2c57dde9 100644
--- a/src/renderer/src/components/native-chat/native-chat-attachment-upload.ts
+++ b/src/renderer/src/components/native-chat/native-chat-attachment-upload.ts
@@ -7,8 +7,19 @@
 import { toast } from 'sonner'
 import { translate } from '@/i18n/i18n'
 import { extractIpcErrorMessage } from '@/lib/ipc-error'
+import { findKnownWorktreeById } from '@/store/slices/worktrees/listing/detected-worktree-meta'
+import {
+  parseExecutionHostId,
+  toRuntimeExecutionHostId,
+  toSshExecutionHostId,
+  type ExecutionHostId
+} from '../../../../shared/execution-host'
 import { getConnectionIdFromState } from '@/lib/connection-context'
-import { getRuntimeEnvironmentIdForWorktree } from '@/lib/worktree-runtime-owner'
+import {
+  getExplicitRuntimeEnvironmentIdForWorktree,
+  getKnownExecutionHostIdForWorktree
+} from '@/lib/worktree-runtime-owner'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
 import { getRuntimeEnvironmentRevision } from '@/runtime/runtime-environment-revision'
 import { callRuntimeRpc } from '@/runtime/runtime-rpc-client'
 import type { RuntimeStatus } from '../../../../shared/runtime-types'
@@ -21,10 +32,7 @@ import type {
 import type { AppState } from '@/store/types'
 import { reportTerminalDropUploadSkipsAndFailures } from '../terminal-pane/terminal-drop-upload-report'
 import { NATIVE_FILE_DROP_MAX_PATHS } from '../../../../shared/native-file-drop'
-import {
-  findTerminalTabWorktreeId,
-  resolveNativeChatFileLinkContext
-} from './native-chat-file-link'
+import { findTerminalTabWorktreeId } from './native-chat-file-link'
 import {
   captureDirectSshMutationExpectation,
   type DirectSshMutationExpectation
@@ -59,15 +67,16 @@ export type NativeChatAttachmentOwner =
 
 type NativeChatAttachmentOwnerState = Pick<
   AppState,
+  | 'detectedWorktreesByRepo'
+  | 'floatingWorkspacePath'
   | 'folderWorkspaces'
-  | 'getKnownWorktreeById'
   | 'projectGroups'
   | 'repos'
   | 'settings'
   | 'sshConnectionStates'
   | 'tabsByWorktree'
   | 'worktreesByRepo'
-> & { floatingWorkspacePath?: AppState['floatingWorkspacePath'] }
+>
 
 /** Resolve who owns the composer's backing worktree at attach time. Mirrors the
  *  terminal drop resolver's order: runtime owner first, then SSH vs local. */
@@ -79,27 +88,51 @@ export function resolveNativeChatAttachmentOwner(
   if (!worktreeId) {
     return { kind: 'not-ready' }
   }
-  return resolveNativeChatAttachmentOwnerForWorktree(state, worktreeId, terminalTabId)
+  return resolveNativeChatAttachmentOwnerForWorktree(state, worktreeId)
+}
+
+export function resolveNativeChatAttachmentHost(
+  state: NativeChatAttachmentOwnerState,
+  worktreeId: string
+): ExecutionHostId | null {
+  if (worktreeId === FLOATING_TERMINAL_WORKTREE_ID) {
+    return getKnownExecutionHostIdForWorktree(state, worktreeId)
+  }
+  const runtimeId = getExplicitRuntimeEnvironmentIdForWorktree(state, worktreeId)
+  const connectionId = getConnectionIdFromState(state, worktreeId)
+  if (!runtimeId && connectionId === undefined) {
+    return null
+  }
+  const hostId = runtimeId
+    ? toRuntimeExecutionHostId(runtimeId)
+    : connectionId
+      ? toSshExecutionHostId(connectionId)
+      : 'local'
+  return findKnownWorktreeById(state, worktreeId, hostId) ? hostId : null
 }
 
 export function resolveNativeChatAttachmentOwnerForWorktree(
   state: NativeChatAttachmentOwnerState,
-  worktreeId: string,
-  terminalTabId?: string
+  worktreeId: string
 ): NativeChatAttachmentOwner {
-  if (getRuntimeEnvironmentIdForWorktree(state, worktreeId)) {
+  const hostId = resolveNativeChatAttachmentHost(state, worktreeId)
+  if (!hostId) {
+    return { kind: 'not-ready' }
+  }
+  if (parseExecutionHostId(hostId)?.kind === 'runtime') {
     return { kind: 'runtime' }
   }
+  if (hostId === 'local') {
+    return { kind: 'local' }
+  }
   const connectionId = getConnectionIdFromState(state, worktreeId)
   if (connectionId === undefined) {
     return { kind: 'not-ready' }
   }
   if (connectionId === null) {
-    return { kind: 'local' }
+    return { kind: 'not-ready' }
   }
-  const worktreePath = terminalTabId
-    ? resolveNativeChatFileLinkContext(state, terminalTabId)?.worktreePath
-    : state.getKnownWorktreeById(worktreeId)?.path
+  const worktreePath = findKnownWorktreeById(state, worktreeId, hostId)?.path
   if (!worktreePath) {
     return { kind: 'not-ready' }
   }
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-autogrow.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-autogrow.test.tsx
index 2cd8c431982e..c55810547733 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-autogrow.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-autogrow.test.tsx
@@ -46,7 +46,6 @@ function TestField({
   const imeEnterGesture = useImeEnterGestureOwnership()
   return (
     <NativeChatComposerField
-      dropScopeKey="pane-test"
       draftScopeKey="pane-test"
       textareaRef={createRef<HTMLTextAreaElement>()}
       draft={draft}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-composition.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-composition.test.tsx
index ff44d3ef5724..1d94a92471f1 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-composition.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-composition.test.tsx
@@ -35,7 +35,6 @@ function TestField(props: TestFieldProps): React.JSX.Element {
 
 function fieldProps(overrides: Partial<TestFieldProps> = {}): TestFieldProps {
   return {
-    dropScopeKey: 'pane-test',
     draftScopeKey: 'pane-test',
     textareaRef: createRef<HTMLTextAreaElement>(),
     draft: '',
@@ -78,19 +77,12 @@ function textarea(): HTMLTextAreaElement {
   return screen.getByRole('textbox') as HTMLTextAreaElement
 }
 
-describe('native chat composer drop-scope marker', () => {
-  // The drop pipeline stops walking at the drop-target marker, so a scope key on
-  // any other element would never reach the payload.
-  it('publishes the pane key, not the draft key, on the same element as the drop-target marker', () => {
-    const view = render(
-      <TestField
-        {...fieldProps({ dropScopeKey: 'tab-7:pane-9', draftScopeKey: 'agent-session:session-9' })}
-      />
-    )
-    const marker = view.container.querySelector('[data-native-file-drop-target="composer"]')
-    expect(marker).not.toBeNull()
-    expect(marker?.getAttribute('data-composer-scope-key')).toBe('tab-7:pane-9')
-    expect(view.container.querySelectorAll('[data-composer-scope-key]')).toHaveLength(1)
+describe('native chat composer drop ownership', () => {
+  it('keeps the conversation editor key without publishing drop routing markers', () => {
+    const view = render(<TestField {...fieldProps({ draftScopeKey: 'agent-session:session-9' })} />)
+    expect(view.container.querySelector('[data-native-file-drop-target]')).toBeNull()
+    expect(view.container.querySelector('[data-composer-scope-key]')).toBeNull()
+    expect(view.container.querySelector('.ProseMirror')).not.toBeNull()
   })
 })
 
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
index bd87875d3031..d7affebe5fed 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
@@ -7,12 +7,13 @@ import { useRef, useState } from 'react'
 import type * as AttachmentUploadModule from './native-chat-attachment-upload'
 import type { NativeChatComposerInput } from './native-chat-composer-input'
 import { NativeChatPromptEditor } from './NativeChatPromptEditor'
-import { useNativeChatExternalAttachments } from './use-native-chat-external-attachments'
+import { useNativeChatFileDrops } from './use-native-chat-file-drops'
+import { NativeChatPaneFileDropSurface } from './NativeChatPaneFileDropSurface'
+import { useNewWorkspaceComposerFileDrop } from '../new-workspace/use-new-workspace-composer-file-drop'
 import { NativeChatImageAttachmentPreview } from './NativeChatImageAttachmentPreview'
+import { toast } from 'sonner'
 import { resetLocalImageSrcStateForTests } from '../editor/useLocalImageSrc'
-import { useComposerDropListener } from '../../hooks/composer-state/composer-drop-listener'
 import type { NativeFileDropPayload } from '../../../../shared/native-file-drop'
-import { useNativeChatFileAttachmentActions } from './use-native-chat-file-attachment-actions'
 import {
   clearNativeChatAttachmentCacheForTests,
   readNativeChatAttachmentCache,
@@ -30,7 +31,9 @@ const intake = vi.hoisted(() => ({
   owner: { kind: 'local' } as { kind: string; connectionId?: string },
   stat: vi.fn(),
   readFile: vi.fn(),
-  upload: vi.fn()
+  upload: vi.fn(),
+  prepare: vi.fn(async ({ paths }: { paths: string[] }) => ({ paths, failures: [] })),
+  pick: vi.fn()
 }))
 vi.mock('@/store', () => ({ useAppStore: { getState: () => ({ tabsByWorktree: {} }) } }))
 // Keeps the real notice strings so the silent-failure guards assert what users see.
@@ -44,6 +47,7 @@ vi.mock('electron', () => ({
   ipcRenderer: electron,
   webUtils: { getPathForFile: electron.getPathForFile }
 }))
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), loading: vi.fn(), dismiss: vi.fn() } }))
 vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
 vi.mock('@/runtime/runtime-terminal-inspection', () => ({ isRemoteRuntimePtyId: () => false }))
 
@@ -52,16 +56,18 @@ import {
   subscribeNativeFileDrop
 } from '../../../../preload/preload-runtime-support'
 
-// Uses the production drop listener, subscriber fan-out, attachment hook, and scope cache.
-function ComposerProbe({
+// Exercises real element delivery, path authorization and the draft attachment cache.
+function ComposerBody({
   pane,
   draft = pane,
-  hidden = false
+  hidden = false,
+  disabled = false
 }: {
   pane: string
   /** The draft's owner; a structured chat's composers share their conversation's. */
   draft?: string
   hidden?: boolean
+  disabled?: boolean
 }) {
   const textareaRef = useRef<NativeChatComposerInput>(null)
   const [notice, setNotice] = useState<string | null>(null)
@@ -69,7 +75,7 @@ function ComposerProbe({
     attachmentScopeKey: draft,
     allowWithoutTarget: true,
     caret: 0,
-    disabled: false,
+    disabled,
     isComposing: () => false,
     resolveTarget: () => null,
     textareaRef,
@@ -77,17 +83,19 @@ function ComposerProbe({
     setDraft: () => {},
     setNotice
   })
-  const { attachExternalPaths } = useNativeChatExternalAttachments({
+  const { pickAttachments } = useNativeChatFileDrops({
+    paneKey: pane,
+    draftScopeKey: draft,
+    targetPtyId: null,
     terminalTabId: pane,
-    disabled: false,
+    disabled,
     attachResolvedPaths: attachments.attachResolvedPaths,
     pendingChips: attachments.pendingChips,
     setNotice
   })
-  useNativeChatFileAttachmentActions(pane, attachExternalPaths)
   return (
     <div data-pane={pane} style={{ display: hidden ? 'none' : 'block' }}>
-      <div data-native-file-drop-target="composer" data-composer-scope-key={pane}>
+      <div>
         <NativeChatPromptEditor
           scopeKey={draft}
           inputRef={textareaRef}
@@ -106,11 +114,20 @@ function ComposerProbe({
         />
       ))}
       <output>{JSON.stringify(attachments.imageAttachments.map(({ path }) => path))}</output>
+      <button onClick={pickAttachments}>Attach to {pane}</button>
       <output data-notice={pane}>{notice}</output>
     </div>
   )
 }
 
+function ComposerProbe(props: React.ComponentProps<typeof ComposerBody>) {
+  return (
+    <NativeChatPaneFileDropSurface className="chat-pane">
+      <ComposerBody {...props} />
+    </NativeChatPaneFileDropSurface>
+  )
+}
+
 /** The external-attach loop awaits once per path; drain those before asserting. */
 async function settleAttachments(): Promise<void> {
   await act(async () => {
@@ -122,6 +139,7 @@ async function settleAttachments(): Promise<void> {
 
 async function dropTwoImages(target: Element): Promise<void> {
   const event = new Event('drop', { bubbles: true, cancelable: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
   Object.defineProperty(event, 'dataTransfer', {
     value: {
       types: ['Files'],
@@ -133,9 +151,18 @@ async function dropTwoImages(target: Element): Promise<void> {
   })
 }
 
-function WorkspaceComposerProbe({ onDrop }: { onDrop: (paths: string[]) => void }) {
-  useComposerDropListener(onDrop)
-  return <div data-native-file-drop-target="composer" data-workspace-composer="true" />
+function WorkspaceComposerProbe({
+  onDrop
+}: {
+  onDrop: (paths: string[], current: () => boolean) => void
+}) {
+  const owner = useNewWorkspaceComposerFileDrop({
+    projectPath: '/repo',
+    hostId: 'local',
+    connectionId: null,
+    applyDrop: async (paths, current) => onDrop(paths, current)
+  })
+  return <div ref={owner} data-workspace-composer="true" />
 }
 
 describe('native chat composer drop scoping', () => {
@@ -153,7 +180,15 @@ describe('native chat composer drop scoping', () => {
     })
     Object.defineProperty(window, 'api', {
       configurable: true,
-      value: { ui: { onFileDrop: subscribeNativeFileDrop }, fs: intake }
+      value: {
+        ui: { onFileDrop: subscribeNativeFileDrop },
+        shell: { pickAttachments: intake.pick },
+        fs: {
+          ...intake,
+          getPathForFile: electron.getPathForFile,
+          prepareDroppedPaths: intake.prepare
+        }
+      }
     })
     installNativeFileDropHandlers()
     // Repeated preload setup must stay singleton or every OS drop is processed once per install.
@@ -166,6 +201,8 @@ describe('native chat composer drop scoping', () => {
     intake.stat.mockReset().mockResolvedValue(undefined)
     intake.readFile.mockReset().mockResolvedValue({ content: '', isBinary: false })
     intake.upload.mockReset()
+    intake.prepare.mockReset().mockImplementation(async ({ paths }) => ({ paths, failures: [] }))
+    intake.pick.mockReset()
     vi.stubGlobal('IntersectionObserver', undefined)
   })
 
@@ -175,6 +212,59 @@ describe('native chat composer drop scoping', () => {
     vi.unstubAllGlobals()
     clearNativeChatAttachmentCacheForTests()
     electron.send.mockClear()
+    vi.clearAllMocks()
+  })
+
+  it('keeps the paperclip picker attached to its own chat', async () => {
+    intake.pick.mockResolvedValue(['/picked/image.png'])
+    const view = render(
+      <>
+        <ComposerProbe pane="chat-a" />
+        <ComposerProbe pane="chat-b" hidden />
+      </>
+    )
+    await act(async () => screen.getByText('Attach to chat-a').click())
+    await settleAttachments()
+    expect(intake.pick).toHaveBeenCalledOnce()
+    expect(intake.stat).toHaveBeenCalledExactlyOnceWith({
+      filePath: '/picked/image.png',
+      access: { kind: 'user-file' }
+    })
+    expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
+      '/picked/image.png'
+    ])
+    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(view.container.querySelector('[data-notice="chat-a"]')?.textContent).toBe('')
+  })
+  it('keeps a cancelled paperclip picker quiet', async () => {
+    intake.pick.mockResolvedValue([])
+    render(<ComposerProbe pane="chat-a" />)
+    await act(async () => screen.getByText('Attach to chat-a').click())
+    expect(intake.stat).not.toHaveBeenCalled()
+    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+  it('captures the host before preparation and refuses a changed host before upload', async () => {
+    const gate = Promise.withResolvers<{ paths: string[]; failures: never[] }>()
+    intake.prepare.mockImplementationOnce(() => gate.promise)
+    const view = render(<ComposerProbe pane="chat-a" />)
+    await dropTwoImages(view.container.querySelector('.ProseMirror')!)
+    intake.owner = { kind: 'ssh', connectionId: 'other-host' }
+    await act(async () => gate.resolve({ paths: ['/prepared/a.png'], failures: [] }))
+    expect(intake.stat).not.toHaveBeenCalled()
+    expect(intake.upload).not.toHaveBeenCalled()
+    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
+  })
+  it('refuses preparation captured for a draft that changed in the same pane', async () => {
+    const gate = Promise.withResolvers<{ paths: string[]; failures: never[] }>()
+    intake.prepare.mockImplementationOnce(() => gate.promise)
+    const view = render(<ComposerProbe pane="chat-a" draft="session-a" />)
+    await dropTwoImages(view.container.querySelector('.ProseMirror')!)
+    view.rerender(<ComposerProbe pane="chat-a" draft="session-b" />)
+    await act(async () => gate.resolve({ paths: ['/prepared/a.png'], failures: [] }))
+    expect(readNativeChatAttachmentCache('session-a')).toEqual([])
+    expect(readNativeChatAttachmentCache('session-b')).toEqual([])
+    expect(intake.stat).not.toHaveBeenCalled()
   })
 
   // #15782: an OS drop that produces nothing must say so. Every assertion here
@@ -185,12 +275,11 @@ describe('native chat composer drop scoping', () => {
 
     await dropTwoImages(view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!)
 
-    expect(electron.send).toHaveBeenCalledExactlyOnceWith('terminal:file-dropped-from-preload', {
-      byteLength: 0,
-      pathCount: 2,
-      reason: 'unresolved-paths',
-      target: 'rejected'
-    })
+    expect(toast.error).toHaveBeenCalledWith(
+      "Orca couldn't read a path for the dropped files.",
+      expect.any(Object)
+    )
+    expect(electron.send).not.toHaveBeenCalled()
     expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
   })
 
@@ -235,11 +324,8 @@ describe('native chat composer drop scoping', () => {
     const target = view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!
     await dropTwoImages(target)
 
-    expect(electron.send).toHaveBeenCalledExactlyOnceWith('terminal:file-dropped-from-preload', {
-      target: 'composer',
-      scopeKey: 'chat-a',
-      paths: ['/repro/first.png', '/repro/second.png']
-    })
+    expect(electron.send).not.toHaveBeenCalled()
+    expect(view.container.querySelector('[data-composer-scope-key]')).toBeNull()
     expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
       '/repro/first.png',
       '/repro/second.png'
@@ -263,11 +349,8 @@ describe('native chat composer drop scoping', () => {
     await dropTwoImages(view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!)
     await settleAttachments()
 
-    expect(electron.send).toHaveBeenCalledExactlyOnceWith('terminal:file-dropped-from-preload', {
-      target: 'composer',
-      scopeKey: 'chat-a',
-      paths: ['/repro/first.png', '/repro/second.png']
-    })
+    expect(electron.send).not.toHaveBeenCalled()
+    expect(view.container.querySelector('[data-composer-scope-key]')).toBeNull()
     expect(readNativeChatAttachmentCache('agent-session:s1').map(({ path }) => path)).toEqual([
       '/repro/first.png',
       '/repro/second.png'
@@ -344,11 +427,7 @@ describe('native chat composer drop scoping', () => {
         <ComposerProbe pane="chat-b" hidden />
       </>
     )
-    await dropTwoImages(
-      view.container.querySelector(
-        '[data-pane="chat-a"] [data-native-file-drop-target="composer"]'
-      )!
-    )
+    await dropTwoImages(view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!)
     expect(await screen.findByRole('img', { name: 'first.png' })).toBeTruthy()
     expect(await screen.findByRole('img', { name: 'second.png' })).toBeTruthy()
     expect(intake.stat.mock.calls).toEqual([
@@ -386,23 +465,6 @@ describe('native chat composer drop scoping', () => {
     expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
   })
 
-  // Mirrors the terminal target, whose leaf id sits inside its drop-target marker.
-  it('reads a scope key published inside the drop-target marker', async () => {
-    const view = render(
-      <div data-native-file-drop-target="composer">
-        <div data-composer-scope-key="chat-a">
-          <span data-inner-drop-point="true" />
-        </div>
-      </div>
-    )
-    await dropTwoImages(view.container.querySelector('[data-inner-drop-point="true"]')!)
-    expect(electron.send).toHaveBeenCalledExactlyOnceWith('terminal:file-dropped-from-preload', {
-      target: 'composer',
-      scopeKey: 'chat-a',
-      paths: ['/repro/first.png', '/repro/second.png']
-    })
-  })
-
   it('control: an editor-targeted drop does not attach images to either chat', async () => {
     const view = render(
       <>
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-field-resume.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-field-resume.test.tsx
index 1f878175754d..d0889a1a542c 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-field-resume.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-field-resume.test.tsx
@@ -71,7 +71,6 @@ function TestField({
   const textareaRef = useRef<HTMLTextAreaElement>(null)
   return (
     <NativeChatComposerField
-      dropScopeKey="pane-test"
       draftScopeKey="pane-test"
       textareaRef={textareaRef}
       draft={draft}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-ime-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-ime-file-drop.test.tsx
new file mode 100644
index 000000000000..3687e99afb93
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-composer-ime-file-drop.test.tsx
@@ -0,0 +1,261 @@
+// @vitest-environment happy-dom
+
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { useRef, useState } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ExecutionHostId } from '../../../../shared/execution-host'
+import type * as AttachmentUploadModule from './native-chat-attachment-upload'
+import type { NativeChatComposerInput } from './native-chat-composer-input'
+import { NativeChatComposerField } from './NativeChatComposerField'
+import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
+import { useNativeChatComposerNotice } from './use-native-chat-composer-notice'
+import { useNativeChatFileDrops } from './use-native-chat-file-drops'
+import { NativeChatPaneFileDropSurface } from './NativeChatPaneFileDropSurface'
+import { useNativeChatDraft } from './use-native-chat-draft'
+import { clearNativeChatDraftCacheForTests } from './native-chat-draft-cache'
+import { changePrompt, promptValue } from './native-chat-prompt-editor.test-support'
+import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
+
+const testState: {
+  executionHostId: ExecutionHostId
+  ownerConnectionId: string
+  ownerKind: 'local' | 'not-ready' | 'runtime' | 'ssh'
+  ownerSshGeneration: number
+  ownerWorktreePath: string
+  targetIsRemoteRuntime: boolean
+  store: { tabsByWorktree: Record<string, { id: string }[]> }
+} = vi.hoisted(() => ({
+  executionHostId: 'local',
+  ownerConnectionId: 'ssh-1',
+  ownerKind: 'local',
+  ownerSshGeneration: 4,
+  ownerWorktreePath: '/remote/repo',
+  targetIsRemoteRuntime: false,
+  store: {
+    tabsByWorktree: {
+      'worktree-1': [{ id: 'terminal-tab-1' }]
+    }
+  }
+}))
+
+vi.mock('@/store', () => {
+  const useAppStore = (selector: (state: typeof testState.store) => unknown) =>
+    selector(testState.store)
+  useAppStore.getState = () => testState.store
+  return { useAppStore }
+})
+vi.mock('@/lib/worktree-runtime-owner', () => ({
+  getExecutionHostIdForWorktree: () => testState.executionHostId
+}))
+// Real notice strings, so a copy of the wording here cannot outlive the string
+// users actually read, and a newly added export cannot go missing from the mock.
+vi.mock('./native-chat-attachment-upload', async (importOriginal) => ({
+  ...(await importOriginal<typeof AttachmentUploadModule>()),
+  resolveNativeChatAttachmentHost: () => testState.executionHostId,
+  resolveNativeChatAttachmentOwnerForWorktree: () =>
+    testState.ownerKind === 'ssh'
+      ? {
+          kind: 'ssh',
+          connectionId: testState.ownerConnectionId,
+          worktreePath: testState.ownerWorktreePath,
+          expectedExecutionHostId: `ssh:${testState.ownerConnectionId}`,
+          expectedSshTargetId: testState.ownerConnectionId,
+          expectedSshConnectionGeneration: testState.ownerSshGeneration
+        }
+      : { kind: testState.ownerKind }
+}))
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string) => fallback
+}))
+vi.mock('@/runtime/runtime-terminal-inspection', () => ({
+  isRemoteRuntimePtyId: () => testState.targetIsRemoteRuntime
+}))
+vi.mock('./NativeChatComposerActions', () => ({
+  NativeChatComposerActions: () => <div data-testid="composer-actions" />
+}))
+vi.mock('./NativeChatAutocompleteMenus', () => ({
+  NativeChatMentionMenu: () => null,
+  NativeChatPickerMenu: () => null
+}))
+vi.mock('./NativeChatImageAttachmentPreview', () => ({
+  NativeChatImageAttachmentPreview: ({
+    attachment
+  }: {
+    attachment: { connectionId?: string; path: string }
+  }) => (
+    <output data-image-attachment data-connection-id={attachment.connectionId}>
+      {attachment.path}
+    </output>
+  )
+}))
+
+type ProbeProps = {
+  disabled?: boolean
+  initialDraft?: string
+  structured?: boolean
+  /** Overrides only the structured target, leaving the pane's scope key alone. */
+  structuredWorkspaceId?: string
+  workspaceId?: string
+}
+
+const bubbledDrop = vi.fn()
+
+function ComposerProbe({
+  disabled = false,
+  initialDraft = '',
+  structured = true,
+  structuredWorkspaceId,
+  workspaceId = 'worktree-1'
+}: ProbeProps): React.JSX.Element {
+  const [caret, setCaret] = useState(initialDraft.length)
+  const { notices, setNotice } = useNativeChatComposerNotice()
+  const inputRef = useRef<NativeChatComposerInput>(null)
+  const imeEnterGesture = useImeEnterGestureOwnership()
+  const { draft, setDraft, flushDraftAppends } = useNativeChatDraft(
+    `pane:${workspaceId}`,
+    imeEnterGesture.isComposing
+  )
+  const attachments = useNativeChatComposerAttachments({
+    attachmentScopeKey: `pane:${workspaceId}`,
+    allowWithoutTarget: structured,
+    caret,
+    disabled,
+    isComposing: imeEnterGesture.isComposing,
+    resolveTarget: () =>
+      structured ? null : { ptyId: 'pty-1', settings: { activeRuntimeEnvironmentId: null } },
+    textareaRef: inputRef,
+    setCaret,
+    setDraft,
+    setNotice
+  })
+  useNativeChatFileDrops({
+    paneKey: `pane:${workspaceId}`,
+    draftScopeKey: `pane:${workspaceId}`,
+    targetPtyId: 'pty-1',
+    terminalTabId: 'terminal-tab-1',
+    structuredWorktreeId: structured ? (structuredWorkspaceId ?? workspaceId) : undefined,
+    disabled,
+    attachResolvedPaths: attachments.attachResolvedPaths,
+    pendingChips: attachments.pendingChips,
+    setNotice
+  })
+
+  return (
+    <div onDrop={bubbledDrop}>
+      <div>
+        <NativeChatComposerField
+          draftScopeKey={`pane:${workspaceId}`}
+          textareaRef={inputRef}
+          draft={draft}
+          disabled={disabled}
+          hasPty
+          canSend={!disabled}
+          autocomplete={{ mode: 'none' }}
+          activeSuggestion={0}
+          notices={notices}
+          imageAttachments={attachments.imageAttachments}
+          sendButtonDisabled={false}
+          isWorking={false}
+          attachDisabled={disabled}
+          dictationDisabled
+          isDictating={false}
+          isDictationHoldMode={false}
+          imeEnterGesture={imeEnterGesture}
+          onDraftChange={(value, input) => {
+            setDraft(value)
+            setCaret(input.selectionStart ?? value.length)
+          }}
+          onTextareaSelect={(input) => setCaret(input.selectionStart ?? input.value.length)}
+          onKeyDown={() => {}}
+          onImeSettled={(input) => {
+            setDraft(input.value)
+            flushDraftAppends()
+            attachments.flushPendingAttachments()
+          }}
+          onPaste={() => {}}
+          pickerListboxId="picker"
+          onChoosePickerItem={() => {}}
+          onRetrySkills={() => {}}
+          onChooseMentionFile={() => {}}
+          mentionFiles={{ files: [], loading: false, failed: false }}
+          onRemoveImageAttachment={attachments.removeImageAttachment}
+          onAttach={() => {}}
+          onDictationToggle={() => {}}
+          onDictationHoldStart={() => {}}
+          onDictationHoldEnd={() => {}}
+          onSend={() => {}}
+          sessionOptionsSurface={null}
+          sessionOptionsSnapshot={[]}
+        />
+      </div>
+      <output data-testid="draft">{draft}</output>
+    </div>
+  )
+}
+
+const prepare = vi.fn(async ({ paths }: { paths: string[] }) => ({ paths, failures: [] }))
+beforeEach(() => {
+  vi.clearAllMocks()
+  clearNativeChatDraftCacheForTests()
+  vi.stubGlobal('api', {
+    fs: {
+      getPathForFile: (file: File) => `/drop/${file.name}`,
+      prepareDroppedPaths: prepare,
+      stat: vi.fn(async () => ({ isDirectory: false }))
+    }
+  })
+})
+afterEach(() => {
+  cleanup()
+  clearNativeChatDraftCacheForTests()
+  vi.unstubAllGlobals()
+})
+
+async function osDrop(target: HTMLElement) {
+  const event = new Event('drop', { bubbles: true, cancelable: true, composed: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
+  Object.defineProperty(event, 'dataTransfer', {
+    value: {
+      types: ['Files'],
+      files: [new File(['notes'], 'notes.txt')]
+    }
+  })
+  await act(async () => target.dispatchEvent(event))
+}
+
+describe('OS file drops through the real composing chat field', () => {
+  it.each(['commit', 'double commit', 'cancel', 'blur', 'blur then commit', 'restart'])(
+    'settles one drop exactly once on %s and never replays it in a later composition',
+    async (ending) => {
+      render(
+        <NativeChatPaneFileDropSurface className="chat">
+          <ComposerProbe />
+        </NativeChatPaneFileDropSurface>
+      )
+      const editor = screen.getByRole('textbox')
+      fireEvent.compositionStart(editor)
+      changePrompt(editor, 'ni')
+      await osDrop(editor)
+      expect(promptValue(editor)).toBe('ni')
+      if (ending === 'cancel') {
+        changePrompt(editor, '')
+      }
+      if (ending === 'blur' || ending === 'blur then commit') {
+        fireEvent.blur(editor)
+      }
+      if (ending === 'restart') {
+        fireEvent.compositionStart(editor)
+      } else if (ending !== 'blur') {
+        fireEvent.compositionEnd(editor, { data: ending === 'cancel' ? '' : 'ni' })
+      }
+      if (ending === 'double commit') {
+        fireEvent.compositionEnd(editor, { data: 'ni' })
+      }
+      expect(promptValue(editor).match(/@\/drop\/notes.txt/g)).toHaveLength(1)
+      expect(prepare).toHaveBeenCalledOnce()
+      fireEvent.compositionStart(editor)
+      fireEvent.compositionEnd(editor, { data: 'later' })
+      expect(promptValue(editor).match(/@\/drop\/notes.txt/g)).toHaveLength(1)
+    }
+  )
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx
index 70eb93599874..ac039ffb7c16 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx
@@ -52,6 +52,7 @@ vi.mock('@/lib/worktree-runtime-owner', () => ({
 // users actually read, and a newly added export cannot go missing from the mock.
 vi.mock('./native-chat-attachment-upload', async (importOriginal) => ({
   ...(await importOriginal<typeof AttachmentUploadModule>()),
+  resolveNativeChatAttachmentHost: () => testState.executionHostId,
   resolveNativeChatAttachmentOwnerForWorktree: () =>
     testState.ownerKind === 'ssh'
       ? {
@@ -151,7 +152,6 @@ function ComposerProbe({
     terminalTabId: 'terminal-tab-1',
     structuredWorktreeId: structured ? (structuredWorkspaceId ?? workspaceId) : undefined,
     disabled,
-    paneKey: `pane:${workspaceId}`,
     attachResolvedPaths: attachments.attachResolvedPaths,
     setNotice
   })
@@ -165,7 +165,6 @@ function ComposerProbe({
           on a bare wrapper so the drop logic is exercised on its own. */}
       <div {...workspaceFileDropHandlers}>
         <NativeChatComposerField
-          dropScopeKey={`pane:${workspaceId}`}
           draftScopeKey={`pane:${workspaceId}`}
           textareaRef={inputRef}
           draft={draft}
diff --git a/src/renderer/src/components/native-chat/native-chat-element-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-element-file-drop.test.tsx
new file mode 100644
index 000000000000..91890bc2aa7f
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-element-file-drop.test.tsx
@@ -0,0 +1,268 @@
+// @vitest-environment happy-dom
+import { act, cleanup, fireEvent, render } from '@testing-library/react'
+import { useRef, useState } from 'react'
+import { createPortal } from 'react-dom'
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { toast } from 'sonner'
+import type { NativeChatComposerInput } from './native-chat-composer-input'
+import {
+  NativeChatPaneFileDropSurface,
+  useNativeChatPaneFileDropClaim
+} from './NativeChatPaneFileDropSurface'
+import { NativeChatPromptEditor } from './NativeChatPromptEditor'
+import { useNewWorkspaceComposerFileDrop } from '../new-workspace/use-new-workspace-composer-file-drop'
+
+const electron = vi.hoisted(() => ({
+  on: vi.fn(),
+  removeListener: vi.fn(),
+  send: vi.fn(),
+  getPathForFile: vi.fn((file: File) => `/drop/${file.name}`)
+}))
+vi.mock('electron', () => ({
+  ipcRenderer: electron,
+  webUtils: { getPathForFile: electron.getPathForFile }
+}))
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+import { installNativeFileDropHandlers } from '../../../../preload/preload-runtime-support'
+
+const prepare = vi.fn(async ({ paths }: { paths: string[] }) => ({ paths, failures: [] }))
+function Composer({
+  attach,
+  disabled = false
+}: {
+  attach: (paths: string[]) => void
+  disabled?: boolean
+}) {
+  const input = useRef<NativeChatComposerInput>(null)
+  useNativeChatPaneFileDropClaim({
+    destinationKey: 'draft',
+    disabled,
+    onDragOverCapture: () => {},
+    onDropCapture: () => {},
+    captureExternalDrop: () => async (paths) => attach(paths)
+  })
+  return (
+    <NativeChatPromptEditor
+      scopeKey="draft"
+      inputRef={input}
+      initialValue="Original"
+      disabled={disabled}
+      placeholder="Message"
+      onChange={() => {}}
+      onSelect={() => {}}
+    />
+  )
+}
+function Chat({
+  attach,
+  hidden = false,
+  disabled = false
+}: {
+  attach: (paths: string[]) => void
+  hidden?: boolean
+  disabled?: boolean
+}) {
+  return (
+    <div style={{ display: hidden ? 'none' : 'block' }}>
+      <NativeChatPaneFileDropSurface className="chat">
+        <Composer attach={attach} disabled={disabled} />
+      </NativeChatPaneFileDropSurface>
+    </div>
+  )
+}
+async function drop(target: Element, types = ['Files']) {
+  const event = new Event('drop', { bubbles: true, cancelable: true, composed: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
+  Object.defineProperty(event, 'dataTransfer', {
+    value: {
+      types,
+      files: [new File(['x'], 'a.png')],
+      getData: (type: string) => (type === 'text/html' ? '<b>Injected</b>' : '')
+    }
+  })
+  await act(async () => {
+    target.dispatchEvent(event)
+  })
+  return event
+}
+function dragEvent(target: Element, type: string, transfer: { dropEffect: string }): Event {
+  const event = new Event(type, { bubbles: true, cancelable: true, composed: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
+  Object.defineProperty(event, 'dataTransfer', { value: transfer })
+  target.dispatchEvent(event)
+  return event
+}
+function negotiateAndRelease(target: Element) {
+  const transfer = { types: ['Files'], files: [new File(['x'], 'a.png')], dropEffect: 'move' }
+  const hover = dragEvent(target, 'dragover', transfer)
+  const release = dragEvent(target, transfer.dropEffect === 'none' ? 'dragleave' : 'drop', transfer)
+  return { hover, release, transfer }
+}
+function AvailabilityComposer({ attach }: { attach: (paths: string[]) => void }) {
+  const [disabled, setDisabled] = useState(true)
+  return (
+    <>
+      <button onClick={() => setDisabled((value) => !value)}>Toggle availability</button>
+      <Composer attach={attach} disabled={disabled} />
+    </>
+  )
+}
+function WorkspaceWithoutPath({ attach }: { attach: () => Promise<void> }) {
+  const owner = useNewWorkspaceComposerFileDrop({
+    projectPath: null,
+    hostId: 'local',
+    connectionId: null,
+    applyDrop: attach
+  })
+  return <div ref={owner} className="workspace-card" />
+}
+beforeAll(() => installNativeFileDropHandlers())
+beforeEach(() => {
+  vi.clearAllMocks()
+  vi.stubGlobal('api', {
+    fs: { getPathForFile: electron.getPathForFile, prepareDroppedPaths: prepare }
+  })
+})
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+})
+
+describe('element-owned native chat drops', () => {
+  it('attaches to visible chat A while mounted chat B is hidden, without scope markers', async () => {
+    const a = vi.fn()
+    const b = vi.fn()
+    const view = render(
+      <>
+        <Chat attach={a} />
+        <Chat attach={b} hidden />
+      </>
+    )
+    const target = view.container.querySelector('.ProseMirror')!
+    await drop(target)
+    expect(a).toHaveBeenCalledExactlyOnceWith(['/drop/a.png'])
+    expect(b).not.toHaveBeenCalled()
+    expect(view.container.querySelector('[data-composer-scope-key]')).toBeNull()
+    expect(electron.send).not.toHaveBeenCalled()
+  })
+  it('shows the attachment overlay on dragover while the chat can accept files', async () => {
+    const attach = vi.fn()
+    const view = render(<Chat attach={attach} />)
+    const target = view.container.querySelector('.ProseMirror')!
+    const transfer = { types: ['Files'], dropEffect: 'move' }
+    await act(async () => dragEvent(target, 'dragover', transfer))
+    expect(transfer.dropEffect).toBe('copy')
+    expect(view.getByText('Drop to attach to this chat')).toBeTruthy()
+    await drop(target)
+    expect(view.queryByText('Drop to attach to this chat')).toBeNull()
+    expect(attach).toHaveBeenCalledExactlyOnceWith(['/drop/a.png'])
+  })
+  it('claims a portaled chat inside a legacy terminal while the terminal outside stays legacy exactly once', async () => {
+    const attach = vi.fn()
+    const terminal = document.createElement('div')
+    terminal.dataset.nativeFileDropTarget = 'terminal'
+    terminal.dataset.terminalTabId = 'terminal-a'
+    document.body.append(terminal)
+    const terminalDrop = vi.fn()
+    terminal.addEventListener('drop', terminalDrop)
+    try {
+      render(createPortal(<Chat attach={attach} />, terminal))
+      await drop(terminal.querySelector('.ProseMirror')!)
+      expect(attach).toHaveBeenCalledExactlyOnceWith(['/drop/a.png'])
+      expect(terminalDrop).not.toHaveBeenCalled()
+      expect(electron.send).not.toHaveBeenCalled()
+      await drop(terminal)
+      expect(electron.send).toHaveBeenCalledExactlyOnceWith('terminal:file-dropped-from-preload', {
+        target: 'terminal',
+        tabId: 'terminal-a',
+        paths: ['/drop/a.png']
+      })
+      expect(attach).toHaveBeenCalledOnce()
+    } finally {
+      terminal.remove()
+    }
+  })
+  it.each([false, true])(
+    'refuses by cursor only through dragover and release when composer disabled is %s',
+    async (disabled) => {
+      const attach = vi.fn()
+      const view = render(
+        <div data-native-file-drop-target="terminal">
+          <NativeChatPaneFileDropSurface className="chat">
+            {disabled ? <Composer attach={attach} disabled /> : <span>Question</span>}
+          </NativeChatPaneFileDropSurface>
+        </div>
+      )
+      const target = view.container.querySelector('.chat')!
+      let gesture: ReturnType<typeof negotiateAndRelease> | undefined
+      await act(async () => {
+        gesture = negotiateAndRelease(target)
+      })
+      expect(gesture?.hover.defaultPrevented).toBe(true)
+      expect(gesture?.transfer.dropEffect).toBe('none')
+      expect(gesture?.release.type).toBe('dragleave')
+      // A late delivered drop must preserve the same silent refusal barrier.
+      await drop(target)
+      expect(toast.error).not.toHaveBeenCalled()
+      expect(attach).not.toHaveBeenCalled()
+      expect(prepare).not.toHaveBeenCalled()
+      expect(electron.send).not.toHaveBeenCalled()
+    }
+  )
+  it('keeps a workspace card without a path silent and out of the legacy terminal relay', async () => {
+    const attach = vi.fn(async () => {})
+    const view = render(
+      <div data-native-file-drop-target="terminal">
+        <WorkspaceWithoutPath attach={attach} />
+      </div>
+    )
+    const target = view.container.querySelector('.workspace-card')!
+    let gesture: ReturnType<typeof negotiateAndRelease> | undefined
+    await act(async () => {
+      gesture = negotiateAndRelease(target)
+    })
+    expect(gesture?.hover.defaultPrevented).toBe(true)
+    expect(gesture?.transfer.dropEffect).toBe('none')
+    expect(gesture?.release.type).toBe('dragleave')
+    await drop(target)
+    expect(attach).not.toHaveBeenCalled()
+    expect(prepare).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
+    expect(electron.send).not.toHaveBeenCalled()
+  })
+  it('reads child-only availability changes on the immediate dragover and drop', async () => {
+    const attach = vi.fn()
+    const view = render(
+      <NativeChatPaneFileDropSurface className="chat">
+        <AvailabilityComposer attach={attach} />
+      </NativeChatPaneFileDropSurface>
+    )
+    const target = view.container.querySelector('.ProseMirror')!
+    const refused = negotiateAndRelease(target)
+    expect(refused.transfer.dropEffect).toBe('none')
+    expect(prepare).not.toHaveBeenCalled()
+    fireEvent.click(view.getByText('Toggle availability'))
+    let accepted: ReturnType<typeof negotiateAndRelease> | undefined
+    await act(async () => {
+      accepted = negotiateAndRelease(target)
+    })
+    expect(accepted?.transfer.dropEffect).toBe('copy')
+    expect(accepted?.release.type).toBe('drop')
+    expect(attach).toHaveBeenCalledExactlyOnceWith(['/drop/a.png'])
+    fireEvent.click(view.getByText('Toggle availability'))
+    await drop(target)
+    expect(attach).toHaveBeenCalledOnce()
+    expect(prepare).toHaveBeenCalledOnce()
+    expect(electron.send).not.toHaveBeenCalled()
+  })
+  it('attaches hybrid Files and HTML without inserting HTML into the real editor', async () => {
+    const attach = vi.fn()
+    const view = render(<Chat attach={attach} />)
+    const editor = view.container.querySelector('.ProseMirror')!
+    await drop(editor, ['Files', 'text/html'])
+    expect(attach).toHaveBeenCalledExactlyOnceWith(['/drop/a.png'])
+    expect(editor.textContent).toBe('Original')
+    expect(editor.querySelector('b')).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-floating-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-floating-file-drop.test.tsx
new file mode 100644
index 000000000000..6914b12cb0db
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-floating-file-drop.test.tsx
@@ -0,0 +1,127 @@
+// @vitest-environment happy-dom
+import { act, cleanup, fireEvent, render } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import { NativeChatPaneFileDropSurface } from './NativeChatPaneFileDropSurface'
+import { useNativeChatFileDrops } from './use-native-chat-file-drops'
+
+const state = vi.hoisted(() => {
+  const tabsByWorktree: Record<string, TerminalTab[]> = {}
+  return {
+    repos: [],
+    worktreesByRepo: {},
+    detectedWorktreesByRepo: {},
+    folderWorkspaces: [],
+    projectGroups: [],
+    sshConnectionStates: new Map(),
+    settings: { activeRuntimeEnvironmentId: 'other-remote-runtime' },
+    activeWorktreeId: 'other-workspace',
+    activeWorkspaceExecutionHostId: 'runtime:other-remote-runtime',
+    tabsByWorktree
+  }
+})
+vi.mock('@/store', () => ({ useAppStore: { getState: () => state } }))
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+
+const stat = vi.fn(async () => ({ isDirectory: false }))
+const prepare = vi.fn(async ({ paths }: { paths: string[] }) => ({ paths, failures: [] }))
+const pick = vi.fn(async () => ['/picked/file.txt'])
+const upload = vi.fn()
+
+function Composer({ attach, notice }: { attach: () => void; notice: () => void }) {
+  const { pickAttachments } = useNativeChatFileDrops({
+    paneKey: 'floating-pane',
+    draftScopeKey: 'floating-draft',
+    terminalTabId: 'floating-tab',
+    targetPtyId: 'local-pty',
+    disabled: false,
+    attachResolvedPaths: attach,
+    pendingChips: {
+      begin: () => null,
+      resolve: () => {},
+      drop: () => false,
+      attachReferences: () => {}
+    },
+    setNotice: notice
+  })
+  return <button onClick={pickAttachments}>Attach file</button>
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  state.tabsByWorktree = {
+    [FLOATING_TERMINAL_WORKTREE_ID]: [
+      {
+        id: 'floating-tab',
+        ptyId: 'local-pty',
+        worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
+        title: 'Floating',
+        customTitle: null,
+        color: null,
+        sortOrder: 0,
+        createdAt: 0
+      }
+    ]
+  }
+  vi.stubGlobal('api', {
+    fs: {
+      getPathForFile: (file: File) => `/drop/${file.name}`,
+      stat,
+      prepareDroppedPaths: prepare,
+      resolveDroppedPathsForAgent: upload
+    },
+    shell: { pickAttachments: pick }
+  })
+})
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+})
+
+describe('floating chat attachments with a different remote runtime focused', () => {
+  it.each(['drop', 'paperclip'] as const)(
+    'attaches a local file through %s without catalog rows',
+    async (lane) => {
+      const attach = vi.fn()
+      const notice = vi.fn()
+      const view = render(
+        <NativeChatPaneFileDropSurface className="chat">
+          <Composer attach={attach} notice={notice} />
+        </NativeChatPaneFileDropSurface>
+      )
+      if (lane === 'paperclip') {
+        await act(async () => fireEvent.click(view.getByText('Attach file')))
+      } else {
+        const transfer = {
+          types: ['Files'],
+          files: [new File(['x'], 'file.txt')],
+          dropEffect: 'none'
+        }
+        await act(async () => {
+          for (const type of ['dragover', 'drop']) {
+            const event = new Event(type, { bubbles: true, cancelable: true, composed: true })
+            Object.defineProperty(event, 'isTrusted', { value: true })
+            Object.defineProperty(event, 'dataTransfer', { value: transfer })
+            view.getByText('Attach file').dispatchEvent(event)
+            if (type === 'dragover') {
+              expect(transfer.dropEffect).toBe('copy')
+            }
+          }
+        })
+      }
+      const path = lane === 'drop' ? '/drop/file.txt' : '/picked/file.txt'
+      expect(stat).toHaveBeenCalledExactlyOnceWith({
+        filePath: path,
+        access: { kind: 'user-file' }
+      })
+      expect(attach).toHaveBeenCalledExactlyOnceWith([path], undefined, {
+        destinationIsCurrent: expect.any(Function)
+      })
+      expect(attach.mock.calls[0][2].destinationIsCurrent()).toBe(true)
+      expect(upload).not.toHaveBeenCalled()
+      expect(notice).not.toHaveBeenCalled()
+    }
+  )
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-pane-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-pane-file-drop.test.tsx
index 733215d4efd2..8aefa4885f84 100644
--- a/src/renderer/src/components/native-chat/native-chat-pane-file-drop.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-pane-file-drop.test.tsx
@@ -52,7 +52,8 @@ function ClaimingComposer({
   onDropCapture?: (event: React.DragEvent<HTMLDivElement>) => void
 }) {
   useNativeChatPaneFileDropClaim({
-    scopeKey: 'pane:1',
+    destinationKey: 'pane:1',
+    captureExternalDrop: () => async () => {},
     disabled,
     onDragOverCapture,
     onDropCapture
@@ -115,14 +116,14 @@ describe('NativeChatPaneFileDropSurface', () => {
     expect(container.querySelector(OVERLAY)).toBeNull()
   })
 
-  it('publishes the claiming composer as the OS drop route target', () => {
+  it('owns OS drops without publishing a scope marker', () => {
     const { container } = renderPane(<ClaimingComposer />)
     const surface = container.querySelector('.pane')
-    expect(surface?.getAttribute('data-native-file-drop-target')).toBe('composer')
-    expect(surface?.getAttribute('data-composer-scope-key')).toBe('pane:1')
+    expect(surface?.hasAttribute('data-os-file-drop-owner')).toBe(true)
+    expect(surface?.hasAttribute('data-composer-scope-key')).toBe(false)
   })
 
-  it('leaves the pane to the terminal behind it while no composer is mounted', () => {
+  it('keeps an OS owner even while no composer is mounted', () => {
     const { transcript, container } = renderPane(null)
     fireDrag(transcript, 'dragover', workspaceDrag())
     expect(container.querySelector(OVERLAY)).toBeNull()
@@ -143,7 +144,7 @@ describe('NativeChatPaneFileDropSurface', () => {
     expect(onDragOverCapture).toHaveBeenCalledTimes(1)
   })
 
-  it('shows the overlay for an OS drag without claiming its drop', () => {
+  it('shows the overlay for OS drags while keeping workspace handlers separate', () => {
     const onDropCapture = vi.fn()
     const { transcript, container } = renderPane(<ClaimingComposer onDropCapture={onDropCapture} />)
     fireDrag(transcript, 'dragover', osDrag())
@@ -164,7 +165,7 @@ describe('NativeChatPaneFileDropSurface', () => {
 
     rerender(pane(true))
     expect(container.querySelector(OVERLAY)).toBeNull()
-    expect(container.querySelector('.pane')?.getAttribute('data-composer-scope-key')).toBe('pane:1')
+    expect(container.querySelector('.pane')?.hasAttribute('data-os-file-drop-owner')).toBe(true)
 
     rerender(pane(false))
     expect(container.querySelector(OVERLAY)).toBeNull()
diff --git a/src/renderer/src/components/native-chat/native-chat-pane-file-drop.ts b/src/renderer/src/components/native-chat/native-chat-pane-file-drop.ts
index e0ebfe4243f1..f04793af30de 100644
--- a/src/renderer/src/components/native-chat/native-chat-pane-file-drop.ts
+++ b/src/renderer/src/components/native-chat/native-chat-pane-file-drop.ts
@@ -3,7 +3,7 @@ import { hasNativeFileDragTypes } from '../../../../shared/native-file-drop'
 
 /** What a drag hovering the chat pane is carrying.
  *  `workspace`: an in-app file drag, attached by the composer's own handlers.
- *  `os`: a Finder/Explorer drag, delivered by the preload drop route instead. */
+ *  `os`: a Finder/Explorer drag, handled by the pane's OS file owner. */
 export type NativeChatPaneDragKind = 'os' | 'workspace'
 
 export type NativeChatPaneDragEvent = {
@@ -14,8 +14,8 @@ export type NativeChatPaneDragEvent = {
 
 /** The composer's drop claim, published while a composer is mounted in the pane. */
 export type NativeChatPaneDropClaim = {
-  /** Composer identity the preload drop route addresses (`data-composer-scope-key`). */
-  scopeKey: string
+  destinationKey: string
+  captureExternalDrop: () => (paths: string[]) => Promise<void>
   /** A guarded composer refuses the drop, so the pane must not invite one. */
   disabled: boolean
   onDragOverCapture: (event: React.DragEvent<HTMLDivElement>) => void
@@ -41,12 +41,7 @@ export function movedWithinDropSurface(event: NativeChatPaneDragEvent): boolean
   return enteredNode instanceof Node && event.currentTarget.contains(enteredNode)
 }
 
-/**
- * Decides what the pane does with a drag, given what the mounted composer will
- * accept. Only a workspace drag is claimed here: an OS drag reaches the composer
- * through the preload route, which already consumed the drop event by the time
- * React would see it, so the pane's part of that route is the overlay alone.
- */
+/** Workspace files keep their provenance-checked lane; OS files use the native owner. */
 export function makeNativeChatPaneFileDropHandlers(host: {
   getClaim: () => NativeChatPaneDropClaim | null
   setDragActive: (active: boolean) => void
@@ -62,8 +57,6 @@ export function makeNativeChatPaneFileDropHandlers(host: {
       return false
     }
     const claim = host.getClaim()
-    // No composer (a question card owns the input region) means no attachment
-    // target, so the drag stays the terminal's the way it is today.
     return claim !== null && !claim.disabled
   }
 
diff --git a/src/renderer/src/components/native-chat/native-chat-view-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-view-file-drop.test.tsx
index d3f10a4dcded..96b4ee6c129c 100644
--- a/src/renderer/src/components/native-chat/native-chat-view-file-drop.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-view-file-drop.test.tsx
@@ -15,7 +15,8 @@ vi.mock('./use-native-chat-status-entry', () => ({ useNativeChatStatusEntry: vi.
 vi.mock('./NativeChatStructuredSession', () => ({
   NativeChatStructuredSession: () => {
     useNativeChatPaneFileDropClaim({
-      scopeKey: 'structured:session',
+      destinationKey: 'structured:session',
+      captureExternalDrop: () => async () => {},
       disabled: false,
       onDragOverCapture: (event) => event.preventDefault(),
       onDropCapture: drop.onDrop
@@ -43,11 +44,7 @@ it('owns pane drops for standalone structured sessions without a terminal portal
 
   fireEvent.dragOver(transcript, { dataTransfer })
   expect(container.querySelector('[data-native-chat-drop-overlay]')).not.toBeNull()
-  expect(
-    transcript
-      .closest('[data-native-file-drop-target="composer"]')
-      ?.getAttribute('data-composer-scope-key')
-  ).toBe('structured:session')
+  expect(transcript.closest('[data-os-file-drop-owner]')).not.toBeNull()
 
   fireEvent.drop(transcript, { dataTransfer })
   expect(drop.onDrop).toHaveBeenCalledTimes(1)
diff --git a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx
index 44e48edb2abf..74d257e5af1a 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx
@@ -595,6 +595,68 @@ describe('useNativeChatExternalAttachments', () => {
       expect(mocks.stat).not.toHaveBeenCalled()
     })
 
+    it('refuses a captured drop if its destination changed before preparation finished', async () => {
+      const chips = trackingChips()
+      const probe = await renderProbe({
+        structuredWorktreeId: 'worktree-1',
+        structuredSession: session,
+        attachResolvedPaths: vi.fn(),
+        pendingChips: chips
+      })
+      let current = true
+      const deliver = probe.latest().captureExternalDrop(() => current)
+      current = false
+      await act(async () => deliver(['/Users/me/notes.md']))
+      expect(chips.begun).toEqual([])
+      expect(mocks.prepareNativeChatSessionAttachmentUpload).not.toHaveBeenCalled()
+    })
+
+    it('discards uploaded files if the captured drop destination changed during upload', async () => {
+      const upload = deferred<AgentSessionAttachmentPathUploadResult>()
+      mocks.uploadNativeChatSessionAttachmentPaths.mockReturnValueOnce(upload.promise)
+      const chips = trackingChips()
+      const probe = await renderProbe({
+        structuredWorktreeId: 'worktree-1',
+        structuredSession: session,
+        attachResolvedPaths: vi.fn(),
+        pendingChips: chips
+      })
+      let current = true
+      const deliver = probe.latest().captureExternalDrop(() => current)
+      act(() => void deliver(['/Users/me/notes.md']))
+      current = false
+      await act(async () =>
+        upload.resolve(
+          uploaded([['/Users/me/notes.md', '/srv/agent-session-attachments/u1/notes.md']])
+        )
+      )
+      expect(chips.drop).toHaveBeenCalledExactlyOnceWith('chip-1')
+      expect(chips.attachReferences).not.toHaveBeenCalled()
+    })
+
+    it('settles an upload into its captured chips while a prompt card unmounts the composer', async () => {
+      const upload = deferred<AgentSessionAttachmentPathUploadResult>()
+      mocks.uploadNativeChatSessionAttachmentPaths.mockReturnValueOnce(upload.promise)
+      const chips = trackingChips()
+      const probe = await renderProbe({
+        structuredWorktreeId: 'worktree-1',
+        structuredSession: session,
+        attachResolvedPaths: vi.fn(),
+        pendingChips: chips
+      })
+      act(() => void probe.latest().captureExternalDrop(() => true)(['/Users/me/notes.md']))
+      act(() => root?.unmount())
+      root = null
+      await act(async () =>
+        upload.resolve(
+          uploaded([['/Users/me/notes.md', '/srv/agent-session-attachments/u1/notes.md']])
+        )
+      )
+      expect(chips.attachReferences).toHaveBeenCalledExactlyOnceWith([
+        '/srv/agent-session-attachments/u1/notes.md'
+      ])
+    })
+
     it('does not insert a file whose chip the user removed while it uploaded', async () => {
       const upload = deferred<AgentSessionAttachmentPathUploadResult>()
       mocks.uploadNativeChatSessionAttachmentPaths.mockReturnValueOnce(upload.promise)
diff --git a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts
index b3f92042869a..9620d475f61b 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts
@@ -23,6 +23,7 @@ import {
   type NativeChatPendingAttachmentChips
 } from './native-chat-session-attachment-drop'
 import { userNamedFileAccess } from '@/lib/local-file-access'
+import { useMountedRef } from '@/hooks/useMountedRef'
 import { findTerminalTabWorktreeId } from './native-chat-file-link'
 
 export type UseNativeChatExternalAttachmentsArgs = {
@@ -75,7 +76,9 @@ export function useNativeChatExternalAttachments({
 }: UseNativeChatExternalAttachmentsArgs): {
   attachExternalPaths: (paths: string[]) => void
   resolveAttachmentOwner: () => NativeChatAttachmentOwner
+  captureExternalDrop: (destinationIsCurrent?: () => boolean) => (paths: string[]) => Promise<void>
 } {
+  const mountedRef = useMountedRef()
   const disabledRef = useRef(disabled)
   useLayoutEffect(() => {
     disabledRef.current = disabled
@@ -116,28 +119,9 @@ export function useNativeChatExternalAttachments({
       : resolveNativeChatAttachmentOwner(useAppStore.getState(), terminalTabId)
   }, [])
 
-  const attachExternalPaths = useCallback(
-    (paths: string[]) => {
-      if (paths.length === 0 || disabledRef.current) {
-        return
-      }
+  const captureExternalDrop = useCallback(
+    (destinationIsCurrent: () => boolean = () => true) => {
       const owner = resolveAttachmentOwner()
-      if (owner.kind === 'not-ready') {
-        setNotice(nativeChatWorktreeNotReadyNotice())
-        return
-      }
-      if (owner.kind === 'runtime') {
-        setNotice(nativeChatLocalAttachmentUnsupportedNotice())
-        return
-      }
-      // The picker has no native cap, so it gets the same all-or-nothing limit as a drop.
-      if (paths.length > NATIVE_FILE_DROP_MAX_PATHS) {
-        setNotice(nativeChatTooManyAttachmentsNotice())
-        return
-      }
-      // Why every exit reports: a drop that reaches here and produces nothing is
-      // the silent-failure complaint in #15782. Only a disabled composer stays
-      // quiet — it is being torn down or guarded, and has no notice surface.
       const capturedWorkspace = workspaceRef.current
       const currentWorktreeId = (): string | null =>
         workspaceRef.current.structuredWorktreeId ??
@@ -146,78 +130,107 @@ export function useNativeChatExternalAttachments({
           workspaceRef.current.terminalTabId
         )
       const capturedWorktreeId = currentWorktreeId()
-      // Both halves matter: a moved tab can land on a workspace that reports the
-      // same owner kind, and the owner alone would call that unchanged.
       const ownerStillCurrent = (): boolean =>
+        // Server uploads settle into the captured scope even while its composer is unmounted.
+        (owner.kind === 'runtime-session' || mountedRef.current) &&
+        destinationIsCurrent() &&
         isSameComposerWorkspace(capturedWorkspace, workspaceRef.current) &&
         capturedWorktreeId === currentWorktreeId() &&
         nativeChatAttachmentOwnerUnchanged(owner, resolveAttachmentOwner())
-      if (owner.kind === 'runtime-session') {
-        void attachNativeChatSessionAttachmentPaths({
-          paths,
-          owner,
-          chips: pendingChipsRef.current,
-          isAbandoned: () => disabledRef.current,
-          ownerStillCurrent,
-          setNotice
-        })
-        return
-      }
-      if (owner.kind !== 'ssh') {
-        void (async () => {
-          const readablePaths: string[] = []
-          for (const targetPath of paths) {
-            if (disabledRef.current) {
-              return
-            }
-            if (!ownerStillCurrent()) {
-              setNotice(nativeChatAttachmentOwnerChangedNotice())
-              return
-            }
-            try {
-              await window.api.fs.stat({ filePath: targetPath, access: userNamedFileAccess() })
-              readablePaths.push(targetPath)
-            } catch {
-              // Skip unreadable paths, matching workspace composer drops.
-            }
-          }
-          if (disabledRef.current) {
+      return async (paths: string[]): Promise<void> => {
+        if (paths.length === 0 || disabledRef.current || !mountedRef.current) {
+          return
+        }
+        if (!destinationIsCurrent()) {
+          setNotice(nativeChatAttachmentOwnerChangedNotice())
+          return
+        }
+        if (owner.kind === 'not-ready') {
+          setNotice(nativeChatWorktreeNotReadyNotice())
+          return
+        }
+        if (owner.kind === 'runtime') {
+          setNotice(nativeChatLocalAttachmentUnsupportedNotice())
+          return
+        }
+        // The picker shares the drop limit without partially attaching a batch.
+        if (paths.length > NATIVE_FILE_DROP_MAX_PATHS) {
+          setNotice(nativeChatTooManyAttachmentsNotice())
+          return
+        }
+        if (!ownerStillCurrent()) {
+          setNotice(nativeChatAttachmentOwnerChangedNotice())
+          return
+        }
+        if (owner.kind === 'runtime-session') {
+          await attachNativeChatSessionAttachmentPaths({
+            paths,
+            owner,
+            chips: pendingChipsRef.current,
+            isAbandoned: () => disabledRef.current,
+            ownerStillCurrent,
+            setNotice
+          })
+          return
+        }
+        if (owner.kind === 'ssh') {
+          const remotePaths = await uploadNativeChatAttachmentPaths(paths, owner)
+          if (disabledRef.current || !mountedRef.current) {
             return
           }
           if (!ownerStillCurrent()) {
             setNotice(nativeChatAttachmentOwnerChangedNotice())
             return
           }
-          if (readablePaths.length === 0) {
+          if (!remotePaths || remotePaths.length === 0) {
             setNotice(nativeChatAttachmentUnreadableNotice())
             return
           }
-          attachResolvedPaths(readablePaths, undefined, { destinationIsCurrent: ownerStillCurrent })
-        })()
-        return
-      }
-      void (async () => {
-        const remotePaths = await uploadNativeChatAttachmentPaths(paths, owner)
-        if (disabledRef.current) {
+          attachResolvedPaths(remotePaths, owner.connectionId, {
+            destinationIsCurrent: ownerStillCurrent
+          })
           return
         }
-        if (!remotePaths || remotePaths.length === 0) {
-          // uploadNativeChatAttachmentPaths already toasted the IPC failure;
-          // an empty result with no failure means nothing was readable.
-          setNotice(nativeChatAttachmentUnreadableNotice())
+        const readablePaths: string[] = []
+        for (const targetPath of paths) {
+          if (disabledRef.current || !mountedRef.current) {
+            return
+          }
+          if (!ownerStillCurrent()) {
+            setNotice(nativeChatAttachmentOwnerChangedNotice())
+            return
+          }
+          try {
+            await window.api.fs.stat({ filePath: targetPath, access: userNamedFileAccess() })
+            readablePaths.push(targetPath)
+          } catch {
+            // Skip unreadable paths, matching workspace composer drops.
+          }
+        }
+        if (disabledRef.current || !mountedRef.current) {
           return
         }
         if (!ownerStillCurrent()) {
           setNotice(nativeChatAttachmentOwnerChangedNotice())
           return
         }
-        attachResolvedPaths(remotePaths, owner.connectionId, {
-          destinationIsCurrent: ownerStillCurrent
-        })
-      })()
+        if (readablePaths.length === 0) {
+          setNotice(nativeChatAttachmentUnreadableNotice())
+          return
+        }
+        attachResolvedPaths(readablePaths, undefined, { destinationIsCurrent: ownerStillCurrent })
+      }
+    },
+    [attachResolvedPaths, mountedRef, resolveAttachmentOwner, setNotice]
+  )
+  const attachExternalPaths = useCallback(
+    (paths: string[]): void => {
+      if (!disabledRef.current && mountedRef.current && paths.length > 0) {
+        void captureExternalDrop()(paths)
+      }
     },
-    [attachResolvedPaths, resolveAttachmentOwner, setNotice]
+    [captureExternalDrop, mountedRef]
   )
 
-  return { attachExternalPaths, resolveAttachmentOwner }
+  return { attachExternalPaths, captureExternalDrop, resolveAttachmentOwner }
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.test.tsx
index 19e614f65a14..86923fb15d33 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.test.tsx
@@ -2,43 +2,26 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { act } from 'react'
 import { cleanup, renderHook } from '@testing-library/react'
-import {
-  NATIVE_FILE_DROP_TARGET,
-  type NativeFileDropPayload
-} from '../../../../shared/native-file-drop'
 import { useNativeChatFileAttachmentActions } from './use-native-chat-file-attachment-actions'
 
-const SCOPE_KEY = 'pane-1'
-
 let pickAttachments: ReturnType<typeof vi.fn>
-type DropListener = (payload: NativeFileDropPayload) => void
-
-let dropListeners: DropListener[] = []
+const onFileDrop = vi.fn()
 function renderProbe(
   attachExternalPaths: (paths: string[]) => void
 ): () => { pickAttachments: () => void } {
-  const { result } = renderHook(() =>
-    useNativeChatFileAttachmentActions(SCOPE_KEY, attachExternalPaths)
-  )
+  const { result } = renderHook(() => useNativeChatFileAttachmentActions(attachExternalPaths))
   return () => result.current
 }
 
 describe('useNativeChatFileAttachmentActions', () => {
   beforeEach(() => {
-    dropListeners = []
+    onFileDrop.mockClear()
     pickAttachments = vi.fn()
     Object.defineProperty(window, 'api', {
       configurable: true,
       value: {
         shell: { pickAttachments },
-        ui: {
-          onFileDrop: (listener: DropListener) => {
-            dropListeners.push(listener)
-            return () => {
-              dropListeners = dropListeners.filter((entry) => entry !== listener)
-            }
-          }
-        }
+        ui: { onFileDrop }
       }
     })
   })
@@ -69,26 +52,8 @@ describe('useNativeChatFileAttachmentActions', () => {
     expect(attachExternalPaths.mock.calls.flatMap(([paths]) => paths)).toEqual([])
   })
 
-  it('only attaches a drop aimed at this pane', async () => {
-    const attachExternalPaths = vi.fn()
-    renderProbe(attachExternalPaths)
-    await act(async () => {
-      for (const listener of dropListeners) {
-        listener({
-          target: NATIVE_FILE_DROP_TARGET.composer,
-          scopeKey: 'other-pane',
-          paths: ['/dropped/a.png']
-        })
-        listener({
-          target: NATIVE_FILE_DROP_TARGET.composer,
-          scopeKey: SCOPE_KEY,
-          paths: ['/dropped/a.png', '/dropped/b.png']
-        })
-      }
-    })
-    expect(attachExternalPaths).toHaveBeenCalledExactlyOnceWith([
-      '/dropped/a.png',
-      '/dropped/b.png'
-    ])
+  it('does not subscribe to legacy window drops', () => {
+    renderProbe(vi.fn())
+    expect(onFileDrop).not.toHaveBeenCalled()
   })
 })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.ts b/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.ts
index 5165c00cb018..aa819d742a15 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-file-attachment-actions.ts
@@ -1,23 +1,8 @@
-import { useCallback, useEffect } from 'react'
-import { NATIVE_FILE_DROP_TARGET } from '../../../../shared/native-file-drop'
+import { useCallback } from 'react'
 
 export function useNativeChatFileAttachmentActions(
-  /** Pane identity published as `data-composer-scope-key` on the drop target. */
-  scopeKey: string,
   attachExternalPaths: (paths: string[]) => void
 ): { pickAttachments: () => void } {
-  useEffect(
-    () =>
-      window.api.ui.onFileDrop((payload) => {
-        // Why: this event reaches every mounted composer, including hidden
-        // background chat tabs. Only the pane the drop landed on may attach.
-        if (payload.target === NATIVE_FILE_DROP_TARGET.composer && payload.scopeKey === scopeKey) {
-          attachExternalPaths(payload.paths)
-        }
-      }),
-    [attachExternalPaths, scopeKey]
-  )
-
   const pickAttachments = useCallback(() => {
     void (async () => {
       attachExternalPaths(await window.api.shell.pickAttachments())
diff --git a/src/renderer/src/components/native-chat/use-native-chat-file-drops.ts b/src/renderer/src/components/native-chat/use-native-chat-file-drops.ts
new file mode 100644
index 000000000000..e6fd606db6e2
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-file-drops.ts
@@ -0,0 +1,40 @@
+import { useLayoutEffect, useRef } from 'react'
+import type { NativeChatComposerProps } from './native-chat-composer-types'
+import {
+  useNativeChatExternalAttachments,
+  type UseNativeChatExternalAttachmentsArgs
+} from './use-native-chat-external-attachments'
+import { useNativeChatWorkspaceFileDrop } from './use-native-chat-workspace-file-drop'
+import { useNativeChatFileAttachmentActions } from './use-native-chat-file-attachment-actions'
+import { useNativeChatPaneFileDropClaim } from './NativeChatPaneFileDropSurface'
+
+type Args = UseNativeChatExternalAttachmentsArgs &
+  Pick<NativeChatComposerProps, 'paneKey' | 'draftScopeKey' | 'targetPtyId' | 'structuredTransport'>
+
+export function useNativeChatFileDrops(args: Args) {
+  const external = useNativeChatExternalAttachments(args)
+  const workspace = useNativeChatWorkspaceFileDrop(args)
+  const destinationKey = JSON.stringify([
+    args.paneKey,
+    args.draftScopeKey,
+    args.targetPtyId,
+    args.structuredTransport?.sessionId,
+    args.structuredTransport?.worktreeId,
+    args.structuredTransport?.runtimeEnvironmentId
+  ])
+  const destinationRef = useRef(destinationKey)
+  useLayoutEffect(() => {
+    destinationRef.current = destinationKey
+  }, [destinationKey])
+  useNativeChatPaneFileDropClaim({
+    destinationKey,
+    disabled: args.disabled,
+    ...workspace,
+    captureExternalDrop: () =>
+      external.captureExternalDrop(() => destinationRef.current === destinationKey)
+  })
+  return {
+    ...useNativeChatFileAttachmentActions(external.attachExternalPaths),
+    resolveAttachmentOwner: external.resolveAttachmentOwner
+  }
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts b/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts
index cc37d7783a21..cf38fde2a6fc 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts
@@ -1,6 +1,5 @@
 import { useCallback, useLayoutEffect, useRef, type DragEventHandler } from 'react'
 import { useAppStore } from '@/store'
-import { getExecutionHostIdForWorktree } from '@/lib/worktree-runtime-owner'
 import {
   getWorkspaceFileDragRejectionMessage,
   hasWorkspaceFileDragType,
@@ -10,6 +9,7 @@ import {
 } from '@/lib/workspace-file-drag'
 import {
   resolveNativeChatAttachmentOwnerForWorktree,
+  resolveNativeChatAttachmentHost,
   nativeChatWorktreeNotReadyNotice
 } from './native-chat-attachment-upload'
 import { findTerminalTabWorktreeId } from './native-chat-file-link'
@@ -18,7 +18,6 @@ import {
   nativeChatWorkspaceAttachmentMismatchNotice,
   type NativeChatResolvedPathOptions
 } from './native-chat-resolved-path-ownership'
-import { useNativeChatPaneFileDropClaim } from './NativeChatPaneFileDropSurface'
 
 type WorkspaceFileDropHandlers = {
   onDragOverCapture: DragEventHandler<HTMLDivElement>
@@ -32,9 +31,6 @@ type Args = {
     options?: NativeChatResolvedPathOptions
   ) => void
   disabled: boolean
-  /** Composer identity the preload drop route addresses; published to the pane
-   *  so an OS drop anywhere in it resolves to this composer. */
-  paneKey: string
   setNotice: (notice: string | null) => void
   structuredWorktreeId?: string
   terminalTabId: string
@@ -67,7 +63,6 @@ function setDropEffect(dataTransfer: DataTransfer, effect: 'copy' | 'none'): voi
 export function useNativeChatWorkspaceFileDrop({
   attachResolvedPaths,
   disabled,
-  paneKey,
   setNotice,
   structuredWorktreeId,
   terminalTabId
@@ -122,17 +117,14 @@ export function useNativeChatWorkspaceFileDrop({
         setNotice(nativeChatWorkspaceAttachmentMismatchNotice())
         return
       }
-      const owner = resolveNativeChatAttachmentOwnerForWorktree(
-        state,
-        workspaceId,
-        structuredWorktreeId ? undefined : terminalTabId
-      )
+      const owner = resolveNativeChatAttachmentOwnerForWorktree(state, workspaceId)
       if (owner.kind === 'not-ready') {
         setNotice(nativeChatWorktreeNotReadyNotice())
         return
       }
-      const targetExecutionHostId = getExecutionHostIdForWorktree(state, workspaceId)
+      const targetExecutionHostId = resolveNativeChatAttachmentHost(state, workspaceId)
       if (
+        !targetExecutionHostId ||
         !isResolvedWorkspaceFileDragExecutionHost(targetExecutionHostId) ||
         source.executionHostId !== targetExecutionHostId
       ) {
@@ -148,13 +140,13 @@ export function useNativeChatWorkspaceFileDrop({
         if (currentWorkspaceId !== source.workspaceId) {
           return false
         }
-        const currentHostId = getExecutionHostIdForWorktree(currentState, currentWorkspaceId)
+        const currentHostId = resolveNativeChatAttachmentHost(currentState, currentWorkspaceId)
         const currentOwner = resolveNativeChatAttachmentOwnerForWorktree(
           currentState,
-          currentWorkspaceId,
-          structuredWorktreeIdRef.current ? undefined : terminalTabId
+          currentWorkspaceId
         )
         return (
+          currentHostId !== null &&
           isResolvedWorkspaceFileDragExecutionHost(currentHostId) &&
           currentHostId === source.executionHostId &&
           nativeChatAttachmentOwnerUnchanged(owner, currentOwner)
@@ -168,14 +160,5 @@ export function useNativeChatWorkspaceFileDrop({
     [attachResolvedPaths, disabled, setNotice, structuredWorktreeId, terminalTabId]
   )
 
-  // The pane around the composer is the drop surface; these handlers run from
-  // there so the whole chat, not just the input box, accepts a file.
-  useNativeChatPaneFileDropClaim({
-    scopeKey: paneKey,
-    disabled,
-    onDragOverCapture,
-    onDropCapture
-  })
-
   return { onDragOverCapture, onDropCapture }
 }
diff --git a/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts b/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts
index 875d926a7795..21b5c58684ca 100644
--- a/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts
+++ b/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts
@@ -31,6 +31,8 @@ export type NewWorkspaceComposerCardProps = {
   contextualTourSource?: string
   containerClassName?: string
   contentClassName?: string
+  selectedRepoPath?: string | null
+  onNativeFileDrop?: (paths: string[], isCurrent: () => boolean) => Promise<void>
   composerRef?: React.RefObject<HTMLDivElement | null>
   onComposerNodeChange?: (node: HTMLDivElement | null) => void
   nameInputRef?: React.RefObject<HTMLInputElement | null>
diff --git a/src/renderer/src/components/new-workspace/use-new-workspace-composer-file-drop.ts b/src/renderer/src/components/new-workspace/use-new-workspace-composer-file-drop.ts
new file mode 100644
index 000000000000..380f25b32b10
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/use-new-workspace-composer-file-drop.ts
@@ -0,0 +1,62 @@
+import { useLayoutEffect, useRef, useState } from 'react'
+import { toast } from 'sonner'
+import { createOsFileDropSequence, useOsFileDropOwner } from '@/hooks/use-os-file-drop-owner'
+import { getNativeFileDropRejectionMessage } from '@/hooks/useGlobalFileDrop'
+import { useMountedRef } from '@/hooks/useMountedRef'
+import { useAppStore } from '@/store'
+import { parseExecutionHostId, type ExecutionHostId } from '../../../../shared/execution-host'
+
+type Args = {
+  projectPath?: string | null
+  hostId?: ExecutionHostId | null
+  connectionId: string | null
+  applyDrop?: (paths: string[], isCurrent: () => boolean) => Promise<void>
+}
+
+export function useNewWorkspaceComposerFileDrop(args: Args) {
+  const ownerRef = useRef<HTMLElement | null>(null)
+  const [sequence] = useState(createOsFileDropSequence)
+  const mounted = useMountedRef()
+  const identity = JSON.stringify([args.projectPath, args.hostId, args.connectionId])
+  const identityRef = useRef(identity)
+  useLayoutEffect(() => {
+    identityRef.current = identity
+  }, [identity])
+  return useOsFileDropOwner(ownerRef, {
+    consumer: 'agent',
+    sequence,
+    canAccept: Boolean(args.projectPath && args.hostId && args.applyDrop),
+    captureDestination: () => {
+      const connectionId = args.connectionId
+      const host = parseExecutionHostId(args.hostId)
+      const currentGeneration = (): number | undefined => {
+        if (!connectionId) {
+          return undefined
+        }
+        const state = useAppStore.getState()
+        return host?.kind === 'runtime'
+          ? state.sshStateByEnvironment?.get(host.environmentId)?.connectionStates.get(connectionId)
+              ?.connectionGeneration
+          : state.sshConnectionStates.get(connectionId)?.connectionGeneration
+      }
+      const generation = currentGeneration()
+      return {
+        applyDrop: args.applyDrop,
+        isCurrent: () =>
+          mounted.current && identityRef.current === identity && generation === currentGeneration()
+      }
+    },
+    onDrop: async (prepared, { destination }) => {
+      if (!destination?.isCurrent()) {
+        return
+      }
+      for (const failure of prepared.failures) {
+        const message = getNativeFileDropRejectionMessage(failure)
+        toast.error(message.title, { description: message.description })
+      }
+      if (prepared.paths.length > 0) {
+        await destination.applyDrop?.(prepared.paths, destination.isCurrent)
+      }
+    }
+  })
+}
diff --git a/src/renderer/src/components/sidebar/use-feedback-image-drop.test.tsx b/src/renderer/src/components/sidebar/use-feedback-image-drop.test.tsx
index ca6c00c26015..d39a229c6cd0 100644
--- a/src/renderer/src/components/sidebar/use-feedback-image-drop.test.tsx
+++ b/src/renderer/src/components/sidebar/use-feedback-image-drop.test.tsx
@@ -1,14 +1,9 @@
 // @vitest-environment happy-dom
 
-/**
- * Native file drops never reach React in this app: preload claims them on
- * document capture and routes the paths to the editor. These tests pin the
- * window-capture interception that keeps a screenshot dropped on the feedback
- * dialog from being swallowed by that lane.
- */
 import { act } from '@testing-library/react'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { OS_FILE_DROP_OWNER_ATTRIBUTE } from '../../../../shared/native-file-drop-preparation'
 import { ORCA_INTERNAL_FILE_DRAG_TYPE } from '../../../../shared/native-file-drop'
 import { installOsFileDropCancellationGuard } from '../../lib/os-file-drop-cancellation-guard'
 import { useFeedbackImageDrop } from './use-feedback-image-drop'
@@ -18,6 +13,15 @@ let root: Root
 let preloadDropSpy: ReturnType<typeof vi.fn<(event: Event) => void>>
 
 function preloadDropListener(event: Event): void {
+  if (
+    event
+      .composedPath()
+      .some(
+        (entry) => entry instanceof HTMLElement && entry.hasAttribute(OS_FILE_DROP_OWNER_ATTRIBUTE)
+      )
+  ) {
+    return
+  }
   preloadDropSpy(event)
   // Why: preload consumes the gesture, which is why React's onDrop never runs.
   event.preventDefault()
@@ -68,6 +72,7 @@ async function renderHarness(
 
 function dragEvent(type: string, files: File[], types: string[] = ['Files']): Event {
   const event = new Event(type, { bubbles: true, cancelable: true })
+  Object.defineProperty(event, 'isTrusted', { value: true })
   Object.defineProperty(event, 'dataTransfer', { value: { files, types } })
   return event
 }
@@ -89,6 +94,7 @@ describe('useFeedbackImageDrop', () => {
     const onAddFiles = vi.fn()
     await renderHarness(true, onAddFiles)
 
+    expect(container.querySelector('[data-os-file-drop-owner]')).not.toBeNull()
     const event = dragEvent('drop', [pngFile()])
     act(() => {
       dialogChild().dispatchEvent(event)
@@ -114,7 +120,7 @@ describe('useFeedbackImageDrop', () => {
     expect(preloadDropSpy).toHaveBeenCalledTimes(1)
   })
 
-  it('ignores non-image drops so they keep their existing behavior', async () => {
+  it('claims non-image drops so they cannot open in the editor behind the dialog', async () => {
     const onAddFiles = vi.fn()
     await renderHarness(true, onAddFiles)
 
@@ -124,9 +130,8 @@ describe('useFeedbackImageDrop', () => {
     })
 
     expect(onAddFiles).not.toHaveBeenCalled()
-    expect(preloadDropSpy).toHaveBeenCalledTimes(1)
-    // Why: dragover accepted the drag, so an uncancelled drop navigates the web
-    // client to the file; preload still gets it because propagation continues.
+    expect(preloadDropSpy).not.toHaveBeenCalled()
+    // A refused file still cancels browser navigation.
     expect(event.defaultPrevented).toBe(true)
   })
 
@@ -174,6 +179,7 @@ describe('useFeedbackImageDrop', () => {
     try {
       const onAddFiles = vi.fn()
       await renderHarness(true, onAddFiles)
+      expect(container.querySelector('[data-os-file-drop-owner]')).not.toBeNull()
       const image = pngFile()
       const hover = dragEvent('dragover', [])
       act(() => {
diff --git a/src/renderer/src/components/sidebar/use-feedback-image-drop.ts b/src/renderer/src/components/sidebar/use-feedback-image-drop.ts
index c15d0601e1e8..8fdac155e5fe 100644
--- a/src/renderer/src/components/sidebar/use-feedback-image-drop.ts
+++ b/src/renderer/src/components/sidebar/use-feedback-image-drop.ts
@@ -1,5 +1,6 @@
 import React, { useCallback, useEffect, useRef, useState } from 'react'
 import { hasNativeFileDragTypes } from '../../../../shared/native-file-drop'
+import { OS_FILE_DROP_OWNER_ATTRIBUTE } from '../../../../shared/native-file-drop-preparation'
 import { extractImageFilesFromDataTransfer } from '@/lib/feedback-image-attachments'
 
 type FeedbackImageDragHandlers = {
@@ -10,21 +11,16 @@ type FeedbackImageDragHandlers = {
 
 export type FeedbackImageDrop = {
   isDragActive: boolean
-  contentRef: React.RefObject<HTMLDivElement | null>
+  contentRef: (node: HTMLDivElement | null) => void
   dragHandlers: FeedbackImageDragHandlers
 }
 
-/**
- * Drag-and-drop attachment wiring for the feedback dialog. Native file drops
- * never reach React here: preload consumes them on document capture and routes
- * the paths to the editor, so the drop is claimed one phase earlier on window.
- */
 export function useFeedbackImageDrop(
   open: boolean,
   onAddFiles: (files: readonly File[]) => void
 ): FeedbackImageDrop {
   const [isDragActive, setIsDragActive] = useState(false)
-  const contentRef = useRef<HTMLDivElement | null>(null)
+  const detachRef = useRef<(() => void) | null>(null)
   const dragDepthRef = useRef(0)
 
   const reset = useCallback(() => {
@@ -66,38 +62,50 @@ export function useFeedbackImageDrop(
     }
   }, [])
 
-  useEffect(() => {
-    if (!open) {
-      return
-    }
-    const handleDrop = (event: DragEvent): void => {
-      const droppedInDialog = contentRef.current?.contains(event.target as Node) ?? false
-      reset()
-      if (!droppedInDialog || !hasNativeFileDragTypes(event.dataTransfer?.types)) {
+  const contentRef = useCallback(
+    (node: HTMLDivElement | null): void => {
+      detachRef.current?.()
+      detachRef.current = null
+      if (!node || !open) {
         return
       }
-      // Why: dragover accepted this drag, and a drop left uncancelled after that
-      // is what makes the browser navigate to the file — including the non-image
-      // drops below, which would otherwise wipe the typed feedback on web.
-      event.preventDefault()
-      const images = extractImageFilesFromDataTransfer(event.dataTransfer)
-      if (images.length === 0) {
-        return
+      const handleDrop = (event: DragEvent): void => {
+        if (!hasNativeFileDragTypes(event.dataTransfer?.types)) {
+          return
+        }
+        event.preventDefault()
+        event.stopPropagation()
+        reset()
+        if (!event.isTrusted) {
+          return
+        }
+        const images = extractImageFilesFromDataTransfer(event.dataTransfer)
+        if (images.length > 0) {
+          onAddFiles(images)
+        }
       }
-      // Why: stop preload's native-drop lane from also opening the screenshot
-      // in an editor behind the dialog.
-      event.stopPropagation()
-      onAddFiles(images)
+      node.setAttribute(OS_FILE_DROP_OWNER_ATTRIBUTE, '')
+      node.addEventListener('drop', handleDrop, true)
+      detachRef.current = () => {
+        node.removeEventListener('drop', handleDrop, true)
+        node.removeAttribute(OS_FILE_DROP_OWNER_ATTRIBUTE)
+      }
+    },
+    [onAddFiles, open, reset]
+  )
+  useEffect(() => {
+    if (!open) {
+      reset()
+      return
     }
-    window.addEventListener('drop', handleDrop, true)
-    window.addEventListener('dragend', reset, true)
+    document.addEventListener('drop', reset, true)
+    document.addEventListener('dragend', reset, true)
     return () => {
-      window.removeEventListener('drop', handleDrop, true)
-      window.removeEventListener('dragend', reset, true)
-      // Why: a dialog closed mid-drag would otherwise reopen mid-highlight.
+      document.removeEventListener('drop', reset, true)
+      document.removeEventListener('dragend', reset, true)
       reset()
     }
-  }, [onAddFiles, open, reset])
+  }, [open, reset])
 
   return { isDragActive, contentRef, dragHandlers: { onDragEnter, onDragOver, onDragLeave } }
 }
diff --git a/src/renderer/src/hooks/composer-drop-owner.test.ts b/src/renderer/src/hooks/composer-drop-owner.test.ts
deleted file mode 100644
index fe95275b90ba..000000000000
--- a/src/renderer/src/hooks/composer-drop-owner.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isCurrentComposerDropOwner } from './composer-drop-owner'
-
-describe('composer drop owner', () => {
-  it('keeps the top mounted composer as the only drop owner', () => {
-    const page = Symbol('page')
-    const modal = Symbol('modal')
-
-    expect(isCurrentComposerDropOwner([page], page)).toBe(true)
-    expect(isCurrentComposerDropOwner([page, modal], page)).toBe(false)
-    expect(isCurrentComposerDropOwner([page, modal], modal)).toBe(true)
-  })
-})
diff --git a/src/renderer/src/hooks/composer-drop-owner.ts b/src/renderer/src/hooks/composer-drop-owner.ts
deleted file mode 100644
index f4896aea5079..000000000000
--- a/src/renderer/src/hooks/composer-drop-owner.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export type ComposerDropOwner = symbol
-
-export function isCurrentComposerDropOwner(
-  ownerStack: readonly ComposerDropOwner[],
-  owner: ComposerDropOwner
-): boolean {
-  return ownerStack.at(-1) === owner
-}
diff --git a/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx b/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx
index 31900f8202dc..40dd50686b4b 100644
--- a/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx
+++ b/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx
@@ -14,7 +14,6 @@ vi.mock('@/store', () => ({
 vi.mock('@/runtime/runtime-file-client', () => ({
   importExternalPathsToRuntime: (...args: unknown[]) => mocks.importExternalPaths(...args)
 }))
-vi.mock('./composer-drop-listener', () => ({ useComposerDropListener: vi.fn() }))
 
 import { useAttachmentDropState } from './attachment-drop-state'
 
diff --git a/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx b/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx
index 6709b5e76f34..049cecacffce 100644
--- a/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx
+++ b/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx
@@ -3,7 +3,6 @@
 import { act, cleanup, renderHook } from '@testing-library/react'
 import { createRef, StrictMode } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { NativeFileDropPayload } from '../../../../shared/native-file-drop'
 import { useAttachmentDropState } from './attachment-drop-state'
 
 const mocks = vi.hoisted(() => ({ toastError: vi.fn() }))
@@ -11,7 +10,6 @@ vi.mock('sonner', () => ({ toast: { error: mocks.toastError } }))
 vi.mock('@/store', () => ({ useAppStore: { getState: () => ({}) } }))
 vi.mock('@/runtime/runtime-file-client', () => ({ importExternalPathsToRuntime: vi.fn() }))
 
-const listeners = new Set<(data: NativeFileDropPayload) => void>()
 const stat = vi.fn(async (_input: { filePath: string }) => ({ isDirectory: false }))
 let originalApi: PropertyDescriptor | undefined
 
@@ -36,12 +34,6 @@ function renderDrop(strict = false) {
   return { ...hook, attach, prompt }
 }
 
-function nativeDrop(paths: string[]): void {
-  for (const listener of listeners) {
-    listener({ target: 'composer', paths })
-  }
-}
-
 beforeEach(() => {
   vi.clearAllMocks()
   stat.mockReset().mockResolvedValue({ isDirectory: false })
@@ -49,20 +41,13 @@ beforeEach(() => {
   Object.defineProperty(window, 'api', {
     configurable: true,
     value: {
-      fs: { stat },
-      ui: {
-        onFileDrop: (listener: (data: NativeFileDropPayload) => void) => {
-          listeners.add(listener)
-          return () => listeners.delete(listener)
-        }
-      }
+      fs: { stat }
     }
   })
 })
 
 afterEach(() => {
   cleanup()
-  expect(listeners.size).toBe(0)
   if (originalApi) {
     Object.defineProperty(window, 'api', originalApi)
   } else {
@@ -149,72 +134,41 @@ describe('local composer drop lifetime', () => {
   })
 })
 
-describe('native composer ownership during a local drop', () => {
-  it.each([false, true])(
-    'stops after actual listener cleanup (Strict Mode: %s)',
-    async (strict) => {
-      const gate = Promise.withResolvers<void>()
-      holdStat(gate.promise)
-      const hook = renderDrop(strict)
-      act(() => nativeDrop(['/drop/one', '/drop/two']))
-      await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
-      hook.unmount()
-      expect(listeners.size).toBe(0)
-      await act(async () => gate.resolve())
-
-      expect(stat).toHaveBeenCalledOnce()
-      expect(hook.attach).not.toHaveBeenCalled()
-    }
-  )
-
-  it('continues while temporarily covered and applies if ownership returns', async () => {
-    const first = Promise.withResolvers<void>()
-    const second = Promise.withResolvers<void>()
-    holdStat(first.promise)
-    holdStat(second.promise)
-    const older = renderDrop()
-    act(() => nativeDrop(['/drop/one', '/drop/two']))
+describe('native composer destination lifetime', () => {
+  it.each([false, true])('stops after unmount (Strict Mode: %s)', async (strict) => {
+    const gate = Promise.withResolvers<void>()
+    holdStat(gate.promise)
+    const hook = renderDrop(strict)
+    const pending = hook.result.current.applyNativeDrop(['/drop/one', '/drop/two'], () => true)
     await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
-    const newer = renderDrop()
-    await act(async () => first.resolve())
-    expect(stat).toHaveBeenCalledTimes(2)
-    expect(older.attach).not.toHaveBeenCalled()
-    newer.unmount()
-    await act(async () => second.resolve())
-
-    expect(older.attach).toHaveBeenCalledOnce()
-    expect(newer.attach).not.toHaveBeenCalled()
+    hook.unmount()
+    await act(async () => gate.resolve())
+    await pending
+    expect(stat).toHaveBeenCalledOnce()
+    expect(hook.attach).not.toHaveBeenCalled()
   })
-
-  it('withholds a completed drop while a newer owner remains mounted', async () => {
+  it('keeps the original destination when a newer composer mounts', async () => {
     const gate = Promise.withResolvers<void>()
     holdStat(gate.promise)
     const older = renderDrop()
-    act(() => nativeDrop(['/drop/one', '/drop/two']))
+    const pending = older.result.current.applyNativeDrop(['/drop/one'], () => true)
     await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
     const newer = renderDrop()
     await act(async () => gate.resolve())
-
-    expect(stat).toHaveBeenCalledTimes(2)
-    expect(older.attach).not.toHaveBeenCalled()
+    await pending
+    expect(older.attach).toHaveBeenCalledOnce()
     expect(newer.attach).not.toHaveBeenCalled()
   })
-
-  it('does not revive an old batch when another composer mounts', async () => {
+  it('withholds a completed drop when its destination changes', async () => {
     const gate = Promise.withResolvers<void>()
     holdStat(gate.promise)
-    const older = renderDrop()
-    act(() => nativeDrop(['/drop/old-one', '/drop/old-two']))
+    const hook = renderDrop()
+    let current = true
+    const pending = hook.result.current.applyNativeDrop(['/drop/one'], () => current)
     await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
-    older.unmount()
-    const newer = renderDrop()
-    await act(async () => {
-      nativeDrop(['/drop/new'])
-      gate.resolve()
-    })
-
-    expect(stat.mock.calls.map(([input]) => input.filePath)).toEqual(['/drop/old-one', '/drop/new'])
-    expect(older.attach).not.toHaveBeenCalled()
-    expect(newer.attach).toHaveBeenCalledOnce()
+    current = false
+    await act(async () => gate.resolve())
+    await pending
+    expect(hook.attach).not.toHaveBeenCalled()
   })
 })
diff --git a/src/renderer/src/hooks/composer-state/attachment-drop-state.ts b/src/renderer/src/hooks/composer-state/attachment-drop-state.ts
index 3358a7e028e1..eb8b2c990c9e 100644
--- a/src/renderer/src/hooks/composer-state/attachment-drop-state.ts
+++ b/src/renderer/src/hooks/composer-state/attachment-drop-state.ts
@@ -29,7 +29,6 @@ import {
 } from '../composer-drop-result'
 import { applyComposerNativeFileDrop } from '../composer-native-file-drop'
 import { useMountedRef } from '../useMountedRef'
-import { useComposerDropListener } from './composer-drop-listener'
 import { userNamedFileAccess } from '@/lib/local-file-access'
 
 // Local drops bypass the runtime importer's skip classification.
@@ -250,8 +249,8 @@ export function useAttachmentDropState(input: AttachmentDropStateInput) {
   )
 
   const applyNativeDrop = useCallback(
-    (paths: string[], isCurrentOwner: () => boolean): void => {
-      void applyComposerNativeFileDrop({
+    (paths: string[], isCurrentOwner: () => boolean): Promise<void> => {
+      return applyComposerNativeFileDrop({
         paths,
         isCurrentOwner,
         uploadPaths: (sourcePaths) =>
@@ -279,14 +278,13 @@ export function useAttachmentDropState(input: AttachmentDropStateInput) {
       uploadComposerPaths
     ]
   )
-  // Why: native OS file drops relay via the preload bridge; only the most recently mounted composer applies them.
-  useComposerDropListener(applyNativeDrop)
 
   return {
     addComposerAttachments,
     insertComposerFolderPaths,
     uploadComposerPaths,
     handleAddAttachment,
-    applyLocalComposerDrop
+    applyLocalComposerDrop,
+    applyNativeDrop
   }
 }
diff --git a/src/renderer/src/hooks/composer-state/composer-attachment-drop-state.ts b/src/renderer/src/hooks/composer-state/composer-attachment-drop-state.ts
new file mode 100644
index 000000000000..c80cad12b2f8
--- /dev/null
+++ b/src/renderer/src/hooks/composer-state/composer-attachment-drop-state.ts
@@ -0,0 +1,24 @@
+import type { ComposerTargetState } from './composer-target-state-contract'
+import { resolveComposerAttachmentTarget } from './composer-attachment-target'
+import { useAttachmentDropState } from './attachment-drop-state'
+
+export function useComposerAttachmentDropState(target: ComposerTargetState) {
+  const destination = resolveComposerAttachmentTarget({
+    selectedProjectGroup: target.initialTargetState.selectedProjectGroup,
+    selectedRepoPath: target.asyncComposerState.selectedRepoPath,
+    selectedRepoExecutionHostId: target.runtimeTargetSelection.selectedRepoExecutionHostId,
+    selectedRepoSettings: target.runtimeTargetSelection.selectedRepoSettings,
+    connectionId: target.workspaceIdentityState.connectionId
+  })
+  return useAttachmentDropState({
+    agentPromptRef: target.asyncComposerState.agentPromptRef,
+    cancelPromptCaretFrame: target.providerRuntimeSync.cancelPromptCaretFrame,
+    connectionId: destination.connectionId,
+    promptCaretFrameRef: target.asyncComposerState.promptCaretFrameRef,
+    promptTextareaRef: target.asyncComposerState.promptTextareaRef,
+    selectedRepoPath: destination.path ?? undefined,
+    selectedRepoSettings: destination.settings,
+    setAgentPrompt: target.sourceContextState.setAgentPrompt,
+    setAttachmentPaths: target.sourceContextState.setAttachmentPaths
+  })
+}
diff --git a/src/renderer/src/hooks/composer-state/composer-attachment-target.test.ts b/src/renderer/src/hooks/composer-state/composer-attachment-target.test.ts
new file mode 100644
index 000000000000..f9d8973f5e50
--- /dev/null
+++ b/src/renderer/src/hooks/composer-state/composer-attachment-target.test.ts
@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest'
+import type { ProjectGroup } from '../../../../shared/project-group-types'
+import { resolveComposerAttachmentTarget } from './composer-attachment-target'
+
+const group: ProjectGroup = {
+  id: 'folder-project',
+  name: 'Project',
+  parentPath: '/folder',
+  parentGroupId: null,
+  createdFrom: 'manual',
+  tabOrder: 0,
+  isCollapsed: false,
+  color: null,
+  createdAt: 0,
+  updatedAt: 0
+}
+const selected = {
+  selectedProjectGroup: null,
+  selectedRepoPath: '/repo',
+  selectedRepoExecutionHostId: 'local' as const,
+  selectedRepoSettings: { activeRuntimeEnvironmentId: 'focused-runtime' },
+  connectionId: null
+}
+describe('composer attachment destination', () => {
+  it('uses the selected local host even when a runtime is focused', () => {
+    expect(resolveComposerAttachmentTarget(selected)).toEqual({
+      hostId: 'local',
+      path: '/repo',
+      connectionId: null,
+      settings: { activeRuntimeEnvironmentId: null }
+    })
+  })
+  it('uses the selected runtime without borrowing the focused runtime', () => {
+    expect(
+      resolveComposerAttachmentTarget({
+        ...selected,
+        selectedRepoExecutionHostId: 'runtime:selected'
+      }).settings.activeRuntimeEnvironmentId
+    ).toBe('selected')
+  })
+  it('uses a folder project path and recorded SSH host', () => {
+    expect(
+      resolveComposerAttachmentTarget({
+        ...selected,
+        selectedRepoPath: undefined,
+        selectedProjectGroup: { ...group, connectionId: 'ssh-a' }
+      })
+    ).toEqual({
+      hostId: 'ssh:ssh-a',
+      path: '/folder',
+      connectionId: 'ssh-a',
+      settings: { activeRuntimeEnvironmentId: null }
+    })
+  })
+  it('uses a folder project runtime owner', () => {
+    expect(
+      resolveComposerAttachmentTarget({
+        ...selected,
+        selectedRepoPath: undefined,
+        selectedProjectGroup: { ...group, executionHostId: 'runtime:folder-host' }
+      })
+    ).toEqual({
+      hostId: 'runtime:folder-host',
+      path: '/folder',
+      connectionId: null,
+      settings: { activeRuntimeEnvironmentId: 'folder-host' }
+    })
+  })
+  it.each(['/folder/source-repo', '/outside/source-repo'])(
+    'keeps folder attachments in the project when the task source is %s',
+    (sourcePath) => {
+      expect(
+        resolveComposerAttachmentTarget({
+          ...selected,
+          selectedRepoPath: sourcePath,
+          selectedProjectGroup: { ...group, connectionId: 'ssh-a' }
+        }).path
+      ).toBe('/folder')
+    }
+  )
+  it('keeps the folder destination unchanged when the task source repository changes', () => {
+    const input = { ...selected, selectedProjectGroup: { ...group, connectionId: 'ssh-a' } }
+    expect(
+      resolveComposerAttachmentTarget({ ...input, selectedRepoPath: '/folder/first' })
+    ).toEqual(resolveComposerAttachmentTarget({ ...input, selectedRepoPath: '/outside/second' }))
+  })
+  it('keeps a missing selection unresolved', () => {
+    expect(
+      resolveComposerAttachmentTarget({
+        ...selected,
+        selectedRepoPath: undefined,
+        selectedRepoExecutionHostId: null
+      }).hostId
+    ).toBeNull()
+  })
+})
diff --git a/src/renderer/src/hooks/composer-state/composer-attachment-target.ts b/src/renderer/src/hooks/composer-state/composer-attachment-target.ts
new file mode 100644
index 000000000000..5a147f9ee7c5
--- /dev/null
+++ b/src/renderer/src/hooks/composer-state/composer-attachment-target.ts
@@ -0,0 +1,30 @@
+import { getRepoExecutionHostId, parseExecutionHostId } from '../../../../shared/execution-host'
+import type { ComposerModel } from './composer-model'
+
+type TargetInput = Pick<
+  ComposerModel,
+  | 'selectedProjectGroup'
+  | 'selectedRepoPath'
+  | 'selectedRepoExecutionHostId'
+  | 'selectedRepoSettings'
+  | 'connectionId'
+>
+
+export function resolveComposerAttachmentTarget(input: TargetInput) {
+  const group = input.selectedProjectGroup
+  const hostId = group ? getRepoExecutionHostId(group) : input.selectedRepoExecutionHostId
+  const host = parseExecutionHostId(hostId)
+  return {
+    hostId,
+    path: group ? group.parentPath : (input.selectedRepoPath ?? null),
+    connectionId: group
+      ? host?.kind === 'runtime'
+        ? null
+        : (group.connectionId ?? null)
+      : input.connectionId,
+    settings: {
+      ...input.selectedRepoSettings,
+      activeRuntimeEnvironmentId: host?.kind === 'runtime' ? host.environmentId : null
+    }
+  }
+}
diff --git a/src/renderer/src/hooks/composer-state/composer-card-contract.ts b/src/renderer/src/hooks/composer-state/composer-card-contract.ts
index 64ef15be23f5..bbd084be6bfb 100644
--- a/src/renderer/src/hooks/composer-state/composer-card-contract.ts
+++ b/src/renderer/src/hooks/composer-state/composer-card-contract.ts
@@ -86,6 +86,7 @@ export type ComposerCardActionProps = {
   onAgentPromptChange: ComposerModel['setAgentPrompt']
   linkedOnlyTemplatePreview: string | null
   getAttachmentLabel: (pathValue: string) => string
+  onNativeFileDrop?: ComposerModel['applyNativeDrop']
   onAddAttachment: () => void
   onRemoveAttachment: (pathValue: string) => void
   onRemoveLinkedWorkItem: ComposerModel['handleRemoveLinkedWorkItem']
diff --git a/src/renderer/src/hooks/composer-state/composer-card-props.ts b/src/renderer/src/hooks/composer-state/composer-card-props.ts
index a5a2fb7bd664..4584bec2a5fa 100644
--- a/src/renderer/src/hooks/composer-state/composer-card-props.ts
+++ b/src/renderer/src/hooks/composer-state/composer-card-props.ts
@@ -1,9 +1,11 @@
+import { resolveComposerAttachmentTarget } from './composer-attachment-target'
 import { getAttachmentLabel } from '@/lib/new-workspace'
 import { getQuickComposerCreateDisabled } from '@/lib/new-workspace-create-gates'
 import type { ComposerModel } from './composer-model'
 import type { ComposerCardActionProps, ComposerCardSourceProps } from './composer-card-contract'
 
 export function buildComposerCardProps(state: ComposerModel) {
+  const attachmentTarget = resolveComposerAttachmentTarget(state)
   const {
     advancedOpen,
     agentPrompt,
@@ -78,7 +80,6 @@ export function buildComposerCardProps(state: ComposerModel) {
     selectedProjectHostSetupId,
     selectedProjectId,
     selectedRepo,
-    selectedRepoExecutionHostId,
     selectedRepoConnectInProgress,
     selectedRepoConnectionId,
     selectedRepoGitHubSourceContext,
@@ -152,7 +153,7 @@ export function buildComposerCardProps(state: ComposerModel) {
     onBranchNameOverrideChange: isProjectGroupTarget ? () => {} : handleBranchNameOverrideChange,
     parentWorktreeId: isProjectGroupTarget ? null : parentWorktreeId,
     onParentWorktreeIdChange: isProjectGroupTarget ? () => {} : setParentWorktreeId,
-    selectedRepoExecutionHostId: isProjectGroupTarget ? null : selectedRepoExecutionHostId,
+    selectedRepoExecutionHostId: attachmentTarget.hostId,
     selectedRepoProjectId: isProjectGroupTarget ? null : selectedRepoProjectId,
     onSmartGitHubItemSelect: handleSmartGitHubItemSelect,
     onSmartGitLabItemSelect: handleSmartGitLabItemSelect,
@@ -181,6 +182,8 @@ export function buildComposerCardProps(state: ComposerModel) {
     linkedOnlyTemplatePreview: shouldApplyLinkedOnlyTemplate ? linkedOnlyTemplatePrompt : null,
     attachmentPaths,
     getAttachmentLabel,
+    // Quick create has no attachment display or launch-prompt destination.
+    onNativeFileDrop: undefined,
     onAddAttachment: () => void handleAddAttachment(),
     onRemoveAttachment: (pathValue) =>
       setAttachmentPaths((current) => current.filter((currentPath) => currentPath !== pathValue)),
@@ -210,7 +213,7 @@ export function buildComposerCardProps(state: ComposerModel) {
     onBaseBranchMrSelect: isProjectGroupTarget ? () => {} : handleBaseBranchMrSelect,
     baseBranchLinkedPrNumber:
       linkedWorkItem?.type === 'pr' && baseBranch ? linkedWorkItem.number : null,
-    selectedRepoPath: isProjectGroupTarget ? null : (selectedRepo?.path ?? null),
+    selectedRepoPath: attachmentTarget.path,
     selectedRepoIsRemote: isProjectGroupTarget
       ? folderTargetIsRemote
       : Boolean(selectedRepo?.connectionId),
diff --git a/src/renderer/src/hooks/composer-state/composer-drop-listener.test.ts b/src/renderer/src/hooks/composer-state/composer-drop-listener.test.ts
deleted file mode 100644
index eea389815cf3..000000000000
--- a/src/renderer/src/hooks/composer-state/composer-drop-listener.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-// @vitest-environment happy-dom
-
-import { act, renderHook } from '@testing-library/react'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useComposerDropListener } from './composer-drop-listener'
-import type { NativeFileDropPayload } from '../../../../shared/native-file-drop'
-
-let originalApiDescriptor: PropertyDescriptor | undefined
-
-beforeEach(() => {
-  originalApiDescriptor = Object.getOwnPropertyDescriptor(window, 'api')
-  const ui = {
-    onFileDrop: vi.fn<Window['api']['ui']['onFileDrop']>()
-  } satisfies Pick<Window['api']['ui'], 'onFileDrop'>
-  Object.defineProperty(window, 'api', {
-    configurable: true,
-    value: { ui }
-  })
-})
-
-afterEach(() => {
-  vi.restoreAllMocks()
-  if (originalApiDescriptor) {
-    Object.defineProperty(window, 'api', originalApiDescriptor)
-  } else {
-    Reflect.deleteProperty(window, 'api')
-  }
-})
-
-describe('useComposerDropListener', () => {
-  it('routes to the newest composer and restores the previous owner after cleanup', () => {
-    const listeners: ((data: NativeFileDropPayload) => void)[] = []
-    const unsubscribes: (() => void)[] = []
-    vi.spyOn(window.api.ui, 'onFileDrop').mockImplementation((listener) => {
-      listeners.push(listener)
-      const unsubscribe = vi.fn()
-      unsubscribes.push(unsubscribe)
-      return unsubscribe
-    })
-    const firstApply = vi.fn()
-    const secondApply = vi.fn()
-    const first = renderHook(() => useComposerDropListener(firstApply))
-    const second = renderHook(() => useComposerDropListener(secondApply))
-
-    act(() => {
-      for (const listener of listeners) {
-        listener({ target: 'composer', paths: ['/tmp/newest.txt'] })
-      }
-    })
-    expect(firstApply).not.toHaveBeenCalled()
-    expect(secondApply).toHaveBeenCalledTimes(1)
-
-    second.unmount()
-    expect(unsubscribes[1]).toHaveBeenCalledTimes(1)
-    act(() => {
-      listeners[0]({ target: 'composer', paths: ['/tmp/restored.txt'] })
-    })
-    expect(firstApply).toHaveBeenCalledTimes(1)
-
-    first.unmount()
-    expect(unsubscribes[0]).toHaveBeenCalledTimes(1)
-  })
-})
diff --git a/src/renderer/src/hooks/composer-state/composer-drop-listener.ts b/src/renderer/src/hooks/composer-state/composer-drop-listener.ts
deleted file mode 100644
index 8c57e26d4f82..000000000000
--- a/src/renderer/src/hooks/composer-state/composer-drop-listener.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { useEffect, useRef } from 'react'
-import { isCurrentComposerDropOwner } from '../composer-drop-owner'
-
-const composerDropStack: symbol[] = []
-
-export function useComposerDropListener(
-  applyDrop: (paths: string[], isCurrentOwner: () => boolean) => void
-): void {
-  const applyDropRef = useRef(applyDrop)
-  useEffect(() => {
-    applyDropRef.current = applyDrop
-  }, [applyDrop])
-  const instanceIdRef = useRef<symbol>(undefined!)
-  instanceIdRef.current ??= Symbol('composer')
-
-  useEffect(() => {
-    const instanceId = instanceIdRef.current
-    composerDropStack.push(instanceId)
-    const unsubscribe = window.api.ui.onFileDrop((data) => {
-      if (
-        data.target !== 'composer' ||
-        // Why: a scoped payload belongs to the pane composer that published that
-        // scope key; this stack only owns drops from unscoped composers.
-        data.scopeKey !== undefined ||
-        !isCurrentComposerDropOwner(composerDropStack, instanceId)
-      ) {
-        return
-      }
-      const isCurrentOwner = (): boolean =>
-        isCurrentComposerDropOwner(composerDropStack, instanceId)
-      applyDropRef.current(data.paths, isCurrentOwner)
-    })
-    return () => {
-      unsubscribe()
-      const index = composerDropStack.lastIndexOf(instanceId)
-      if (index !== -1) {
-        composerDropStack.splice(index, 1)
-      }
-    }
-  }, [])
-}
diff --git a/src/renderer/src/hooks/composer-state/composer-source-model.ts b/src/renderer/src/hooks/composer-state/composer-source-model.ts
index bab47484826f..41b335a683b9 100644
--- a/src/renderer/src/hooks/composer-state/composer-source-model.ts
+++ b/src/renderer/src/hooks/composer-state/composer-source-model.ts
@@ -15,6 +15,7 @@ export type ComposerSourceModel = {
     item: GitHubWorkItem,
     options?: { preserveBranchNameOverride?: boolean | undefined }
   ) => void
+  applyNativeDrop: (paths: string[], isCurrentOwner: () => boolean) => Promise<void>
   applyLocalComposerDrop: (paths: string[], canApply?: () => boolean) => Promise<void>
   canPrefetchSelectedRepoWorkItems: boolean
   folderCreateDisabled: boolean
diff --git a/src/renderer/src/hooks/composer-state/composer-source-state-contract.ts b/src/renderer/src/hooks/composer-state/composer-source-state-contract.ts
index e4b95c140cfc..10206c9d40ba 100644
--- a/src/renderer/src/hooks/composer-state/composer-source-state-contract.ts
+++ b/src/renderer/src/hooks/composer-state/composer-source-state-contract.ts
@@ -16,6 +16,7 @@ export type ComposerSourceState = {
     | 'uploadComposerPaths'
     | 'handleAddAttachment'
     | 'applyLocalComposerDrop'
+    | 'applyNativeDrop'
   >
   targetChangeActions: Pick<
     ComposerModel,
diff --git a/src/renderer/src/hooks/composer-state/composer-source-state.ts b/src/renderer/src/hooks/composer-state/composer-source-state.ts
index 4cda33be903b..5199f2d4efbf 100644
--- a/src/renderer/src/hooks/composer-state/composer-source-state.ts
+++ b/src/renderer/src/hooks/composer-state/composer-source-state.ts
@@ -2,7 +2,7 @@ import type { ComposerTargetState } from './composer-target-state-contract'
 import type { ComposerExternalSyncState } from './composer-external-sync-contract'
 import type { ComposerSourceState } from './composer-source-state-contract'
 import { useSourceIdentityActions } from './source-identity-actions'
-import { useAttachmentDropState } from './attachment-drop-state'
+import { useComposerAttachmentDropState } from './composer-attachment-drop-state'
 import { useTargetChangeActions } from './target-change-actions'
 import { useProjectTargetActions } from './project-target-actions'
 import { useBranchStartPointActions } from './branch-start-point-actions'
@@ -49,17 +49,7 @@ export function useComposerSourceState(
     smartGitHubPrStartPointSelectionRef:
       target.asyncComposerState.smartGitHubPrStartPointSelectionRef
   })
-  const attachmentDropState = useAttachmentDropState({
-    agentPromptRef: target.asyncComposerState.agentPromptRef,
-    cancelPromptCaretFrame: target.providerRuntimeSync.cancelPromptCaretFrame,
-    connectionId: target.workspaceIdentityState.connectionId,
-    promptCaretFrameRef: target.asyncComposerState.promptCaretFrameRef,
-    promptTextareaRef: target.asyncComposerState.promptTextareaRef,
-    selectedRepoPath: target.asyncComposerState.selectedRepoPath,
-    selectedRepoSettings: target.runtimeTargetSelection.selectedRepoSettings,
-    setAgentPrompt: target.sourceContextState.setAgentPrompt,
-    setAttachmentPaths: target.sourceContextState.setAttachmentPaths
-  })
+  const attachmentDropState = useComposerAttachmentDropState(target)
   const targetChangeActions = useTargetChangeActions({
     baseBranch: target.workspaceIdentityState.baseBranch,
     branchAutoNameRef: target.asyncComposerState.branchAutoNameRef,
diff --git a/src/renderer/src/hooks/use-os-file-drop-owner.test.tsx b/src/renderer/src/hooks/use-os-file-drop-owner.test.tsx
index efab76d59970..625a85642f97 100644
--- a/src/renderer/src/hooks/use-os-file-drop-owner.test.tsx
+++ b/src/renderer/src/hooks/use-os-file-drop-owner.test.tsx
@@ -102,6 +102,15 @@ afterEach(() => {
 })
 
 describe('useOsFileDropOwner', () => {
+  it('claims a trusted refused drop without reading file paths', () => {
+    const onDrop = vi.fn()
+    const view = render(<Owner onDrop={onDrop} canAccept={false} />)
+    drag(view.getByTestId('owner'), 'drop')
+    expect(getPathForFile).not.toHaveBeenCalled()
+    expect(onDrop).not.toHaveBeenCalled()
+    drag(view.getByTestId('owner'), 'drop', undefined, { trusted: false })
+    expect(onDrop).not.toHaveBeenCalled()
+  })
   it('registers the root with a callback ref and delivers one prepared drop to the nearest owner', async () => {
     const outerDrop = vi.fn<DropHandler>()
     const innerDrop = vi.fn<DropHandler>()
diff --git a/src/renderer/src/hooks/use-os-file-drop-owner.ts b/src/renderer/src/hooks/use-os-file-drop-owner.ts
index f69d6d9f85f1..7c057ac5ac7d 100644
--- a/src/renderer/src/hooks/use-os-file-drop-owner.ts
+++ b/src/renderer/src/hooks/use-os-file-drop-owner.ts
@@ -27,7 +27,7 @@ type OsFileDropContext<Destination> = {
 type OsFileDropOwnerOptions<Destination> = {
   consumer: DroppedPathConsumer
   sequence: OsFileDropSequence
-  canAccept?: boolean
+  canAccept?: boolean | (() => boolean)
   captureDestination?: (event: DragEvent) => Destination
   onDrop: (
     prepared: PreparedDroppedPaths,
@@ -76,6 +76,10 @@ export function useOsFileDropOwner<Destination = undefined>(
       }
 
       let attached = true
+      const canAccept = (): boolean => {
+        const availability = optionsRef.current.canAccept
+        return typeof availability === 'function' ? availability() : availability !== false
+      }
 
       const onDragOver = (event: DragEvent): void => {
         if (!hasOsFileDragTypes(event.dataTransfer?.types) || !isNearestOwner(root, event)) {
@@ -84,7 +88,7 @@ export function useOsFileDropOwner<Destination = undefined>(
         event.preventDefault()
         event.stopPropagation()
         if (event.dataTransfer) {
-          event.dataTransfer.dropEffect = optionsRef.current.canAccept === false ? 'none' : 'copy'
+          event.dataTransfer.dropEffect = canAccept() ? 'copy' : 'none'
         }
       }
 
@@ -94,7 +98,10 @@ export function useOsFileDropOwner<Destination = undefined>(
         }
         event.preventDefault()
         event.stopPropagation()
-        if (!event.isTrusted || optionsRef.current.canAccept === false) {
+        if (!event.isTrusted) {
+          return
+        }
+        if (!canAccept()) {
           return
         }
 
diff --git a/src/renderer/src/hooks/useComposerState.integration.test.ts b/src/renderer/src/hooks/useComposerState.integration.test.ts
index 318aad599cad..747ebdaac0bb 100644
--- a/src/renderer/src/hooks/useComposerState.integration.test.ts
+++ b/src/renderer/src/hooks/useComposerState.integration.test.ts
@@ -70,13 +70,6 @@ describe('useComposerState integrated lifecycle', () => {
       worktreesByRepo: {},
       sparsePresetsByRepo: {}
     })
-    const unsubscribes: ReturnType<typeof vi.fn>[] = []
-    vi.spyOn(window.api.ui, 'onFileDrop').mockImplementation(() => {
-      const unsubscribe = vi.fn()
-      unsubscribes.push(unsubscribe)
-      return unsubscribe
-    })
-
     const first = renderHook(() => useComposerState({ initialName: 'first', persistDraft: false }))
     const second = renderHook(() =>
       useComposerState({ initialName: 'second', persistDraft: false })
@@ -88,12 +81,12 @@ describe('useComposerState integrated lifecycle', () => {
     expect(first.result.current.cardProps.onParentWorktreeIdChange).toBeTypeOf('function')
     act(() => first.result.current.cardProps.onParentWorktreeIdChange('repo-1::/parent'))
     expect(first.result.current.cardProps.parentWorktreeId).toBe('repo-1::/parent')
-    expect(window.api.ui.onFileDrop).toHaveBeenCalledTimes(2)
+    expect(first.result.current.cardProps.onNativeFileDrop).toBeUndefined()
+    expect(second.result.current.cardProps.onNativeFileDrop).toBeUndefined()
+    expect(window.api.ui.onFileDrop).not.toHaveBeenCalled()
 
     second.unmount()
     first.unmount()
-    expect(unsubscribes).toHaveLength(2)
-    expect(unsubscribes[0]).toHaveBeenCalledTimes(1)
-    expect(unsubscribes[1]).toHaveBeenCalledTimes(1)
+    expect(window.api.ui.onFileDrop).not.toHaveBeenCalled()
   })
 })