@@ -242,6 +242,33 @@ describe('Slack member access selection', () => {
     expect(toast.success).not.toHaveBeenCalled()
   })
 
+  it('keeps a new authorization intact if an old deadline callback runs', async () => {
+    vi.useFakeTimers()
+    const timeouts = vi.spyOn(window, 'setTimeout')
+    await render()
+    await submit()
+    const oldDeadline = timeouts.mock.calls.find(([, delay]) => delay === 10 * 60 * 1_000)?.[0]
+    if (typeof oldDeadline !== 'function') throw new Error('Authorization deadline was not set')
+    await clickButton('Cancel')
+
+    const nextPopup = { location: { href: '' }, closed: false, close: vi.fn() }
+    vi.mocked(window.open).mockReturnValueOnce(nextPopup as unknown as Window)
+    mocks.start.mockResolvedValueOnce({
+      state: 'new-state',
+      authorizationUrl: 'https://slack.com/oauth/v2/authorize',
+    })
+    await submit()
+    await act(async () => oldDeadline())
+
+    expect(toast.error).not.toHaveBeenCalled()
+    expect(nextPopup.close).not.toHaveBeenCalled()
+    expect(document.body.textContent).toContain('Waiting for Slack...')
+    await completeAuthorization('new-state')
+    expect(toast.success).toHaveBeenCalledExactlyOnceWith('Slack configured')
+    await act(async () => vi.advanceTimersByTimeAsync(10 * 60 * 1_000))
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
   it('does not navigate or start a timeout when authorization startup finishes after cancel', async () => {
     vi.useFakeTimers()
     let finishStartup!: (value: { state: string; authorizationUrl: string }) => void
 
@@ -282,6 +282,7 @@ export function SlackManagedUsersModal({
       opened.location.href = result.authorizationUrl
       /** COOP can report a live OAuth popup as closed; only the deadline expires its state. */
       authorizationTimeout.current = window.setTimeout(() => {
+        if (popup.current !== opened) return
         authorizationTimeout.current = null
         opened.close()
         popup.current = null
 
@@ -275,13 +275,13 @@ describe('Slack onboarding control delivery', () => {
     eventId: 'Ev1',
     receivedAt: new Date(),
   } as const
-  const send = () =>
+  const send = (reason: 'account' | 'sources' = 'account') =>
     sendSlackSearchOnboarding(slackPrincipal, {
       job,
       turnId: 'turn1',
       leaseId: 'lease1',
       email: state.email,
-      reason: 'account',
+      reason,
       signal: new AbortController().signal,
     })
   it('posts a thread-scoped signup link without bot secrets or email in its URL', async () => {
@@ -301,12 +301,65 @@ describe('Slack onboarding control delivery', () => {
       expect.objectContaining({ turnId: 'turn1', email: state.email })
     )
   })
-  it('rechecks the binding and lease immediately before delivery', async () => {
-    m.authorize.mockResolvedValueOnce(context).mockResolvedValueOnce(null)
-    await expect(send()).rejects.toThrow('disabled')
+  it('sends Connect sources only to the requesting Slack user without requiring an active thread', async () => {
+    await send('sources')
+    expect(m.api).toHaveBeenLastCalledWith({
+      accessToken: 'bot-secret',
+      method: 'chat.postEphemeral',
+      body: {
+        channel: 'D1',
+        user: job.message.userId,
+        text: 'Connect your sources',
+        blocks: expect.arrayContaining([
+          expect.objectContaining({
+            type: 'actions',
+            elements: [
+              expect.objectContaining({
+                text: { type: 'plain_text', text: 'Connect sources' },
+                url: 'https://sim.test/slack-search/connect/opaque-token',
+              }),
+            ],
+          }),
+        ]),
+      },
+      signal: expect.any(AbortSignal),
+    })
     expect(m.post).not.toHaveBeenCalled()
-    expect(m.lease).toHaveBeenCalledWith('turn1', 'lease1')
+    expect(m.outcome).toHaveBeenCalledWith(context.installation, 'sources_required')
   })
+  it.each(['rejected', 'ambiguous'] as const)(
+    'does not replace a %s ephemeral delivery with a persistent message',
+    async (outcome) => {
+      m.api.mockResolvedValueOnce({
+        status: 200,
+        data: { ok: true, permalink: state.slackUrl },
+      })
+      if (outcome === 'rejected') {
+        m.api.mockResolvedValueOnce({
+          status: 200,
+          data: { ok: false, error: 'user_not_in_channel' },
+        })
+      } else {
+        m.api.mockRejectedValueOnce(new Error('connection lost after send'))
+      }
+      await expect(send('sources')).rejects.toThrow(
+        outcome === 'rejected' ? 'Could not deliver Slack onboarding' : 'connection lost after send'
+      )
+      expect(m.api).toHaveBeenCalledTimes(2)
+      expect(m.post).not.toHaveBeenCalled()
+      expect(m.outcome).not.toHaveBeenCalled()
+    }
+  )
+  it.each(['account', 'sources'] as const)(
+    'rechecks the binding and lease immediately before %s delivery',
+    async (reason) => {
+      m.authorize.mockResolvedValueOnce(context).mockResolvedValueOnce(null)
+      await expect(send(reason)).rejects.toThrow('disabled')
+      expect(m.post).not.toHaveBeenCalled()
+      expect(m.api).toHaveBeenCalledTimes(1)
+      expect(m.lease).toHaveBeenCalledWith('turn1', 'lease1')
+    }
+  )
   it('does not retry an ambiguous post or fall back to another transport', async () => {
     m.post.mockRejectedValueOnce(new Error('connection lost after send'))
     await expect(send()).rejects.toThrow('connection lost after send')
 
@@ -113,34 +113,46 @@ export async function sendSlackSearchOnboarding(
   await requireSlackSearchTurnLease(turnId, leaseId)
   if (!(await authorizeSlackSearchInstallation(principal, job)))
     throw new OrchestrationError('forbidden', 'Slack Search is disabled')
-  const response = await postSlackMessage(
-    context.secret.botToken,
-    {
-      channel: job.message.channelId,
-      thread_ts: job.message.threadTs ?? job.message.messageTs,
-      text,
-      unfurl_links: false,
-      unfurl_media: false,
-      blocks: [
-        { type: 'section', text: { type: 'plain_text', text } },
-        {
-          type: 'actions',
-          elements: [
-            {
-              type: 'button',
-              text: {
-                type: 'plain_text',
-                text: reason === 'account' ? 'Get started with Sim' : 'Connect sources',
-              },
-              url,
-              action_id: 'slack_search_onboarding',
+  const message = {
+    channel: job.message.channelId,
+    text,
+    blocks: [
+      { type: 'section', text: { type: 'plain_text', text } },
+      {
+        type: 'actions',
+        elements: [
+          {
+            type: 'button',
+            text: {
+              type: 'plain_text',
+              text: reason === 'account' ? 'Get started with Sim' : 'Connect sources',
             },
-          ],
-        },
-      ],
-    },
-    signal
-  )
+            url,
+            action_id: 'slack_search_onboarding',
+          },
+        ],
+      },
+    ],
+  }
+  /** Channel-level ephemeral prompts also display before the first persistent thread reply exists. */
+  const response =
+    reason === 'sources'
+      ? await requestSlackApi({
+          accessToken: context.secret.botToken,
+          method: 'chat.postEphemeral',
+          body: { ...message, user: job.message.userId },
+          signal,
+        })
+      : await postSlackMessage(
+          context.secret.botToken,
+          {
+            ...message,
+            thread_ts: job.message.threadTs ?? job.message.messageTs,
+            unfurl_links: false,
+            unfurl_media: false,
+          },
+          signal
+        )
   if (response.status !== 200 || response.data.ok !== true)
     throw new Error('Could not deliver Slack onboarding')
   await recordSlackSearchOutcome(
 
@@ -187,7 +187,12 @@ apply. A wrong account or conflicting identity cannot see the original question
 or organization details on the return page.
 
 For an authorized member with no accessible indexed documents, the bot sends a
-**Connect sources** button without starting an Assistant run. The return page
+**Connect sources** button in an ephemeral message visible only to that Slack
+user, without starting an Assistant run. It is posted in the DM rather than
+an ephemeral thread reply, which Slack only displays for an already active
+thread. It disappears when the Slack session ends; private Sim history retains
+the setup notice. Failed delivery never falls back to a persistent Slack message.
+The return page
 opens the organization's existing Integrations page directly, using the same
 source list and connection dialogs as normal visits. Slack adds only indexing,
 retry, and thread-return actions to its header. Shared documents that the member can already search do not