diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx
index d3cc335357cb..be54ac6ac003 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx
@@ -12,11 +12,17 @@ import { clearNativeChatModelEnrichmentForTests } from './native-chat-session-op
 
 const mocks = vi.hoisted(() => ({
   cancelPendingSends: vi.fn(),
+  composerIsComposing: null as (() => boolean) | null,
+  attachmentIsComposing: null as (() => boolean) | null,
+  flushPendingAttachments: vi.fn(),
   fieldProps: null as {
     onSend?: () => void
     onStop?: () => void
-    onCompositionStart?: () => void
-    onCompositionEnd?: (event: { currentTarget: HTMLTextAreaElement }) => void
+    imeEnterGesture?: {
+      isComposing: () => boolean
+      setComposing: (active: boolean) => void
+    }
+    onImeSettled?: (element: HTMLTextAreaElement) => void
     sessionOptionsSurface?: SessionOptionsSurface | null
     sessionOptionsSnapshot?: SessionOptionDescriptor[]
     attachDisabled?: boolean
@@ -103,19 +109,23 @@ vi.mock('./native-chat-draft-cache', () => ({
 vi.mock('./NativeChatComposerField', () => ({
   NativeChatComposerField: (props: { onSend?: () => void; onStop?: () => void }) => {
     mocks.fieldProps = props
-    return null
+    return <div data-testid="native-chat-composer-field" />
   }
 }))
 vi.mock('./use-native-chat-skills', () => ({
   useNativeChatSkills: () => ({ status: 'ready', skills: [], error: null, retry: () => {} })
 }))
 vi.mock('./use-native-chat-composer-attachments', () => ({
-  useNativeChatComposerAttachments: () => ({
-    imageAttachments: mocks.imageAttachments,
-    attachResolvedPaths: vi.fn(),
-    clearImageAttachments: vi.fn(),
-    removeImageAttachment: vi.fn()
-  })
+  useNativeChatComposerAttachments: (args: { isComposing: () => boolean }) => {
+    mocks.attachmentIsComposing = args.isComposing
+    return {
+      imageAttachments: mocks.imageAttachments,
+      attachResolvedPaths: vi.fn(),
+      clearImageAttachments: vi.fn(),
+      flushPendingAttachments: mocks.flushPendingAttachments,
+      removeImageAttachment: vi.fn()
+    }
+  }
 }))
 vi.mock('./use-native-chat-composer-paste', () => ({
   useNativeChatComposerPaste: () => ({
@@ -133,7 +143,10 @@ vi.mock('../dictation/dictation-control-events', () => ({
   dispatchDictationControl: vi.fn()
 }))
 vi.mock('./use-native-chat-composer-keydown', () => ({
-  useNativeChatComposerKeyDown: () => vi.fn()
+  useNativeChatComposerKeyDown: (args: { isComposing: () => boolean }) => {
+    mocks.composerIsComposing = args.isComposing
+    return vi.fn()
+  }
 }))
 vi.mock('./use-native-chat-send-lifecycle', () => ({
   useNativeChatSendLifecycle: () => ({
@@ -155,6 +168,8 @@ describe('NativeChatComposer', () => {
     mocks.imageAttachments = []
     mocks.draftScopeKeys.length = 0
     mocks.confirmationObserver = null
+    mocks.composerIsComposing = null
+    mocks.attachmentIsComposing = null
     mocks.createClaudeModelSwitchConfirmationObserver.mockImplementation(() => {
       const observer = {
         ready: Promise.resolve(),
@@ -402,6 +417,7 @@ describe('NativeChatComposer', () => {
         agent="codex"
       />
     )
+    const field = view.getByTestId('native-chat-composer-field')
 
     view.rerender(
       <NativeChatComposer
@@ -421,6 +437,48 @@ describe('NativeChatComposer', () => {
     )
 
     expect(new Set(mocks.draftScopeKeys)).toEqual(new Set(['tab-1:leaf-1']))
+    expect(view.getByTestId('native-chat-composer-field')).toBe(field)
+  })
+
+  it('remounts the composer field when draft ownership moves to another pane', () => {
+    const view = render(
+      <NativeChatComposer
+        terminalTabId="tab-1"
+        paneKey="tab-1:leaf-1"
+        targetPtyId="pty-1"
+        agent="codex"
+      />
+    )
+    const previousField = view.getByTestId('native-chat-composer-field')
+    act(() => mocks.fieldProps?.imeEnterGesture?.setComposing(true))
+    expect(mocks.composerIsComposing?.()).toBe(true)
+
+    view.rerender(
+      <NativeChatComposer
+        terminalTabId="tab-1"
+        paneKey="tab-1:leaf-2"
+        targetPtyId="pty-2"
+        agent="codex"
+      />
+    )
+
+    expect(view.getByTestId('native-chat-composer-field')).not.toBe(previousField)
+    expect(mocks.composerIsComposing?.()).toBe(false)
+  })
+
+  it('shares one stable composition owner between keyboard and attachment paths', () => {
+    render(
+      <NativeChatComposer
+        terminalTabId="tab-1"
+        paneKey="tab-1:leaf-1"
+        targetPtyId="pty-1"
+        agent="codex"
+      />
+    )
+
+    expect(mocks.attachmentIsComposing).toBe(mocks.composerIsComposing)
+    act(() => mocks.fieldProps?.imeEnterGesture?.setComposing(true))
+    expect(mocks.attachmentIsComposing?.()).toBe(true)
   })
 
   it('adopts an IME deletion delivered only by compositionend', () => {
@@ -435,14 +493,19 @@ describe('NativeChatComposer', () => {
     const textarea = document.createElement('textarea')
     textarea.value = ''
     mocks.setDraft.mockClear()
+    mocks.flushPendingAttachments.mockClear()
 
     act(() => {
-      mocks.fieldProps?.onCompositionStart?.()
-      mocks.fieldProps?.onCompositionEnd?.({ currentTarget: textarea })
+      mocks.fieldProps?.imeEnterGesture?.setComposing(false)
+      mocks.fieldProps?.onImeSettled?.(textarea)
     })
 
     expect(mocks.setDraft).toHaveBeenCalledOnce()
     expect(mocks.setDraft).toHaveBeenCalledWith('')
+    expect(mocks.flushPendingAttachments).toHaveBeenCalledOnce()
+    expect(mocks.setDraft.mock.invocationCallOrder[0]).toBeLessThan(
+      mocks.flushPendingAttachments.mock.invocationCallOrder[0] ?? Number.POSITIVE_INFINITY
+    )
   })
 
   it('does not duplicate a composition value already adopted by onChange', () => {
@@ -457,10 +520,12 @@ describe('NativeChatComposer', () => {
     const textarea = document.createElement('textarea')
     textarea.value = 'hello'
     mocks.setDraft.mockClear()
+    mocks.flushPendingAttachments.mockClear()
 
-    act(() => mocks.fieldProps?.onCompositionEnd?.({ currentTarget: textarea }))
+    act(() => mocks.fieldProps?.onImeSettled?.(textarea))
 
     expect(mocks.setDraft).not.toHaveBeenCalled()
+    expect(mocks.flushPendingAttachments).toHaveBeenCalledOnce()
   })
 
   it('renders the Claude model picker while host discovery is still pending', () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index 8e47eb1a8f47..b11da6676f9d 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -14,7 +14,6 @@ import {
   pushHistory,
   type HistoryState
 } from './native-chat-composer-state'
-import { readNativeChatDraftCache } from './native-chat-draft-cache'
 import { useNativeChatDraft } from './use-native-chat-draft'
 import { useNativeChatLaunchDraftAdoption } from './use-native-chat-launch-draft-adoption'
 import { NativeChatComposerField } from './NativeChatComposerField'
@@ -37,6 +36,7 @@ import type {
 } from './native-chat-composer-types'
 import { dispatchNativeChatStructuredComposerText } from './native-chat-structured-composer-dispatch'
 import { useNativeChatPtyComposerSend } from './use-native-chat-pty-composer-send'
+import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 
 export type {
   NativeChatComposerHandle,
@@ -57,8 +57,8 @@ const ESC = '\x1b'
  * Slash-command and `@file` autocomplete are agent-aware; image paste persists a
  * temp file and injects the agent-appropriate path (or reports unsupported).
  */
-export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeChatComposerProps>(
-  function NativeChatComposer(
+const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatComposerProps>(
+  function NativeChatComposerPane(
     {
       terminalTabId,
       paneKey,
@@ -81,8 +81,7 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
     // images survive both TUI/GUI toggles and PTY replacement on reconnect.
     // Why: local, SSH, and runtime reconnects can replace or temporarily clear
     // the PTY id. Pane identity is the stable ownership key for unsent input.
-    const draftScopeKey = paneKey
-    const { draft, setDraft } = useNativeChatDraft(draftScopeKey)
+    const { draft, setDraft } = useNativeChatDraft(paneKey)
     const [caret, setCaret] = useState(draft.length)
     useNativeChatLaunchDraftAdoption({
       terminalTabId,
@@ -99,7 +98,7 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
     const [notice, setNotice] = useState<string | null>(null)
     const [dictationPressed, setDictationPressed] = useState(false)
     const textareaRef = useRef<HTMLTextAreaElement>(null)
-    const isComposingRef = useRef(false)
+    const imeEnterGesture = useImeEnterGestureOwnership()
     const { cancelPendingSends, trackPendingSend } = useNativeChatSendLifecycle(
       terminalTabId,
       targetPtyId,
@@ -107,7 +106,6 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
     )
     const dictationState = useAppStore((store) => store.dictationState)
     const voiceSettings = useAppStore((store) => store.settings?.voice)
-    const isDictationHoldMode = voiceSettings?.dictationMode === 'hold'
     const dictationDisabled = voiceSettings?.enabled !== true || !voiceSettings.sttModel
     const isDictating =
       dictationPressed ||
@@ -115,15 +113,6 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
       dictationState === 'listening' ||
       dictationState === 'stopping'
 
-    // Place the caret at the end of the (possibly restored) draft when the
-    // composer is reused for a different pane. Adjusted during render (matching
-    // the draft reload) so caret and text stay consistent on the first paint.
-    const lastDraftScopeKey = useRef(draftScopeKey)
-    if (lastDraftScopeKey.current !== draftScopeKey) {
-      lastDraftScopeKey.current = draftScopeKey
-      setCaret(readNativeChatDraftCache(draftScopeKey).length)
-    }
-
     const agentCommands = useMemo(
       () =>
         structuredTransport
@@ -134,7 +123,7 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
     const picker = useNativeChatPickerState({
       agent,
       terminalTabId,
-      draftScopeKey,
+      draftScopeKey: paneKey,
       draft,
       caret,
       agentCommands,
@@ -169,17 +158,20 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
       setCaret(el.selectionStart ?? el.value.length)
     }, [])
 
+    const attachments = useNativeChatComposerAttachments({
+      attachmentScopeKey: paneKey,
+      allowWithoutTarget: Boolean(structuredTransport),
+      caret,
+      disabled,
+      isComposing: imeEnterGesture.isComposing,
+      resolveTarget,
+      textareaRef,
+      setCaret,
+      setDraft,
+      setNotice
+    })
     const { imageAttachments, attachResolvedPaths, clearImageAttachments, removeImageAttachment } =
-      useNativeChatComposerAttachments({
-        attachmentScopeKey: paneKey,
-        allowWithoutTarget: Boolean(structuredTransport),
-        caret,
-        resolveTarget,
-        textareaRef,
-        setCaret,
-        setDraft,
-        setNotice
-      })
+      attachments
     const sendButtonDisabled = isWorking
       ? !hasPty || !onStop
       : disabled || (draft.trim() === '' && imageAttachments.length === 0)
@@ -355,7 +347,7 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
       activeSuggestion,
       draft,
       history,
-      isComposing: () => isComposingRef.current,
+      isComposing: imeEnterGesture.isComposing,
       completePickerItem: completeItem,
       dispatchPickerCommand,
       dismissPicker: dismiss,
@@ -394,7 +386,8 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
         attachDisabled={disabled}
         dictationDisabled={dictationDisabled}
         isDictating={isDictating}
-        isDictationHoldMode={isDictationHoldMode}
+        isDictationHoldMode={voiceSettings?.dictationMode === 'hold'}
+        imeEnterGesture={imeEnterGesture}
         onDraftChange={handleDraftChange}
         onTextareaSelect={(element) => {
           syncCaret(element)
@@ -402,14 +395,11 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
           setActiveSuggestion(0)
         }}
         onKeyDown={handleKeyDown}
-        onCompositionStart={() => {
-          isComposingRef.current = true
-        }}
-        onCompositionEnd={(event) => {
-          isComposingRef.current = false
-          if (event.currentTarget.value !== draft) {
-            handleDraftChange(event.currentTarget.value, event.currentTarget)
+        onImeSettled={(element) => {
+          if (element.value !== draft) {
+            handleDraftChange(element.value, element)
           }
+          attachments.flushPendingAttachments()
         }}
         onPaste={handlePaste}
         pickerListboxId={picker.listboxId}
@@ -440,3 +430,9 @@ export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeCha
     )
   }
 )
+
+export const NativeChatComposer = forwardRef<NativeChatComposerHandle, NativeChatComposerProps>(
+  function NativeChatComposer(props, ref): React.JSX.Element {
+    return <NativeChatComposerPane key={props.paneKey} {...props} ref={ref} />
+  }
+)
diff --git a/src/renderer/src/components/native-chat/NativeChatComposerField.tsx b/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
index 7206b0288bd2..28e973ff9fdb 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
@@ -1,11 +1,8 @@
-import type {
-  ClipboardEventHandler,
-  CompositionEventHandler,
-  KeyboardEventHandler,
-  RefObject
-} from 'react'
+import type { ClipboardEventHandler, KeyboardEventHandler, RefObject } from 'react'
+import { useLayoutEffect } from 'react'
 import { Image as ImageIcon, ImageOff, X } from 'lucide-react'
 import { translate } from '@/i18n/i18n'
+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 { basename } from '@/lib/path'
@@ -36,11 +33,11 @@ export type NativeChatComposerFieldProps = {
   dictationDisabled: boolean
   isDictating: boolean
   isDictationHoldMode: boolean
+  imeEnterGesture: ReturnType<typeof useImeEnterGestureOwnership>
   onDraftChange: (value: string, element: HTMLTextAreaElement) => void
   onTextareaSelect: (element: HTMLTextAreaElement) => void
   onKeyDown: KeyboardEventHandler<HTMLTextAreaElement>
-  onCompositionStart: CompositionEventHandler<HTMLTextAreaElement>
-  onCompositionEnd: CompositionEventHandler<HTMLTextAreaElement>
+  onImeSettled: (element: HTMLTextAreaElement) => void
   onPaste: ClipboardEventHandler<HTMLTextAreaElement>
   pickerListboxId: string
   onChoosePickerItem: (item: NativeChatPickerItem) => void
@@ -79,11 +76,11 @@ export function NativeChatComposerField({
   dictationDisabled,
   isDictating,
   isDictationHoldMode,
+  imeEnterGesture,
   onDraftChange,
   onTextareaSelect,
   onKeyDown,
-  onCompositionStart,
-  onCompositionEnd,
+  onImeSettled,
   onPaste,
   pickerListboxId,
   onChoosePickerItem,
@@ -100,6 +97,18 @@ export function NativeChatComposerField({
   sessionOptionsSnapshot,
   sessionOptionsPickerRequest
 }: NativeChatComposerFieldProps): React.JSX.Element {
+  // Browser owns the provisional value; React synchronizes drafts only between IME sessions.
+  useLayoutEffect(() => {
+    const textarea = textareaRef.current
+    if (!textarea || imeEnterGesture.isComposing()) {
+      return
+    }
+    if (textarea.value === draft) {
+      return
+    }
+    textarea.value = draft
+  }, [draft, imeEnterGesture, textareaRef])
+
   return (
     <div className="shrink-0 bg-background">
       {/* Extra bottom padding keeps the input box off the window rim. */}
@@ -167,13 +176,33 @@ export function NativeChatComposerField({
             ) : null}
             <textarea
               ref={textareaRef}
-              value={draft}
+              defaultValue={draft}
               disabled={disabled}
               rows={2}
               onChange={(e) => onDraftChange(e.target.value, e.currentTarget)}
-              onKeyDown={onKeyDown}
-              onCompositionStart={onCompositionStart}
-              onCompositionEnd={onCompositionEnd}
+              onKeyDown={(event) => {
+                if (!imeEnterGesture.ownsKeyDown(event)) {
+                  onKeyDown(event)
+                }
+              }}
+              onKeyUp={imeEnterGesture.onKeyUp}
+              onBlur={(event) => {
+                const compositionWasActive = imeEnterGesture.isComposing()
+                imeEnterGesture.reset()
+                if (compositionWasActive) {
+                  onImeSettled(event.currentTarget)
+                }
+              }}
+              onCompositionStart={() => {
+                imeEnterGesture.setComposing(true)
+              }}
+              onCompositionEnd={(event) => {
+                const compositionWasActive = imeEnterGesture.isComposing()
+                imeEnterGesture.setComposing(false)
+                if (compositionWasActive) {
+                  onImeSettled(event.currentTarget)
+                }
+              }}
               onPaste={onPaste}
               onSelect={(e) => onTextareaSelect(e.currentTarget)}
               aria-expanded={autocomplete.mode === 'slash' || autocomplete.mode === 'skill'}
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 96f828761142..2ed991ae764e 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
@@ -23,11 +23,13 @@ vi.mock('./NativeChatAutocompleteMenus', () => ({
 }))
 
 import { NativeChatComposerField } from './NativeChatComposerField'
+import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 
 afterEach(() => cleanup())
 
-function renderField(draft: string): HTMLTextAreaElement {
-  render(
+function TestField({ draft }: { draft: string }): React.JSX.Element {
+  const imeEnterGesture = useImeEnterGestureOwnership()
+  return (
     <NativeChatComposerField
       textareaRef={createRef<HTMLTextAreaElement>()}
       draft={draft}
@@ -44,11 +46,11 @@ function renderField(draft: string): HTMLTextAreaElement {
       dictationDisabled={false}
       isDictating={false}
       isDictationHoldMode={false}
+      imeEnterGesture={imeEnterGesture}
       onDraftChange={vi.fn()}
       onTextareaSelect={vi.fn()}
       onKeyDown={vi.fn()}
-      onCompositionStart={vi.fn()}
-      onCompositionEnd={vi.fn()}
+      onImeSettled={vi.fn()}
       onPaste={vi.fn()}
       pickerListboxId="picker"
       onChoosePickerItem={vi.fn()}
@@ -64,6 +66,10 @@ function renderField(draft: string): HTMLTextAreaElement {
       sessionOptionsSnapshot={[]}
     />
   )
+}
+
+function renderField(draft: string): HTMLTextAreaElement {
+  render(<TestField draft={draft} />)
   return screen.getByRole('textbox') as HTMLTextAreaElement
 }
 
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
new file mode 100644
index 000000000000..83615703120d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-composer-composition.test.tsx
@@ -0,0 +1,254 @@
+// @vitest-environment happy-dom
+
+import { createRef } from 'react'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string) => fallback
+}))
+
+vi.mock('./NativeChatComposerActions', () => ({
+  NativeChatComposerActions: () => <div data-testid="composer-actions" />
+}))
+
+vi.mock('./NativeChatAutocompleteMenus', () => ({
+  NativeChatMentionHint: () => null,
+  NativeChatPickerMenu: () => null
+}))
+
+import {
+  NativeChatComposerField,
+  type NativeChatComposerFieldProps
+} from './NativeChatComposerField'
+import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
+
+afterEach(() => cleanup())
+
+type TestFieldProps = Omit<NativeChatComposerFieldProps, 'imeEnterGesture'>
+
+function TestField(props: TestFieldProps): React.JSX.Element {
+  const imeEnterGesture = useImeEnterGestureOwnership()
+  return <NativeChatComposerField {...props} imeEnterGesture={imeEnterGesture} />
+}
+
+function fieldProps(overrides: Partial<TestFieldProps> = {}): TestFieldProps {
+  return {
+    textareaRef: createRef<HTMLTextAreaElement>(),
+    draft: '',
+    disabled: false,
+    hasPty: true,
+    canSend: true,
+    autocomplete: { mode: 'none' },
+    activeSuggestion: 0,
+    notice: null,
+    imageAttachments: [],
+    sendButtonDisabled: false,
+    isWorking: false,
+    attachDisabled: false,
+    dictationDisabled: false,
+    isDictating: false,
+    isDictationHoldMode: false,
+    onDraftChange: vi.fn(),
+    onTextareaSelect: vi.fn(),
+    onKeyDown: vi.fn(),
+    onImeSettled: vi.fn(),
+    onPaste: vi.fn(),
+    pickerListboxId: 'picker',
+    onChoosePickerItem: vi.fn(),
+    onRetrySkills: vi.fn(),
+    onAcceptMention: vi.fn(),
+    onRemoveImageAttachment: vi.fn(),
+    onAttach: vi.fn(),
+    onDictationToggle: vi.fn(),
+    onDictationHoldStart: vi.fn(),
+    onDictationHoldEnd: vi.fn(),
+    onSend: vi.fn(),
+    sessionOptionsSurface: null,
+    sessionOptionsSnapshot: [],
+    ...overrides
+  }
+}
+
+function textarea(): HTMLTextAreaElement {
+  return screen.getByRole('textbox') as HTMLTextAreaElement
+}
+
+describe('native chat composer composition ownership', () => {
+  it('preserves the focused browser preedit through 120 stale streaming rerenders', () => {
+    const textareaRef = createRef<HTMLTextAreaElement>()
+    const onImeSettled = vi.fn()
+    const props = fieldProps({ textareaRef, onImeSettled })
+    const view = render(<TestField {...props} />)
+    const input = textarea()
+    input.focus()
+    fireEvent.compositionStart(input)
+    input.value = '가'
+
+    for (let index = 0; index < 120; index += 1) {
+      view.rerender(<TestField {...props} draft={`stale streaming draft ${index}`} />)
+      expect(textarea()).toBe(input)
+      expect(document.activeElement).toBe(input)
+      expect(input.value).toBe('가')
+    }
+
+    fireEvent.compositionEnd(input, { data: '가' })
+    expect(onImeSettled).toHaveBeenCalledOnce()
+    expect(onImeSettled).toHaveBeenCalledWith(input)
+    expect(input.value).toBe('가')
+  })
+
+  it('synchronizes launch, programmatic, cleared, and pane-scoped drafts while idle', () => {
+    const textareaRef = createRef<HTMLTextAreaElement>()
+    const props = fieldProps({ textareaRef, draft: 'launch draft' })
+    const view = render(<TestField {...props} />)
+    const input = textarea()
+
+    for (const draft of ['programmatic insertion', '', 'next pane draft']) {
+      view.rerender(<TestField {...props} draft={draft} />)
+      expect(textarea()).toBe(input)
+      expect(input.value).toBe(draft)
+    }
+  })
+
+  it('keeps adopting change events and exposes the final deletion at composition end', () => {
+    const onDraftChange = vi.fn()
+    let settledValue: string | null = null
+    render(
+      <TestField
+        {...fieldProps({
+          draft: '한',
+          onDraftChange,
+          onImeSettled: (element) => {
+            settledValue = element.value
+          }
+        })}
+      />
+    )
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    fireEvent.change(input, { target: { value: '한글' } })
+    expect(onDraftChange).toHaveBeenLastCalledWith('한글', input)
+
+    input.value = ''
+    fireEvent.compositionEnd(input, { data: '' })
+    expect(settledValue).toBe('')
+  })
+
+  it('uses the shared Enter gesture owner without swallowing the next deliberate Enter', () => {
+    const onKeyDown = vi.fn()
+    render(<TestField {...fieldProps({ draft: '가', onKeyDown })} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+
+    fireEvent.keyDown(input, { key: 'Process', keyCode: 229, isComposing: true })
+    fireEvent.compositionEnd(input, { data: '가' })
+    const redispatch = fireEvent.keyDown(input, {
+      key: 'Enter',
+      keyCode: 13,
+      isComposing: false
+    })
+
+    expect(redispatch).toBe(false)
+    expect(onKeyDown).not.toHaveBeenCalled()
+
+    fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, isComposing: false })
+    expect(onKeyDown).toHaveBeenCalledOnce()
+  })
+
+  it('releases composition ownership on blur even when compositionend is omitted', () => {
+    const onImeSettled = vi.fn()
+    const onKeyDown = vi.fn()
+    const props = fieldProps({ draft: '가', onImeSettled, onKeyDown })
+    const view = render(<TestField {...props} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    input.value = '각'
+
+    fireEvent.blur(input)
+    view.rerender(<TestField {...props} draft="external draft" />)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, isComposing: false })
+
+    expect(onImeSettled).toHaveBeenCalledOnce()
+    expect(input.value).toBe('external draft')
+    expect(onKeyDown).toHaveBeenCalledOnce()
+  })
+
+  it('settles the browser value instead of an unrelated draft rerender on blur', () => {
+    const onImeSettled = vi.fn()
+    const props = fieldProps({ onImeSettled })
+    const view = render(<TestField {...props} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    input.value = '각'
+
+    view.rerender(<TestField {...props} draft="programmatic draft" />)
+    expect(input.value).toBe('각')
+    fireEvent.blur(input)
+
+    expect(onImeSettled).toHaveBeenCalledOnce()
+    expect(onImeSettled).toHaveBeenCalledWith(input)
+    expect(input.value).toBe('각')
+  })
+
+  it('exposes the browser value on blur when compositionend is omitted', () => {
+    const onImeSettled = vi.fn()
+    render(<TestField {...fieldProps({ onImeSettled })} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    input.value = '각'
+
+    fireEvent.blur(input)
+
+    expect(onImeSettled).toHaveBeenCalledOnce()
+    expect(onImeSettled.mock.calls[0]?.[0].value).toBe('각')
+  })
+
+  it('settles once when compositionend and blur arrive in one batch', () => {
+    const onImeSettled = vi.fn()
+    render(<TestField {...fieldProps({ onImeSettled })} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    input.value = '각'
+
+    act(() => {
+      fireEvent.compositionEnd(input, { data: '각' })
+      fireEvent.blur(input)
+    })
+
+    expect(onImeSettled).toHaveBeenCalledOnce()
+    expect(onImeSettled).toHaveBeenCalledWith(input)
+  })
+
+  it('settles once when blur precedes compositionend in one batch', () => {
+    const onImeSettled = vi.fn()
+    render(<TestField {...fieldProps({ onImeSettled })} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    input.value = '각'
+
+    act(() => {
+      fireEvent.blur(input)
+      fireEvent.compositionEnd(input, { data: '각' })
+    })
+
+    expect(onImeSettled).toHaveBeenCalledOnce()
+    expect(onImeSettled).toHaveBeenCalledWith(input)
+  })
+
+  it('keeps the browser value through a same-draft streaming rerender', () => {
+    const onImeSettled = vi.fn()
+    const props = fieldProps({ onImeSettled })
+    const view = render(<TestField {...props} />)
+    const input = textarea()
+    fireEvent.compositionStart(input)
+    input.value = '각'
+
+    view.rerender(<TestField {...props} />)
+    fireEvent.blur(input)
+
+    expect(input.value).toBe('각')
+    expect(onImeSettled).toHaveBeenCalledWith(input)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx
index 06b61d9610bf..16487c53314e 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx
@@ -1,6 +1,6 @@
 // @vitest-environment happy-dom
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { act, createElement, useRef, useState } from 'react'
+import { act, createElement, useEffect, useRef, useState } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
 import {
   clearNativeChatAttachmentCacheForTests,
@@ -8,6 +8,7 @@ import {
   useNativeChatComposerAttachments
 } from './use-native-chat-composer-attachments'
 import type { NativeChatResolvedTarget } from './native-chat-composer-target'
+import { NATIVE_FILE_DROP_MAX_PATHS } from '../../../../shared/native-file-drop'
 
 vi.mock('@/i18n/i18n', () => ({
   translate: (_key: string, fallback: string) => fallback
@@ -16,7 +17,8 @@ vi.mock('@/runtime/runtime-terminal-inspection', () => ({
   isRemoteRuntimePtyId: () => false
 }))
 
-type ProbeApi = ReturnType<typeof useNativeChatComposerAttachments>
+type AttachmentApi = ReturnType<typeof useNativeChatComposerAttachments>
+type ProbeApi = AttachmentApi & { adoptDraft: (draft: string) => void }
 
 const target: NativeChatResolvedTarget = {
   ptyId: 'pty-1',
@@ -26,34 +28,56 @@ const target: NativeChatResolvedTarget = {
 function Probe({
   scopeKey,
   structured = false,
+  disabled = false,
+  isComposing,
   onReady
 }: {
   scopeKey: string
   structured?: boolean
+  disabled?: boolean
+  isComposing: () => boolean
   onReady: (api: ProbeApi) => void
 }): React.JSX.Element {
   const [caret, setCaret] = useState(0)
-  const [, setDraftValue] = useState('')
-  const [, setNotice] = useState<string | null>(null)
+  const [draftValue, setDraftValue] = useState('')
+  const [notice, setNotice] = useState<string | null>(null)
   const textareaRef = useRef<HTMLTextAreaElement>(null)
   const api = useNativeChatComposerAttachments({
     attachmentScopeKey: scopeKey,
     allowWithoutTarget: structured,
     caret,
+    disabled,
+    isComposing,
     resolveTarget: () => (structured ? null : target),
     textareaRef,
     setCaret,
     setDraft: (updater) => setDraftValue((previous) => updater(previous)),
     setNotice
   })
-  onReady(api)
-  return createElement('textarea', { ref: textareaRef })
+  useEffect(() => {
+    onReady({ ...api, adoptDraft: setDraftValue })
+  }, [api, onReady])
+  return (
+    <div>
+      <textarea ref={textareaRef} />
+      <output data-draft>{draftValue}</output>
+      <output data-notice>{notice}</output>
+    </div>
+  )
 }
 
 async function renderProbe(
   scopeKey: string,
-  structured = false
-): Promise<{ root: Root; latest: () => ProbeApi; rerender: (scopeKey: string) => Promise<void> }> {
+  structured = false,
+  options: { disabled?: boolean; isComposing?: () => boolean } = {}
+): Promise<{
+  draft: () => string
+  latest: () => ProbeApi
+  notice: () => string
+  rerender: (scopeKey: string, disabled?: boolean) => Promise<void>
+  root: Root
+  textarea: () => HTMLTextAreaElement
+}> {
   const container = document.createElement('div')
   document.body.append(container)
   // onReady fires on every render, so keep the freshest snapshot — reading a
@@ -63,13 +87,26 @@ async function renderProbe(
   const onReady = (next: ProbeApi): void => {
     api = next
   }
-  await act(async () => {
-    root.render(createElement(Probe, { scopeKey, structured, onReady }))
-  })
+  const isComposing = options.isComposing ?? (() => false)
+  const render = async (nextScopeKey: string, disabled: boolean): Promise<void> => {
+    await act(async () => {
+      root.render(
+        createElement(Probe, {
+          scopeKey: nextScopeKey,
+          structured,
+          disabled,
+          isComposing,
+          onReady
+        })
+      )
+    })
+  }
+  await render(scopeKey, options.disabled ?? false)
   if (!api) {
     throw new Error('Probe did not render')
   }
   return {
+    draft: () => container.querySelector('[data-draft]')?.textContent ?? '',
     root,
     latest: () => {
       if (!api) {
@@ -77,10 +114,15 @@ async function renderProbe(
       }
       return api
     },
-    rerender: async (nextScopeKey: string) => {
-      await act(async () => {
-        root.render(createElement(Probe, { scopeKey: nextScopeKey, structured, onReady }))
-      })
+    notice: () => container.querySelector('[data-notice]')?.textContent ?? '',
+    rerender: (nextScopeKey: string, disabled = options.disabled ?? false) =>
+      render(nextScopeKey, disabled),
+    textarea: () => {
+      const textarea = container.querySelector('textarea')
+      if (!textarea) {
+        throw new Error('Probe textarea is not mounted')
+      }
+      return textarea
     }
   }
 }
@@ -142,25 +184,75 @@ describe('useNativeChatComposerAttachments', () => {
     act(() => probe.root.unmount())
   })
 
-  it('rescopes attachments when the scope key changes (composer reused for another pane)', async () => {
-    const probe = await renderProbe('pty-1')
-    await act(async () => {
-      probe.latest().attachResolvedPaths(['/tmp/orca-native-chat-pane-1.png'])
+  it('adopts browser text before draining ordered duplicate paths exactly once', async () => {
+    let composing = true
+    const probe = await renderProbe('pty-1', false, { isComposing: () => composing })
+    const textarea = probe.textarea()
+    textarea.focus()
+    textarea.value = '각 '
+    textarea.setSelectionRange(2, 2)
+    const focus = vi.spyOn(textarea, 'focus')
+
+    act(() => {
+      probe.latest().attachResolvedPaths(['/remote/b.txt', '/remote/b.txt'])
+      probe.latest().attachResolvedPaths(['/remote/a.txt'])
     })
-    expect(probe.latest().imageAttachments).toMatchObject([
-      { path: '/tmp/orca-native-chat-pane-1.png' }
-    ])
+    expect(probe.draft()).toBe('')
 
-    // Reused for a different pane: pane-1's chip must not stay live (it would
-    // otherwise be submitted to pane-2's target now that images defer to submit).
-    await probe.rerender('pty-2')
-    expect(probe.latest().imageAttachments).toMatchObject([])
+    composing = false
+    textarea.blur()
+    act(() => {
+      probe.latest().adoptDraft(textarea.value)
+      probe.latest().flushPendingAttachments()
+      probe.latest().flushPendingAttachments()
+    })
 
-    // Switching back restores pane-1's still-cached chip.
-    await probe.rerender('pty-1')
-    expect(probe.latest().imageAttachments).toMatchObject([
-      { path: '/tmp/orca-native-chat-pane-1.png' }
-    ])
+    expect(probe.draft()).toBe('각 @/remote/b.txt @/remote/b.txt @/remote/a.txt ')
+    expect(focus).not.toHaveBeenCalled()
+    expect(document.activeElement).not.toBe(textarea)
+    act(() => probe.root.unmount())
+  })
+
+  it('drops queued paths after any disabled transition', async () => {
+    let composing = true
+    const probe = await renderProbe('pty-1', false, { isComposing: () => composing })
+
+    act(() => probe.latest().attachResolvedPaths(['/remote/a.txt']))
+    await probe.rerender('pty-1', true)
+    await probe.rerender('pty-1', false)
+    composing = false
+    act(() => probe.latest().flushPendingAttachments())
+
+    expect(probe.draft()).toBe('')
+    act(() => probe.root.unmount())
+  })
+
+  it('caps paths queued during composition and keeps overflow visible after flush', async () => {
+    let composing = true
+    const probe = await renderProbe('pty-1', false, { isComposing: () => composing })
+    const acceptedPaths = Array.from(
+      { length: NATIVE_FILE_DROP_MAX_PATHS },
+      (_, index) => `/remote/accepted-${index}.txt`
+    )
+
+    act(() => {
+      probe.latest().attachResolvedPaths(acceptedPaths)
+      probe.latest().attachResolvedPaths(['/remote/rejected.txt'])
+    })
+
+    expect(probe.draft()).toBe('')
+    expect(probe.notice()).toBe(
+      'Too many attachments are waiting. Finish composing before attaching more.'
+    )
+
+    composing = false
+    act(() => probe.latest().flushPendingAttachments())
+
+    expect(probe.draft().match(/@\/remote\/accepted-/g)).toHaveLength(NATIVE_FILE_DROP_MAX_PATHS)
+    expect(probe.draft()).not.toContain('rejected.txt')
+    expect(probe.notice()).toBe(
+      'Too many attachments are waiting. Finish composing before attaching more.'
+    )
     act(() => probe.root.unmount())
   })
 })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
index b9d94d8e2533..63bbf35aabe9 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
@@ -1,5 +1,6 @@
-import { useCallback, useRef, useState, type RefObject } from 'react'
+import { useCallback, useLayoutEffect, useRef, useState, type RefObject } from 'react'
 import { translate } from '@/i18n/i18n'
+import { NATIVE_FILE_DROP_MAX_PATHS } from '../../../../shared/native-file-drop'
 import { isNativeChatImageAttachmentPath } from './native-chat-image-paste'
 import {
   formatNativeChatFileReference,
@@ -13,6 +14,8 @@ export type UseNativeChatComposerAttachmentsArgs = {
   attachmentScopeKey: string
   allowWithoutTarget?: boolean
   caret: number
+  disabled: boolean
+  isComposing: () => boolean
   resolveTarget: () => NativeChatResolvedTarget | null
   textareaRef: RefObject<HTMLTextAreaElement | null>
   setCaret: (caret: number) => void
@@ -24,6 +27,8 @@ export function useNativeChatComposerAttachments({
   attachmentScopeKey,
   allowWithoutTarget = false,
   caret,
+  disabled,
+  isComposing,
   resolveTarget,
   textareaRef,
   setCaret,
@@ -31,25 +36,26 @@ export function useNativeChatComposerAttachments({
   setNotice
 }: UseNativeChatComposerAttachmentsArgs): {
   imageAttachments: NativeChatComposerImageAttachment[]
-  appendImageAttachments: (paths: string[]) => void
   attachResolvedPaths: (paths: string[]) => void
   clearImageAttachments: () => void
+  flushPendingAttachments: () => void
   removeImageAttachment: (id: string) => void
 } {
   const [imageAttachments, setImageAttachments] = useState<NativeChatComposerImageAttachment[]>(
     () => readNativeChatAttachmentCache(attachmentScopeKey)
   )
   const imageAttachmentCounter = useRef(0)
+  const pendingResolvedPathsRef = useRef<string[]>([])
+  const pendingPathLimitRejectedRef = useRef(false)
+  const disabledRef = useRef(disabled)
 
-  // Reload chips from the cache when the composer is reused for a different pane
-  // (scope-key change), adjusting state during render rather than in an effect.
-  // Without this the previous pane's chips would stay live and be submitted to
-  // the new target now that images are deferred to submit.
-  const lastScopeKey = useRef(attachmentScopeKey)
-  if (lastScopeKey.current !== attachmentScopeKey) {
-    lastScopeKey.current = attachmentScopeKey
-    setImageAttachments(readNativeChatAttachmentCache(attachmentScopeKey))
-  }
+  useLayoutEffect(() => {
+    disabledRef.current = disabled
+    if (disabled) {
+      pendingResolvedPathsRef.current = []
+      pendingPathLimitRejectedRef.current = false
+    }
+  }, [disabled])
 
   const updateImageAttachments = useCallback(
     (
@@ -97,17 +103,15 @@ export function useNativeChatComposerAttachments({
         setCaret(before.length + insertion.length)
         return next
       })
-      setNotice(null)
-      requestAnimationFrame(() => textareaRef.current?.focus())
     },
-    [caret, setCaret, setDraft, setNotice, textareaRef]
+    [caret, setCaret, setDraft, textareaRef]
   )
 
   // Attach paths the TARGET AGENT can read: local paths for local worktrees,
   // already-uploaded remote paths for SSH worktrees (the composer uploads
   // before calling this — see native-chat-attachment-upload.ts).
-  const attachResolvedPaths = useCallback(
-    (paths: string[]) => {
+  const applyResolvedPaths = useCallback(
+    (paths: string[], focus: boolean, preserveNotice = false) => {
       const target = resolveTarget()
       if (
         (!target && !allowWithoutTarget) ||
@@ -128,8 +132,10 @@ export function useNativeChatComposerAttachments({
       // diverge and removing a chip needs no TUI un-paste.
       appendImageAttachments(imagePaths)
       insertFileReferences(filePaths)
-      if (imagePaths.length > 0) {
+      if (!preserveNotice) {
         setNotice(null)
+      }
+      if (focus && paths.length > 0) {
         requestAnimationFrame(() => textareaRef.current?.focus())
       }
     },
@@ -143,11 +149,47 @@ export function useNativeChatComposerAttachments({
     ]
   )
 
+  const attachResolvedPaths = useCallback(
+    (paths: string[]) => {
+      if (paths.length === 0 || disabledRef.current) {
+        return
+      }
+      if (isComposing()) {
+        if (paths.length > NATIVE_FILE_DROP_MAX_PATHS - pendingResolvedPathsRef.current.length) {
+          // Reject the whole completion so ordered path batches are never partially applied.
+          pendingPathLimitRejectedRef.current = true
+          setNotice(
+            translate(
+              'components.native-chat.composer.pendingAttachmentLimit',
+              'Too many attachments are waiting. Finish composing before attaching more.'
+            )
+          )
+          return
+        }
+        pendingResolvedPathsRef.current.push(...paths)
+        return
+      }
+      applyResolvedPaths(paths, true)
+    },
+    [applyResolvedPaths, isComposing, setNotice]
+  )
+
+  const flushPendingAttachments = useCallback(() => {
+    const paths = pendingResolvedPathsRef.current
+    const preserveNotice = pendingPathLimitRejectedRef.current
+    pendingResolvedPathsRef.current = []
+    pendingPathLimitRejectedRef.current = false
+    if (paths.length === 0 || disabledRef.current) {
+      return
+    }
+    applyResolvedPaths(paths, false, preserveNotice)
+  }, [applyResolvedPaths])
+
   return {
     imageAttachments,
-    appendImageAttachments,
     attachResolvedPaths,
     clearImageAttachments: () => updateImageAttachments(() => []),
+    flushPendingAttachments,
     removeImageAttachment: (id) =>
       updateImageAttachments((prev) => prev.filter((attachment) => attachment.id !== id))
   }
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 3d9017a0c8a8..7e87169252ae 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
@@ -24,6 +24,14 @@ import { useNativeChatExternalAttachments } from './use-native-chat-external-att
 
 type HookApi = ReturnType<typeof useNativeChatExternalAttachments>
 
+function deferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
+  let resolve: (value: T) => void = () => undefined
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise
+  })
+  return { promise, resolve }
+}
+
 function Probe({
   disabled,
   attachResolvedPaths,
@@ -127,6 +135,40 @@ describe('useNativeChatExternalAttachments', () => {
     expect(attachResolvedPaths).toHaveBeenCalledWith(['/remote/wt/.orca/drops/a.txt'])
   })
 
+  it('delivers concurrent SSH resolutions in order without deduplicating paths', async () => {
+    mocks.resolveNativeChatAttachmentOwner.mockReturnValue({
+      kind: 'ssh',
+      connectionId: 'conn-1',
+      worktreePath: '/remote/wt',
+      expectedExecutionHostId: 'ssh:conn-1',
+      expectedSshTargetId: 'conn-1',
+      expectedSshConnectionGeneration: 4
+    })
+    const firstUpload = deferred<string[]>()
+    const secondUpload = deferred<string[]>()
+    mocks.uploadNativeChatAttachmentPaths
+      .mockReturnValueOnce(firstUpload.promise)
+      .mockReturnValueOnce(secondUpload.promise)
+    const attachResolvedPaths = vi.fn()
+    const probe = await renderProbe({ attachResolvedPaths })
+
+    act(() => {
+      probe.latest().attachExternalPaths(['/local/a.txt'])
+      probe.latest().attachExternalPaths(['/local/b.txt'])
+    })
+    await act(async () => {
+      secondUpload.resolve(['/remote/wt/.orca/drops/b.txt', '/remote/wt/.orca/drops/b.txt'])
+    })
+    await act(async () => {
+      firstUpload.resolve(['/remote/wt/.orca/drops/a.txt'])
+    })
+
+    expect(attachResolvedPaths.mock.calls).toEqual([
+      [['/remote/wt/.orca/drops/b.txt', '/remote/wt/.orca/drops/b.txt']],
+      [['/remote/wt/.orca/drops/a.txt']]
+    ])
+  })
+
   it('shows the not-ready notice instead of attaching unresolved paths', async () => {
     mocks.resolveNativeChatAttachmentOwner.mockReturnValue({ kind: 'not-ready' })
     const attachResolvedPaths = vi.fn()
@@ -153,6 +195,17 @@ describe('useNativeChatExternalAttachments', () => {
     expect(attachResolvedPaths).not.toHaveBeenCalled()
   })
 
+  it('ignores local attachment insertion while already disabled', async () => {
+    mocks.resolveNativeChatAttachmentOwner.mockReturnValue({ kind: 'local' })
+    const attachResolvedPaths = vi.fn()
+    const probe = await renderProbe({ disabled: true, attachResolvedPaths })
+
+    act(() => probe.latest().attachExternalPaths(['/local/a.txt']))
+
+    expect(mocks.resolveNativeChatAttachmentOwner).not.toHaveBeenCalled()
+    expect(attachResolvedPaths).not.toHaveBeenCalled()
+  })
+
   it('drops an upload that resolves after the composer became disabled', async () => {
     mocks.resolveNativeChatAttachmentOwner.mockReturnValue({
       kind: 'ssh',
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 25794e4c1287..3bdd27f95e0a 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
@@ -1,4 +1,4 @@
-import { useCallback, useRef } from 'react'
+import { useCallback, useLayoutEffect, useRef } from 'react'
 import { useAppStore } from '@/store'
 import {
   nativeChatLocalAttachmentUnsupportedNotice,
@@ -35,7 +35,9 @@ export function useNativeChatExternalAttachments({
   resolveAttachmentOwner: () => NativeChatAttachmentOwner
 } {
   const disabledRef = useRef(disabled)
-  disabledRef.current = disabled
+  useLayoutEffect(() => {
+    disabledRef.current = disabled
+  }, [disabled])
 
   const resolveAttachmentOwner = useCallback(
     () =>
@@ -47,7 +49,7 @@ export function useNativeChatExternalAttachments({
 
   const attachExternalPaths = useCallback(
     (paths: string[]) => {
-      if (paths.length === 0) {
+      if (paths.length === 0 || disabledRef.current) {
         return
       }
       const owner = resolveAttachmentOwner()
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 6660bb6c2007..12bc8a13e865 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -16551,7 +16551,8 @@
           "ultra": "Ultra",
           "on": "On",
           "off": "Off"
-        }
+        },
+        "pendingAttachmentLimit": "Too many attachments are waiting. Finish composing before attaching more."
       },
       "tool": {
         "running": "Running…",