@@ -232,6 +232,11 @@ describe('organization provider management', () => {
       expect(container.textContent).toContain('Loading integration')
       expect(container.textContent).not.toContain('Activate this integration')
       expect(mocks.people).not.toHaveBeenCalled()
+      expect(
+        container.querySelector(
+          `input[placeholder="${params ? 'Search people...' : 'Search sources...'}"]`
+        )
+      ).toBeEnabled()
     }
   )
 
@@ -243,17 +248,21 @@ describe('organization provider management', () => {
       error: new ApiClientError({ status: 403, message: 'Access denied', body: null }),
       refetch,
     })
-    await render('google_drive', '?view=accounts')
+    await render('google_drive', '?view=accounts&credential-group-people=alex')
     expect(container.textContent).toContain('Access denied')
     expect(mocks.people).not.toHaveBeenCalled()
+    expect(container.querySelector('input[placeholder="Search people..."]')).toHaveValue('alex')
+    expect(container.querySelector('input[placeholder="Search people..."]')).toBeEnabled()
     await click('Try again')
     expect(refetch).toHaveBeenCalledOnce()
   })
 
   it('offers activation from the accounts tab when an existing provider is deactivated', async () => {
     mocks.overview.mockReturnValue({ data: { providers: [{ ...provider, approved: false }] } })
-    await render('google_drive', '?view=accounts')
+    await render('google_drive', '?view=accounts&credential-group-people=alex')
     expect(mocks.people).not.toHaveBeenCalled()
+    expect(container.querySelector('input[placeholder="Search people..."]')).toHaveValue('alex')
+    expect(container.querySelector('input[placeholder="Search people..."]')).toBeEnabled()
     await click('Activate')
     expect(mocks.activate).toHaveBeenCalledWith({
       organizationId: 'org-one',
@@ -276,6 +285,46 @@ describe('organization provider management', () => {
     })
   })
 
+  it.each([
+    ['loading', 'Loading accounts…'],
+    ['error', 'Accounts unavailable'],
+    ['missing group', 'Add a source to set up account connections.'],
+    ['missing provider option', 'Add a source to set up account connections.'],
+  ])('preserves Accounts search while %s', async (state, message) => {
+    const refetch = vi.fn()
+    mocks.accounts.mockReturnValue(
+      state === 'loading'
+        ? { isPending: true }
+        : state === 'error'
+          ? { isError: true, error: new Error(message), refetch }
+          : {
+              data: {
+                credentialGroup:
+                  state === 'missing group' ? null : { ...credentialGroup, options: [] },
+              },
+              isPending: false,
+            }
+    )
+    await render('google_drive', '?view=accounts&credential-group-people=alex&search=handbook')
+
+    expect(container.textContent).toContain(message)
+    expect(container.querySelector('input[placeholder="Search people..."]')).toHaveValue('alex')
+    expect(container.querySelector('input[placeholder="Search people..."]')).toBeEnabled()
+    expect(container.querySelector('input[placeholder="Search sources..."]')).toBeNull()
+    expect(mocks.people).not.toHaveBeenCalled()
+    if (state === 'error') {
+      await click('Try again')
+      expect(refetch).toHaveBeenCalledOnce()
+    }
+
+    await click('Sources')
+    expect(container.querySelector('input[placeholder="Search sources..."]')).toHaveValue(
+      'handbook'
+    )
+    await click('Accounts')
+    expect(container.querySelector('input[placeholder="Search people..."]')).toHaveValue('alex')
+  })
+
   it('preserves source navigation and retries connection availability failures', async () => {
     mocks.availabilityError = new Error('Connection availability could not be loaded')
     await render()
@@ -355,6 +404,80 @@ describe('organization provider management', () => {
     expect(query.has('addConnector')).toBe(false)
   })
 
+  it.each([
+    { name: 'missing bot', slackBotCredentialId: undefined, configurationStatus: 'ready' },
+    {
+      name: 'outdated app',
+      slackBotCredentialId: 'slack-bot',
+      configurationStatus: 'needs_update',
+    },
+  ])('offers Slack Accounts recovery for an active option with $name', async (option) => {
+    mocks.access = { admin: false, members: true }
+    mocks.overview.mockReturnValue({
+      data: { providers: [{ ...provider, connectorType: 'slack' }] },
+    })
+    mocks.accounts.mockReturnValue({
+      data: {
+        credentialGroup: {
+          ...credentialGroup,
+          options: [
+            {
+              id: 'slack-option',
+              provider: 'slack',
+              status: 'active',
+              slackBotCredentialId: option.slackBotCredentialId,
+              configurationStatus: option.configurationStatus,
+            },
+          ],
+        },
+      },
+      isPending: false,
+    })
+    await render('slack', '?view=accounts&credential-group-people=alex')
+
+    expect(mocks.people).not.toHaveBeenCalled()
+    expect(container.textContent).toContain('Set up the Slack app to connect accounts.')
+    expect(container.querySelector('input[placeholder="Search people..."]')).toHaveValue('alex')
+    await click('Set up Slack app')
+    const query = new URLSearchParams(mocks.updateUrl.mock.calls.at(-1)![0].queryString)
+    expect(query.get('connectedAccounts')).toBe('slack')
+    expect(query.get('view')).toBe('accounts')
+    expect(query.get('credential-group-people')).toBe('alex')
+    expect(query.has('addConnector')).toBe(false)
+  })
+
+  it('opens focused account management after the Slack app is ready', async () => {
+    mocks.access = { admin: false, members: true }
+    mocks.overview.mockReturnValue({
+      data: { providers: [{ ...provider, connectorType: 'slack' }] },
+    })
+    mocks.accounts.mockReturnValue({
+      data: {
+        credentialGroup: {
+          ...credentialGroup,
+          options: [
+            {
+              id: 'slack-option',
+              provider: 'slack',
+              status: 'active',
+              slackBotCredentialId: 'slack-bot',
+              configurationStatus: 'ready',
+            },
+          ],
+        },
+      },
+      isPending: false,
+    })
+    await render('slack', '?view=accounts')
+
+    expect(mocks.people).toHaveBeenCalledWith(
+      expect.objectContaining({
+        searchConnection: { optionId: 'slack-option', providerName: 'Slack' },
+      })
+    )
+    expect(container.textContent).not.toContain('Set up the Slack app to connect accounts.')
+  })
+
   it('does not load admin queries or render setup controls for nonadmins', async () => {
     mocks.admin = false
     await render()
 
@@ -80,19 +80,19 @@ describe('shared connector settings form', () => {
   let onSaved: ReturnType<typeof vi.fn>
   let baseline: ConnectorData
 
-  function Probe({ row }: { row: ConnectorData }) {
+  function Probe({ row, isSearchIndex = true }: { row: ConnectorData; isSearchIndex?: boolean }) {
     form = useConnectorSettingsForm({
       scope: { kind: 'organization', organizationId: 'org-1' },
       knowledgeBaseId: 'kb-search',
-      isSearchIndex: true,
+      isSearchIndex,
       connector: row,
       onSaved,
     })
     return null
   }
 
-  function render(row = baseline, key = 'baseline') {
-    act(() => root.render(<Probe key={key} row={row} />))
+  function render(row = baseline, key = 'baseline', isSearchIndex = true) {
+    act(() => root.render(<Probe key={key} row={row} isSearchIndex={isSearchIndex} />))
   }
 
   beforeEach(() => {
@@ -134,6 +134,71 @@ describe('shared connector settings form', () => {
     expect(form.dirty).toBe(true)
   })
 
+  it('keeps a new member Gmail source clean and preserves its derived listing cap on save', () => {
+    const sourceConfig = {
+      label: ['INBOX'],
+      dateRange: '7d',
+      query: 'subject:SIM-SEARCH-QA',
+      _canonicalModes: { label: 'advanced' },
+      maxThreads: 0,
+    }
+    render(connector({ connectorType: 'gmail', sourceConfig }), 'gmail-members')
+
+    const capField = form.fieldsProps.connectorConfig?.configFields.find(
+      (field) => field.id === 'maxThreads'
+    )!
+    expect(capField).toBeDefined()
+    expect(form.fieldsProps.isFieldVisible(capField)).toBe(false)
+    expect(form.dirty).toBe(false)
+    expect(form.canSave).toBe(false)
+
+    act(() => form.fieldsProps.onFieldChange('query', 'subject:updated'))
+    expect(form.dirty).toBe(true)
+    expect(form.canSave).toBe(true)
+    act(() => form.save())
+    expect(mocks.update).toHaveBeenCalledWith(
+      {
+        knowledgeBaseId: 'kb-search',
+        connectorId: baseline.id,
+        updates: { sourceConfig: { ...sourceConfig, query: 'subject:updated' } },
+      },
+      expect.any(Object)
+    )
+  })
+
+  it('keeps general knowledge-base listing caps editable and includes their changes on save', () => {
+    const sourceConfig = {
+      label: ['INBOX'],
+      _canonicalModes: { label: 'basic' },
+      maxThreads: '100',
+    }
+    render(
+      connector({ connectorType: 'gmail', accessMode: 'workspace', sourceConfig }),
+      'gmail-workspace',
+      false
+    )
+
+    const capField = form.fieldsProps.connectorConfig?.configFields.find(
+      (field) => field.id === 'maxThreads'
+    )!
+    expect(capField).toBeDefined()
+    expect(form.fieldsProps.isFieldVisible(capField)).toBe(true)
+    expect(form.dirty).toBe(false)
+
+    act(() => form.fieldsProps.onFieldChange('maxThreads', '200'))
+    expect(form.dirty).toBe(true)
+    expect(form.canSave).toBe(true)
+    act(() => form.save())
+    expect(mocks.update).toHaveBeenCalledWith(
+      {
+        knowledgeBaseId: 'kb-search',
+        connectorId: baseline.id,
+        updates: { sourceConfig: { ...sourceConfig, maxThreads: '200' } },
+      },
+      expect.any(Object)
+    )
+  })
+
   it('guards access drafts separately from a settings save', () => {
     expect(form.dirty).toBe(false)
     expect(form.canSave).toBe(false)
 
@@ -299,6 +299,7 @@ export function useConnectorSettingsForm({
     if (didCanonicalModesChange(canonicalModes, persistedCanonicalModes)) return true
     const resolved = resolveSourceConfig()
     for (const [key, value] of Object.entries(resolved)) {
+      if (hiddenCapFieldIds.has(key)) continue
       if (!valuesEqual(connector.sourceConfig[key], value)) return true
     }
     return false
@@ -309,6 +310,7 @@ export function useConnectorSettingsForm({
     connector.sourceConfig,
     canonicalModes,
     persistedCanonicalModes,
+    hiddenCapFieldIds,
   ])
 
   const handleSave = useCallback(() => {
@@ -324,6 +326,7 @@ export function useConnectorSettingsForm({
     const resolved = resolveSourceConfig()
     const changedEntries: Record<string, unknown> = {}
     for (const [key, value] of Object.entries(resolved)) {
+      if (hiddenCapFieldIds.has(key)) continue
       if (!valuesEqual(connector.sourceConfig[key], value)) changedEntries[key] = value
     }
 
@@ -364,6 +367,7 @@ export function useConnectorSettingsForm({
     resolveSourceConfig,
     canonicalModes,
     persistedCanonicalModes,
+    hiddenCapFieldIds,
     onSaved,
     updateConnector,
     knowledgeBaseId,
 
@@ -108,20 +108,24 @@ async function selectPersonAction(label: string) {
   )
   if (!action) throw new Error(`Missing ${label} action`)
   await act(async () => action.click())
+  return action
 }
 
 async function openConfirmation(label: string) {
   if (label === 'Revoke') await selectPersonAction(label)
   else await act(async () => button(container, label).click())
 }
 
-async function renderPeople() {
+async function renderPeople(searchConnection?: { optionId: string; providerName: string }) {
   await act(async () =>
     root.render(
       <NuqsTestingAdapter hasMemory>
         <SettingsHeaderProvider>
           <SettingsHeaderShell>
-            <OrganizationAccountPeople organizationId='organization-1' />
+            <OrganizationAccountPeople
+              organizationId='organization-1'
+              searchConnection={searchConnection}
+            />
           </SettingsHeaderShell>
         </SettingsHeaderProvider>
       </NuqsTestingAdapter>
@@ -144,6 +148,7 @@ it('keeps the compact People rows and resends from the actions menu', async () =
   expect(container.textContent).toContain('2 accounts connected')
   expect(container.textContent).not.toContain('Copy new link')
   expect(container.textContent).not.toContain('gmail: active')
+  expect(container.textContent).not.toContain('People (1)')
   await selectPersonAction('Resend')
   expect(mocks.resend).toHaveBeenCalledExactlyOnceWith(
     { organizationId: 'organization-1', enrollmentId: 'enrollment-1' },
@@ -308,7 +313,64 @@ it('offers requests from an empty configured pool', async () => {
   await renderPeople()
 
   expect(container.textContent).toContain('No people invited yet')
+  expect(container.textContent).not.toContain('People (0)')
+  expect(container.querySelector('input[placeholder="Search people..."]')).toBeEnabled()
+  expect(button(container, 'Request connections')).toBeEnabled()
+})
+
+it('loads more people below the ungrouped rows', async () => {
+  const fetchNextPage = vi.fn()
+  mocks.people.mockReturnValue({
+    ...mocks.people(),
+    hasNextPage: true,
+    isFetchingNextPage: false,
+    fetchNextPage,
+  })
+  await renderPeople()
+
+  expect(container.textContent).toContain('person@example.com')
+  expect(container.textContent).not.toContain('People (1+)')
+  const personActions = container.querySelector('[aria-label="person@example.com actions"]')
+  const loadMore = button(container, 'Load more')
+  expect(personActions).not.toBeNull()
+  expect(personActions!.compareDocumentPosition(loadMore) & Node.DOCUMENT_POSITION_FOLLOWING).toBe(
+    Node.DOCUMENT_POSITION_FOLLOWING
+  )
+  expect(loadMore).toBeEnabled()
+  await act(async () => loadMore.click())
+  expect(fetchNextPage).toHaveBeenCalledOnce()
+})
+
+it.each([
+  { view: 'all people', searchConnection: undefined },
+  {
+    view: 'provider accounts',
+    searchConnection: { optionId: 'gmail-option', providerName: 'Gmail' },
+  },
+])('disables resending revoked invitations in $view', async ({ searchConnection }) => {
+  mocks.people.mockReturnValue({
+    data: {
+      pages: [
+        {
+          enrollments: [
+            {
+              id: 'enrollment-1',
+              email: 'person@example.com',
+              status: 'revoked',
+              connections: [],
+              mcpConnections: [],
+            },
+          ],
+        },
+      ],
+    },
+  })
+  await renderPeople(searchConnection)
+
   expect(button(container, 'Request connections')).toBeEnabled()
+  const resend = await selectPersonAction('Resend')
+  expect(resend).toHaveAttribute('aria-disabled', 'true')
+  expect(mocks.resend).not.toHaveBeenCalled()
 })
 
 it('hides cached people after a first-page authorization failure and offers a retry', async () => {
@@ -440,7 +502,6 @@ it.each([
       optionId: 'gmail-option',
     })
     expect(container.textContent).toContain('Gmail')
-    expect(container.textContent).toContain('Organization account contributors')
     expect(container.textContent).toContain(label)
     expect(container.textContent).not.toContain('No people invited')
   }