fix(native-chat): open a New Chat's composer at once, before its host answers

src/renderer/src/components/native-chat/NativeChatComposer.test.tsx

@@ -295,7 +295,7 @@ describe('NativeChatComposer', () => {
       subscribe: () => () => {}
     } satisfies SessionOptionsSurface
     const optionSnapshot = [{ id: 'model' }] as SessionOptionDescriptor[]
-    render(
+    const composer = (sessionPending = false) => (
       <NativeChatComposer
         terminalTabId="tab-1"
         paneKey="tab-1:structured"
@@ -307,16 +307,22 @@ describe('NativeChatComposer', () => {
           optionsSurface,
           optionSnapshot,
           onError: vi.fn(),
-          runtime: 'local',
+          runtime: 'remote',
           sessionId: 'session-test',
-          runtimeEnvironmentId: null
+          runtimeEnvironmentId: 'paired-host',
+          sessionPending
         }}
       />
     )
+    const { rerender } = render(composer())
 
     expect(mocks.fieldProps?.sessionOptionsSurface).toBe(optionsSurface)
     expect(mocks.fieldProps?.sessionOptionsSnapshot).toBe(optionSnapshot)
     expect(mocks.fieldProps?.attachDisabled).toBe(false)
+    rerender(composer(true))
+    expect(mocks.fieldProps?.attachDisabled).toBe(true)
+    rerender(composer())
+    expect(mocks.fieldProps?.attachDisabled).toBe(false)
     await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(dispatchCommand).toHaveBeenCalledWith('hello')

src/renderer/src/components/native-chat/NativeChatComposer.tsx

@@ -375,7 +375,10 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
         isWorking={isWorking}
         isStopping={isStopping}
         afterStop={afterStop}
-        attachDisabled={disabled}
+        attachDisabled={
+          disabled ||
+          (structuredTransport?.runtime === 'remote' && structuredTransport.sessionPending === true)
+        }
         dictationDisabled={dictation.dictationDisabled}
         isDictating={dictation.isDictating}
         isDictationHoldMode={dictation.isDictationHoldMode}

src/renderer/src/components/native-chat/NativeChatComposerNotices.tsx

@@ -79,8 +79,7 @@ function NoticeRow({ notice }: { notice: NativeChatComposerNotice }): React.JSX.
         />
         <p
           className={cn(
-            'min-w-0 flex-1 select-text py-px leading-5',
-            notice.kind === 'host' ? 'truncate' : '[overflow-wrap:anywhere]',
+            'min-w-0 flex-1 select-text py-px leading-5 [overflow-wrap:anywhere]',
             'text-muted-foreground',
             isError && 'text-foreground',
             isHostWarning && 'text-destructive'

src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx

@@ -212,6 +212,7 @@ export function NativeChatStructuredSession(
     controller,
     sendThroughLaunch: provisionalLaunch.sendThroughLaunch,
     starting: provisionalLaunch.starting,
+    transportEnabled: provisionalLaunch.transportEnabled,
     worktreeId: ownerWorktreeId ?? undefined,
     optionPickerRequest,
     setOptionPickerRequest,

src/renderer/src/components/native-chat/native-chat-attachment-upload.ts

@@ -53,7 +53,7 @@ export type NativeChatAttachmentOwner =
   /** Store not hydrated / worktree unknown. Callers must not attach local
    *  paths in this window — the worktree may turn out to be remote, and the
    *  agent would silently receive paths it cannot read (see #6648). */
-  | { kind: 'not-ready' }
+  | { kind: 'not-ready'; notice?: string }
 
 type NativeChatAttachmentOwnerState = Pick<
   AppState,
@@ -129,6 +129,9 @@ export type NativeChatStructuredAttachmentSession = {
   sessionId: string
   /** Null: the chat runs on this machine. */
   runtimeEnvironmentId: string | null
+  /** The host has not confirmed this chat, so nothing can be uploaded into it. */
+  sessionPending?: boolean
+  sessionPendingNotice?: string
 }
 
 /** A structured chat on a paired server owns its attachments by where it runs, not by worktree. */

src/renderer/src/components/native-chat/native-chat-composer-reveal-focus.test.tsx

@@ -116,6 +116,7 @@ describe('useNativeChatComposerRevealFocus', () => {
     tab.focus()
 
     act(() => requestNativeChatComposerFocus('chat-tab'))
+    expect(container.querySelector('textarea')).toBe(document.activeElement)
     drainFrames()
 
     expect(container.querySelector('textarea')).toBe(document.activeElement)

src/renderer/src/components/native-chat/native-chat-composer-types.ts

@@ -65,6 +65,9 @@ export type NativeChatStructuredComposerTransport = {
   sessionId: string
   /** Owning runtime for that report; null is the local runtime. */
   runtimeEnvironmentId: string | null
+  /** The host has not confirmed this chat: session uploads wait for publication. */
+  sessionPending?: boolean
+  sessionPendingNotice?: string
 }
 
 export type NativeChatOptimisticSendOutcome = {

src/renderer/src/components/native-chat/native-chat-pending-attachment-cache.ts

@@ -31,6 +31,16 @@ export function nativeChatPendingAttachmentSnapshot(
   return pendingCache.get(scopeKey) ?? EMPTY
 }
 
+/** Pending chips are user content before their file paths settle into the draft. */
+export function nativeChatComposerHasUserContent(scopeKey: string): boolean {
+  const draft = readNativeChatComposerDraft(scopeKey)
+  return (
+    draft.text.trim() !== '' ||
+    draft.images.length > 0 ||
+    nativeChatPendingAttachmentSnapshot(scopeKey).length > 0
+  )
+}
+
 function writePending(scopeKey: string, next: readonly NativeChatComposerImageAttachment[]): void {
   if (next.length === 0) {
     pendingCache.delete(scopeKey)

src/renderer/src/components/native-chat/native-chat-structured-session-notices.ts

@@ -46,7 +46,7 @@ function nativeChatLaunchNotice({
         )
   const cause =
     lifecycle === 'failed' && failure
-      ? (failure.authStartupMessage ??
+      ? (failure.causeText ??
         agentSessionWriteNoticeText(
           agentSessionRefusalCauseParts(failure, agentLabel ? { agentName: agentLabel } : {})
         ))
@@ -100,8 +100,9 @@ export function structuredSessionNotices({
   /** Why this chat's host may not take a turn, from `useNativeChatHostPermissionGate`. */
   hostPermission?: NativeChatComposerNotice | null
 }): NativeChatComposerNotice[] {
+  // A host held for its permission mode already says why nothing starts; Retry returns with it.
   const launchNotice = nativeChatLaunchNotice({
-    lifecycle: launch.lifecycle,
+    lifecycle: hostPermission ? null : launch.lifecycle,
     failure: launch.failure,
     agentLabel,
     onRetry: launch.retry,

src/renderer/src/components/native-chat/structured-agent-session-status-bridge-unconfirmed-start.test.tsx

@@ -328,7 +328,8 @@ describe('a chat whose start was never confirmed', () => {
         })
       }),
       expect.any(Function),
-      true
+      true,
+      expect.any(Function)
     )
     expect(lifecycle()).toBeNull()
     expect(rows()).toEqual([])

src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts

@@ -205,7 +205,7 @@ export function useNativeChatComposerPaste({
         return
       }
       if (owner.kind === 'not-ready') {
-        setNotice(nativeChatWorktreeNotReadyNotice())
+        setNotice(owner.notice ?? nativeChatWorktreeNotReadyNotice())
         return
       }
       // Why: snapshot the caret before the async temp-file round-trip — `caret`
@@ -285,7 +285,7 @@ export function useNativeChatComposerPaste({
           setNotice(
             owner.kind === 'remote'
               ? nativeChatLocalAttachmentUnsupportedNotice()
-              : nativeChatWorktreeNotReadyNotice()
+              : (owner.notice ?? nativeChatWorktreeNotReadyNotice())
           )
         }
         return

src/renderer/src/components/native-chat/use-native-chat-composer-reveal-focus.ts

@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from 'react'
+import { useEffect, useLayoutEffect, useRef, useState } from 'react'
 import type { RefObject } from 'react'
 import { shouldPreserveEditableFocus } from '@/components/terminal-pane/pane-helpers'
 import { scheduleNextFrame } from '@/components/terminal-pane/terminal-ime-input-context-refresh'
@@ -40,7 +40,7 @@ export function captureNativeChatComposerFocusIntent(): NativeChatComposerFocusI
     }
   }
   const pending: { tabId: string | null; cancel: () => void } = { tabId: null, cancel }
-  let timeout: ReturnType<typeof setTimeout> | undefined
+  const timeout = setTimeout(cancel, PENDING_FOCUS_MS)
   pendingFocusRequest = pending
   document.addEventListener('pointerdown', cancel, true)
   document.addEventListener('keydown', cancelForNavigation, true)
@@ -50,8 +50,6 @@ export function captureNativeChatComposerFocusIntent(): NativeChatComposerFocusI
         return
       }
       pending.tabId = tabId
-      clearTimeout(timeout)
-      timeout = setTimeout(cancel, PENDING_FOCUS_MS)
       const reclaim = revealedComposerReclaims.get(tabId)
       if (reclaim) {
         cancel()
@@ -101,34 +99,43 @@ export function useNativeChatComposerRevealFocus({
   const explicitRef = useRef(false)
   const [reclaimCount, setReclaimCount] = useState(0)
 
-  useEffect(() => {
+  useLayoutEffect(() => {
     mountedComposers.add(composerRef)
     return () => {
       mountedComposers.delete(composerRef)
     }
   }, [composerRef])
 
-  useEffect(() => {
+  useLayoutEffect(() => {
     if (!revealed || !composerReady) {
       return
     }
     const reclaim = (): void => {
       claimedRef.current = false
       explicitRef.current = true
+      const active = rootRef.current?.ownerDocument.activeElement ?? null
+      const siblingComposer = [...mountedComposers].some(
+        (ownerRef) => ownerRef !== composerRef && ownerRef.current?.contains(active)
+      )
+      if (
+        (!shouldPreserveEditableFocus(active) || siblingComposer) &&
+        composerRef.current?.focus()
+      ) {
+        explicitRef.current = false
+      }
       setReclaimCount((count) => count + 1)
     }
     revealedComposerReclaims.set(tabId, reclaim)
     if (pendingFocusRequest?.tabId === tabId) {
       pendingFocusRequest.cancel()
-      claimedRef.current = false
-      explicitRef.current = true
+      reclaim()
     }
     return () => {
       if (revealedComposerReclaims.get(tabId) === reclaim) {
         revealedComposerReclaims.delete(tabId)
       }
     }
-  }, [composerReady, revealed, tabId])
+  }, [composerReady, composerRef, revealed, rootRef, tabId])
 
   useEffect(() => {
     if (!revealed || !composerReady) {

src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx

@@ -36,6 +36,7 @@ import { useNativeChatExternalAttachments } from './use-native-chat-external-att
 import type { NativeChatPendingAttachmentChips } from './native-chat-session-attachment-drop'
 import type { AgentSessionAttachmentPathUploadResult } from '../../../../shared/agent-session-attachments'
 import { replaceRuntimeEnvironmentRevisions } from '@/runtime/runtime-environment-revision'
+import type { NativeChatStructuredAttachmentSession } from './native-chat-attachment-upload'
 
 type HookApi = ReturnType<typeof useNativeChatExternalAttachments>
 
@@ -68,7 +69,7 @@ function Probe({
 }: {
   disabled: boolean
   structuredWorktreeId?: string
-  structuredSession?: { sessionId: string; runtimeEnvironmentId: string | null }
+  structuredSession?: NativeChatStructuredAttachmentSession
   attachResolvedPaths: (paths: string[]) => void
   pendingChips: NativeChatPendingAttachmentChips
   setNotice: (notice: string | null) => void
@@ -96,7 +97,7 @@ let root: Root | null = null
 async function renderProbe(args: {
   disabled?: boolean
   structuredWorktreeId?: string
-  structuredSession?: { sessionId: string; runtimeEnvironmentId: string | null }
+  structuredSession?: NativeChatStructuredAttachmentSession
   attachResolvedPaths: (paths: string[]) => void
   pendingChips?: NativeChatPendingAttachmentChips
   setNotice?: (notice: string | null) => void
@@ -160,6 +161,30 @@ afterEach(() => {
 })
 
 describe('useNativeChatExternalAttachments', () => {
+  it('keeps a failed paired chat from issuing an upload and says how to retry', async () => {
+    const attachResolvedPaths = vi.fn()
+    const setNotice = vi.fn()
+    const notice = 'Codex chat could not open. Use Retry in the chat, then attach the files again.'
+    const probe = await renderProbe({
+      structuredWorktreeId: 'folder-1',
+      structuredSession: {
+        sessionId: 'codex-1',
+        runtimeEnvironmentId: 'server-1',
+        sessionPending: true,
+        sessionPendingNotice: notice
+      },
+      attachResolvedPaths,
+      setNotice
+    })
+    await act(async () => {
+      await probe.latest().captureExternalDrop()(['/local/a.txt'])
+    })
+    expect(setNotice).toHaveBeenCalledWith(notice)
+    expect(mocks.prepareNativeChatSessionAttachmentUpload).not.toHaveBeenCalled()
+    expect(mocks.uploadNativeChatSessionAttachmentPaths).not.toHaveBeenCalled()
+    expect(attachResolvedPaths).not.toHaveBeenCalled()
+  })
+
   it('attaches local worktree paths unchanged', async () => {
     mocks.resolveNativeChatAttachmentOwner.mockReturnValue({ kind: 'local' })
     const attachResolvedPaths = vi.fn()

src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts

@@ -97,20 +97,14 @@ export function useNativeChatExternalAttachments({
   // The post-await gate asks which workspace this composer serves now, so it
   // reads the pane through a ref. Resolving through the render closure would
   // re-ask the workspace the upload started in — a comparison with itself.
-  const sessionId = structuredSession?.sessionId
-  const runtimeEnvironmentId = structuredSession?.runtimeEnvironmentId ?? null
   const workspaceRef = useRef<ComposerWorkspace>({
     structuredWorktreeId,
     terminalTabId,
     structuredSession
   })
   useLayoutEffect(() => {
-    workspaceRef.current = {
-      structuredWorktreeId,
-      terminalTabId,
-      structuredSession: sessionId ? { sessionId, runtimeEnvironmentId } : undefined
-    }
-  }, [runtimeEnvironmentId, sessionId, structuredWorktreeId, terminalTabId])
+    workspaceRef.current = { structuredWorktreeId, terminalTabId, structuredSession }
+  }, [structuredSession, structuredWorktreeId, terminalTabId])
   const pendingChipsRef = useRef(pendingChips)
   useLayoutEffect(() => {
     pendingChipsRef.current = pendingChips
@@ -119,6 +113,9 @@ export function useNativeChatExternalAttachments({
   const resolveAttachmentOwner = useCallback((): NativeChatAttachmentOwner => {
     const { structuredWorktreeId, structuredSession, terminalTabId } = workspaceRef.current
     if (structuredWorktreeId && structuredSession?.runtimeEnvironmentId) {
+      if (structuredSession.sessionPending) {
+        return { kind: 'not-ready', notice: structuredSession.sessionPendingNotice }
+      }
       return resolveNativeChatRuntimeSessionAttachmentOwner({
         sessionId: structuredSession.sessionId,
         runtimeEnvironmentId: structuredSession.runtimeEnvironmentId
@@ -159,7 +156,7 @@ export function useNativeChatExternalAttachments({
           return nativeChatAttachmentOwnerChangedNotice()
         }
         if (owner.kind === 'not-ready') {
-          return nativeChatWorktreeNotReadyNotice()
+          return owner.notice ?? nativeChatWorktreeNotReadyNotice()
         }
         if (owner.kind === 'remote') {
           return nativeChatLocalAttachmentUnsupportedNotice()

src/renderer/src/components/native-chat/use-native-chat-host-permission-gate.ts

@@ -38,6 +38,19 @@ export function useNativeChatHostPermissionGate(
   const text = hostPermissionRefusedText(agentLabel, verdict.kind, requested)
   return {
     sendBlockedReason: text,
-    notice: { key: `host-permission:${verdict.kind}`, kind: 'host', tone: 'warning', text }
+    notice: {
+      key: `host-permission:${verdict.kind}`,
+      kind: 'host',
+      tone: 'warning',
+      text,
+      ...(verdict.kind === 'unverified'
+        ? {
+            action: {
+              label: translate('components.native-chat.hostPermission.checkAgain', 'Check again'),
+              onClick: verdict.checkAgain
+            }
+          }
+        : {})
+    }
   }
 }